Traditional Operating Systems Research Articles

Legion: Lessons Learned Building a Grid Operating System

Legion was the first integrated grid middleware architected from first principles to address the complexity of grid environments. Just as a traditional operating system provides an abstract interface to the underlying physical resources of a machine, Legion was designed to provide a powerful virtual machine interface layered over the distributed, heterogeneous, autonomous, and fault-prone physical and logical resources that constitute a grid. We believe that without a solid, integrated, operating system-like grid middleware, grids will fail to cross the chasm from bleeding-edge supercomputing users to more mainstream computing. This work provides an overview of the architectural principles that drove Legion, a high-level description of the system with complete references to more detailed explanations, and the history of Legion from first inception in August 1993 through commercialization. We present a number of important lessons, both technical and sociological, learned during the course of developing and deploying Legion.

Test bench for software development of object-oriented processor

HISC (High-level Instruction Set Computer) is proposed to provide hardware support for OOP. It applies the concept of object-orientation in the architecture and provides special instructions for object manipulation. An operating system is under developing for HISC. It divided into several modules by using the object-oriented paradigm. It includes some special modules for object-manipulation such as object management and garbage collection which traditional operating system do not support.In order to do the functional verification of each module, a test bench is needed. Its aims are to ease the effort to written the testing program and to simulate the working environment. It can make it easier to evaluate if an algorithm is suitable for HISC or not. In this paper, we discuss the design of the test bench. The architecture of the system will be described, together with the implementation of the modules and the pluggable modules architecture.

Implementing an untrusted operating system on trusted hardware

Recently, there has been considerable interest in providing "trusted computing platforms" using hardware~---~TCPA and Palladium being the most publicly visible examples. In this paper we discuss our experience with building such a platform using a traditional time-sharing operating system executing on XOM~---~a processor architecture that provides copy protection and tamper-resistance functions. In XOM, only the processor is trusted; main memory and the operating system are not trusted.Our operating system (XOMOS) manages hardware resources for applications that don't trust it. This requires a division of responsibilities between the operating system and hardware that is unlike previous systems. We describe techniques for providing traditional operating systems services in this context.Since an implementation of a XOM processor does not exist, we use SimOS to simulate the hardware. We modify IRIX 6.5, a commercially available operating system to create xomos. We are then able to analyze the performance and implementation overheads of running an untrusted operating system on trusted hardware.

Cover feature - Toward internet distributed computing

Emerging Internet uses-including peer-to-peer and grid computing-provide both a glimpse of and the impetus for evolving the Internet into a distributed computing, platform of unprecedented scale. Taking a longer view, the authors consider what would be needed to make the Internet an application-hosting platform: a networked, distributed counterpart of the hosting environment traditional operating systems provide to applications within a single node. The foundation of their proposed approach is to disaggregate and virtualize individual system resources as services that can be described, discovered, and dynamically configured at runtime to execute an application.

DECAF - A Flexible Multi Agent System Architecture

The first wave of agent implementation toolkits focussed mostly on providing APIs for agent communication. We believe that new toolkits should focus on the public dissemination of complete agent architectures that provide significant value over building software agents from scratch. DECAF (Distributed, Environment Centered Agent Framework) is a software toolkit for the rapid design, development, and execution of “intelligent” agents to achieve solutions in complex software systems. DECAF is based on the premise that execution of the actions required to accomplish a task specified by an agent program is similar to a traditional operating system executing a sequence of user requests. In the same fashion that an operating system provides an environment for the execution of a user request, an agent framework provides the needed environment for the execution of agent actions. The agent environment includes the ability to communicate with other agents, efficiently maintain the current state of an executing agent, and select an execution path from a set of possible execution paths so as to support persistent, flexible, and robust actions. From a research community perspective, DECAF provides a modular platform for evaluating and disseminating results in agent architectures, including communication, planning, action scheduling, execution monitoring, coordination, and learning. By modularizing the design of the software, researchers can attack and analyze specific issues in agent development, coordination and planning without disturbing other parts of the architecture. From a user/programmer perspective, DECAF distinguishes itself by removing the focus from the underlying components of agent building such as socket creation, agent communication, and efficient implementation of complex architectural details. Instead, users may quickly prototype agent systems by focusing on the domain-specific parts of the problem via a graphical plan editor, reusable generic behaviors, and various supporting middle-agents. This article discusses the high level architecture of DECAF long with comparisons to operating systems architecture and other agent frameworks; descriptions of supporting middle agents and development tools; and an analysis of projects already developed using DECAF and some performance benchmarks from DECAF.

