Bolt: faster reconfiguration in operating systems

Abstract Dynamic resource scaling enables provisioning extra resources during peak loads and saving energy by reclaiming those resources during off-peak times. Scaling the number of CPU cores is particularly valuable as it allows power savings during low-usage periods. Current systems perform scaling with a slow hotplug mechanism, which was primarily designed to remove or replace faulty cores. The high cost of scaling is reflected in power management policies that perform scaling at coarser time scales to amortize the high reconfiguration latency. We describe Bolt, a new mechanism built on existing hotplug infrastructure to reduce scaling latency. Bolt also supports a new bulk interface to add or remove multiple cores at once. We implemented Bolt for x86 and ARM architectures. Our evaluation shows that Bolt can achieve over 20x speedup for entering offline state. While turning on CPUs, Bolt achieve speedups of 1.3x and 21x for x86 and ARM. The speedup is limited by high latency hardware intialization. On an ideal processor with zerolatency initialization, the speedup on x86 rises to 10x

Firestorm: Operating Systems for Power-Constrained Architectures

The phenomenon of Dark Silicon has made processors over-provisioned with compute units that cannot be used at full performance without exceeding power limits. Such limits primarily exist to exercise control over heat dissipation. Current systems support mechanisms to ensure system-wide guarantees of staying within the power and thermal limit. However, these mechanisms are not sufficient to provide process-level control to ensure applications level SLAs: power may be wasted on low-priority applications while high-priority ones are throttled. We built Firestorm, an operating system extension that introduces power and thermal awareness. Firestorm considers power a limited resource and distributes it to applications based on their importance. To control temperature, Firestorm also introduces the notion of thermal capacity as another resource that the OS manages. These abstractions, implemented in Firestorm with mechanisms and policies to distribute power and limit heat production, help applications to achieve guaranteed performance and stay within the system limits. In experiments, we show that Firestorm improved performance by up to 10% by avoiding thermal interference and can guarantee SLAs for soft real time applications in the presence of limited power and competing applications

Proteus: Efficient Resource Use in Heterogeneous Architectures

Current processors provide a variety of different processing units to improve performance and power efficiency. For example, ARM?S big.LITTLE, AMD?s APUs, and Oracle?s M7 provide heterogeneous processors, on-die GPUs, and on-die accelerators. However, the performance experienced by programs on these accelerators can be highly variable due to issues like contention from multiprogramming or thermal constraints. In these systems, the decision of where to execute a task will have to consider not only stand-alone performance but also current system conditions and the program?s performance goals such as throughput, latency or real-time deadlines. We built Proteus, a kernel extension and runtime library, to perform scheduling and handle task placement in such dynamic heterogeneous systems. Proteus enables programs to perform task placement decisions by choosing the right processing units with the libadept runtime, since programs are best suitable to determine how to achieve their performance goals. System conditions such as load on accelerators are exposed by the OpenKernel, the kernel component of Proteus, to the libadept enabling programs to make an informed decision. While placement is determined by libadept, the OpenKernel is also responsible for resource management including resource allocation and enforcing isolation among applications. When integrated with StarPU, a runtime system for heterogeneous architectures, Proteus improves StarPU by performing 1.5-2x better than its native scheduling policies in a shared heterogeneous environment

Dynamic Processors Demand Dynamic Operating Systems

The rise of multicore processors has lead to techniques that dynamically vary the set and characteristics of cores or threads available to the operating system. For example, Core Fusion merges multiple cores for faster processing. While the mechanics of the change, such as merging two cores into a more powerful core, can be handled by a virtualization layer, operating systems still have an interest in the exact set of cores available. For example, the read-copy-update mechanism in Linux must contact all cores to complete an update. Thus, the OS must be informed when the set of CPUs changes. We demonstrate through an analysis of a recent Linux kernel that (i) there are over 15 subsystems- each subsystem can have multiple callbacks registered – that depend on knowing the set of cores, and (ii) the existing hotplug mechanism is poorly suited to handling dynamic processors due to its poor performance and scalability. Based on this analysis, we propose two mechanisms, processor proxies and parallel and deferred hotplug to provide low-latency reconfiguration. In initial experiments, we show that we can reduce the latency of reconfiguration in Linux by 95 percent.