Schedulers that spread work across a multicore processor to avoid hot spots are usually designed in simulators. Those simulators encode a guess about how heat leaves the chip: through the heatsink on top, with the side edges of the silicon treated as perfectly insulated. Engineers call this the adiabatic wall assumption, meaning zero heat flow across a boundary. The best simulated schedulers then exploit a geometric rule of thumb, that cores near the die edge cool faster than central ones, and they place or rotate threads accordingly. Nobody has checked on real hardware whether the cooling ranking this rule implies holds once the true boundary is in play: a real heatsink mount, uneven fan airflow, socket conduction. In other engineering fields, an unchecked insulated-boundary assumption is a known source of large, systematic error between simulation and measurement.
We propose to identify, on real processors, a per-core model of heat leaving the chip. The model captures each core's own leak to the environment and its lateral coupling to neighbors, and we fit it from short power-step probes read through the on-die temperature sensors. We then test whether scheduling on this measured model beats scheduling on geometry or on an insulated-edge simulator. The central question is a falsifiable one. Does the measured cooling order of cores agree with the geometric "edge effect", and does it stay stable when the physical boundary changes? If it does not, schedulers tuned in simulation are optimizing the wrong map.
Core Claim
Thermal-aware placement depends on three things: a ranking of cores by how quickly they shed heat, and the time constants and neighbor couplings that govern transients. Our claim is that all of these are set by the package's real boundary conditions rather than by die geometry. A thermal model identified in place, with explicit non-insulated boundary terms, will therefore give better placements than geometric rings or default compact models. The advantage should be largest when the boundary is asymmetric or changes during operation. Concretely, each core $i$ is modeled as
$$ C_i \frac{dT_i}{dt} = P_i - g_i\,(T_i - T_{amb}) - \sum_{j} k_{ij}\,(T_i - T_j), $$
where $T_i$ is the core's sensor temperature, $P_i$ its power (from on-chip energy counters), $C_i$ its thermal capacitance, $g_i$ its conductance to the environment (the term an insulated-edge model constrains by construction), $k_{ij}$ its lateral conductance to core $j$, and $T_{amb}$ the ambient or coolant temperature. The new element is not this equation. Resistor–capacitor thermal networks are standard. What is new is estimating $g_i$ and $k_{ij}$ in place, from sparse and noisy sensors, cheaply enough to redo when conditions change, and then showing how much of the published scheduling gain survives or reverses once they are measured.
Why This Gap Is Real
Three kinds of prior work motivate the question. On the scheduling side, HotPotato groups the cores of a 64-core chip into concentric rings by Manhattan distance from the die center and rotates threads across rings every 0.5 ms. In the HotSniper simulator it reports a 10.72% average response-time improvement over the migration-plus-throttling baseline PCMig. Hossein Khani et al. show in HotSpot that lateral conduction from one busy core can cut an idle neighbor's lifetime by up to 29%, and they bin cores by temperature for mapping. Both results rest entirely on compact simulated thermal models whose boundary treatment was never compared to hardware. CoMeT goes furthest on modeling fidelity, uncovering memory-induced core heating and thermal lag. It is validated only against another code (ANSYS Icepak), not against silicon.
On the boundary side, two studies show how much an insulated-wall assumption can cost. In a drilling-fluid heater study, a simulation with adiabatic walls overpredicted measured outlet temperature by about 12 °C at low flow. Pauzauskie et al. found with infrared imaging that changing only a micro-device's substrate boundary, from insulating glass to direct thermoelectric cooling, cut its temperature rise from about 2.5 °C to about 0.4 °C. Similar overoptimism from ignoring wall heat loss appears in two-stroke engine modeling. These works supply the physical intuition but no computing workload.
On the validation side, ReLeTA is the closest existing work. It runs a deep Q-learning task allocator on a physical Intel Core i7-4790 using real core sensors. It treats the chip as a black box, uses four cores, and never asks what physical structure its policy is learning. Bashir et al. do model insulation explicitly as a thermal resistance and validate it in an incubator from −30 °C to 40 °C. Their model is lumped at the enclosure level, so it cannot say anything about which core should run what. Our proposal sits between these: physical like ReLeTA, boundary-explicit like Bashir et al., and at the core resolution of HotPotato.
Research Program
The first component is an in-place identification procedure. We pin a calibrated power virus (a fixed-intensity compute loop) to one core at a time, and then to selected pairs, for short steps. We log all per-core digital thermal sensors and per-core or per-package energy counters, and fit $C_i$, $g_i$ and $k_{ij}$ by least squares on the step responses. Pair probes separate self-leak from neighbor coupling. As a by-product, the fitted coupling matrix $k_{ij}$ recovers the physical adjacency of cores. This matters because commercial parts do not publish which logical core ID sits where on the die, and geometric ring schemes silently assume that map is known. We will characterize how many probe seconds are needed for the fitted ranking of $g_i$ to stabilize, since cheap re-identification is what makes the approach practical.
The second component is a controlled boundary perturbation rig. On multi-core server and desktop parts of the kind used in COUNTDOWN (Haswell/Broadwell nodes) and ReLeTA (i7-4790), we deliberately change the boundary. We use asymmetric airflow by partially blocking fan intake, reduced heatsink mounting pressure or partial thermal-paste coverage, and a raised ambient temperature in an enclosure. These mirror in spirit the substrate swap of Pauzauskie et al. and the ambient sweep of Bashir et al. For each condition we measure how $g_i$ and the core cooling ranking move. Where a lidless part is available, we add an optional midwave infrared check of the spatial field following Pauzauskie et al. The on-chip sensors are the primary instrument, because that is what a deployed scheduler would see.
The third component is a scheduler that uses the identified model. It chooses thread placement and, for rotation-style policies, the ring membership and rotation period. It ranks cores by measured $g_i$ rather than by distance, penalizes placements through $k_{ij}$, and sets the period relative to the fitted time constants $C_i/(g_i+\sum_j k_{ij})$. It re-identifies whenever the residual between predicted and measured temperature drifts beyond a threshold. The scheduler is deliberately simple. The research question is whether measured boundary physics is the missing ingredient, not whether a clever optimizer can be built on top of it.
Baselines
The naive reference is the stock operating-system scheduler with the processor's built-in reactive frequency throttling (dynamic voltage and frequency scaling, which lowers clock speed when a sensor exceeds a limit). This is what every deployed machine does, and ReLeTA reports that a reactive allocation baseline incurred 41% latency violations on PARSEC. We will run it on the same machines and workloads with default settings.
The strongest physical-hardware competitor is ReLeTA itself. It is a model-free learned allocator reading the same sensors, and its reported result on the i7-4790 with PARSEC is an average peak-temperature reduction of 4 °C (up to 13 °C) against the Long-Term Benefit allocator, with latency violations of 0–3% and 0.54 ms allocation overhead. We will reimplement it with the same state (frequency, utilization, sensor temperature) and relative reward, and give it the same wall-clock budget of hardware interaction that our identification probes consume plus its reported 800 training steps. We will also give it an extended budget, so that any advantage we show is not a starved-baseline artifact. Beating it means lower peak temperature and less throttled time at equal or lower latency violations. It also means recovering faster after a boundary change, measured in minutes of hardware time to return within 1 °C of pre-change peak performance.
The strongest simulated-design competitor is HotPotato-style concentric ring rotation, implemented on hardware with rings from nominal die geometry. There is no reported result on Lacuna for HotPotato on physical hardware; its only number is the simulated 10.72% response-time gain over PCMig. We will run it with its published 0.5 ms epoch and a tuned epoch. Beating it means better response time and peak temperature under the same thread counts, and especially under perturbed boundaries.
A default compact-model scheduler serves as a further baseline. It uses the same placement logic as ours, driven by a HotSpot model with standard insulated side edges and datasheet parameters. It isolates whether in-place boundary identification, rather than the scheduling logic, drives any gain.
The key ablation is an empirical static ranking. We measure each core's steady temperature under identical solo load once, sort cores, and schedule by that table with no coupling or time constants. A second ablation zeroes $k_{ij}$ in our model.
Why not just…?
Why not just rank cores once by measured temperature and skip the model? This is the most serious threat, and we treat it as the primary ablation rather than argue it away. If a one-shot solo-load ranking matches our scheduler, the finding still stands that geometric rings are the wrong basis, but the model adds nothing. We expect the ranking to fall short in two regimes. The first is multi-thread placements, where lateral coupling means a core that is cool alone is hot next to a busy neighbor, an effect Hossein Khani et al. found large in simulation. The second is choosing rotation periods, which needs time constants that a static ranking lacks. The experiments report both regimes separately, so a tie in either will be visible.
Why not just use a model-free learner on the real sensors, as ReLeTA does? A learner implicitly absorbs the boundary, so it may perform well at a fixed operating point. Its weakness is that it must relearn whenever the boundary shifts, and it was shown only on four cores. DeepOHeat-v2 is relevant here only as a numerical, not physical, result: its purely learned thermal surrogates exceeded 30 K peak error under distribution shift until explicit discretized physics was added. The boundary perturbation experiment is exactly a distribution shift. Adaptation time after the shift settles the question. If ReLeTA adapts as fast as our re-identification, we will say so.
Why not just trust the chip's built-in throttling? Throttling protects the silicon but slows the whole chip and stalls synchronized parallel threads. Both HotPotato (in simulation) and ReLeTA (on hardware) show proactive placement beating reactive baselines. We keep throttling enabled underneath every policy and report time spent throttled. This makes the benefit of placement directly measurable as avoided throttling.
Why not just fix the simulator's boundary conditions and keep designing in simulation? That is a legitimate outcome of this work rather than a rival to it. If calibrated $g_i$ values transfer across chips of the same model and across boundary conditions, a corrected HotSpot configuration is the cheaper product. The cross-unit and cross-condition transfer test below decides this.
Proposed Experiments
We will run PARSEC and SPLASH-2 multithreaded workloads (blackscholes, bodytrack, ferret, raytrace, fft) and NAS Parallel Benchmarks on at least a quad-core desktop matching ReLeTA's platform and a many-core server node. Each will be tested under nominal cooling and the three boundary perturbations, with repeated runs to bound sensor noise. Metrics are peak and average core temperature, spatial temperature spread, fraction of time throttled, response time, latency violations, and model prediction error in kelvin on held-out workloads.
The first decisive check is rank agreement. We compute the rank correlation between measured core cooling order (from $g_i$) and Manhattan-distance order, at nominal cooling and under each perturbation. Low or sign-flipping correlation would directly show that the geometric edge effect is not a property of real packages. Preserved correlation would be evidence that ring schemes transfer to hardware, which is also worth publishing.
The second check is model fidelity. We compare held-out temperature prediction error for the identified model against insulated-edge HotSpot with datasheet parameters. This quantifies, for processors, the kind of simulation-to-measurement gap the heater study found in a fluid system.
The third check is scheduling consequence. For every baseline and ablation, we measure performance and peak temperature at nominal and perturbed boundaries. The prediction to test is that geometric rings and the static ranking lose ground under asymmetric perturbations while the re-identifying scheduler holds.
The fourth check is transfer. We fit $g_i$ on one unit and one condition and evaluate on another unit of the same model and on other conditions. This separates chip-specific from design-level boundary behavior, and determines whether the lasting contribution is an online method or a corrected simulator.
References
- 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
- CoMeT: An Integrated Interval Thermal Simulation Toolchain for 2D, 2.5D, and 3D Processor-Memory Systems
- Study on the Flow Characteristics and Heating Performance of a Drilling Fluid Helical Heater
- Quantifying heat transfer in DMD-based optoelectronic tweezers with infrared thermography
- Thermodynamic modeling and simulation of working process of high efficiency two-stroke engine
- ReLeTA: Reinforcement Learning for Thermal-Aware Task Allocation on Multicore
- Jointly Managing Electrical and Thermal Energy in Solar- and Battery-powered Computer Systems
- COUNTDOWN: A Run-Time Library for Performance-Neutral Energy Saving in MPI Applications
- DeepOHeat-v2: Self-Improving Operator Learning for Fast and Trustworthy Thermal Optimization in 3D-IC Design