Operating-system schedulers that keep processors from overheating, by deciding which core runs which thread, trust the readings of the small temperature sensors built into the chip. Those readings are biased in ways the schedulers never model. Each sensor has its own offset. The exact sensor positions on the chip are often undocumented. Every sensor also rises and falls together with the room, the fan, and the package. Fiber-optic and strain sensing solved a structurally identical problem long ago. They pair two matched elements that see the same environmental heating but opposite mechanical signals, and subtract one reading from the other, so the shared thermal term cancels. We propose that a scheduler can build such a matched pair out of its own actions. It runs a thread on one of two cores placed symmetrically on the die, then swaps the thread to the other core, and differences the four readings. This cancels both the shared ambient drift and each sensor's fixed offset, and leaves a clean measurement of how much the thread heats its own core relative to its neighbor.
These differential measurements continuously re-fit a lightweight thermal model of the chip, which we call a digital twin: a simulation kept in step with the physical chip that also issues commands back to it. The scheduler then uses the twin to decide where threads should go. The loop is bidirectional in a concrete sense. Migrations are chosen both because they spread heat and because they make the model's parameters observable. The concrete question is whether a scheduler that plans on a twin calibrated this way keeps peak temperature and throttling lower than published schedulers when sensors are offset, ambient conditions drift, and moving a thread has a real cache cost.
Core Claim
Single-ended calibration fits a thermal model to raw sensor readings, and under realistic conditions it cannot separate three quantities that all shift readings the same way: per-sensor offset, shared ambient drift, and the self-heating coefficient of a core. Under ordinary operation, workload intensity and ambient temperature tend to rise together, so passive data leaves these quantities confounded. A swap between die-symmetric cores provides the missing contrast. Write $y_k^{(p)}$ for the reading of sensor $k \in \{a,b\}$ in phase $p \in \{1,2\}$, $P$ for the thread's power, $g_s$ and $g_x$ for the self- and cross-heating coefficients (°C per watt), $c^{(p)}$ for the common-mode temperature in phase $p$, and $o_k$ for sensor offset. The thread runs on $a$ in phase 1 and on $b$ in phase 2. Then
$$\big(y_a^{(1)}-y_b^{(1)}\big)-\big(y_a^{(2)}-y_b^{(2)}\big)=2\,(g_s-g_x)\,P,$$
$$\big(y_a^{(1)}-y_b^{(1)}\big)+\big(y_a^{(2)}-y_b^{(2)}\big)=2\,(o_a-o_b)+\epsilon_{\text{asym}},$$
where $\epsilon_{\text{asym}}$ is the error from imperfect symmetry. These are the same two equations as the opposed-element sensors of Direction 1, with the scheduler playing the role of the mechanical load.
The known weakness of differential sensing is that it assumes both elements share the same thermal field. That assumption fails under steep gradients. Our twin addresses this by predicting $\epsilon_{\text{asym}}$ from its current model of the gradient instead of assuming it is zero. Absolute offsets need one anchor, such as a package-level sensor. The pairwise differences fix everything else.
Relation to Prior Work
Three groups of prior work set up this proposal.
The first group shows the gap. The software thermal sensor of Efficient power modeling and software thermal sensing for runtime temperature monitoring runs an RC thermal model driven by performance counters. An RC model treats the chip as a network of thermal resistors and capacitors. This one tracks HotSpot within 0.08°C. Its authors acknowledge that undocumented diode locations and an approximated ambient temperature corrupt its calibration, and it never acts on the chip. We keep its model class but close the loop and attack exactly that calibration error.
The second group supplies the scheduling regime and the strongest competitors. HotPotato groups cores into rings by Manhattan distance from the die center and rotates threads every 0.5 ms. Its rings already provide sets of positionally symmetric cores, which our pairing reuses. However, it assumes perfect sensors and near-free migration on a shared last-level cache. The two-level DBSCAN mapping clusters cores by temperature and shows that lateral heat from a busy neighbor can cut an idle core's lifetime by up to 29%. Its clustering depends on offline profiles and raw temperatures, and offset sensors would corrupt it directly. ReTMiC and TABS argue that proactive placement beats reactive throttling. Neither models sensor error; TABS sidesteps diodes with a power-density proxy and custom hardware. Our scheduler is proactive in their sense, but its model inputs are corrected.
The third group constrains the design. COUNTDOWN finds that history-based predictors lose to a simple 500 µs reactive timer on irregular MPI codes. We take this seriously. Our twin does not predict future workload behavior. It estimates slowly varying physical parameters, which are far more stationary than communication timing. Any swap must still pay for itself, just as power-state transitions must clear COUNTDOWN's 500 µs threshold.
2D-ThermAl is a fast neural thermal solver. It is the obvious "AI surrogate in the loop," but we do not use it. It predicts steady state, and its sub-10 ms inference is twenty times longer than a 0.5 ms scheduling epoch. A compact RC model fits the timing budget.
The closest cross-direction work is T-XGBoost digital-twin laser cutting, which regresses and compensates thermal error on CNC machinery. It uses passive regression rather than designed differential excitation, and it schedules nothing.
Research Program
We would build three components.
The first is a twin. It is a compact RC thermal model of the floorplan, as in HotSpot/MatEx. Its learnable parameters are per-sensor offsets, a common-mode ambient state, per-core self- and cross-heating coefficients, and a low-order gradient term. A Kalman-style filter updates these parameters from both ordinary readings and swap differentials.
The second is an excitation planner. At each epoch it scores candidate swaps between ring-symmetric core pairs by their thermal benefit plus the expected reduction in parameter uncertainty. From this score it subtracts the migration cost, which is the cache refill estimated from the thread's working set. The planner therefore swaps often when the twin is uncertain, for example after an ambient step, and rarely once it has converged.
The third is a placement policy. It runs a short-horizon search on the twin to choose where threads go. Thermal-cycling penalties follow the reliability model of the DBSCAN mapping paper.
The analysis has two parts. We derive when the swap differential is identifiable and how $\epsilon_{\text{asym}}$ grows with gradient steepness. We also measure the residual error empirically by sweeping floorplan asymmetry and heat-flux skew.
Baselines
The naive reference is the hardware's own reactive frequency throttling, using raw sensors and no placement policy. Every proactive method must beat it on throttling time and response time, or the problem is moot.
The strongest existing method on this question is HotPotato. It reports a 10.72% average response-time improvement over PCMig on PARSEC, with schedule computation at 4.75% of a 0.5 ms epoch (Thermal Management for S-NUCA Many-Cores via Synchronous Thread Rotations). We run it in HotSniper on the same 64-core floorplan, workloads, and sensor-error injection as our method. We run it in two settings: its native shared-cache configuration, and a private-cache configuration where migration costs refill time. Its rotation period is retuned within the same budget as our hyperparameters. Beating it means lower peak temperature and throttling time at equal or better response time under injected sensor error, without losing in the error-free shared-cache setting. We would read a win only in private caches as a narrower result.
The second competitor is the two-level DBSCAN mapping. It reports up to a 20% lifetime (MTTF) gain over standard thermal-aware mapping, 53% over random mapping, and 3.3% overhead (A Two-Level Thermal Cycling-aware Task Mapping Technique). We run it with its reported clustering threshold of 0.7 and offline profiles from the same simulator. Beating it means higher estimated MTTF under sensor offsets.
The third competitor is a software-thermal-sensor-style observer with single-ended least-squares calibration, feeding the same placement policy. This baseline isolates the calibration method from the scheduler.
The key ablation replaces swap differentials with random thread dithering that spends the same migration budget. This tests whether the symmetric pairing matters or whether any excitation would do.
We found no reported result on Lacuna for sensor-offset estimation error or scheduling quality under injected diode drift. Those comparisons will be new measurements, not checks against published figures.
Why not just…?
Why not just rely on hardware throttling? It does prevent damage, but it reacts only after a hotspot has formed. TABS reports that proactive placement cuts throttling slowdown by an average of 60% relative to reactive management. Throttling also lets temperature swing between peaks and troughs, and those swings drive the fatigue documented by the DBSCAN mapping work. It remains our floor baseline.
Why not just run HotPotato-style rotation on raw sensors? Rotation spreads heat without any model. Offsets matter to it only through its threshold triggers, so it may be robust to sensor error. That makes it a real threat. Its weak point is migration cost on non-shared caches. If HotPotato matches us under offsets in the shared-cache setting, our claim narrows to architectures where moves are expensive and must be chosen selectively. The two-cache-setting design settles this directly.
Why not just calibrate a Kalman filter on passive data, or with random dithering? This is the most serious alternative. A filter that carries ambient as a state may already separate the confounded terms when the workload varies enough. Our identifiability argument predicts that it will fail when workload and ambient are correlated, as in an ambient ramp during a heavy phase. The dithering ablation tests whether symmetric pairing adds anything beyond generic excitation. If dithering matches the swap differentials, the paper becomes a result about active excitation, and the differential-sensing framing is dropped.
Why not just calibrate sensors once at the factory? Offsets shift with package stress and aging, and ambient varies in deployment. Our drift-injection experiments quantify how fast a one-time calibration decays. Even so, the software-thermal-sensor authors report calibration trouble from undocumented diode locations alone, before any drift.
Proposed Experiments
All experiments use HotSniper with McPAT power and a HotSpot-grid ground truth on a 64-core 22 nm floorplan, running PARSEC/SPLASH2 mixes (blackscholes, fft, raytrace and others). We inject per-diode offsets, slow offset drift, and ambient ramps and steps into the sensor readings seen by the schedulers. The ground-truth temperatures stay hidden from the schedulers and are used only for scoring. Metrics are offset-estimation error, hotspot prediction error, peak temperature, throttling time, response time, thermal-cycle-based MTTF, and migration overhead.
Three checks would decide the question. First, under correlated ambient ramps, swap differentials should estimate offsets with clearly lower error than single-ended calibration and random dithering at equal migration budget. Second, the error should degrade gracefully as floorplan asymmetry grows, provided the twin models $\epsilon_{\text{asym}}$, and sharply if it does not. Third, the closed-loop scheduler should beat HotPotato on throttling time under sensor error in the private-cache setting while matching it with ideal sensors.
A stretch study would pin threads on a commodity multi-core that exposes per-core sensors. It would test whether the pairwise offset estimates stay stable across repeated ambient changes, which needs no ground-truth thermometry to falsify.
References
- Efficient power modeling and software thermal sensing for runtime temperature monitoring
- Thermal Management for S-NUCA Many-Cores via Synchronous Thread Rotations
- A Two-Level Thermal Cycling-Aware Task Mapping Technique for Reliability Management in Manycore Systems
- ReTMiC: Reliability-Aware Thermal Management in Multicore Mixed-Criticality Embedded Systems
- Temperature aware thread block scheduling in GPGPUs
- COUNTDOWN: A Run-Time Library for Performance-Neutral Energy Saving in MPI Applications
- 2D-ThermAl: Physics-Informed Framework for Thermal Analysis of Circuits using Generative AI
- Thermal Error Prediction and Compensation of Digital Twin Laser Cutting Based on T-XGBoost