Multiprocessor Operating Systems Research Articles

Transparent, lightweight application execution replay on commodity multiprocessor operating systems

We present Scribe, the first system to provide transparent, low-overhead application record-replay and the ability to go live from replayed execution. Scribe introduces new lightweight operating system mechanisms, rendezvous and sync points, to efficiently record nondeterministic interactions such as related system calls, signals, and shared memory accesses. Rendezvous points make a partial ordering of execution based on system call dependencies sufficient for replay, avoiding the recording overhead of maintaining an exact execution ordering. Sync points convert asynchronous interactions that can occur at arbitrary times into synchronous events that are much easier to record and replay. We have implemented Scribe without changing, relinking, or recompiling applications, libraries, or operating system kernels, and without any specialized hardware support such as hardware performance counters. It works on commodity Linux operating systems, and commodity multi-core and multiprocessor hardware. Our results show for the first time that an operating system mechanism can correctly and transparently record and replay multi-process and multi-threaded applications on commodity multiprocessors. Scribe recording overhead is less than 2.5% for server applications including Apache and MySQL, and less than 15% for desktop applications including Firefox, Acrobat, OpenOffice, parallel kernel compilation, and movie playback.

Improving server software support for simultaneous multithreaded processors

Simultaneous multithreading (SMT) represents a fundamental shift in processor capability. SMT's ability to execute multiple threads simultaneously within a single CPU offers tremendous potential performance benefits. However, the structure and behavior of software affects the extent to which this potential can be achieved. Consequently, just like the earlier arrival of multiprocessors, the advent of SMT processors prompts a needed re-evaluation of software that will run on them. This evaluation is complicated, since SMT adopts architectural features and operating costs of both its predecessors (uniprocessors and multiprocessors). The crucial task for researchers is to determine which software structures and policies - multi-processor, uniprocessor, or neither - are most appropriate for SMT.This paper evaluates how SMT's changes to the underlying hardware affects server software, and in particular, SMT's effects on memory allocation and synchronization. Using detailed simulation of an SMT server implemented in three different thread models, we find that the default policies often provided with multiprocessor operating systems produce unacceptably low performance. For each area that we examine, we identify better policies that combine techniques from both uniprocessors and multi-processors. We also uncover a vital aspect of multi-threaded synchronization (interaction with operating system thread scheduling) that previous research on SMT synchronization had overlooked. Overall, our results demonstrate how a few simple changes to applications' run-time support libraries can dramatically boost the performance of multi-threaded servers on SMT, without requiring modifications to the applications themselves.

Minimizing the Flow Time Without Migration

We consider the classical problem of scheduling jobs in a multiprocessor setting in order to minimize the flow time (total time in the system). The performance of the algorithm, both in offline and online settings, can be significantly improved if we allow preemption, i.e., interrupt a job and later continue its execution, perhaps migrating it to a different machine. Preemption is inherent to make a scheduling algorithm efficient. While in the case of a single processor most operating systems can easily handle preemptions, migrating a job to a different machine results in a huge overhead. Thus, it is not commonly used in most multiprocessor operating systems. The natural question is whether migration is an inherent component for an efficient scheduling algorithm in either the online or offline setting. Leonardi and Raz [Proceedings of the Twenty-Ninth Annual ACM Symposium on Theory of Computing, El Paso, TX, 1997, pp. 110--119] showed that the well-known algorithm, shortest remaining processing time (SRPT), performs within a logarithmic factor of the optimal offline algorithm. Note that SRPT must use both preemption and migration to schedule the jobs. It is not known if better approximation factors can be reached and thus SRPT, although it is an online algorithm, becomes the best known algorithm in the offline setting. In fact, in the online setting, Leonardi and Raz showed that no algorithm can achieve a better bound. Without migration, no (offline or online) approximations are known. This paper introduces a new algorithm that does not use migration, works online, and is just as effective (in terms of approximation ratio) as the best known offline algorithm that uses migration.

Guest editorial on multiprocessor operating systems

Guest editorial on multiprocessor operating systems

Guest editorial on multiprocessor operating systems

Guest editorial on multiprocessor operating systems

Multiprocessor Operating Systems: Harnessing The Power

The five articles in this special issue cover a wide range of important topics for multiprocessor operating systems. Two focus on IPC, two focus on operating system structure, and the final one describes fault-tolerance support for distributed systems. Each is briefly summarized herein.

Trends in multiprocessor and distributed operating systems designs

