Real-time dynamic voltage scaling for low-power embedded operating systems

Padmanabhan PillaiK. Shin

article2001SOSP1,380 citationsSIGMOBILE Test of Time Award

Presents real-time dynamic voltage scaling algorithms that integrate processor frequency adjustments directly into embedded operating system schedulers to cut energy consumption by up to 40% without missing task deadlines.

Listen

Mobile and embedded devices such as cell phones, digital camcorders, and portable medical instruments increasingly rely on high-performance processors. This growth creates a direct conflict between computational capability and battery life. Dynamic voltage scaling saves energy by reducing processor frequency and voltage when full speed is not required. However, standard dynamic scaling methods rely on average workload feedback and disregard strict timing deadlines, making them unsafe for time-critical embedded systems where late execution causes system failure.

The article develops and evaluates real-time dynamic voltage scaling algorithms that integrate directly into operating system task schedulers to lower power consumption while strictly guaranteeing all periodic task deadlines.

The authors designed multiple algorithm variants across two standard scheduling models: rate monotonic (static priority based on task period) and earliest-deadline-first (dynamic priority based on task deadline). These techniques include static voltage scaling, cycle-conserving scaling that lowers frequency when tasks finish earlier than their worst-case estimates, and look-ahead scaling that actively defers non-urgent workloads. The authors evaluated these methods through extensive custom simulations across hundreds of synthetic task workloads and verified the results on a physical laptop testbed running modified Linux kernel modules under hardware-level power measurement.

The primary findings show that the proposed algorithms deliver large energy reductions, saving 20% to 40% of total system power on the physical hardware prototype even with non-processor overheads included. In simulations, the dynamic schemes closely approach the theoretical lower bound of energy consumption, particularly at mid-range processor workloads. Earliest-deadline-first algorithms consistently yielded greater energy savings than rate-monotonic approaches because of more flexible schedulability bounds. Furthermore, system energy savings depend heavily on the available hardware frequency-voltage levels and average workload demands, whereas the total number of tasks and processor idle power efficiency have minimal relative impact.

These results demonstrate that embedded systems can achieve substantial battery life extensions and lower thermal dissipation without sacrificing real-time reliability. Because processor power scales quadratically with operating voltage, integrating voltage scaling directly into task scheduling provides a low-overhead, highly effective software solution for power-constrained platforms.

Engineering teams developing energy-critical embedded systems should consider implementing cycle-conserving or look-ahead scheduling algorithms tailored to their hardware step profiles. System architects must also account for implementation edge cases: initial task invocations require execution margin to absorb cache and memory initialization overheads, and the admission of new tasks must be deferred until active task cycles conclude to prevent transient deadline misses. Future work should explore extending these mechanisms to probabilistic deadline guarantees and integrating dynamic voltage scaling with application-level and network power management.

The experimental findings carry high confidence as physical hardware measurements closely matched simulation models. However, users should note that the evaluation assumes independent periodic tasks with negligible scheduling overheads, and actual energy reductions in production devices will depend on the discrete voltage settings supported by the specific processor hardware.

Department of Electrical Engineering and Computer Science Real-Time Computing Laboratory University of Michigan cache cell phone embedded device real-time dynamic voltage scaling low-power embedded operating systems real-time operating system

Pillai et al (2001).pdf

No sufficiently relevant recommendations were found.

Paper: Managing energy and server resources in hosting centers, Jeffrey S. Chase et al. (2001). Expands dynamic power management from single-system CPU voltage scaling to cluster-level server provisioning and energy management under fluctuating workloads.
Paper: Power provisioning for a warehouse-sized computer, Xiaobo Fan et al. (2007). Scales power-aware management principles up to warehouse-scale computing infrastructure by analyzing aggregate server utilization and aggregate power provisioning.
Paper: Dark silicon and the end of multicore scaling, Hadi Esmaeilzadeh et al. (2011). Investigates the long-term hardware limitations that emerge when traditional voltage and multicore scaling breakdown under strict thermal and power limits.

Cover for Real-time dynamic voltage scaling for low-power embedded operating systems

