Sparse parity on the ET-SoC-1

29 September 2026 · CPU prototypes on aifoundry1's host (28 September) and aifoundry3's host; every card run on aifoundry3's card at 600 MHz, 04:15–11:40 PDT (M1–M5) · commits 92b168f to 6082cb9 · part of the ET-SoC-1 measurement reports

The ET-SoC-1 solves noisy sparse parity on all 1,024 of its kernel minions as an exhaustive correlation search, written as an int8 matrix product on the tensor units. On aifoundry3's card the flagship size, L2 (n = 512 features, a secret of k = 4 of them, labels flipped with probability η = 0.4, m = 1,850 samples: 2.83 billion candidate subsets), solves in . One core of the host's i7-11700K, running a tuned AVX-512 scan, takes (); six tuned threads running the CPU's best method at the same risk of missing the secret take (). Across the three showcase sizes the card is one core and six tuned threads. Against the whole 16-thread host, extrapolated from six threads, it is about level (). Energy was measured on the one-stage scan: the board alone uses less per solve than the CPU's package energy at an assumed 125–251 W, and less once the host that drives the card is counted. The design's first prediction, 3.5–16× a whole 16-thread host, did not survive a critique of its CPU baseline and the card's own measurements (§6).

L2 on the card, 2.83×109 candidates
(512, 4, 0.4, 1,850), two-stage screen, 1,024 minions
Against one core (tuned AVX-512 scan)
L1, L2 and (256,5)
Against six tuned threads, the CPU's best method
both sides lose the secret with P < 10−4
Board energy per solve, idle included
L1 · L2 · (256,5), one-stage scan: the board alone below the CPU's assumed package energy ( with the host)
The owner's request (28 September, 21:14 PDT): “prototype a sparse parity solver which is efficient on this machine. Come up with dimensions of the problem where it's visible to use the ~1,000 cores; toy prototyping first, experiment with various sizes, then a scalable solution which runs on the Esperanto chip.”
In short

1. The problem, and where 1,024 cores become visible

The problem. Each sample x is uniform in {±1}n. Its label y is the product of x over a secret subset S of k features, flipped with probability η. Given m samples, return S. A candidate subset T scores

where the tildes mark ±1 values and d(T) counts the samples whose label disagrees with the parity of T. The answer is the candidate with the largest score; a tie counts as a failure. m is SP3's 99% sample count, about 2 ln C(n,k)/(1−2η)2, which SP3's binomial model predicted within 0.63–1.37× of 20-seed measurements at 85 points.

Without noise it is not a many-core problem. With m ≥ n samples the labels are a linear system over GF(2), and elimination solves n = 512 in on one core (SP3, 400 runs, all solved by m = n + 6). The Sutro group's challenge tiers (n = 20, k = 3 and n = 32, k = 5, both noiseless) take microseconds. With noise elimination needs a clean subset of samples, and SP3's best elimination variant was 6–3,200× slower than the plain scan everywhere but k = 5, η = 0.1, n ≤ 128. What remains is the exhaustive correlation search, the statistical-query-optimal method: C(n,k) candidates times m samples. It is a matrix product, which is what the tensor unit does.

Where the minions show. A kernel launch on 32 shires costs about 0.56 ms and opening the device about 0.18 s, and the lab's rule caps a device-holding process at 10 s. So a solve is worth the card when its work W = C(n,k)·m is about 1012 subset-samples or more: a kernel of 50 ms or longer, where the launch is under 1% (DESIGN.md §1.3). Past about 8 s of card time a solve has to be split across processes. The chart shows where that falls: one core of SP3's AVX-512 bit scan at the 99% sample count, for n = 128–512, k = 3–5 and η = 0–0.4.

One core's time for the exhaustive scan, by noise η, sample count at 99% success

Filled marks: work C(n,k)·m ≥ 1012, where the 1,024 minions show; hollow: below it. Rings mark the three showcase sizes. Diamonds: GF(2) elimination on noiseless labels, the same for every k. SP3's scan (workloads/sparseparity/proto/spbits.c) on aifoundry1's i7-11700K, 28 September: measured at one thread where timed, else a timed slice, 4 threads × their measured speedup (), or the per-subset fit. The tuned scan used as the baseline from §3 on is 2.4–4.4× faster on one core.

Every point: one core's time, m and C(n,k) (the chart's table)

