Implementing new operating systems is tedious, costly, and often impractical except for large projects. The Flux OSKit addresses this problem in a novel way by providing clean, well-documented OS components designed to be reused in a wide variety of other environments, rather than defining a new OS structure. The OSKit uses unconventional techniques to maximize its usefulness, such as intentionally exposing implementation details and platform-specific facilities. Further, the OSKit demonstrates a technique that allows unmodified code from existing mature operating systems to be incorporated quickly and updated regularly, by wrapping it with a small amount of carefully designed “glue” code to isolate its dependencies and export well-defined interfaces. The OSKit uses this technique to incorporate over 230,000 lines of stable code including device drivers, file systems, and network protocols. Our experience demonstrates that this approach to component software structure and reuse has a surprisingly large impact in the OS implementation domain. Four real-world examples show how the OSKit is catalyzing research and development in operating systems and programming languages. 1

Although multicast is an important communication primitive for parallel programming, many modern networks do not support it in hardware. Multicast can be implemented in software on such networks, using some spanning tree protocol. Making multicast reliable, however, is a difficult problem, even if the hardware point-to-point communication is reliable. The key issue is that a flow control mechanism is needed to prevent overflow of software buffers. Without flow control, messages may have to be dropped, resulting in unreliable communication. Flow control for multicast communication is hard, because buffer space at many processors is involved. This paper describes a reliable multicast algorithm, using a flow control method based on a credit scheme. It also describes the implementation of the algorithm on Myrinet, which supports reliable point-to-point communication but no multicast. Our multicast algorithm has been implemented by extending the Illinois Fast Messages software. To ...

Panda is a virtual machine designed to support portable implementations of parallel programming systems. It provides communication primitives and thread support to higher-level layers (such as a runtime system). We have used Panda to implement four parallel programming systems: Orca, data parallel Orca, PVM, and SR. The paper describes our experiences in implementing these systems using Panda and it evaluates the performance of the Panda-based implementations. 1 Introduction Portability is one of the most important issues in designing parallel software. The portability of parallel applications can be enhanced by using portable programming systems, but this leaves many of the problems to the implementor of such systems. In particular, it is difficult to obtain both portability and efficiency. In our research on the Orca [2] programming system, we use the well-known implementation technique of a virtual machine to achieve portability. We have designed a virtual machine, called Panda [4]...

We present a generalization of Java's Remote Method Invocation model (RMI) providing an efficient group communication mechanism for parallel programming. Our Group Method Invocation model (GMI) allows methods to be invoked either on a single object or on a group of objects, the latter possibly with personalized parameters. Likewise, result values and exceptions can be returned normally (as with RMI), discarded, or, when multiple results are produced, combined into a single result. The different method invocation and reply handling schemes can be combined orthogonally, allowing us to express a large spectrum of communication mechanisms of which RMI and MPI-style collective communication are special cases. With GMI, the invocation and reply schemes can be selected for each method individually at run time.

Java provides a clean object-oriented programming model and allows for inherently systemindependent programs. Unfortunately, Java has a limited concurrency model, providing only threads and remote method invocation (RMI). The JR programming language extends Java to provide a rich concurrency model, based on that of SR. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, asynchronous communication, rendezvous, and dynamic process creation. JR’s concurrency model stems from the addition of operations (a generalization of procedures) and JR supports the redefinition of operations through inheritance. JR programs are written in an extended Java and then translated into standard Java programs. The JR run-time support system is also written in standard Java. This paper describes the JR programming language and its implementation. Some initial measurements of the performance of the implementation are also included.

. Many high speed networks have been developed that may be suitable for parallel computing on clusters of workstations. This paper compares three different networks: FastEthernet, ATM, and Myrinet. We have implemented the Panda portability layer on all three networks, using the same host machines and as much the same software as possible. We compare the latency and throughput for Panda's point-to-point and multicast communication on the three networks and analyze the performance differences. 1 Introduction The suitability of a cluster of workstations for parallel computing depends strongly on the local area network (LAN) that interconnects the machines. Whereas massively parallel processors (e.g., the SP-2) use efficient, specially-designed switching networks, workstation clusters typically use off-the-shelf LANs. With traditional LANs such as 10 Mpbs Ethernet, the relative communication overhead is high and will even get worse as processors become faster. Fortunately, many high speed...

. This paper presents a technique for specifying and reasoning about the operational semantics of distributed programming languages. We formalize the concept of "vertical stacking" of distributed systems, an extension of Joyce's, Windley's and Curzon's stacking methodologies for sequential systems and of the CLI "short stack" which stacks interpreters for object code, assembly code, and a high-level sequential language. We use a state transition model to account for the issues of atomicity, concurrency and nondeterminism at all levels in our stack. A correctness definition is given, which for each pair of adjacent language semantics and mappings between them, produces proof obligations corresponding to the correctness of the language implementation. We present an application of the method to a two-level stack: the microSR distributed programming language and a multi-processor instruction set, which is the target language for a compiler for microSR. We also present the development of a ...

Microkernels provide a core set of abstractions; these usually include threads, interprocess communication (IPC), and memory regions. These abstractions are used to implement higher-level operating system functionality, such as file systems and network protocols. However, programming these low-level abstractions is cumbersome and error-prone. Using a concurrent programming language can raise the level of abstraction in which users write programs, thus hiding details such as thread management, data marshaling, and error handling. The MkSR project focuses on developing high-performance, microkernel-based implementations of the SR concurrent programming language. This paper describes experience implementing a version of MkSR on the Mach microkernel, and presents design rationale and initial performance results. Keywords: Concurrent Programming Language Implementation, Distributed and Parallel Computing, SR, Microkernels 1 Introduction The basic goal of a microkernel is to provide an eff...

A run-time system is the glue between the compiler-generated code and the underlying platform. In addition to having a significant impact on performance, run-time systems are also largely responsible for the degree of portability of a language implementation. Concurrent programming languages are particularly dependent on threads and communication, both of which can vary greatly from platform to platform. This paper presents our current work in developing a portable run-time system for the SR programming language. We argue that portability must be addressed at multiple layers in a run-time system, and not just in a single virtual machine layer. We also present detailed design issues of our run-time system, especially with respect to the thread interface. Performance results are presented for three Linux-based thread packages. Although our work focused on the SR implementation, our overall approach and general observations should also be applicable to implementations of other concurrent ...

i Integrating Concurrency Constructs with Object-Oriented Programming