Resource management in a multicore operating system

Trends in hardware design have led to processors with many cores on a single die, which present the opportunity for commodity computing to become increasingly parallel. These multicore architectures bring with them complex memory and cache hierarchies and processor interconnects. While the execution of batch parallel applications has been researched in the context of high-performance computing (HPC), commodity hardware is evolving at a faster pace than specialized supercomputers and applications are interactive, requiring fast system response times and the ability to react to ad-hoc workload changes. Leveraging and managing the existing potential for parallelization thus presents a difficult challenge for the development of both commodity operating systems and application programs, which have to keep up with hardware developments and present nimble solutions. This dissertation presents the design and implementation of operating system mechanisms to support the execution of a dynamic mix of interactive and parallel applications on commodity multicore computers. The main goals are to provide a system that is scalable with an increasing number of processor cores, is agile with a changing hardware architecture, and provides interactive response time to the user when running a mix of parallel, interactive applications. I describe a new operating system architecture, the Multikernel, and report about a concrete implementation of it, called Barrelfish. The Multikernel takes a novel view on the underlying hardware architecture: as a network of autonomous, heterogeneous processors. The Barrelfish operating system is structured as a distributed system of servers to facilitate easy restructuring of OS services according to the hardware architecture. Applying techniques from the field of distributed systems, Barrelfish demonstrates that the operating system can scale and perform equally well as manually tuned operating systems, like Linux, and in some cases better, while remaining agile with a range of different multicore systems. I present the design and implementation of the inter-process communication system and process scheduler within Barrelfish and show how it can be made scalable and agile by applying the Multikernel design principles. Finally, I apply the gang scheduling technique from HPC and show how it can be made nimble to support interactive response times via a novel technique called phase-locked scheduling to support scheduling a dynamic mix of parallel, interactive applications.