Intuitively, we want to amortize spinups across multiple disk operations, which benefits from encouraging more bursty behavior. The key to more effectively manipulating the spinup/spindown behavior is shaping the disk access patterns to take advantage of this cost-sharing benefit within the debiting policy.
Pricing disk accesses can be used to reward a task for performing disk accesses in bursts. One approach we investigate sets the entry price of a disk access that requires a spinup cost much higher than the actual cost. When the access is actually permitted, we then debit the actual cost. This forces the task to accumulate enough currentcy to ensure that it can execute for a reasonable amount of time following the first access in hopes of generating more disk accesses while the disk is spinning.
We augment this pricing policy with the ability of tasks to bid on disk accesses. Tasks can indicate they are willing to contribute certain amounts toward the price of spinning up the disk. This is a natural place for API extensions. However, the OS can apply this technique transparently by checking the task's budget for sufficient surplus, analogous to a credit check. One goal of this technique is to enable multiple tasks to pool their currentcy and cooperatively use the disk in an energy-efficient manner.
Traditional techniques of skewing access patterns are amenable to currentcy-based variations. These include exploiting block caching and delaying writes while the disk is not spinning, piggybacking prefetching upon requests that spin up the disk on demand, and managing the buffer allocation. Thus, we explore a buffer allocation policy tied to the average disk access cost. Subject to limitations on the number of buffers systemwide, this policy attempts to reduce the costs (via effective prefetching, delayed writes) and make them uniform across tasks (which can tend to synchronize tasks into producing batches of disk activity).
We trigger prefetching operations and flushing of delayed writes that
cause spinups using a bidding function based on the fraction of
consumed buffers. Investigating the range of potentially useful
bidding functions is clearly beyond the scope of this paper. We
provide results for one bidding function that sets a bid offer to zero
if less than 80% of the prefetch buffers are consumed otherwise to a
weighted linear value (
. This corresponds to a
function where value is greatly increased as the task nears a demand
fetch. The disk flush daemon performs a large number of writes once
it starts flushing pages to a spinning disk, writing back all dirty
pages that have been idle for a more than 5 seconds. By contrast, the
default Linux page flush policy is to check every 5 seconds for dirty
pages that have not been accessed for 30 seconds and write those to
disk.