Abstract

In recent years, there has been a rapid and wide spread of non-traditional computing platforms, especially mobile and portable computing devices. As applications become increasingly sophisticated and processing power increases, the most serious limitation on these devices is the available battery life. Dynamic Voltage Scaling (DVS) has been a key technique in exploiting the hardware characteristics of processors to reduce energy dissipation by lowering the supply voltage and operating frequency. The DVS algorithms are shown to be able to make dramatic energy savings while providing the necessary peak computation power in general-purpose systems. However, for a large class of applications in embedded real-time systems like cellular phones and camcorders, the variable operating frequency interferes with their deadline guarantee mechanisms, and DVS in this context, despite its growing importance, is largely overlooked/under-developed. To provide real-time guarantees, DVS must consider deadlines and periodicity of real-time tasks, requiring integration with the real-time scheduler. In this paper, we present a class of novel algorithms called real-time DVS (RT-DVS) that modify the OS’s real-time scheduler and task management service to provide significant energy savings while maintaining real-time deadline guarantees. We show through simulations and a working prototype implementation that these RT-DVS algorithms closely approach the theoretical lower bound on energy consumption, and can easily reduce energy consumption 20% to 40% in an embedded real-time system.

1. INTRODUCTION
2. RT-DVS
2.1 Why DVS?
2.2 Real-time issues
2.3 Static voltage scaling
2.4 Cycle-conserving RT-DVS
2.5 Look-Ahead RT-DVS
2.6 Summary of RT-DVS algorithms
3. SIMULATIONS
3.1 Simulation Methodology
3.2 Simulation Results
4. IMPLEMENTATION
4.1 Hardware Platform
4.2 Software Architecture
4.3 Measurements and Observations
5. RELATED WORK
6. CONCLUSIONS AND FUTURE DIRECTIONS
7. REFERENCES

Knowls

Knowl 1 — Look-Ahead Real-Time Dynamic Voltage Scaling Algorithm for EDF (laEDF)
algorithm
Look-Ahead RT-DVS for Earliest-Deadline-First (laEDF) scheduling minimizes processor operating frequency and voltage by greedily deferring task execution as far into the future as possible without violating any task deadline. It calculates the minimum cycle budget, $s$ , that must be executed before the earliest task deadline $D_n$ , assuming tasks with earlier deadlines will require their full worst-case computation time in future periods.
Input: Periodic task set $T = \{T_1, T_2, \dots, T_n\}$ sorted such that $D_1 \le D_2 \le \dots \le D_n$ , available CPU frequencies $\{f_1, \dots, f_m\}$ with $f_1 < \dots < f_m$ , worst-case execution cycles $C_i$ , periods $P_i$ , and deadlines $D_i$ .
State: $c\_left_i$ (remaining worst-case computation cycles for task $T_i$ in current invocation).
procedure select_frequency(x):
    use lowest frequency $f_i \in \{f_1, \dots, f_m\}$ such that $x \le f_i / f_m$
procedure defer():
    set $U = \sum_{j=1}^n (C_j / P_j)$
    set $s = 0$
    for $i = n$ down to 1: /* Traverse in reverse EDF order */
        set $U = U - (C_i / P_i)$
        set $x = \max(0, c\_left_i - (1 - U) \cdot (D_i - D_n))$
        set $U = U + (c\_left_i - x) / (D_i - D_n)$
        set $s = s + x$
    select_frequency( $s / (D_n - \text{current\_time})$ )
upon task_release( $T_i$ ):
    set $c\_left_i = C_i$
    defer()
upon task_completion( $T_i$ ):
    set $c\_left_i = 0$
    defer()
during task_execution( $T_i$ ):
    decrement $c\_left_i$ by elapsed cycles