This paper presents an overview of the developments in operating systems technology for distributed computing systems and multiprocessor machines. We focus on those design principles that are now widely accepted as useful design paradigms. Approaches common to distributed and multiprocessor operating systems are identified. Issues discussed include process scheduling and synchronization, load balancing, virtual and shared-memory management and parallel file systems. The task-thread model and the object model of computing are also discussed.

Hierarchical clustering: A structure for scalable multiprocessor operating system design

We introduce the concept ofhierarchical clustering as a way to structure shared-memory multiprocessor operating systems for scalability. The concept is based on clustering and hierarchical system design. Hierarchical clustering leads to a modular system, composed of easy-to-design and efficient building blocks. The resulting structure is scalable because it 1) maximizes locality, which is key to good performance in NUMA (non-uniform memory access) systems and 2) provides for concurrency that increases linearly with the number of processors. At the same time, there is tight coupling within a cluster, so the system performs well for local interactions that are expected to constitute the common case. A clustered system can easily be adapted to different hardware configurations and architectures by changing the size of the clusters. We show how this structuring technique is applied to the design of a microkernel-based operating system calledHurricane. This prototype system is the first complete and running implementation of its kind and demonstrates the feasibility of a hierarchically clustered system. We present performance results based on the prototype, demonstrating the characteristics and behavior of a clustered system. In particular, we show how clustering trades off the efficiencies of tight coupling for the advantages of replication, increased locality, and decreased lock contention.

PARALLEL PROGRAMMING ISSUES

Parallel computer architectures and hardware have evolved impressively in the last few years from the architecture and the hardware point of view. Progress on the software side can be best characterized as moderate. The lack of methodologies and software to support parallel programming is profound even on the most advanced parallel machines. Parallel programming is a complex task and the performance of a parallel program can be influenced by many different factors such as coding of parallel constructs and/or restructuring, scheduling schemes and scheduling overhead, synchronization and/or communication cost, program and data partitioning and memory allocation. In this paper we discuss the major aspects of parallel programming. Parallel programming environments are considered in three fundamental phases: parallelism specification, parallelism exploita tion and supporting environments and tools. A parallel programming environment built at the University of Illinois is discussed as a case study. Finally, we address the influence of parallel programming on multiprocessor operating systems and discuss future research directions.

Scheduler activations

Threadsare the vehicle for concurrency in many approaches to parallel programming. Threads can be supported either by the operating system kernel or by user-level library code in the application address space, but neither approach has been fully satisfactory.This paper addresses this dilemma. First, we argue that the performance of kernel threads isinherentlyworse than that of user-level threads, rather than this being an artifact of existing implementations; managing parallelism at the user level is essential to high-performance parallel computing. Next, we argue that the problems encountered in integrating user-level threads with other system services is a consequence of the lack of kernel support for user-level threads provided by contemporary multiprocessor operating systems; kernel threads are thewrong abstractionon which to support user-level management of parallelism. Finally, we describe the design, implementation, and performance of a new kernel interface and user-level thread package that together provide the same functionality as kernel threads without compromising the performance and flexibility advantages of user-level management of parallelism.

Scheduler activations

Threads are the vehicle for concurrency in many approaches to parallel programming. Threads separate the notion of a sequential execution stream from the other aspects of traditional UNIX-like processes, such as address spaces and I/O descriptors. The objective of this separation is to make the expression and control of parallelism sufficiently cheap that the programmer or compiler can exploit even fine-grained parallelism with acceptable overhead.Threads can be supported either by the operating system kernel or by user-level library code in the application address space, but neither approach has been fully satisfactory. This paper addresses this dilemma. First, we argue that the performance of kernel threads is inherently worse than that of user-level threads, rather than this being an artifact of existing implementations; we thus argue that managing parallelism at the user level is essential to high-performance parallel computing. Next, we argue that the lack of system integration exhibited by user-level threads is a consequence of the lack of kernel support for user-level threads provided by contemporary multiprocessor operating systems; we thus argue that kernel threads or processes, as currently conceived, are the wrong abstraction on which to support user-level management of parallelism. Finally, we describe the design, implementation, and performance of a new kernel interface and user-level thread package that together provide the same functionality as kernel threads without compromising the performance and flexibility advantages of user-level management of parallelism.

The run-time efficiency of parallel asynchronous algorithms

The problem studied is similar to the problems found in multiprocessor operating systems. The lockout problem in multiprocessor operating systems is a direct result of multiple processors attempting to process common data structures asynchronously. There are numerous such shared data structures. The models developed are applicable to the study of contention for software and hardware resources in multiprocessor operating systems. The authors introduce an approximate analytical model to evaluate the performance of asynchronous processes found in asynchronous algorithms, including the combined effects of software lockout on critical sections and on job queues, and of shared-memory access conflicts. Because of the strong similarities between the two effects, the same model can be used for both, leading to a uniform and elegant formulation. The models are combined to find the run-time efficiency of asynchronous iterations. >

