Gerd Zellweger

SpaceJMP: Programming with Multiple Virtual Address Spaces

Memory-centric computing demands careful organization of the virtual address space, but traditional methods for doing so are inflexible and inefficient. If an application wishes to address larger physical memory than virtual address bits allow, if it wishes to maintain pointer-based data structures beyond process lifetimes, or if it wishes to share large amounts of memory across simultaneously executing processes, legacy interfaces for managing the address space are cumbersome and often incur excessive overheads. We propose a new operating system design that promotes virtual address spaces to first-class citizens, enabling process threads to attach to, detach from, and switch between multiple virtual address spaces. Our work enables data-centric applications to utilize vast physical memory beyond the virtual range, represent persistent pointer-rich data structures without special pointer representations, and share large amounts of memory between processes efficiently. We describe our prototype implementations in the DragonFly BSD and Barrelfish operating systems. We also present programming semantics and a compiler transformation to detect unsafe pointer usage. We demonstrate the benefits of our work on data-intensive applications such as the GUPS benchmark, the SAMTools genomics workflow, and the Redis key-value store.

Customized OS support for data-processing

For decades, database engines have found the generic interfaces offered by the operating systems at odds with the need for efficient utilization of hardware resources. As a result, most engines circumvent the OS and manage hardware directly. With the growing complexity and heterogeneity of modern hardware, database engines are now facing a steep increase in the complexity they must absorb to achieve good performance. Taking advantage of recent proposals in operating system design, such as multi-kernels, in this paper we explore the development of a light weight OS kernel tailored for data processing and discuss its benefits for simplifying the design and improving the performance of data management systems.

Unifying synchronization and events in a multicore OS

In this paper, we argue that an operating system structured as a distributed system needs a coordination and a name service to make OS services work correctly. While a distributed structure allows applying algorithms from the distributed field, it also suffers from similar problems like synchronization, naming, distributed locking and coordination of service instances. Octopus, our solution to this problem in the context of a real OS, provides an easy-to-use, high-level, uniform coordination service with events at reasonable performance. Based on this service, we describe three real use cases: device management, OS service registry and boot-up coordination.

So many performance events, so little time

Many modern workloads are a heterogeneous mix of parallel applications running on machines with complex processors and memory systems. These workloads often interfere with each other by contending for the limited set of resources in a machine, leading to performance degradation. In principle, one can use hardware performance counters to characterize the root causes of interference inside a modern machine. However, we show that current facilities in todays operating systems mean that such an analysis requires careful consideration of the intricacies of specific hardware counters, domain knowledge about the applications, and a deep understanding of the underlying hardware architecture. In contrast, we present the design of Glatt, which is able to automatically identify the root causes of interference in a machine online. Glatt can expose this information to a runtime or the operating system for predicting better thread assignments or for dynamically increasing/decreasing parallelism within each runtime.