A modern multicore chip cannot run all its cores at full speed at once. If it did, it would exceed its power and cooling budget, so at any moment much of the silicon must be switched off or slowed down. This is the "dark silicon" problem. Operating systems cope with it through dynamic voltage and frequency scaling (DVFS), which lowers a core's clock and supply voltage when full speed is not needed. One long-standing use of DVFS is slack reclamation: when a real-time task finishes earlier than its worst-case budget, the spare time is spent running later work more slowly and with less energy. Each such decision trades something now against something later. Running fast heats the chip and uses up the time before it must throttle. Running slowly spends banked time and raises leakage energy while the core stays hot. Current runtimes either decide one epoch at a time, as greedy power upgraders do, or plan over a fixed window with an optimizer that is too slow to run at the timescales that matter.
We propose to borrow one specific tool from economic model predictive control (EMPC). EMPC is a controller that repeatedly plans a short sequence of actions to minimize a real cost such as energy or lateness, rather than to track a setpoint. The tool is a terminal value: a price, attached to the end of each short plan, on the "stocks" the plan leaves behind. In a multicore chip those stocks are thermal headroom (how far each core sits below its temperature limit) and banked slack (how far each task chain is ahead of its deadline). Our claim is that a controller planning only two or three epochs ahead, with headroom and slack priced correctly at the end of the plan, can match a long-horizon optimizer while costing about as little to run as a greedy heuristic. The same prices also settle, online, whether a core should stretch its work to fill the available time or race to finish and power off.
Core Claim and Why It Is New
The failure mode we target is known in control theory but has not been named in computer architecture. In wind turbine control, An economic NMPC formulation for wind turbine control shows that a finite-horizon controller maximizing power will brake the rotor at the end of each plan to cash in its kinetic energy, leaving the turbine stalled. The fix there is a terminal cost that values the remaining rotor energy. Computing systems have two exact analogues. An energy-minimizing controller will spend all banked slack in the last steps of its plan, leaving the next window with deadline pressure. A throughput-maximizing controller under a thermal cap will run turbo frequencies until the plan ends, leaving the chip hot and forcing deep throttling afterward. Modeling and Evaluation of Application-Aware Dynamic Thermal Control in HPC Nodes solves a finite-horizon integer program that exploits thermal capacitance, the delay before silicon reaches its steady temperature. It attaches no value to the end-of-horizon thermal state, and it pays for this with horizon length: the 10 s horizon gives a 6% net gain, while a 1 s horizon loses 10.20% to solver overhead. Our proposal attacks that overhead problem directly. The goal is to make short horizons good, not to make the solver faster.
The second piece of novelty is structural. Thread Progress Equalization (TPEq) greedily upgrades the most lagging thread under a chip power budget in 1 ms epochs. It can be read as our controller with a one-epoch horizon and a zero terminal value. That reading gives a clean ablation. It also suggests an efficient solver: with terminal values that are linear in the stocks, the per-epoch problem splits across cores under a single price on the shared power budget, so a greedy procedure close to TPEq's remains applicable.
Formulation
Each epoch, the controller chooses a discrete voltage–frequency level or power-off for each core $i$ over the next $N$ epochs. Its state has three parts. The first is core temperatures $T_i$, evolving under a lumped resistor–capacitor thermal model of the floorplan, as in the first-order model of Cesarini et al. The second is per-chain banked slack $s_j$, which grows when work completes ahead of its budget and shrinks when work runs slowly. The third is remaining work, predicted from performance counters. The problem it solves is
$$\min \sum_{k=0}^{N-1} \Big[E_{\text{dyn}}(u_k)+E_{\text{leak}}(T_k,u_k)+c\,\text{lateness}_k\Big] \;-\; \sum_i \lambda_i\,(T_{\max}-T_{i,N}) \;-\; \sum_j \mu_j\, s_{j,N},$$
subject to the chip power cap and per-core temperature limits. Here $u_k$ is the frequency/power-gating choice at epoch $k$, $E_{\text{leak}}$ grows with temperature, $c$ prices lateness, and $\lambda_i,\mu_j\ge 0$ are the prices of headroom and slack at the end of the plan. Because leakage depends on temperature, as Thermal aware overall energy minimization scheduling for hard real-time systems shows, stretching a task on a hot core can cost more energy than it saves. The objective therefore decides between stretching and racing to sleep without a separate rule.
The research question is where $\lambda$ and $\mu$ come from. We test three sources in increasing cost. The first is the dual variables of the steady-state version of the same economic problem. In EMPC these give a linear storage function, the object used to prove that the closed loop settles to good operation; see Dissipativity in economic model predictive control: beyond steady-state optimality. The second adapts those duals online as the workload's phase changes. This borrows the moving "artificial reference" idea from Adaptive Economic Model Predictive Control: Performance Guarantees for Nonlinear Systems, which re-estimates the best reachable steady state as parameters drift. We do not inherit its guarantees, because CMOS leakage violates its linear-in-parameters assumption, and we say so. The third fits the terminal value offline from simulated rollouts, following Verification of Dissipativity and Evaluation of Storage Function in Economic Nonlinear MPC using Q-Learning, which evaluates storage functions by undiscounted Q-learning when analytic derivation is hard. Theory will be modest. We aim to show that, under the linearized thermal model with continuous frequencies, the steady-state duals remove the end-of-horizon depletion. The discrete, nonlinear case is handled empirically.
Research Program
We will build the controller in two settings. The first is the Sniper simulator with McPAT power models, the setup used by TPEq, extended with a floorplan thermal model and temperature-dependent leakage, at 16 and 64 cores. The second is an Odroid-XU3 board (four big and four LITTLE cores, with on-die thermal sensors) for real closed-loop actuation, the platform used by AdaMD. Workloads are PARSEC, SPLASH-2 and Phoenix for barrier-synchronized throughput under a power cap. For deadline-constrained work we use the Barcelona OpenMP Tasksuite DAGs with deadlines and dual typical/worst-case budgets as in Precise Scheduling of DAG Tasks with Dynamic Power Management. The Quantum ESPRESSO traces from Cesarini et al. give an HPC thermal-coupling case. We also build a synthetic mixed-criticality set modeled on MonTM's setting, with critical chains placed next to best-effort hot cores.
The analysis has three parts. We first measure the turnpike effect in computing by logging end-of-horizon temperature and slack for controllers without a terminal value. We then map energy, misses and overhead across horizon lengths $N\in\{1,2,3,5,10,20\}$, crossed with the three terminal-value sources and no terminal value. Finally, we characterize when racing to sleep beats stretching, as a function of temperature and neighbor activity.
Baselines
The naive reference points are the Linux "performance" and "ondemand" governors, run unchanged on the same workloads and platforms. They show what an untuned system does.
The strongest myopic competitor is TPEq, reimplemented in our Sniper setup with its 1 ms epoch and last-value predictor. Its reported result is a 6.9% performance improvement over MaxBIPS in DVFS mode, and up to 23% over Criticality Stacks, across 18 SPLASH-2/PARSEC/Phoenix benchmarks (Thread Progress Equalization). It is the strongest competitor on throughput under a power cap because it is cheap (under 0.6% overhead at 16 cores) and already reclaims barrier slack. We give it the same power cap, add a thermal-cap guard so it can be compared under thermal limits, and tune its epoch length with the same budget we spend tuning our horizon. Beating it means equal or better runtime with fewer thermal-limit violations and less energy at overhead within 1% of runtime, and a clear win on workloads with phase changes or thermal coupling.
The strongest predictive competitor is Cesarini et al.'s two-tier integer-programming controller with its energy-aware MPI wrapper. Its reported numbers are a 7.06% raw and 6% net performance gain at a 10 s horizon, and a 10.20% execution-time penalty at a 1 s horizon on QE traces (Modeling and Evaluation of Application-Aware Dynamic Thermal Control in HPC Nodes). We run it on the same traces and thermal model, counting solver time in wall-clock. Beating it means a net gain of at least its 6% while replanning at 1 s or faster without the overhead penalty.
For DAG deadlines we compare against Bhuiyan et al.'s dual-budget scheduler, which reports up to 30% energy savings and at least 29.2% power savings over MCFS_Li on BOTS. We use the same typical/worst-case budgets. Beating it means lower energy at zero hard-deadline misses once thermal-dependent leakage is modeled, a factor it ignores.
For heterogeneous mapping we compare against AdaMD on the Odroid board. It reports up to 28% energy savings over ITMD and meets performance targets in 95% of concurrent cases. The comparison uses the same performance targets.
The key ablation is our own controller with the terminal value set to zero, and separately with a long horizon. This isolates whether the price on headroom and slack, rather than predictive planning as such, does the work.
Why not just…?
Why not just use a temperature-aware critical-speed rule? On a single core, the stretch-versus-race question has a near closed-form answer: below a temperature-dependent "critical frequency," leakage dominates and racing wins. This rule is a real threat, and we include it as a baseline: each core picks the larger of its critical frequency and its slack-fitting frequency. Its blind spot is that it is local. It cannot know that a neighbor's best-effort work will soon need the shared thermal and power budget. MonTM's authors note exactly this: slowing a critical task is wrong when no hot neighbor exists (MonTM), which is a decision that depends on the neighborhood. The mixed-criticality and QE experiments settle this. If the rule matches our controller there, we will report that the terminal value only matters for shared-budget coordination and narrow the claim to it.
Why not just lengthen the horizon and pay for the solver? Cesarini et al.'s own numbers show the cost: the shorter replanning interval that adaptivity needs turned a 6% net gain into a 10.20% loss. The horizon-sweep experiment checks directly whether a short horizon with a priced terminal state matches a long horizon. If it does not, this proposal fails at its central claim.
Why not just train a reinforcement-learning governor end to end? A learned policy could absorb the same trade-offs, but it offers no handle on hard deadlines or thermal limits, which the planner enforces as constraints at every epoch. We use learning only where it is safe: for the terminal value, as in Kordabad's Q-learning storage evaluation. We include a learned direct policy as a secondary comparison on throughput workloads, and we report its constraint violations.
Decisive Experiments
Three results decide the proposal. First, the turnpike effect must appear in computing. Short-horizon economic control without a terminal value should end windows with depleted headroom or slack, followed by measurable throttling or deadline misses. If it does not, the motivation collapses. Second, a horizon of two or three epochs with steady-state-dual terminal prices should land within 2% of a 20-epoch planner on energy and runtime while keeping controller overhead comparable to TPEq's. That would hold across PARSEC/SPLASH-2 under a power cap and BOTS with deadlines. Third, on thermally coupled scenarios (QE traces, the mixed-criticality set, and Odroid big/LITTLE runs), the priced controller must beat both TPEq and the temperature-aware critical-speed rule. The comparison must report energy at zero hard misses and best-effort runtime at no thermal violations. Overhead is counted in wall-clock time throughout, since overhead is exactly where prior predictive controllers have lost.
References
- An economic NMPC formulation for wind turbine control
- Modeling and Evaluation of Application-Aware Dynamic Thermal Control in HPC Nodes
- Thread Progress Equalization: Dynamically Adaptive Power-Constrained Performance Optimization of Multi-Threaded Applications
- Thermal aware overall energy minimization scheduling for hard real-time systems
- Dissipativity in economic model predictive control: beyond steady-state optimality
- Adaptive Economic Model Predictive Control: Performance Guarantees for Nonlinear Systems
- Verification of Dissipativity and Evaluation of Storage Function in Economic Nonlinear MPC using Q-Learning
- AdaMD: Adaptive Mapping and DVFS for Energy-Efficient Heterogeneous Multicores
- Precise Scheduling of DAG Tasks with Dynamic Power Management
- MonTM: Monitoring-Based Thermal Management for Mixed-Criticality Systems