m is SP3's measured 20-of-20 sample count where the 20-seed search ran, else its binomial model's 99% point. Source: , through workloads/sparseparity/proto/report.py's helpers.

The showcase sizes follow from the chart. L1 (512, 4, 0.3, 448) is the strong-scaling size; L2 (512, 4, 0.4, 1,850) the flagship; (256, 5, 0.4, 1,925) the k = 5 size. The design first made (512, 5, 0.2, 218) its flagship, where m is small and the card's predicted lead was largest. After its critique the flagship moved to η = 0.4 (DESIGN.md, Amendments), where the CPU's AVX-512 popcount is at its best, so the comparison is the harder one for the card.

2. The algorithm and how it maps onto the chip

The scan as a matrix product. Write a candidate as T = R ∪ {j}: R a (k−1)-subset, j a feature larger than every element of R. The row for R holds, for each sample, the label times the product of R's features; the column for j holds feature j itself. Their dot product over the samples is c(T). Bits become the int8 values +1 and −1, the tensor unit's int32 sums are exact, and padding samples are zero bytes. Rows are taken in colex order, which sorts them by their largest element, so the valid entries (j above max R) form a staircase and each k-subset appears exactly once.

The tile. TensorIMA8A32 computes C[16×16] += A[16×64] × B[64×16] in int32. One output tile is 16 consecutive rows by 16 features; it takes S = ⌈m/64⌉ ops, one per 64 samples, accumulating in the tensor unit's C registers. A comes from the minion's 3 KB L1 scratchpad, B streams in from the shire's scratchpad. Only hart 0 of a minion may issue tensor ops, so the two harts split the work:

1 · The scan as tiles

Rows: the (k−1)-subsets R, 16 to a row tile, in colex order. Columns: the n features, 16 to a tile. Only tiles right of the staircase (j > max R) are computed; entries left of it inside a boundary tile are masked. The coloured strip shows the planner's blocks, dealt round-robin to the shires.

2 · One minion's two harts
Hart 1 builds a row tile: 16 rows × 64·S bytes of ±1, from bit-packed X and y (XOR the features of R, then expand to bytes), and stages it in the shire's scratchpad.
↓ published through an L2 line
Hart 0 loads A into its L1 scratchpad and a feature tile B into the tensor unit, then issues TensorIMA8A32 S times:C[16×16] += A[16×64]·B[64×16]
↓ after the last of the S ops
Epilogue (hart 0): mask the staircase, add Σc and Σc², keep the best score and a tie flag; in M5 also log every candidate with c1 ≥ τ1.
↓ at the end
one 64 B record per hart; one survivor log per minion (M5)
3 · 32 shires × 32 minions

The host cuts the row tiles into 4,096 blocks of equal modelled cost and deals block q to shire q mod 32: four blocks per minion. The features are copied once into every shire's 2.5 MB scratchpad. Nothing crosses between shires; the host reads 2,048 records back and checks them.

The mapping, schematically: the tile counts are illustrative (L2 has 1,381,776 row tiles and 32 column tiles). Only 32 of the chip's 34 minion shires run kernels: one is the firmware's master and one a spare.

Checking coverage. Two sums over all C(n,k) candidates have closed forms in the data alone, through the Krawtchouk polynomial Kk(w) = Σt (−1)t C(w,t) C(n−w,k−t), with wi the weight of sample i and d the Hamming distance:

A run that covers every candidate must reproduce both exactly, which a dropped, doubled or mis-scored tile fails: the three negative controls (a tile dropped, a tile scanned twice, one tile's staircase shifted) fail both sums on the card, as they should. Two sums cannot rule out every compensating error (two candidates' scores swapped keep both), so the CPU oracle also rescores whole minions and compares every hart's record field by field: a sample of minions in the host process (17 and 8 in M3's L1 and L2), and all 1,024 offline for the steps that card_run.sh re-checked at the end of M4 and M5, M5's two-stage runs among them.

The two-stage screen (M5). The card scores every candidate on the first m1 samples and logs those with c1 ≥ τ1; the host rescores the survivors on all m. The secret is lost only if its own c1 falls under τ1, a binomial tail that sets τ1: P(loss) is 8.8×10−5 at L1 (m1 = 320) and 8.9×10−5 at L2 and (256,5) (m1 = 1,152). At L2 that leaves survivors of 2.83×109 for the host.

The details that make it work on this chip