The algorithm executes in $O(n)$ time at each scheduling event (task release or task completion) assuming the task queue remains sorted by deadline.
Knowl 2 — Cycle-Conserving Real-Time Dynamic Voltage Scaling for EDF (ccEDF)
algorithm
Cycle-Conserving RT-DVS for EDF (ccEDF) dynamically adjusts the operating frequency by reclaiming unused worst-case cycles upon task completion. While a task is active, its worst-case processor utilization $C_i / P_i$ is assumed. Upon completion of invocation $k$ using actual cycles $cc_i \le C_i$ , the utilization entry $U_i$ is reduced to $cc_i / P_i$ until the task's next release, lowering total system utilization and enabling a lower operating frequency.
Input: Periodic task set $\{T_1, \dots, T_n\}$ , worst-case cycles $C_i$ , periods $P_i$ , discrete frequencies $\{f_1, \dots, f_m\}$ with $f_1 < \dots < f_m$ .
State: Per-task utilization variable $U_i$ .
procedure select_frequency():
    use lowest frequency $f_k \in \{f_1, \dots, f_m\}$ such that $\sum_{j=1}^n U_j \le f_k / f_m$
upon task_release( $T_i$ ):
    set $U_i = C_i / P_i$
    select_frequency()
upon task_completion( $T_i$ ):
    let $cc_i$ be the actual cycles consumed during this invocation
    set $U_i = cc_i / P_i$
    select_frequency()
The time complexity of select_frequency() is $O(n)$ per task release or completion event, with at most 2 frequency/voltage switches per task invocation.
Knowl 3 — Cycle-Conserving Real-Time Dynamic Voltage Scaling for Rate Monotonic Schedulers (ccRM)
algorithm
Cycle-Conserving RT-DVS for Rate Monotonic scheduling (ccRM) paces execution to match or exceed the worst-case progress guaranteed by a statically-scaled RM schedule. It tracks remaining worst-case cycles $c\_left_i$ for each task and computes the number of cycles $s_j$ that the statically scaled RM schedule would complete by the earliest deadline in the system. It allocates these cycles to tasks in priority order and sets the processor frequency to execute that allocation.
Input: Task set $\{T_1, \dots, T_n\}$ sorted by increasing period ( $P_1 \le \dots \le P_n$ ), available frequencies $\{f_1, \dots, f_m\}$ , static RM target frequency $f_j$ .
State: $c\_left_i$ (remaining worst-case cycles), $d_i$ (allocated cycles to complete before next deadline).
procedure allocate_cycles(k):
    for $i = 1$ to $n$ :
        if $c\_left_i < k$ then
            set $d_i = c\_left_i$
            set $k = k - c\_left_i$
        else
            set $d_i = k$
            set $k = 0$
procedure select_frequency():
    set $s_m = \text{max\_cycles\_until\_next\_deadline()}$
    use lowest frequency $f_i \in \{f_1, \dots, f_m\}$ such that $(\sum_{k=1}^n d_k) / s_m \le f_i / f_m$
upon task_release( $T_i$ ):
    set $c\_left_i = C_i$
    set $s_m = \text{max\_cycles\_until\_next\_deadline()}$
    set $s_j = s_m \cdot (f_j / f_m)$
    allocate_cycles( $s_j$ )
    select_frequency()
upon task_completion( $T_i$ ):
    set $c\_left_i = 0$
    set $d_i = 0$
    select_frequency()
during task_execution( $T_i$ ):
    decrement $c\_left_i$ and $d_i$ by elapsed cycles
Knowl 4 — Static Voltage Scaling Schedulability Tests for EDF and Rate Monotonic Schedulers
algorithm
Static voltage scaling sets a single fixed operating frequency and voltage for a given task set by selecting the lowest frequency $f_i \in \{f_1, \dots, f_m\}$ that satisfies the frequency-scaled schedulability test.

Scaling frequency by $\alpha = f_i / f_m \in (0, 1]$ expands the worst-case computation time from $C_j$ to $C_j / \alpha$ while periods $P_j$ remain unchanged.
Input: Periodic tasks $\{T_1, \dots, T_n\}$ with worst-case times $C_j$ and periods $P_j$ , ordered frequencies $\{f_1, \dots, f_m\}$ ( $f_1 < \dots < f_m$ ).
function EDF_test( $\alpha$ ):
    return ( $\sum_{j=1}^n \frac{C_j}{P_j} \le \alpha$ )