A middleware infrastructure for active spaces

The paper discusses the Gaia metaoperating system which extends the reach of traditional operating systems to manage ubiquitous computing habitats and living spaces as integrated programmable environments. Gaia exports services to query, access, and use existing resources and context, and provides a framework to develop user-centric, resource-aware, multidevice, context-sensitive, and mobile applications.

Exploiting Regularities in Web Traffic Patterns for Cache Replacement

Abstract. Caching web pages at proxies and in web servers' memories can greatly enhance performance. Proxy caching is known to reduce network load and both proxy and server caching can significantly decrease latency. Web caching problems have different properties than traditional operating systems caching, and cache replacement can benefit by recognizing and exploiting these differences. We address two aspects of the predictability of traffic patterns: the overall load experienced by large proxy and web servers, and the distinct access patterns of individual pages. We formalize the notion of ``cache load'' under various replacement policies, including LRU and LFU, and demonstrate that the trace of a large proxy server exhibits regular load. Predictable load allows for improved design, analysis, and experimental evaluation of replacement policies. We provide a simple and (near) optimal replacement policy when each page request has an associated distribution function on the next request time of the page. Without the predictable load assumption, no such online policy is possible and it is known that even obtaining an offline optimum is hard. For experiments, predictable load enables comparing and evaluating cache replacement policies using partial traces , containing requests made to only a subset of the pages. Our results are based on considering a simpler caching model which we call the interval caching model . We relate traditional and interval caching policies under predictable load, and derive (near)-optimal replacement policies from their optimal interval caching counterparts.

Java support for data-intensive systems

Database system designers have traditionally had trouble with the default services and interfaces provided by operating systems. In recent years, developers and enthusiasts have increasingly promoted Java as a serious platform for building data-intensive servers. Java provides a number of very helpful language features, as well as a full run-time environment reminiscent of a traditional operating system. This combination of features and community support raises the question of whether Java is better or worse at supporting data-intensive server software than a traditional operating system coupled with a weakly-typed language such as C or C++.In this paper, we summarize and discuss our experience building the Telegraph dataflow system in Java. We highlight some of the pleasures of coding with Java, and some of the pains of coding around Java in order to obtain good performance in a data-intensive server. For those issues that were painful, we present concrete suggestions for evolving Java's interfaces to better suit serious software systems development. We believe these experiences can provide insight for other designers to avoid pitfalls we encountered and to decide if Java is a suitable platform for their system.