Virtual memory and backing storage management in multiprocessor operating systems using object-oriented design techniques

The Choices operating system architecture [3, 4, 15] uses class hierarchies and object-oriented programming to facilitate the construction of customized operating systems for shared memory and networked multiprocessors. The software is being used in the Tapestry Parallel Computing Laboratory at the University of Illinois to study the performance of algorithms, mechanisms, and policies for parallel systems. This paper describes the architectural design and class hierarchy of the Choices memory and secondary storage management system. The mechanisms and policies of a virtual memory system implement a memory hierarchy that exploits the trade-offs between response times and storage capacities. In Choices , the notion of a memory hierarchy is represented by layers in which abstract classes define interfaces between and internal to the layers. Concrete subclasses implement new algorithms or data structures or specializations of existing ones. This paper describes the motivation for an object-oriented, class-hierarchical approach to virtual memory system design, and describes the overall architecture of such an approach, as it has been applied to the Choices system. Special attention is paid to the advantages in both design and implementation that have resulted from using object-oriented techniques.

Process management and exception handling in multiprocessor operating systems using object-oriented design techniques

The programming of the interrupt handling mechanisms, process switching primitives, scheduling mechanisms, and synchronization primitives of an operating system for a multiprocessor require both efficient code in order to support the needs of high-performance or real-time applications and careful organization to facilitate maintenance. Although many advantages have been claimed for object-oriented class hierarchical languages and their corresponding design methodologies, the application of these techniques to the design of the primitives within an operating system has not been widely demonstrated. To investigate the role of class hierarchical design in systems programming, the authors have constructed the Choices multiprocessor operating system architecture using the C++ programming language. During the implementation, it was found that many operating system design concerns can be represented advantageously using a class hierarchical approach, including: the separation of mechanism and policy; the organization of an operating system into layers, each of which represents an abstract machine; and the notions of process and exception management. In this paper, we discuss an implementation of the low-level primitives of this system and outline the strategy by which we developed our solution.

Why a distributed kernel?

Until now, the design of operating systems assumed the kernel as an extension of a single processor's physical layer supporting user processes in the one cpu. The present multiprocessor operating systems duplicate this set-up in multiple cpus in order to reduce complex inter-processor communication. Since the functions of a kernel in both a uniprocessor and a multiprocessor operating system have a tendency to grow in an unlimited manner, the redesign of both an intelligent and high speed kernel, becomes an important issue. In this paper, I describe firstly, a brief summary of the current status of a kernel, and secondly the future requirements of a complex operating system. Finally, I present part of a possible solution to construct a high speed kernel based on multiple processors.

Low contention semaphores and ready lists

A method for reducing semaphore and ready-list contention in multiprocessor operating systems is described. Its correctness is established. Its performance is compared with conventional implementations. A ready list implemented as a ring network is proposed and evaluated.

Insights into the implementation and application of heterogeneous local area networks

The ideal local area network is a mechanism which provides concurrent high speed error-free data paths over a limited geographical area and between any computational entities on the network. A computational entity may be a program running on any type of computer, any intelligent device, or any terminal. This means that such an ideal network must be able to support systems of cooperating processes within disjoint and dissimilar host environments. Achieving such an ideal heterogeneous network (referred to as an “open” network with respect to the ISO Reference Model for Open Systems Interconnection) may be impossible in the limit. However, the ideal shows promise of being approachable. Recent work in local area networks, protocols, and multiprocessor operating systems looks promising for attacking the problem. This paper first discusses data paths and the dilemma of heterogeneous data communications. Existing local area networks, their functionality, shortcomings, and relationship to networking standards are described. Commercial LANs are discussed and classified. Standards, high level protocols, and operating system concepts are discussed and related to networks. Finally some possible approaches to the implementation of hetergeneous networks are discussed.

On minimizing contention at semaphores

A method for reducing semaphore and ready list contention in multiprocessor operating systems is described. The method is based on tagged memory, semaphore words, and the principle of locking the individual semaphores rather than the programs that manipulate them.

On minimizing contention at semaphores

A method for reducing semaphore and ready list contention in multiprocessor operating systems is described. The method is based on tagged memory, semaphore words, and the principle of locking the individual semaphores rather than the programs that manipulate them.

Design of distributed multiprocessor operating systems

Design of distributed multiprocessor operating systems