function RM_test( $\alpha$ ):
    assume tasks are indexed by priority ( $P_1 \le P_2 \le \dots \le P_n$ )
    return ( $\forall i \in \{1, \dots, n\}, \sum_{j=1}^i \lceil \frac{P_i}{P_j} \rceil C_j \le \alpha P_i$ )
procedure select_frequency():
    use lowest frequency $f_i \in \{f_1, \dots, f_m\}$ such that:
        EDF_test( $f_i / f_m$ ) is true /* under EDF */
        or RM_test( $f_i / f_m$ ) is true /* under RM */
Knowl 5 — Modular OS Architecture for Kernel-Level Real-Time Dynamic Voltage Scaling
model/method
A real-time DVS (RT-DVS) architecture in an operating system kernel is structured as three distinct, decoupled modules to enable dynamic switching of scheduling and power policies without kernel modification or rebooting:
1. Periodic RT Task Module: Hooks directly into the kernel scheduler and timer tick handlers to override standard time-sharing scheduling, tracking periods, releases, and deadlines of real-time tasks.
2. RT Scheduler / RT-DVS Module: Implements the specific scheduling policy (e.g., EDF or RM) integrated with an RT-DVS algorithm (such as ccEDF, ccRM, or laEDF). It computes the required frequency and voltage at task release and completion points.
3. Hardware Voltage/Frequency Driver Module: Exposes an abstract interface to set hardware processor clock dividers and external voltage regulator control bits (e.g., AMD PowerNow! special feature registers).
User-space real-time tasks interface with the kernel modules via pseudo-filesystem entries (/procfs), writing period and worst-case execution parameters to register as RT tasks, and writing completion tokens upon finishing each invocation.
Knowl 6 — Empirical Power Reduction and Switching Overheads on AMD K6-2+ Hardware
empirical result
The RT-DVS algorithms implemented on a laptop platform featuring an AMD K6-2+ processor with PowerNow! (supporting frequencies 200–550 MHz and two operating voltages, 1.4 V and 2.0 V) achieved a 20% to 40% reduction in total system power dissipation across different processor utilization levels for a 5-task workload executing at 90% of worst-case computation time.

Measured hardware switching latencies during processor state transitions were:
- Voltage change: 0.4 ms (programmable halt duration of 10 bus intervals to allow DC-DC regulator stabilization).
- Frequency-only change: 41 $\mu$ s (the minimum halt interval of 4096 cycles of the 100 MHz system bus).
Because at most two transitions occur per task invocation (at release and completion), the hardware transition overhead can be safely accounted for by adding at most $0.8\text{ ms}$ to each task's worst-case computation requirement.
Knowl 7 — Task Set Utilization Rather Than Invocation Distribution Dictates Dynamic RT-DVS Energy Savings
empirical result
Simulations evaluating static and dynamic RT-DVS algorithms across constant computation fractions (90%, 70%, 50% of worst-case allocation $C_i$ ) and uniformly distributed random allocations ( $U(0, C_i)$ ) demonstrated that:
1. Static scaling algorithms (Static EDF, Static RM) depend solely on worst-case CPU utilization and achieve zero additional energy savings when actual execution time is less than $C_i$ .
2. Dynamic algorithms (ccEDF and laEDF) depend on the average system CPU utilization; a uniform distribution between 0 and $C_i$ yields identical normalized energy dissipation to a deterministic execution requirement of $0.5 C_i$ .
3. The number of tasks in the task set (tested with 5, 10, and 15 tasks) has negligible impact on relative and absolute energy savings across all utilization levels.
Knowl 8 — Impact of Discrete Voltage/Frequency Step Granularity on ccEDF vs. laEDF
empirical result
The relative energy-saving performance of look-ahead EDF (laEDF) versus cycle-conserving EDF (ccEDF) depends significantly on the number of discrete operating frequencies provided by the hardware platform:
- When the platform provides many fine-grained frequency steps (e.g., 7 frequency steps from 0.36 to 1.0), ccEDF outperforms laEDF and closely tracks the theoretical lower bound across the entire utilization spectrum. Fine steps allow ccEDF to match actual utilization precisely.
- In contrast, fine-grained steps degrade laEDF performance because aggressive work deferral causes it to select very low frequencies initially, requiring high-voltage/high-frequency operation later to meet deferred deadlines.
- When the platform provides few coarse frequency steps (e.g., 3 settings: 0.5, 0.75, 1.0), laEDF outperforms ccEDF because the discretization error forces laEDF to select slightly higher initial frequencies, reducing the probability of needing high-voltage bursts later.
Knowl 9 — Deferred-Release Protocol for Dynamic Task Admission in RT-DVS
model/method
In an operating RT-DVS system operating near capacity, adding a new periodic task dynamically can cause existing tasks to miss deadlines due to past voltage scaling decisions based on the lighter task set.

