The electrical power used by all classes of computers is becoming of increasing importance. A major component of the cost of running large server operations is power, and, on the other end, the utility of laptops, palmtops, pads, and other portable devices is highly constrained by their batteries? capacity to power operations. One important element of the power used by computers is that burned by the operating system, the software that controls the computer?s operation. Little is known about the impact different operating system options have on a machine?s power budget, due to difficulties with existing technology in precisely measuring power use and correctly ascribing power expended to its true source. Thus, determining if scheduling algorithm alternatives, different forms of memory management, or different security options offered by the operating system have good, bad, or neutral power impacts has been difficult. The Kalipers project will address this issue by using new technology to obtain detailed and reliable information about how important operating system components affect machine power use. Kalipers will achieve this goal through a program of experimentation using a unique hardware/software platform called LEAP. The LEAP platform, which we have already built and tested, allows fine-grained assignments of power use to particular piece of code. It also measures the differing power consumption by important system components, such as the CPU, the memory, and the hard drive. We will use the LEAP?s capabilities to determine how operating system actions and decisions affect the power use of platforms that have strong needs to minimize their power budget. Our experiments will be concentrated in three areas: file systems, memory management, and security services. These are areas we have experience in and where we have reason to believe power savings can be found. We will investigate alternative technologies (such as the power costs of different file systems, or software vs. hardware full disk encryption). The LEAP technology will allow us to dive more deeply into the power costs of different system components, allowing us to shed light on issues like the degree to which higher power costs for ext3 are due to its implementation details and the degree to which they are inherent in the journaling nature of that file system. We will also reimplement key components of the operating system to demonstrate how the knowledge we have gained can be used to improve a system?s power consumption.
As we rely ever more heavily on computers to run our modern world, they require an ever-increasing amount of power. Minimizing the power a computer requires to perform its operations is thus extremely important. However, existing techniques for measuring computersâ€™ power consumption are inadequate. A commonplace among engineers is that one cannot optimize what one cannot measure. The available techniques to measure a machineâ€™s power use tend to rely on attaching power meters to the machineâ€™s power cord, or using a rough heuristic that the amount of time a computer requires to do something is closely related to the amount of power it uses for that purpose. While these techniques are somewhat accurate at a rather gross level, they offer little help in determining whether making changes to some particular piece of software will result in more power use, less power use, or no difference. The Kalipers project addressed this issue in the particular context of system software, which includes the operating system that sits below all user applications and controls the computerâ€™s hardware. Kalipers used a combination of minor hardware alterations and software analysis to provide, for the first time, a detailed, accurate measurement of how much power was used to run a particular piece of system software. Knowing this, software developers could determine whether that piece of code performed a critical, power-expensive operation whose optimization would make a huge difference, or if that code represented a rarely-performed function that used little power. Further, experimental changes could be compared to the previous versionâ€™s behavior, telling the developers if they had improved power use. We demonstrated the Kalipers approach by applying our experimental system to several operating system functions, measuring their power behavior and seeking opportunities to improve it. For example, we performed a detailed analysis of Linuxâ€™s file I/O subsystem, which handles all file reads and writes, and thus is heavily used and of critical importance. Moreover, it typically uses a disk drive to store and retrieve this data; disk drives consume a great deal of power when actively used. This investigation was challenging because modern file I/O systems perform many complex operations to improve the speed of file I/O, including caching, batching multiple requests, and scheduling when to use the disk hardware for particular reads and writes. As a result, the code that handles one particular read or write tends not to be done all at once, but is interspersed with many other system operations. That makes determining the power cost of one particular I/O challenging. To do so, in addition to adding software probes into appropriate places in the operating system, we had to tag system resources related to particular I/O operations to allow us to determine which I/O was being serviced by the OS code. As another example, on modern computers, there are several pieces of hardware that can run instructions. These are called cores, and a computer might have four or more cores, which allows it to potentially run that many programs simultaneously. This requires the computerâ€™s operating system to decide which of several programs to run on which core at any given instant. There are detailed performance issues related to the costs of running programs on particular cores. For example, if two programs both need exclusive access to the same data, they cannot be run simultaneously, so putting them on two separate cores will likely not improve their performance. One of them will always be waiting for access to the shared data, while the other is using it. The power implications of how these scheduling decisions are made were particularly murky. We used our Kalipers approach to measure the power use resulting from different choices. Based on that, we built a new scheduler algorithm that made better choices from a power use perspective. It was able to reduce power use by 30%. The Kalipers hardware and software was improved during our project to make it usable by other researchers, even those in different parts of the world. We provide remote access and control of our testbed, allowing researcher in, for example, Brazil to measure the power used by system security software they were developing. We improved the software tools to make use of our system extremely easy. A modestly adept programmer can, within half an hour, instrument his code, compile it, run it on the testbed, obtain the results, and plot them to see how much power was used in his experiment. The Kalipers approach thus offers a realistic, easily usable method of determining how to optimize the power use of the systems used by both individual people and the largest corporations. This research thus promises to revolutionize our ability to reduce power use by computers. We have been in frequent consultation with major industry players, such as Intel, to discuss incorporation of our technology in their future products.