Abstract:
As manufacturing feature geometries continue to shrink, component variability plays an increasingly large role in determining a system’s power consumption. Specifically, prior work has illustrated that variations in sleep power caused by manufacturer variation can have a very large effect on system lifetime and consequently application quality for low power devices.
We provide an extension to the FreeRTOS operating system that tunes task activations and duty cycling rates in order order to maximize total system quality in the face of an energy budget. This is accomplished by introducing task knobs --- variables defined by the application developer that affect either the frequency or duration of a task. The scheduler determines values for any given knob according to a reward function, task priorities, and the individual power consumption characteristics of the hardware executing the tasks. Accounting for hardware variability requires accurate instance models. We evaluate the potential for learning various models online---per-instance sleep power vs. temperature, deployment temperature profiles, knob value vs. duty cycle ratio, etc. We evaluate the proposed variability-aware RTOS using the QEMU simulation suite with added variability extensions.
In the proposed variability-aware task scheduler, we consider a general case where utility is non- homogeneous across tasks and is defined by the utility function u(d), d being the duty cycle in [0,1]. Usually, the utility of a task will increase to some threshold where an increase in d no longer yields an appreciable increase in u.We define each task as an application Ai={Fi,ui(d),ki,kmiin,kmiax,pi}, where Fi is the application handle, ui(d) is the utility function, k is a user-provided knob that presumably will have a proportionate increase in the quality of the task, kmin and kmax are the minimum and maximum acceptable knob values for Ai, and pi in R+ is the pseudo-priority (read utility scalar) of application Ai. Upon task creation, the OS will enter a learning period wherein it will perturb the task knob and measure the corresponding execution time. This yields a mapping per task from knob value to duty cycle ratio. Once this mapping has converged for all tasks, the OS arrives at and assigns an optimal task knob for all active tasks. This is done by successive incrementation of duty cycle per-task where priority is given to tasks with the highest marginal utility determined from ui(d) and the mapping k -> d. This assumes that utility is monotonically non-decreasing, and rather than rely on the user to provide some function of quality per task we transfer this burden to the OS, where ui(d) is modeled as a logistic sigmoid function reachingmaximumvalueatkmiax.
The resulting OS has almost negligible code overhead as seen by the user, while intelligently achieving a lifetime goal within the bounds of reason as specified by the user and each specific application. This variability-aware OS is implemented as an extension to the FreeRTOS kernel—a preemptable embedded RTOS. The extension comprises 830 LoC, giving a 7% code overhead and 52.7% overhead in ROM from 10.7 kB to 16.4 kB. Memory per task is increased from 64 bytes to 86 bytesa 34% increase. Variability-tasks are created through a new API, taking as an input the user-provided knob address.