Alessandro Forin

Mach: a system software kernel

The Mach operating system can be used as a system software kernel which can support a variety of operating system environments. Key elements of the Mach design which allow it to efficiently support system software include integrated virtual memory management and interprocess communication, multiple threads of control within on address space, support for transparent system trap callout, and an object programming facility integrated with the Mach IPC mechanisms.<<ETX>>

Multilanguage parallel programming of heterogeneous machines

A system called Agora was designed and implemented that supports the development of multilanguage parallel applications for heterogeneous machines. Agora hinges on two ideas: the first one is that shared memory can be a suitable abstraction to program concurrent, multilanguage modules running on heterogeneous machines. The second idea is that a shared memory abstraction can be efficiently supported across different computer architectures that are not connected by a physical shared memory, e.g., local area network workstations or ensemble machines. Agora has been in use for more than a year. The authors describe the Agora shared memory and its software implementation on both tightly and loosely coupled architectures. Measurements of the current implementation are also included. >

Mach: a foundation for open systems (operating systems)

An alternative approach to building an entire operating system (OS) separating those parts of the OS that control the basic hardware resources (the kernel) from those that determine the unique characteristics of an OS environment, is examined, taking the Mach kernel as an example. Mach features which support OS emulation are discussed. In-kernel and out-of-kernel emulation are described. Two instances of the latter approach, the multithreaded Unix server and the multiserver Unix, are considered. Related work and Mach availability are addressed.<<ETX>>

Using microbenchmarks to evaluate system performance

An implicit assumption underlying the use of microbenchmarks is that the time required for the microbenchmark to exercise the code path in question is the same as it when the code path is used by real programs. The vulnerability of this assumption is demonstrated by showing the significant variation that can occur with even simple microbenchmarks. The behavior of cache memory can distort the performance of a microbenchmark. Cache collisions can occur between memory in the same address space, or between memory in different address spaces. Flushing the cache while running a microbenchmark and counting memory accesses, rather than instructions, are two techniques for reducing the variability of results. It is stressed that it is important to understand low-level details about architectural implementation when interpreting microbenchmarks.<<ETX>>

Debugging of heterogeneous parallel systems

The Agora system supports the development of heterogeneous parallel programs, e.g. programs written in multiple languages and running on heterogeneous machines. Agora has been used since September 1986 in a large distributed system [1]: Two versions of the application have been demonstrated in one year, contrary to the expectation of two years per one version. The simplicity in debugging is one of the reasons of the productivity speedup gained. This simplicity is due both to the deeper understanding that the debugger has of parallel systems, and to a novel feature: the ability to replay the execution of parallel systems built with Agora. A user is able to exactly repeat for any number of times and at a slower pace an execution that failed. This makes it easy to identify time-dependent errors, which are peculiar to parallel and distributed systems. The debugger can also be customized to support user defined synchronization primitives, which are built on top of the system provided ones. The Agora debugger tackles three set of problems that no parallel debugger in the past has simultaneously addressed: dealing with programming-in-the-large, multiple processes in different languages, and multiple machine architectures.