The most dramatic gains in compute density in the last decade have come from graphics processing units (GPUs) rather than central processing units (CPUs). Unfortunately, current operating systems (OSes) do not provide the same kind of high-level programming abstractions for GPUs that applications expect for other resources like CPUs, input devices, and file systems. OSes hide GPUs behind an awkward ioctl interface, shifting the burden of abstraction onto user libraries and run-times.
New technologies require new abstractions. Rich interfaces like recognizing gestures, brain-computer interfaces, and audio/visual interfaces are highly compute-intensive. Because they process voluminous data under real-time constraints, they are beyond the capabilities of modern CPUs. These workloads rely on data-parallel algorithms, making GPUs an ideal resource to accelerate these tasks, but some form of OS support is required to ensure safe interaction with the user.
The SymbiOS model is a fundamental reorganization of kernel abstractions for managing interactive, massively parallel devices. The kernel must expose enough of the hardware detail of GPUs to allow programmers to take advantage of their enormous processing capabilities, but must hide programmer inconveniences like memory that is incoherent between the CPU and GPU. Under the SymbiOS model, GPUs are promoted to first-class computing resources, with traditional OS guarantees such as fairness and isolation.
The goal of this project is the design and development of OS abstractions for GPUs, and implementation of several case-studies including a gesture-driven UI that leverages the SymbiOS Model to deliver real-time performance on commodity GPU hardware.
Graphical processing units (GPUs) have a highly parallel internal structure that allows them to compute certain algorithms moreefficiently than central processing units (CPUs). GPUs are efficientfor problems that apply nearly identical functions to different inputdata. Because of their computational efficiency, GPUs have become theprocessor of choice for many types of intensively parallel computations from data mining to molecular dynamics simulations. As GPUs have matured and acquired increasingly general-purpose processing capabilities, a richer and more powerful set of languages, tools, and computational algorithms have evolved to make use of GPU hardware. Unfortunately, GPU programming models are still almost entirely lacking core system abstractions, such as files and sockets, that CPU programmers have taken for granted for decades. Today's GPU is a bit of an idiot savant: it is capable of amazing computational feats when spoon-fed with the right data and micro-managed by application code on the host CPU. However, it is incapable of initiating even the simplest system interactions for itself, such as reading an input file from a disk. The traditional coprocessor-style GPU programming model requires developers to explicitly manage GPU I/O on the host CPU, which increases the design complexity and code size of even simple GPU programs that require system services. The work supported by this grant has gone into development of software prototypes that make it easier for GPU programs to access files (via GPUfs) and to connect with other machines over the network (via GPUnet). The first figure shows the design of GPUfs, where both CPU and GPU applications can access files and the system optimizes locality by caching those files in the memory where it is being used. The second figure shows the design of GPUnet, where both CPU and GPU applications can create network connections, with network data being transfered directly into GPU memory.