To prevent transient deadline misses during dynamic task admission:
1. The new task is immediately inserted into the active task set representation so that all future voltage and frequency scaling calculations account for the increased workload.
2. The actual release and first execution of the new task are deferred until the current invocations of all existing tasks in the system have completed.
This ensures that all previous DVS decisions made under the prior task set configuration expire before the new task begins consuming CPU cycles.
Knowl 10 — First-Invocation Execution Time Overrun from Cold Processor and OS State
limitation
When deploying RT-DVS on general-purpose hardware and commodity operating kernels (e.g., x86 Linux), the initial invocation of a newly created real-time task may overrun its specified worst-case computation time $C_i$ .

This transient overrun is caused by cold processor and OS states during the first execution cycle, including cache misses, translation lookaside buffer (TLB) misses, and initial page faults (such as copy-on-write allocations). Subsequent invocations execute in a 'warm' state and conform to specified computation bounds. Real-time implementations must account for initial cold-state overhead during worst-case execution time profiling.

Coverage note — None was omitted; all contributed real-time dynamic voltage scaling algorithms (Static EDF/RM, ccEDF, ccRM, laEDF), kernel architecture, simulation results, hardware measurements, and implementation nuances were converted into standalone knowls.

References

1.ADVANCED MICRO DEVICES CORPORATION. Mobile AMD-K6-2+ Processor Data Sheet, June 2000. Publication # 23446.
2.BURD, T. D., AND BRODERSEN, R. W. Energy efficient CMOS microprocessor design. In Proceedings of the 28th Annual Hawaii International Conference on System Sciences. Volume 1: Architecture (Los Alamitos, CA, USA, Jan. 1995), T. N. Mudge and B. D. Shriver, Eds., IEEE Computer Society Press, pp. 288–297.
3.ELLIS, C. S. The case for higher-level power management. In Proceedings of the 7th IEEE Workshop on Hot Topics in Operating Systems (HotOS-VIII) (Rio Rico, AZ, Mar. 1999), pp. 162–167.
4.FLAUTNER, K., REINHARDT, S., AND MUDGE, T. Automatic performance-setting for dynamic voltage scaling. In Proceedings of the 7th Conference on Mobile Computing and Networking MOBICOM’01 (Rome, Italy, July 2001).
5.FLINN, J., AND SATYANARAYANAN, M. Energy-aware adaptation for mobile applications. In Proceedings of the 17th ACM Symposium on Operating System Principles (Kiawah Island, SC, Dec. 1999), ACM Press, pp. 48–63.
6.FLINN, J., AND SATYANARAYANAN, M. PowerScope: a tool for profiling the energy usage of mobile applications. In Proceedings of the Second IEEE Workshop on Mobile Computing Systems and Applications (New Orleans, LA, Feb. 1999), pp. 2–10.
7.GOVIL, K., CHAN, E., AND WASSERMANN, H. Comparing algorithms for dynamic speed-setting of a low-power CPU. In Proceedings of the 1st Conference on Mobile Computing and Networking MOBICOM’95 (Mar. 1995).
8.GRUIAN, F. Hard real-time scheduling for low energy using stochastic data and DVS processors. In Proceedings of the International Symposium on Low-Power Electronics and Design ISLPED’01 (Huntington Beach, CA, Aug. 2001).
9.INTEL CORPORATION. http://developer.intel.com/design/intelxscal/.
10.INTEL CORPORATION. Mobile Intel Pentium III Processor in BGA2 and MicroPGA2 Packages, 2000. Order Number 245483-003.
11.KRAVETS, R., AND KRISHNAN, P. Power management techniques for mobile communication. In Proceedings of the 4th Annual ACM/IEEE International Conference on Mobile Computing and Networking (MOBICOM-98) (New York, Oct. 1998), ACM Press, pp. 157–168.
12.KRISHNA, C. M., AND LEE, Y.-H. Voltage-clock-scaling techniques for low power in hard real-time systems. In Proceedings of the IEEE Real-Time Technology and Applications Symposium (Washington, D.C., May 2000), pp. 156–165.
13.KRISHNA, C. M., AND SHIN, K. G. Real-Time Systems. McGraw-Hill, 1997.
14.LEHOCZKY, J., SHA, L., AND DING, Y. The rate monotonic scheduling algorithm: exact characterization and average case behavior. In Proceedings of the IEEE Real-Time Systems Symposium (1989), pp. 166–171.
15.LEHOCZKY, J., AND THUEL, S. Algorithms for scheduling hard aperiodic tasks in fixed-priority systems using slack stealing. In Proceedings of the IEEE Real-Time Systems Symposium (1994).
16.LEHOCZKY, J. P., SHA, L., AND STROSNIDER, J. K. Enhanced aperiodic responsiveness in hard real-time environments. In Proc. of the 8th IEEE Real-Time Systems Symposium (Los Alamitos, CA, Dec. 1987), pp. 261–270.
17.LEUNG, J. Y.-T., AND WHITEHEAD, J. On the complexity of fixed-priority scheduling of periodic, real-time tasks. Performance Evaluation 2, 4 (Dec. 1982), 237–250.
18.LIU, C. L., AND LAYLAND, J. W. Scheduling algorithms for multiprogramming in a hard real-time environment. J. ACM 20, 1 (Jan. 1973), 46–61.
19.LORCH, J., AND SMITH, A. J. Improving dynamic voltage scaling algorithms with PACE. In Proceedings of the ACM SIGMETRICS 2001 Conference (Cambridge, MA, June 2001), pp. 50–61.
20.LORCH, J. R., AND SMITH, A. J. Apple Macintosh’s energy consumption. IEEE Micro 18, 6 (Nov. 1998), 54–63.
21.MOSSE, D., AYDIN, H., CHILDERS, B., AND MELHEM, R. Compiler-assisted dynamic power-aware scheduling for real-time applications. In Workshop on Compilers and Operating Systems for Low-Power (COLP’00) (Philadelphia, PA, Oct. 2000).
22.PERING, T., AND BRODERSEN, R. Energy efficient voltage scheduling for real-time operating systems. In Proceedings of the 4th IEEE Real-Time Technology and Applications Symposium RTAS’98, Work in Progress Session (Denver, CO, June 1998).
23.PERING, T., AND BRODERSEN, R. The simulation and evaluation of dynamic voltage scaling algorithms. In Proceedings of the International Symposium on Low-Power Electronics and Design ISLPED’98 (Monterey, CA, Aug. 1998), pp. 76–81.
24.PERING, T., BURD, T., AND BRODERSEN, R. Voltage scheduling in the lpARM microprocessor system. In Proceedings of the International Symposium on Low-Power Electronics and Design ISLPED’00 (Rapallo, Italy, July 2000).
25.POUWELSE, J., LANGENDOEN, K., AND SIPS, H. Dynamic voltage scaling on a low-power microprocessor. In Proceedings of the 7th Conference on Mobile Computing and Networking MOBICOM’01 (Rome, Italy, July 2001).
26.POUWELSE, J., LANGENDOEN, K., AND SIPS, H. Energy priority scheduling for variable voltage processors. In Proceedings of the International Symposium on Low-Power Electronics and Design ISLPED’01 (Huntington Beach, CA, Aug. 2001).
27.STANKOVIC, J., ET AL. Deadline Scheduling for Real-Time Systems. Kluwer Academic Publishers, 1998.
28.SWAMINATHAN, V., AND CHAKRABARTY, K. Real-time task scheduling for energy-aware embedded systems. In Proceedings of the IEEE Real-Time Systems Symp. (Work-in-Progress Session) (Orlando, FL, Nov. 2000).
29.TRANSMETA CORPORATION. http://www.transmeta.com/.
30.WEISER, M., WELCH, B., DEMERS, A., AND SHENKER, S. Scheduling for reduced CPU energy. In Proceedings of the First Symposium on Operating Systems Design and Implementation (OSDI) (Monterey, CA, Nov. 1994), pp. 13–23.
31.ZUBERI, K. M., PILLAI, P., AND SHIN, K. G. EMERALDS: A small-memory real-time microkernel. In Proceedings of the 17th ACM Symposium on Operating System Principles (Kiawah Island, SC, Dec. 1999), ACM Press, pp. 277–291.