Embedded battle royal [embedded operating systems

In this paper, the author describes how Windows and Linux are extending their competition for the desktop to cell phones and set-top boxes in the form of embedded microprocessor systems. In addition, he questions whether traditional embedded operating systems are up to the challenge.

The design, implementation and initial evaluation of an advanced knowledge-based process scheduler

Traditional operating systems control the execution of programs regardless of how often they are run. This raises the question: can't the often run or the often used programs provide better performance if an operating system had an ability to optimize their execution behavior based on a knowledge the operating system had obtained from their previous execution(s)? In this paper, we integrate this ability into a part of an operating system called a process scheduler and examine its cost and benefit. Our initial evaluations show that the cost involved in our scheduler is small and the processing time can be reduced by using this scheduler.

An open source laboratory for operating systems projects

Typical undergraduate operating systems projects use services provided by an operating system via system calls or develop code in a simulated operating system. With the increasing popularity of operating systems with open source code such as Linux, there are untapped possibilities for operating systems projects to modify real operating system code. We present the hardware and software configuration of an open source laboratory that promises to provide students that use it with a better understanding of operating system internals than is typically gained in a traditional operating systems course. Our preliminary projects and evaluation suggest that thus far the lab has achieved its primary goal in that students that used the lab feel more knowledgeable in operating systems and more confident in their ability to write and modify operating system code.

Coordination of the supply chain of seasonal products

Because of the demand uncertainty of seasonal products, the retailer prefers to place an order as late as possible, so that he can have enough time to collect more information, which is helpful to reduce demand forecast error. On the other hand, the manufacturer has limited production capacity in general cases. The late ordering would result in insufficient production times, thus increasing the production cost. Such a conflict exists universally in a supply chain, especially in the seasonal products' supply chain. As a result, coordination between the retailer and the manufacturer becomes very important. In the paper, based on the traditional operating system, an improved operating system is introduced whose impact to both bodies of a supply chain is examined under the condition of information symmetry. The result shows that the manufacturer may not be better off or well off, although the retailer's performance is improved. Then, some profit compensation plans are designed so as to make the operating system Pareto improve.

J-SEAL2—A Secure High-Performance Mobile Agent System

Even though the advantages of mobile agents for distributed electronic commerce applications have been highlighted in numerous research works, mobile agent applications are not in widespread use today. For the success of mobile agent applications, secure, portable, and efficient execution platforms for mobile agents are crucial. However, popular mobile agent systems do not meet the high security requirements of electronic commerce applications, are not portable, or cause high overhead. Currently, the majority of mobile agent platforms is based on Java. These systems simply rely on the security model of Java, although it is not suited to protect agents and service components from each other. In contrast, J-SEAL2 is a mobile agent system designed to meet the high security, portability, and performance requirements of large-scale electronic commerce applications. J-SEAL2 extends the Java environment with a model of strong protection domains. The core of the system is a micro-kernel fulfilling the same functions as a traditional operating system kernel: protection, communication, domain termination, and resource control. For portability reasons, J-SEAL2 is implemented in pure Java. This paper focuses on the design of the new communication model in J-SEAL2, which allows convenient, efficient, and mediated communication in a hierarchy of strong protection domains.

The mungi single-address-space operating system

Single-Address-Space Operating Systems (SASOS) are an attractive model for making the best use of the wide address space provided by the latest generations of microprocessors. SASOS remove the address space boundaries which make data sharing between processes difficult and expensive in traditional operating systems. They offer the potential of significant performance advantages for applications where sharing is important, such as object-oriented databases or persistent programming systems. We have built the Mungi system to demonstrate that a SASOS can offer these performance advantages without resorting to special hardware. Mungi is a very ‘pure’ SASOS, featuring an unintrusive protection model based on sparse capabilities, a fast protected procedure call mechanism, and uses shared memory as the exclusive inter-process communication mechanism, as well as for I/O. The simplicity of our model makes it easy to implement it efficiently on conventional architectures. Our implementation of Mungi for the MIPS R4600 64-bit microprocessor is presented, which is based on our port of the L4 microkernel. Mungi is shown to outperform, in some instances by more than an order of magnitude, two UNIX operating systems, Irix and Linux, in several important operations, such as task creation and inter-process communications, and on the OO1 object-oriented database benchmark. As well, we describe how our approach to key issues in SASOS design provides better performance than other systems, such as Opal. Our experience shows that the SASOS concept is viable, and that a well-designed microkernel is an excellent base on which to build high-performance operating systems. © 1998 John Wiley & Sons, Ltd.

A Virtual Shared Tuplespace Resource Manager

Traditional operating systems limit flexibility, performance and utilization of hardware resources by forcing applications to use inappropriate high-level abstractions, uniform protection schemes and high-level static resource management. This forced use of inappropriate services results in poor application and operating system performance. A radical new approach to operating systems design and construction is needed to meet the requirements of modern applications. Within our Centre, we are designing BITS: the Component Based Operating System, to address these issues. To realize its full potential, BITS requires a radically new resource management strategy. The operating system design gives an environment for implementing extensions, but a resource manager module is responsible for making them available. It allows system services to be specialized, replaced or extended to better serve application-specific needs. In this paper we propose the MAGNET Resource Manager enabling a free-market negotiation of application requests and server resources. It provides an additional level of flexibility for application participation in resource management. MAGNET also provides a platform for an additional runtime level of extensibility: dynamic modification and replacement of its parts during execution.

A system for parallel media processing

We describe a parallel computer system for processing media: audio,video, and graphics, among others. The system supports medium to coarse grain parallelism, using a dataflow model of execution, on a range of machine architectures scaling from a single von Neumann or general purpose processor (GPP) up to networks of several hundred heterogeneous processors. A distributed resource manager, extending or subsuming the functionality of a traditional operating system, is an integral and necessary part of the system. While we are building a system for processing a variety of media, in this paper we concentrate on video because it provides an extreme case in terms of both data rates and available parallelism.

Multithreaded transaction processing in distributed systems

Distributed operating systems are potentially more powerful than traditional operating systems due to their advantages of fault tolerance, parallelism, scalability, reliability, resource sharing and availability. The price to pay for such power is the complexity encountered in software design and implementation of such systems. Various software tools like Remote Procedure Calls (RPC) have been devised to help simplify the process of building distributed applications. Light-weight processes or threads is another such tool that helps improve system performance. In this project, support for atomic transactions has been provided on an existing RPC system. By incorporating a multithreaded architecture in this system, the goal of improving performance has also been attempted. A traditional banking system has been prototyped along the above goals of combining high performance with support for atomic transactions in distributed systems.

Customized Message Passing

Replacing traditional operating systems communication implementations with customized implementations increases the performance of parallel and distributed applications. This paper describes the design and implementation of customizable message passing systems. The customized message passing systems are generated using application-specific information such as the profile of an application's communication pattern. FFT, Simplex, and Cholesky are used as example parallel applications. The message passing system has also been customized for different types of distributed system services including a distributed scheduling facility. The customized message passing system likewise improves the performance of these facilities and enhances their scalability. As a practical concern, as there are a large number of possible optimizations, object-oriented frameworks are employed to organize the implementations and to facilitate the choice of optimizations.

A High Performance Message-Passing System for Network of Workstations

With the proliferation of Network of Workstations (NOW) environment, there has been a great demand for a high performance message-passing system to implement High Performance Distributed Computing (HPDC) applications over NOW environment. NYNET (ATM wide area network testbed in New York state) Communication System (NCS) is a multithreaded message-passing system developed at Syracuse University that provides low-latency and high-throughput communication services over the Asynchronous Transfer Mode (ATM) based HPDC environment. NCS provides High Performmance Application Communication Interface (HPI) to support applications that demand high-throughput and low-latency communication services. This paper outlines the general architecture of NCS and presents the implementation approach of NCS HPI over an ATM network. This interface has been developed by modifying Fore Systems‘ ATM Application Programming Interface (API) and its device driver. NCS HPI uses read/writetrap routines to bypass traditional operating system calls and kernel-level communication interface (e.g. UNIX System V Streams). It reduces latency, data transfer time, and avoid using traditional communication protocols (e.g., TCP/IP). This substantially improves the communication performance.

The EOS laboratory environment for a course in operating systems

This paper describes a laboratory environment for teaching operating systems. The EOS (Exploratory Operating Systems) lab was developed with a National Science Foundation ILI grant to be used in conjunction with a traditional operating systems (OS) course. The main goal of the EOS project was to improve the teaching of operating system principles without the necessity of a special purpose laboratory and the addition to the curriculum of a second course in OS. The EOS labs are summarized and a CPU scheduling lab is described in some detail. A standardized testing instrument was used to compare class performance before and after adding the lab to the OS course. Preliminary results show an improvement attributable to the EOS laboratory. The author's experience in building a workstation laboratory from an externally funded grant is described.