The Horace experiment: the same matmul draws 38 to 63 W depending on the data 20–22 September 2026, checked on three cards on 26 September · aifoundry2 (sections 1–9); aifoundry3 and card 1 of aifoundry1 (aifoundry1-c1) in section 10 and beside the claims the check re-measured · fp32 TensorFMA on all 1,024 minions · workloads/sparsity, tools/ettelem, rtl-sim/fma_toggle · part of the ET-SoC-1 measurement reports Checked on three cards (26 September 2026). This page's claims were re-measured under a pre-registered plan on aifoundry2, aifoundry3 and aifoundry1-c1 (four runs of each pattern per card). Of 39 claims tested here: 12 held, 22 corrected or narrowed, 2 differ by card and 3 not confirmed, as the hub’s scoreboard counts them. The pattern-to-pattern steps held on aifoundry2 and aifoundry3 and read the same on aifoundry1-c1; the flip model's out-of-sample error on the check's patterns is 0.9 to 1.0 W rather than 0.5 W, and a test at two launch temperatures could not say whether aifoundry3's lower switching power is the card or its cooler die (section 10). Most of that deficit, 10% as registered, comes from the reduction's fixed reference temperature: at the same die temperature aifoundry3 switches 3–4% less than aifoundry2 (post-data note C2). The earlier sessions' numbers stay, labelled as theirs (the record). Horace He's post "Strangely, Matrix Multiplications on GPUs Run Faster When Given 'Predictable' Data!" (April 2024) found that an A100 multiplies matrices of zeros about 15% faster than random ones (295 against 257 TFLOPS): predictable data flips fewer transistors, draws less power, and a power-limited GPU then clocks higher. On this chip the whole chain can be taken apart, because the RTL (the Verilog source) of its core family's multiply-add unit is open. At the same clock and the same 9.2 TFLOPS, a matmul on aifoundry2's card draws 38 W on zeros, 47 W on ones and 63 W on random values (the other cards' watts are in the figures below). It heats the die roughly in proportion to the watts above idle (12 and 30 W): 27 and 76 thousandths of a degree per trillion FLOPs on ones and random values. Zeros, 2 W above idle, move the whole-degree reading by at most one step, so their rise is not resolved (section 1). It follows the sparse compute report, whose first two runs, on aifoundry3, found that zeros save most of the tensor unit's power but no cycles. Simulating that RTL (core-et's Erbium branch: the same Minion core lineage in a later configuration, not the taped-out netlist) on the operands the card ran explains the watts: register bits clocked and nets toggled predict the board power of 14 patterns to 0.5 W rms in aifoundry2's session of 21 September, each predicted by a fit that left it out (0.9 to 1.0 W on each card's patterns of 26 September). A thermal network fitted to the same session then turns watts into the temperature curve to about 0.3 °C rms, which is what the sensor's rounding to whole degrees alone would leave. Horace's speed effect itself needs a die cool enough for the governor to raise the clock; section 6 shows it in a demonstration of seven runs on aifoundry2, the only card measured here whose governor raised the clock. Run for minutes instead of seconds, only zeros hold a steady temperature at full load (aifoundry2, one four-hour session): random data takes the die from 80 to 90 °C in 19 to 26 s (four runs), ones in about two minutes (three runs). A three-line model (flip rates to watts, leakage that grows with temperature, a thermal network) predicts those times from the flip counts, on runs it was not fitted to, to within a quarter; at ten minutes it runs a few degrees hot near the card's flip budget. It priced 14 structured matrices, from Hadamard to kaleidoscope, before they ran. On two more cards the power model needs at most one scale factor, which a random-data run calibrates: 0.88 to 0.99 as registered, 0.93 to 1.00 at the same die temperature; whether aifoundry3's is the card or its cooler die the check could not say (section 10). The thermal network is aifoundry2's alone: no other card's cooling over minutes was measured. Five runs each of zeros, ones and random normal matrices on aifoundry2, every run launched as the die cooled through the same temperature. The thin staircases are the sensor's whole-degree readings; the smooth lines are the temperature recovered from the step times (section 2). The random runs use five different random matrices and still land on top of each other. To repost: horace-heating.gif (three kinds, 0.5 MB) or horace-heating-6.gif (six kinds, 0.9 MB). Terms used on this page The compute cores of the ET-SoC-1 (Esperanto's RISC-V accelerator, now open-sourced by AI Foundry) are minions, each with two hardware threads (harts) and a tensor unit whose matrix multiply-add instruction is TensorFMA (one fp32 op multiplies 16×16×16 tiles: 4,096 multiply-adds); 32 minions form a shire. The service processor is the on-die management core whose firmware reads the sensors and runs the clock governor (600, 700 or 800 MHz). aifoundry2 and aifoundry3 are lab machines with one card each; aifoundry1 holds two, of which card 1 (aifoundry1-c1) was measured (card 0 could not hold a load then; a broken fan, replaced on 2 October). More in the hub's glossary. 1. Same FLOPs, different heat All 1,024 minions (the chip's compute cores, 32 to a shire; the chip has 1,088 in 34 shires, and the two not used here are the master and spare shires) each run one 16×16×16 fp32 TensorFMA (the tensor unit's matrix multiply-add) over and over, on operands held in the L1 scratchpad (3 KB of each minion's 4 KB data cache). Every pattern takes 546.0 cycles per op at 600 MHz, so every run does the same 9.18 × 10¹² FLOPs per second, 6.7 × 10¹³ in its 7.3 s. Only the values in A and B differ. Six patterns ran five times each; eight more ran twice each for the model in section 3. Sections 1 to 9 are aifoundry2's card; section 10 repeats these 7 s runs on aifoundry3 and aifoundry1-c1, and where another card's values differ the text gives them. Every run of the six main patterns. Top: die temperature; thin staircases are the sensor's whole-degree readings, one per run, and bold lines the mean recovered temperature. Bottom: board power, one thin line per run. Click a pattern to hide it. Heating per FLOP: the chart, table, and how small rises were measured Heating per FLOP: temperature gained over a 7 s run, divided by the FLOPs done in it (aifoundry2, 21 September; the eight extra patterns ran twice each) aifoundry2, launched at 81 °C. The rises of the three coolest patterns are not resolved by the whole-degree sensor, which moves by at most one step during their runs (0.3 to 0.8 °C by the thermal network); see section 4. The pJ columns divide each run's mean power over the whole 7 s by the FLOP rate; the W column is the launch-temperature value. The four findings, with every number The runs cluster by kind, tightly. Random normal draws 63.40 W with a run-to-run spread of 0.08 W over five different random matrices; zeros 38.29 ± 0.03 W; ones 46.73 ± 0.07 W. The rises of those three repeat to 0.03 °C (on aifoundry3 to 0.05 to 0.2 °C). They form three groups, 7 to 15 W apart on both cards (aifoundry2 and aifoundry3, 20–22 September): zeros alone, 2 W above idle; ones, π and the half-zero random matrix within a watt of each other (46 to 47 W, +1.7 to +1.8 °C); random uniform and random normal within about 2 W (61.3 against 63.4 W, a gap aifoundry2 resolves and aifoundry3 does not). Heating per FLOP follows power over idle, roughly, not total power. Just before each launch the idle card draws 36.3 W and the die is in balance. Averaged over the run, including the leakage its own heating adds, zeros add 2.0 W to that; the reading moves by at most one step, so the rise is only bounded (below about 1 °C; the recovered curve and the thermal network put it at 0.1 to 0.3 °C, 1 to 5 m°C per 10¹² FLOPs). Ones add 11.6 W: 27 m°C. Random normal adds 30.4 W: 76 m°C. (At the launch temperature the three add 2.0, 10.5 and 27.1 W; aifoundry3, idling at 25.1 W, adds 1.9, 9.7 and 24.9 W at its launch temperature and 2.0, 10.4 and 27.2 W over its runs: 21 and 70 m°C for ones and random normal.) The proportion is not exact: the ratio of the last two rises, 2.85, exceeds the ratio of the added watts, 2.63 (3.29 against 2.61 on aifoundry3), so random data heat 8% (aifoundry2) and 26% (aifoundry3) more per board watt than ones; section 4 compares the two run by run. In energy, averaged over the 7 s run, a FLOP costs 4.2 pJ of board energy on zeros, 5.2 pJ on ones and 7.3 pJ on random normal (3.0, 3.9 and 5.7 pJ on aifoundry3, whose idle is lower). Over the idle card those are 0.2, 1.3 and 3.3 pJ: the data decides a factor of 15 (14 on aifoundry3). The run average includes the leakage the run's own heating adds (66.7 W mean for random normal); at the launch temperature random normal is 63.4 W ÷ 9.18 TFLOPS = 6.9 pJ per FLOP (aifoundry3: 50.0 W, 5.4 pJ). Which bits are random matters. Random signs alone (±1) and random exponents alone cost about the same, 51.4 and 52.6 W; random mantissas alone 60.4 W, and all three together 63.4 W. One random operand with the other held at 1 costs 54.3 W when A is the random one and 57.9 W when B is. Section 3 shows why. The three-card check repeated these with four runs each on 26 September: the steps from ones to random signs, from signs to random mantissas and from mantissas to random normal held on aifoundry2 (+5.0, +8.8 and +3.0 W) and aifoundry3 (+4.8, +8.2 and +2.8 W) and read the same on aifoundry1-c1 (+5.1, +9.4 and +3.2 W), and B random cost 3.7, 3.4 and 3.8 W more than A random. The rails agree on where it goes. Late in the run random normal is 29.6 W above zeros on the board. The minion-core rail's own sensor accounts for 21.5 W of that and the SRAM and mesh rails for 1.0 W between them, about what a die 5 °C hotter adds to their leakage. The remaining 7 W is on no rail sensor, consistent with conversion loss in the regulators, which grows with the current. On aifoundry3 the same difference is 25.9 W: 20.5 W on the minion rail, 0.5 W on the SRAM and mesh rails, 4.9 W on no sensor. 2. Strict temperature control Two things make temperature a confound on this card. Power at the same work rises with die temperature through leakage: about 0.8 W per °C on the board while a hot pattern runs, measured from the drift of power within the hot 7 s runs (82–86 °C; measured the same way on 26 September, 0.80 W/°C [0.59, 1.00] on aifoundry2 and 0.80 [0.75, 0.85] on aifoundry1-c1, but 0.38 [0.29, 0.48] on aifoundry3, whose runs start at 57 °C; over minutes of a long matmul the check's busy slope is steeper, 1.0 [0.7, 1.4] W/°C on aifoundry2 at 81 to 97 °C, 1.1 [1.0, 1.2] on aifoundry1-c1 and 0.6 [0.5, 0.7] on aifoundry3); the idle law's slope is 0.65 W/°C at 80 °C (section 8). And on aifoundry2 the firmware's clock governor has a 65 °C threshold: below it a busy card is clocked up to 800 MHz at 0.62 V, above it the card is held at 600 MHz and 0.52 V (section 6). So every run starts from the same thermal state, well above that threshold: The protocol steps, the checks, and the sensor's quantisation Heat. If the die is below 84 °C, 2 s bursts of random-data matmul bring it there. Cool along the same curve. The card idles until the mean of the 34 minion-shire sensors first reads 80 °C. Approached from above, that reading is an edge, not a range: the kernel launches within a second of the 81→80 step. Run one pattern for 7 s, with 10 Hz telemetry throughout. Each process holds the card for under 10 s. The control held (the checks are under Method): every sample read 600 MHz and 516–518 mV; at the launches the die was at °C in the sensor's units with W idle, and random normal repeated across the hour's five blocks to W and °C (standard deviations). The limit that remains is the sensor: it reports whole degrees. A run's rise read off the sensor is good to
