Sparse parity on the ET-SoC-1
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).
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.”
- Which sizes. Without noise the problem is a GF(2) linear solve: on one core at n = 512. With noise (η = 0.3–0.4) the practical method is the exhaustive correlation search, and at n = 256–512, k = 4–5 it scores candidates, seconds to a quarter of a minute on one core (§1).
- How. Each candidate's score is one entry of a ±1 matrix product. Hart 1 of every minion builds the rows, hart 0 feeds the tensor unit. On every run two closed-form checksums over all the candidates must come out exact, which a dropped, doubled or mis-scored tile fails, and a CPU oracle rescores whole minions (§2).
- How fast. L1, L2 and (256,5) solve in on the card. One core takes ; six tuned threads, with the CPU's best method at P(loss) ≤ 10−4, (§3).
- Energy. Measured on the one-stage scan, the board uses , and per solve, idle included. The board alone is below the CPU's package energy at an assumed 125–251 W, and below it with the host that drives the card (§4).
- What limits it. Hart 1's row generation, the shire's bandwidth for streamed operands (a floor of about 512 cycles per tensor op at 32 minions per shire, against 270 in a microbenchmark whose rows stay resident), and the per-tile epilogue. Cooperative operand loads, resident rows and a faster row generator are what would help next (§5).
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.
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:
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.
TensorIMA8A32 S times:C[16×16] += A[16×64]·B[64×16]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
- Hand-off. Hart 1 stages each row tile with stores that bypass its L1 (
fswg.psinto the scratchpad), then publishes it withfence; amoswapl.don an L2 line; hart 0 polls with a pause between polls. Whether that fence waits for the stores is not in the manual, so M1 ran a probe that loads every row tile right after it is published: probe runs exact, no race seen. - No shared writes. The L1 is not coherent: the features are written once in disjoint 1 KB tiles before a barrier, the staging areas are private, and each hart owns one 64 B record and each minion its log.
- The manual's wait is needed. Skipping the
TensorWaitthe manual requires before an A buffer is reloaded gave a wrong result on silicon (M2, ). - The 10 s rule in the host. It refuses a work list modelled over 4 s and launches only while the launch's timeout still ends inside 9 s of the process's start; a larger size runs as host-side slices, one process each.
- The survivor logs. Each minion's log holds 1.5× its expected share plus 10σ; an overflow is counted, flagged and fails the run. The host fills the log area with all-ones before every launch, so a log line that never reached DRAM reads as an invalid entry, not as an old one.
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.
- 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.
- 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.
- M3, 1,024 minions: L1 in and L2 in , both with exact checksums: slower than the design's .
- 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.
- 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.
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.
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).
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:
- Hart 1's row generation. In M3 a row tile cost hart 1 about 2,081 + S·(2,108 + 570·(k−1)) cycles, 4.8× what the planner assumed; at L2 the mean minion's hart 0 waited cycles per op for rows, and the busiest . Incremental generation (M4) gained 1.1–1.2×; the second half of (256,5) still ran at cycles per op on its busiest minion.
- The shire's bandwidth for streamed rows. When m > 192 the rows do not fit the L1 scratchpad, so every op brings 2 KB into each of 32 minions, and the shire's 128 B per cycle caps an op at 512 cycles. At that rate L2's one-stage scan cannot run faster than on 1,024 minions from the ops alone, or with the staged rows counted too (DESIGN.md's Amendments). Its two-stage stage 1 ran at cycles per op on the busiest minion: a launch of where 512 cycles per op would take .
- The epilogue. Each output tile's epilogue costs cycles with the tensor unit idle ( cycles per op at L1, where S = 7). Hiding it between the next tile's ops (variant c), which the fitted model favoured, ran slower on silicon: L1 and L2 , × and × its model.
What would help next, in the order the data suggests:
- Cooperative operand loads.
tensor_coopmerges identicalTensorLoads 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. - 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.
- 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.
- 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
- One card. Every card run used aifoundry3's card, which a boot service pins at 600 MHz; the host's clock estimate read in the timed runs (M3–M5). aifoundry2's card was running a frozen validation, and the other cards were not tried.
- One seed per showcase size on the card (seed 1; C1 ran 20). A full scan's time does not depend on the data; the survivors' count does, and each two-stage run found the expected number.
- What is timed. The card's time is the launch as the host measures it: without the device open (0.18 s per process) and the instance's upload. The two-stage time adds the survivors' readback and stage 2 on six host threads. The CPU's times are the median of five repetitions, except L1's six-thread figure, the meet in the middle's expected time (a mean over 10 seeds); threads pinned one per core, niced, with the card idle.
- Equal risk on both sides. m is SP3's 99% sample count for both. The card's screens and the CPU's lose the secret with P < 10−4 (binomial tail). The CPU's faster screen at m1 = 1,024 () loses it with P = and is not used.
- The one-core baseline is the tuned AVX-512 scan (
spbase vexh, 8 candidates per 512-bit register), 2.4–4.4× faster on one core than SP3's scan. The card data's READMEs quote the first CPU run's one-core times (); this page uses the run after the reviews (). For L1 the meet in the middle is faster in expectation even on one core; the ratio is to the scan. - 16 threads are extrapolated from 6, not measured. Against them the card is about level ().
- CPU energy is assumed (§4), and so is the share of the host that drives the card. Measuring either needs the lab's admin: read access to the package's energy counter, or a wall meter.
- The critique that corrected the design. The design (DESIGN.md, brief SP4) first predicted the card at 120–130× one core and about 15× the host at its flagship, and 3.5–16× a whole 16-thread host across its ladder. It set the card against SP3's slower scan and a 16-thread host assumed at 8.5× one core. An adversarial critique (SP5) and four reviews (R1–R4) replaced that with the CPU's best measured method at equal risk, made the CPU's energy an assumption rather than a bound, and moved the showcase to η = 0.4. Then the card itself ran slower than the design's model at M3; M4 and M5 cut the card's time by from there, and the ratio that stands is six tuned threads. The changes are listed in DESIGN.md's Amendments (SP5, R1–R3) and the workload README's table of what the reviews found (R4).
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
Related reports
- Limits of observability — the hub: every ET-SoC-1 report, and what the meters cannot see; its §4.1 is the meter chain behind this page's §4.
- The ET-SoC-1, interactively — the die, a shire and a minion, and a matmul on the tensor unit: the parts §2 maps the scan onto.
- Matmul efficiency — the tensor unit's matmul on all 1,024 minions at 91% of peak in int8 (97% in fp32 and fp16), the rate this scan falls short of.
- Sparse compute — what the silicon does with zeros; its kernel was the template for this workload's shire masks and per-hart records.
- Memory hierarchy — latency and bandwidth of every level, the shire's L2 behind the 512-cycle floor among them.
- Influence functions on the ET-SoC-1 — another workload weighed against the chip's 1,024 minions, as a desk analysis.
- The energy manual — joules per operation, the idle law and the leakage correction used in §4.
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).