3. The ladder: M1 to M5

Every step ran on aifoundry3's card as its own process, under the card lock and a 10 s timeout, and the step scripts stop at the first unexpected result. The chart gives the time per solve of each size at each milestone against the CPU.

  1. M1, one minion (04:15 PDT): the smallest size's 4,960 correlations equal the CPU's one by one, the three negative controls fail as they should, the tie instance is flagged, and C1 (128, 4, 0.2, 192) on 32 minions passes on seeds. One minion at the L1 and L2 geometry ran cycles per tensor op with the epilogue off ( with it), against the design's 270–280.
  2. M2, one shire: from 1 to 32 minions a tensor op took cycles, so the shire's bandwidth is not the limit at this size. All of L1 on one shire solved in , the slowest minion × the median.
  3. M3, 1,024 minions: L1 in and L2 in , both with exact checksums: slower than the design's .
  4. M4: a cycle model fitted to the per-hart records of M1–M3 (19 constants, rms 1.8%) said why, and three fixes were tried as switches on one build. The planner weighted by the fitted model and incremental row generation (variant b) took L1 and L2 ; the epilogue split between the next tile's ops ran 1.4–1.8× slower than its model on silicon.
  5. M5, the two-stage screen (11:29 PDT): L1 , L2 , (256,5) , launch, survivor readback and host stage 2 included; the secret survived in all three, and the full oracle confirmed every survivor set offline on all 1,024 minions.
Time per solve at each milestone, against the CPU