Citation

MLA

Pillai, P., and K. G. Shin. “Real-time Dynamic Voltage Scaling for Low-power Embedded Operating Systems”. Proceedings of the Eighteenth ACM Symposium on Operating Systems Principles, 2001, pp. 89–102, https://doi.org/10.1145/502034.502044.

APA

Pillai, P., & Shin, K. G. (2001). Real-time dynamic voltage scaling for low-power embedded operating systems. Proceedings of the Eighteenth ACM Symposium on Operating Systems Principles, 89–102. https://doi.org/10.1145/502034.502044

Chicago

Pillai, P., and K. G. Shin. 2001. “Real-time Dynamic Voltage Scaling for Low-power Embedded Operating Systems”. Proceedings of the Eighteenth ACM Symposium on Operating Systems Principles, 89–102. https://doi.org/10.1145/502034.502044.

Harvard

Pillai, P. and Shin, K.G. (2001) “Real-time dynamic voltage scaling for low-power embedded operating systems”, Proceedings of the eighteenth ACM symposium on Operating systems principles. ACM, pp. 89–102. Available at: https://doi.org/10.1145/502034.502044.

Vancouver

1. Pillai P, Shin KG (2001) Real-time dynamic voltage scaling for low-power embedded operating systems. In: Proceedings of the eighteenth ACM symposium on Operating systems principles. ACM, pp 89–102