Card: the kernel's launch time as the host measures it, on 32 shires × 32 minions except M2 (one shire); M5 adds the survivors' readback and stage 2 on six host threads. (256,5)'s M3 point is M1's kernel and planner run in two halves during M4's A/B. CPU lines: one core of the tuned AVX-512 scan (spbase vexh); six threads of the CPU's fastest method at P(loss) ≤ 10−4 (L1 the meet in the middle, L2 and (256,5) the CPU's own two-stage screen). Hollow rings: DESIGN.md's first predictions, with private operand loads at M3 and cooperative loads at M4.

16 threads are extrapolated from 6 (this work may use at most 6 threads on the host): linear to 8 cores at the fast end, the measured 4 → 6 step efficiency at the slow end, SMT not counted (no SMT run of the two-stage screen or the meet in the middle; one core's one-stage scan gained from its second thread) (workloads/sparseparity/tools/table_cpu.py).

Every point of the ladder, with its file
M1 and M2, step by step

Cycles per op are the busiest minion's (hpmcounter3, corrected). The timing steps run without the epilogue. Data: workloads/sparseparity/data/2026-09-29-aifoundry3-card/.

M4's A/B: six variants on one build

m1 = M1's kernel and planner; a = the planner weighted by the fitted cycle model; b = a + incremental row generation; c = a + the epilogue split between the next tile's ops; m4 = b + c; m4d = m4 + three A buffers. Each cell is one launch (for (256,5), two halves); the second line is the busiest minion's cycles per op.

Data: workloads/sparseparity/data/2026-09-29-aifoundry3-card-m4/ (08:17–08:45 PDT).

M5's two-stage runs, and its controls

4. Energy per solve

The board's energy was measured for the one-stage scan (variant b), one host process of back-to-back solves between idle brackets, sampled at 10 Hz: the service processor's board average above idle, less the rise of leakage with the die's measured temperature, ±3% claimed. The board idled at and read during the solves; the die stayed at , and every busy sample read 600 MHz.

The CPU's energy is assumed, not measured. The package's energy counter (RAPL) is root-only on the lab hosts, and the board lifts both package power limits to 4,095 W, so nothing bounds it either. The chart multiplies the CPU's measured six-thread time (at L1 the meet in the middle's expected time, a mean over 10 seeds) by the i7-11700K's rated 125 W (PL1) and 251 W (PL2), idle included, as the card's figure is.

Joules per solve: the card's board, measured, against the CPU's package, assumed

The card's board alone is below the CPU's assumed package energy. The host that drives the card is not free: its own package, assumed at 10–20 W idle plus 10–38.5 W per busy core-second (it kept cores busy on average), adds per solve, and the ratio with it is . The two-stage screen's energy was not measured: its launch is shorter, and its stage 2 runs on six host threads.

The energy runs, and the rails

The rails are the PMIC's running averages above idle: upper bounds, −2% to +7%; unmetered is the headline less the rails. The SRAM rail carries almost as much as the minion rail. Data: workloads/sparseparity/data/2026-09-29-aifoundry3-m5-energy/, reduced by workloads/sparseparity/tools/energy_reduce.py.

5. Where the time goes, and what would help next

A tensor op takes 270 cycles when its rows stay in the L1 scratchpad (E39) and 280 when both operands come from a small shared pool (mmbench, E37). M3 ran × and × slower than 270 cycles per op at L1 and L2. The cycle model (workloads/sparseparity/tools/cycle_model.py, fitted to M1–M3's records before M4 and M5 ran: 33 runs, 146 sampled minions, rms 1.8%) splits that gap into a product: the planner's imbalance ( and , busiest over mean minion), hart 0's overhead per op ( and ) and the op itself ( cycles streamed, × 270).

Cycles per tensor op in M3, by what hart 0 was doing

The fitted model's split of hart 0's time on M3's L1 and L2, for the mean minion and the busiest one. Issue-slot sharing is hart 0 slowed by hart 1, the two harts sharing one issue slot; waiting for rows is hart 0 idle until hart 1 publishes the next row tile. The dashed lines are the two rates measured elsewhere: 270 cycles with the rows resident, 512 when all 32 minions of a shire stream 2 KB per op from its L2 (4 B per minion-cycle).

Three limits remain after M4 and M5:

What would help next, in the order the data suggests:

  1. Cooperative operand loads. tensor_coop merges identical TensorLoads from the minions of a shire into one L2 request, so 32 minions walking the same feature tiles in lockstep would bring about 1.1 KB per op instead of 2 KB, under the 512-cycle floor; the design predicted about 295 cycles per op. It is not written, and lockstep across 32 minions has never run in this repository.
  2. Resident rows. At m ≤ 192 a row tile can stay in the L1 scratchpad for all its column tiles, and only the features stream (270 cycles per op in E39's microbenchmark). At η = 0.4 the threshold that keeps P(loss) under 10−4 still passes of the candidates at m1 = 192–320; the cheapest screen was m1 = 1,152. At L1 the resident screen (m1 = 192) launched in against streamed at m1 = 320 (its epilogue dominates at S = 3: cycles per op on the busiest minion), kept survivors at P(loss) and took , of it stage 2 on the host. It could pay at lower noise (DESIGN.md's S2, η = 0.2) or with a cheaper epilogue.
  3. A faster row generator. Fewer instructions per staged byte on hart 1, or the balanced split of the design (both operands generated, shared across a shire once cooperative loads work). Letting both harts generate gains at most 1.06×: they share one issue slot.
  4. The epilogue with the tensor unit busy. The split that the model favoured needs a second look on silicon before it can pay.
The busiest minion's cycles per op, from M3 to M5

The floor is the run's ops at 512 cycles each, spread over 1,024 minions: the time the streamed operands alone would take at the shire's measured rate. Counting the staged rows as well (1 KB per row tile and sample slice) adds at L1 and L2: and for the one-stage scan, the figures in DESIGN.md's Amendments.

The split of M3's cycles, as numbers

The busiest minion of M3's L1 drew row tiles to the median's : M1's planner undercosted narrow row tiles, which is what the fitted planner (M4's variant a) corrected.

6. Method and caveats

Data and how to rebuild this page. The design and research are in docs/research/sparse-parity/ (literature, the chip's primitives, DESIGN.md with its amendments, and docs/research/sparse-parity/design_model.py); the code, the tests and every result file in workloads/sparseparity/ (its README has the card runs' commands, which need the owner's go-ahead and a named card). This page's data is docs/reports/data/2026-09-29-sparse-parity/page.json, which docs/reports/data/2026-09-29-sparse-parity/make_page_data.py computes from those files, with no card:

python3 docs/reports/data/2026-09-29-sparse-parity/make_page_data.py
NODE_PATH=$PWD/node_modules python3 scripts/build-report.py sparse-parity \
    docs/reports/data/2026-09-29-sparse-parity/page.json docs/reports/2026-09-29-sparse-parity.html

Versions. 29 September 2026: first version, from the CPU prototypes of 28 September and the card runs M1–M5 of 29 September (04:15–11:40 PDT); public since that afternoon. 5 October: links to the hub's meter chain (§4.1) and the chip diagram, and this note corrected (it said the page was not yet published).