BibTeX

@inproceedings{Pillai_2001, series={SOSP01}, title={Real-time dynamic voltage scaling for low-power embedded operating systems}, url={http://dx.doi.org/10.1145/502034.502044}, DOI={10.1145/502034.502044}, booktitle={Proceedings of the eighteenth ACM symposium on Operating systems principles}, publisher={ACM}, author={Pillai, Padmanabhan and Shin, Kang G.}, year={2001}, month=Oct, pages={89–102}, collection={SOSP01} }

Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

Real-time dynamic voltage scaling for low-power embedded operating systems

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — Look-Ahead Real-Time Dynamic Voltage Scaling Algorithm for EDF (laEDF)

Knowl 2 — Cycle-Conserving Real-Time Dynamic Voltage Scaling for EDF (ccEDF)

Knowl 3 — Cycle-Conserving Real-Time Dynamic Voltage Scaling for Rate Monotonic Schedulers (ccRM)

Knowl 4 — Static Voltage Scaling Schedulability Tests for EDF and Rate Monotonic Schedulers

Knowl 5 — Modular OS Architecture for Kernel-Level Real-Time Dynamic Voltage Scaling

Knowl 6 — Empirical Power Reduction and Switching Overheads on AMD K6-2+ Hardware

Knowl 7 — Task Set Utilization Rather Than Invocation Distribution Dictates Dynamic RT-DVS Energy Savings

Knowl 8 — Impact of Discrete Voltage/Frequency Step Granularity on ccEDF vs. laEDF

Knowl 9 — Deferred-Release Protocol for Dynamic Task Admission in RT-DVS

Knowl 10 — First-Invocation Execution Time Overrun from Cold Processor and OS State

References

Citation

BibTeX

Access the Paper