betaFeedback

WorksPhysics and Astronomy

CHEQ: A Concurrent Hardware Evaluation Platform for QEC Decoders via Batch-Invariant Circuit-Level Noise Sampling

Abstract

Hardware quantum error correction (QEC) decoders require validation of logical error suppression and timing compliance before deployment. Rare logical failures and deadline violations demand extensive sampling, while algorithm-level software evaluation does not directly measure hardware response times. Circuit-level noise models contain many error mechanisms but few firings per shot at low physical error rates, making exhaustive per-shot scanning inefficient. We present CHEQ, an FPGA platform integrating on-chip sampling, concurrent decoder evaluation, scoring, and RISC-V control. Its Sampling Units use geometric skipping to sample firing locations from detector error models and amortize mechanism traversal across shots within each batch. Under independent random draws and exact geometric sampling, the shot distribution is invariant to batch size, enabling a memory-throughput tradeoff. A throughput model guides joint selection of the Sampling Unit count, batch size, and decoder count under FPGA resource constraints. Across evaluated conditions, the pooled one-sided 95% upper bound on the weighted root-mean-square relative firing-rate difference from Stim is 0.16%. At a batch size of 4,096, a Sampling Unit uses only 4.8%-11.2% of a Helios decoder's LUTs for code distances 7, 9, 11, and 13. On an AMD VCU118 FPGA at code distance 7 and physical error rate 10^-3, two Sampling Units supply 20 Helios decoders at 49.2 million shots/s, completing 10^10 shots in 3.4 minutes without host-side shot generation.

Introduction

As quantum computing progresses from the noisy intermediate-scale quantum era toward fault-tolerant operation, quantum error correction (QEC) decoders are becoming essential components of quantum computing systems [1, 2, 3, 4]. A QEC decoder is a classical processor that infers errors from repeatedly measured syndromes and determines corrections. In superconducting systems, syndrome rounds arrive approximately every 1 μs1\,\mu\mathrm{s}, requiring decoding throughput to keep pace [5, 6, 7]. Sustained throughput deficits cause syndrome backlogs, while long response times can violate time-sensitive feedback deadlines [7, 8, 9]. These throughput and latency constraints motivate dedicated FPGA and ASIC implementations [10, 11, 12, 13]. For surface codes below threshold, increasing the code distance exponentially suppresses logical errors but also increases the syndrome volume per round and decoding-graph size without extending the syndrome interval. Although recent superconducting processors have demonstrated improved logical error suppression with increasing distance, practical applications may require logical error rates several orders of magnitude lower than those demonstrated [5], [14], [15]. These requirements continue to motivate faster and more scalable decoder designs [16, 17, 18].

Before deployment, hardware QEC decoders must be evaluated for both logical error suppression and timing compliance [19, 20, 21]. Algorithm-level software evaluation can characterize decoding decisions but does not directly measure target-hardware response times; evaluating the implementation as a device under test (DUT) exposes both in the same run. Because logical failures and deadline violations must be rare, direct evaluation requires large numbers of sampled decoding instances, or shots [21], [22]. For direct Monte Carlo estimation at fixed relative precision, the required shot count scales inversely with failure probability. Large-scale applications can require logical error probabilities below 10−1010^{-10} per operation [5], [15]; for perspective, a per-shot logical failure probability of 10−1010^{-10} yields only one expected failure in 101010^{10} shots. At this scale, evaluation throughput depends on the complete path from shot generation through DUT delivery to result scoring, rather than generation alone. External generation incurs per-shot off-chip transfer, while storing pregenerated shots requires space proportional to the shot count. Generating and consuming shots on the same device removes this external transfer from the per-shot evaluation path.

Recent studies have explored on-chip noise generation for hardware QEC decoder evaluation [22], [23]. Because the generator and DUTs share device resources, greater generation parallelism leaves fewer resources for decoding, whereas insufficient parallelism can make generation the bottleneck, particularly at low physical error rates [22]. Realistic evaluation further requires circuit-level noise, where faults in syndrome-extraction gates and measurements propagate into correlated detector patterns [24], [25]. At larger code distances, such models can contain tens of thousands of error mechanisms, although only a small fraction fire in each shot. Testing every mechanism per shot therefore devotes most sampling work to non-firing events, motivating hardware that samples firing locations and amortizes mechanism traversal across shots.

We present CHEQ (Concurrent Hardware Evaluation platform for QEC decoders), an FPGA platform that generates circuit-level noise samples on chip and concurrently evaluates the logical error suppression and timing compliance of multiple decoder DUTs. Each Sampling Unit accepts a detector error model (DEM) exported by Stim [26] and uses geometric skipping to sample each mechanism’s firing locations within a batch. One DEM traversal serves as an entire batch, amortizing traversal overhead while event-processing work scales with actual firings. Under independent random draws and exact geometric sampling, the shot distribution is invariant to batch size, enabling a memory–throughput tradeoff. Shots from each completed batch are distributed among multiple DUTs, allowing one Sampling Unit to feed several DUTs concurrently. A throughput model guides joint selection of Sampling Unit count, batch size, and DUT count under FPGA resource constraints. CHEQ integrates Sampling Units, a DUT cluster, a Decoder Interfacing Unit, and a Scoring Unit with a RISC-V processor on one FPGA to execute evaluation campaigns without exchanging bulk shot data with an external host. We evaluate CHEQ using Helios decoder instances [11] at physical error rates of 10−310^{-3} and 5×10−45 \times10^{-4}. In the evaluated configurations, each Sampling Unit generates shots faster than a single DUT consumes them, enabling multiple DUTs to share its generation capacity. Comparisons with Stim using the same DEMs yield a pooled one-sided 95% upper confidence bound of 0.16% on the weighted root-mean-square relative difference in per-mechanism firing rates. At a batch size of 4,096, a Sampling Unit uses 4.8%–11.2% of a single Helios decoder’s LUTs across the evaluated code distances 7–13. At d=7d = 7 and pphys=10−3p_{\mathrm{phys}} = 10^{-3}, two Sampling Units sustain 20 DUTs at 49.2 million shots/s on a VCU118.

QEC Decoder Evaluation at Scale

Evaluation Requirements and Circuit-Level Noise

Direct Monte Carlo estimation of a rare logical failure probability requires a shot count that scales inversely with that probability at a fixed relative precision. Decoder response times also depend on the input syndrome, so characterizing rare deadline violations requires sufficient samples from the latency tail [5, 17]. Logical failures corrupt encoded information, whereas deadline violations can delay dependent logical operations and violate time-sensitive feedback constraints [7, 9]. Software rare-event methods can reduce the sampling cost of logical failure estimation by modifying the sampling distribution [27, 28, 29]. These estimates alone, however, do not directly characterize the response times of the target hardware under the target distribution. Evaluating the hardware as a DUT with shots drawn from this distribution directly exposes both its decoding decisions and response times. To avoid generation becoming the evaluation bottleneck, shots must be supplied at least as fast as the DUT consumes them.

Circuit-level evaluation must preserve the detector patterns and correlations induced by the target syndrome-extraction circuit [25]. In circuits using ancilla qubits, a Pauli fault can propagate through entangling gates and flip detectors at different spatial locations and measurement rounds [24]. Because both decoding decisions and response times depend on these patterns, the evaluation workload must capture the corresponding circuit-level error statistics. Relevant fault locations include gates and measurements, as well as idle intervals when specified by the target noise model [30].

A DEM captures these effects and enables shot generation without re-simulating the circuit for every shot [26]. It represents the noise as a set of independent stochastic error mechanisms, each specifying a firing probability and the detector and logical-observable bits flipped upon firing. For stabilizer circuits with stochastic Pauli noise, the effect of each fault on these bits can be precomputed by propagating the fault through the circuit [31]. A shot is then formed by independently sampling the mechanisms and XOR-accumulating the flip targets of those that fire. Although the mechanisms are independent, detector flips can be correlated because a single mechanism may affect multiple detectors. Direct sampling from a DEM with MM mechanisms therefore replaces per-shot circuit simulation with MM Bernoulli draws and XOR accumulation over the firing mechanisms. For the surface-code circuits considered in this work, the mechanism count scales as O(d2r)O(d^{2}r) with code distance dd and the number of syndrome rounds rr. In the evaluated configurations, MM increases from 5,471 at d=7d = 7 to 41,909 at d=13d = 13.

Batch-Invariant Firing-Based Shot Generation

Geometric-skip sampling avoids testing non-firing events individually by drawing successive firing positions directly. If mechanism ii fires with probability pip_i, the expected number of firing mechanisms per shot is Λ=∑i=1Mpi\Lambda= \sum_{i=1}^{M} p_i, with Λ≪M\Lambda\ll M at low physical error rates. For a fixed mechanism, firings across shots form independent Bernoulli trials with probability pip_i, so the number of non-firing shots before the next firing follows a geometric distribution. Sampling this gap jumps directly to the next firing without testing the intervening shots. Stim similarly uses geometric skipping for low-probability sampling [26].

The Sampling Unit traverses the mechanism list sequentially with a shared datapath, avoiding per-mechanism sampling logic that would compete with the decoder DUTs for FPGA resources [22]. Repeating this traversal for every shot would incur an O(M)O(M) per-shot cost despite sparse firings, so the Sampling Unit amortizes one traversal over a batch of WW shots while using geometric skipping to enumerate each mechanism’s firing positions. Mechanism ii contributes WpiWp_i expected firings plus one terminating draw per batch, yielding M+WΛM + W\Lambda draws per batch, or M/W+ΛM/W + \Lambda per shot. As WW increases, the per-shot draw count approaches Λ\Lambda rather than MM.

In hardware, WW determines the batch-buffer depth and associated control structure and is fixed at design time. Under independent random draws and exact geometric sampling, the generated shot distribution is invariant to WW. By the memoryless property of the geometric distribution, drawing a fresh gap at a batch boundary is distributionally equivalent to continuing from the residual gap of an uninterrupted Bernoulli firing process. Restarting each mechanism at batch boundaries therefore preserves its firing process in distribution. Because the mechanisms remain independent and shots are formed by XOR accumulation, batching does not change the joint shot distribution. Finite-precision deviations and consistency across the evaluated WW values are examined in Section IV-B.

Batch size can therefore tune the memory–throughput trade-off without changing the target shot distribution. Amortizing the per-mechanism traversal and termination overhead across WW shots gives the following first-order model for the average generation time per shot, excluding downstream stalls:

T(W)=aM/W+bΛ,(1)T(W) = aM/W + b\Lambda, \tag*{(1)}

where aa captures the effective fixed cost incurred once per mechanism per batch, including traversal and termination, and bb captures the incremental cost associated with an in-batch firing event. Both coefficients are implementation dependent and absorb the effects of pipeline overlap. Only the first term decreases with WW, so increasing the batch size reduces the amortized traversal overhead at the cost of a larger batch buffer, while T(W)T(W) approaches the firing-limited term bΛb\Lambda. When T(W)T(W) becomes smaller than the per-shot service interval of a decoder DUT, one Sampling Unit can supply multiple DUTs; increasing WW enlarges this headroom until the firing-dependent term or FPGA resources become the limiting factor.

CHEQ Evaluation Engine Architecture

Figure 1 shows the CHEQ evaluation engine integrated into a RISC-V-based FPGA platform. The engine implements the complete evaluation path from shot generation and distribution to decoding and result scoring on a single FPGA. It comprises an AXI Interface for processor access, a Mechanism Memory providing one descriptor read port per Sampling Unit, NN Sampling Units that generate shots, a Decoder Interfacing Unit (DIU) that dispatches them to KK decoder DUTs and collects their responses, and a Scoring Unit that evaluates results.

Figure 1. Block diagram of the CHEQ platform on a single FPGA. Shot rows flow left to right from the Sampling Units through the Decoder Interfacing Unit to KK decoder DUTs and the Scoring Unit; the RISC-V core loads the configuration beforehand, drains failure logs during the campaign, and reads the counters upon completion.

Sampling Unit

Each Sampling Unit generates batches of WW shots by drawing firing positions rather than individual mechanism–shot decisions. DEM preprocessing produces a sampling coefficient cpc_p and a detector/observable flip descriptor mechdescmechdesc for each mechanism, stored in the unit’s cpc_p memory and shared Mechanism Memory, respectively. The Batch Memory accumulates shot vectors in DEM-defined detector and observable bit order and delivers completed batches to the DIU.

Gap generation. For firing probability pp and a uniform variate U∈(0,1)U \in(0, 1), inverse-transform sampling gives Gap=⌊(−log⁡2U)cp⌋Gap = \lfloor(-\log_2 U)c_p\rfloor, where cp=−1/log⁡2(1−p)c_p = -1/\log_2(1-p). Precomputing cpc_p replaces division with multiplication. A hardware xoshiro128++ PRNG [32] supplies one 32-bit value representing UU per cycle. Since cp≈0.693/pc_p \approx0.693/p for small pp, each coefficient uses an 18-bit normalized significand and a 4-bit shift. The Gap Generator approximates −log⁡2U-\log_2 U using a leading-zero count and a 256-entry log⁡2\log_2 table with linear interpolation, then multiplies by the coefficient significand and restores the scale using the shift. Its six-stage pipeline sustains one gap per cycle. A zero random input or a computed gap of at least WW is saturated to WW, placing the next firing outside the batch. Coefficient quantization, logarithm approximation, and finite random-number precision are evaluated in Section IV. Section IV

Interleaved scheduling. Successive draws of the same mechanism have an eight-cycle recurrence because each depends on the preceding position update. Eight interleaved Slots hide this latency, each storing mechidxmech_{idx} and the next search position shotidxshot_{idx}. At batch start, the Mech Cursor assigns the first eight mechanisms with zero search positions. The Slots issue draws in round-robin order using their cpc_p values and successive PRNG outputs, allowing each update to complete before the Slot is revisited. For a returned gap, shotidx′=shotidx+Gapshot'_{idx}=shot_{idx}+Gap. If shotidx′<Wshot'_{idx}<W, the unit emits an event and advances to shotidx′+1shot'_{idx}+1; otherwise, the Mech Cursor assigns the next mechanism with a zero search position or empties the Slot if none remain.

Sparse mask generation. Each descriptor stores observable flip bits and sparse detector-index entries with valid bits rather than a full-width shot mask. Four detector entries suffice for the evaluated DEMs, with unused entries marked invalid and repeated indices reduced modulo two during preprocessing. The Target Index Registers load one descriptor per Slot upon mechanism assignment and reuse it for every firing. The Mask Generator OR-combines one-hot vectors of the valid detector indices and appends the observable flip bits to form a shot-width maskmask. XOR-accumulated observable bits provide the reference observable for scoring.

Double-buffered accumulation. Two Batch Memory banks overlap filling the current batch with draining the preceding one. Each event reads the row at shotidx′shot'_{idx}, XORs it with maskmask, and writes it back, making the final shot independent of event order. The read–modify–write pipeline accepts one event per cycle, matching the maximum arrival rate of one event per draw, while a bypass handles successive accesses to the same row before writeback. Both banks are cleared at campaign initialization, and drained rows are cleared for reuse. A fill completes after the mechanism list is exhausted, all Slots are empty, and all writes have committed; the banks exchange roles after both fill and drain complete. The next batch restarts the Mech Cursor at the beginning of the DEM while retaining the PRNG state to avoid repeating the same sequence.

The model in Section II-B predicts M+WΛM+W\Lambda draws per batch: WΛW\Lambda expected firings and one terminating draw per mechanism. Because descriptor access, gap generation, and event accumulation overlap, the expected fill cost is Cfill≈M+WΛC_{\mathrm{fill}}\approx M+W\Lambda cycles after neglecting pipeline startup and final Slot retirement, giving the coefficients a=b=1a=b=1 in (1).

Decoder Evaluation Path

Tagged dispatch. Variable decoding latency across KK concurrent DUTs can produce out-of-order results, while only detector bits enter the DUT and the reference observable must be retained for scoring. CHEQ uses the index of a free Pending Buffer entry as each shot’s tag and retains the complete shot in that entry until scoring. Its detector bits and tag are forwarded to the Decoder Adapter, which selects and rearranges the required detectors to match the DUT’s input format. For the unmodified Helios circuit-level union-find decoder [11], the Adapter formats the ZZ-subgraph detectors as r+1r+1 detector layers of (d2−1)/2(d^2-1)/2 bits. An N:KN:K Arbiter dispatches each adapted input and tag to an idle Decoder Bridge, which transfers the input according to the DUT handshake and retains the tag in its Tag Queue. Because the Bridges operate independently, other shots can be dispatched while earlier DUTs are receiving or processing their inputs.

ResponseDeadline violationLogical failureFailure log
On-time match–––
On-time mismatch–CountedRecorded
Late matchCounted–Recorded
Late mismatchCountedCountedRecorded
TimeoutCountedNot evaluatedRecorded

Table 1. Independent deadline and logical scoring.

Response tracking and scoring. A Bridge counter measures TdecT_{\mathrm{dec}} from acceptance of the final input layer to emission of the final result bit. Because input layers arrive sequentially in real-time operation, this interval captures the post-input latency relevant to downstream feedback; it includes result output but excludes input loading and pre-dispatch waiting. The processor sets an evaluation deadline and a larger maximum wait. If no complete response arrives by the latter, the Bridge resets the DUT and records the limit as a timeout bound rather than a measured completion latency. For a completed response, odeco_{\mathrm{dec}} is the parity of the returned correction bits selected by a processor-programmed observable mask. The Bridge forwards each tagged response or timeout record to the Result Buffer.

The Scoring Controller uses the returned tag to retrieve the original shot and releases its Pending Buffer entry after scoring. Table I summarizes the policy: every completed response is checked for logical mismatch, and one exceeding the deadline is additionally counted as a deadline violation; a timeout is counted only as a deadline violation. For each failed shot, the Failure Log Memory stores its batch and shot indices, original shot, available DUT correction data, TdecT_{\mathrm{dec}}, and deadline-violation status.

DUT integration and throughput. DUT-specific interface logic is confined to the Decoder Adapters and Decoder Bridges. Retargeting requires adapting only these two blocks to the DUT’s input and output conventions, while the DEM and decoding graph must correspond to the same syndrome-extraction circuit and detector definitions. Each Bridge waits for DUT input readiness, allowing non-overlapped DUTs that accept a new shot only after completing the current one to be evaluated without modification.

A full Pending Buffer stalls drain reads and delays bank exchange, so throughput is limited by the slower of generation and downstream consumption. For each Sampling Unit, excluding bank-switch overhead, the steady-state batch period is max⁡(Cfill,Cdrain)\max(C_{\mathrm{fill}}, C_{\mathrm{drain}}), where CdrainC_{\mathrm{drain}} includes delivery and clearing of the WW shots and stalls from DUT availability and buffer occupancy. The average DUT service interval CdecC_{\mathrm{dec}} spans input loading, decoding, and result output, making it distinct from the response latency TdecT_{\mathrm{dec}}. With T(W)T(W) also in cycles per shot, § 3-C jointly selects NN, WW, and KK using these costs and the FPGA resource budget.

Campaign control

Before execution, the RISC-V processor loads mechdescmech_{\mathrm{desc}}, cpc_p, the observable mask, maximum wait, evaluation deadline, one PRNG seed per Sampling Unit, and the total batch count BB through the AXI Interface, and then issues a single start command. It drains failure logs to DDR during execution and reads the aggregate counters after all n=BWn=BW shots are evaluated. All generation, decoding, and scoring remain on chip; after configuration, only aggregate counters and failure logs cross the FPGA boundary.

Configuration Selection

For a given workload and clock frequency, CHEQ jointly selects NN, WW, and KK to maximize campaign throughput within the FPGA resource budget. With sufficient buffering and no DIU or Scoring Unit bottleneck, the steady-state throughput in evaluated shots per cycle is modeled as

Q(N,K,W)=min⁡(N/T(W), K/Cdec),(2)Q(N,K,W)=\min\left(N/T(W),\,K/C_{\mathrm{dec}}\right), \tag*{(2)}

where T(W)=M/W+ΛT(W)=M/W+\Lambda is the per-shot generation cost and CdecC_{\mathrm{dec}} is the average DUT service interval. For each candidate NN, KK is set to the maximum resource-feasible value because QQ is nondecreasing in KK. Conversely, once the aggregate sampling rate reaches the aggregate DUT service rate K/CdecK/C_{\mathrm{dec}}, additional sampling capacity does not increase throughput. Moreover, T(W)>ΛT(W)>\Lambda for any finite WW, so the number of DUTs that one Sampling Unit can keep continuously supplied remains below Cdec/ΛC_{\mathrm{dec}}/\Lambda. Supplying a DUT cluster beyond this limit therefore requires additional Sampling Units rather than batch expansion alone.

For this selection model, the WW-dependent resource cost is represented by the Batch Memory allocation. For each feasible NN, Wmax⁡(N)W_{\max}(N) denotes the largest per-unit batch size for which the NN double-buffered Batch Memories fit within the URAM budget. The maximum DUT count supported by the remaining resources, accounting for the Sampling Units, Mechanism Memory, per-DUT interface logic, and platform overhead, is denoted by Kres(N)K_{\mathrm{res}}(N). The maximum throughput for this NN is therefore QN=min⁡{N/T(Wmax⁡(N)),Kres(N)/Cdec}Q_N=\min\{N/T(W_{\max}(N)), K_{\mathrm{res}}(N)/C_{\mathrm{dec}}\}. CHEQ evaluates QNQ_N over all feasible NN, chooses the smallest NN attaining the maximum predicted throughput as N∗N^*, and sets K∗=Kres(N∗)K^*=K_{\mathrm{res}}(N^*).

The batch size is then reduced to the smallest Batch Memory allocation that preserves QN∗Q_{N^*}. When the selected configuration is DUT-limited, the condition N∗/T(W)≥K∗/CdecN^*/T(W)\ge K^*/C_{\mathrm{dec}} gives

W∗=⌈MN∗Cdec/K∗−Λ⌉Du,(3)W^*=\left\lceil\frac{M}{N^*C_{\mathrm{dec}}/K^*-\Lambda}\right\rceil_{D_u}, \tag*{(3)}

where ⌈x⌉Du=Du⌈x/Du⌉\lceil x\rceil_{D_u}=D_u\lceil x/D_u\rceil rounds xx up to a multiple of the URAM depth DuD_u, which determines the Batch Memory allocation granularity. The denominator is positive whenever the DUT-limited rate is achievable with a finite batch size. If sampling remains the bottleneck, W∗=Wmax⁡(N∗)W^*=W_{\max}(N^*) is retained to maximize the predicted throughput. For the selected N∗N^*, the descriptor table is replicated across ⌈N∗/2⌉\lceil N^*/2\rceil identical dual-port memories, providing one dedicated read port to each Sampling Unit.

Experimental Evaluation

We evaluate the Sampling Unit’s fidelity to the target distribution and its ability to generate shots faster than a single DUT consumes them. We then characterize the campaign throughput, DUT response latency, and logical error rates of configurations selected using the method in § 3-C.

Evaluation Methodology

Implementation. The CHEQ evaluation engine is implemented in Verilog RTL and integrated into a stand-alone FPGA system built upon the hardware infrastructure developed for our prior quantum-circuit emulation work [33, 34, 35], comprising a Rocket RISC-V core [36], DDR4 controller, AXI interconnect, and peripherals. The complete system is synthesized, placed, and routed for an AMD VCU118 FPGA board [37] using Vivado 2024.2 at fclk=100f_{\mathrm{clk}} = 100 MHz with the same implementation strategy across all configurations. Table II shows the post-route resources of a representative d=7d = 7, pphys=10−3p_{\mathrm{phys}} = 10^{-3} prototype integrating two Sampling Units and 20 DUTs. The 20 DUTs account for 80.6% of the system LUTs, while the CHEQ Evaluation Engine accounts for 15.9%. Within the engine, the DIU dominates LUT usage at 14.0% of the system LUTs because each DUT requires a Decoder Bridge and Tag Queue, whereas the two Sampling Units and Mechanism Memory together use only 0.9%.

ComponentLUTsFFsBRAMsURAMs
Rocket Core15,2469,75512.00
System IPs14,32920,67541.50
Interconnect5,3168,95500
CHEQ Evaluation Engine160,191119,03541.026
└ 2× Sampling Unit9,0325,6082.024
└ Mechanism Memory4212102
└ Scoring Unit9,93812,69839.00
└ Decoder Interfacing Unit141,179100,60800
20× Helios Decoders (DUTs)810,284224,68200

Table II. FPGA resource breakdown of CHEQ.

Workloads. We use rotated surface-code memory-Z circuits generated by Stim v1.16.0 [26]. Each circuit initializes ∣0L⟩|0_L\rangle, performs rr syndrome-extraction rounds, and measures ZLZ_L. We evaluate d∈{7,9,11,13}d \in\{7,9,11,13\} with r=dr = d and set the four generator noise parameters—post-Clifford depolarization, pre-round data-qubit depolarization, reset errors, and measurement errors—to pphys∈{10−3,5×10−4}p_{\mathrm{phys}} \in\{10^{-3}, 5 \times10^{-4}\}. No additional idle noise is applied, and DEMs keep hyperedges, with identical-target mechanisms merged. Table III summarizes the workload parameters, per-DUT resources, and service intervals; for each dd, detector, observable, and mechanism counts are independent of pphysp_{\mathrm{phys}}, with (d2−1)r(d^2 - 1)r detectors and Λ=∑pi\Lambda= \sum p_i approximately proportional to pphysp_{\mathrm{phys}}.

Metricd=7d = 7d=9d = 9d=11d = 11d=13d = 13
Detectors3367201,3202,184
Observables1111
Workload Mechanisms5,47112,70524,48341,909
Λ\Lambda (10−310^{-3})2.435.249.6616.04
Λ\Lambda (5×10−45 \times10^{-4})1.222.624.838.02
DUT (Helios) LUTs41,341102,521202,442368,164
DUT (Helios) FFs11,27224,68045,61280,400
CdecC_{\mathrm{dec}} (10−310^{-3})40.4349.5158.1766.83
CdecC_{\mathrm{dec}} (5×10−45 \times10^{-4})37.8146.1153.9961.67

Table III. Workload and DUT characteristics. Parentheses denote pphysp_{\mathrm{phys}}; CdecC_{\mathrm{dec}} is in cycles/shot.

DUT configuration and timing. The DUT is the publicly available circuit-level Helios union-find decoder [11], with its decoding RTL unchanged. Helios decodes a finite syndrome window and accepts the next window only after emitting the final correction word of the current one. Its decoding graph is configured to match the DEM circuit and detector definitions by closing the temporal boundary preceding round 0, which is open in the released configuration but has no matching boundary before the target DEM’s fixed initialization. The correspondence between the DIU mapping and decoding graph is verified by exhaustively injecting every DEM mechanism. The LUT and FF entries in Table III are for one standalone Helios DUT. In a separate run that keeps the DUT continuously supplied, CdecC_{\mathrm{dec}} is measured at the DUT interface as the average interval from the start of one shot’s input transfer until the DUT can accept the next shot. It therefore includes input loading, decoding, result output, and the transition to next-shot readiness, unlike the post-input response latency TdecT_{\mathrm{dec}} in § 3-B. To capture TdecT_{\mathrm{dec}} for every shot, we use a cycle-indexed counter bank occupying one additional BRAM; this auxiliary measurement logic is excluded from Table II.

Results and Analysis

Sampling fidelity. We assess finite-precision fidelity at the arithmetic and RTL levels across eight workloads and six batch sizes W∈{210,211,…,215}W \in\{2^{10}, 2^{11}, \ldots, 2^{15}\} (48 conditions). Exhaustive enumeration of all 32 Gap Generator inputs yields per-mechanism batch-average firing probabilities within 0.002% of the DEM probabilities pip_i. Position-wise probabilities show no dependence on WW; relative errors reach 1.49% for the least probable mechanism and 0.23% when firing-weighted across mechanisms. Uniform averaging across batch positions yields the batch-average firing-rate error reported above.

RTL firing counts before Batch Memory accumulation are compared with 10810^8 Stim shots from the same DEM. For each condition, per-mechanism two-sample χ2\chi^2 statistics are summed to MM degrees of freedom and tested at the Bonferroni threshold 0.05/480.05/48. The 1.0×1061.0 \times10^6–5.0×1065.0 \times10^6 RTL shots per condition provide at least 0.9 power to detect a 1% weighted RMS relative deviation δ\delta, with weights pi/(1−pi)p_i/(1-p_i). No condition is rejected (minimum pp-value 0.025); δ\delta estimates reach 0.66% and Bonferroni-adjusted one-sided 95% upper bounds 1.07%. The one-sided 95% upper bound pooled over the 48 conditions is 0.16%. Batch firing-count variances and lag-1 correlations are consistent with independent firing at 95% confidence; all 32 traced shots per condition match the Batch Memory contents.

Sampling resources and throughput. In Table IV, increasing WW by 32×32\times changes LUT and FF usage by at most 3.7% and 4.3%, whereas URAM grows beyond W=4,096W = 4{,}096 in Batch Memory allocation units of Du=4,096D_u = 4{,}096. This supports the

ddWWLUT / FF / URAMWWLUT / FF / URAM
71k4,614 / 2,860 / 128k4,660 / 2,925 / 22
2k4,652 / 2,881 / 1216k4,657 / 2,944 / 42
4k4,635 / 2,899 / 1232k4,680 / 2,969 / 82
91k6,250 / 4,084 / 268k6,321 / 4,132 / 48
2k6,228 / 4,097 / 2616k6,310 / 4,260 / 92
4k6,301 / 4,118 / 2632k6,318 / 4,168 / 180
111k10,611 / 6,009 / 448k10,713 / 6,062 / 82
2k10,330 / 5,993 / 4416k10,682 / 6,077 / 158
4k10,699 / 6,058 / 4432k10,693 / 6,090 / 310
131k17,616 / 8,708 / 738k17,649 / 8,769 / 135
2k17,647 / 8,729 / 7316k17,673 / 8,783 / 259
4k17,835 / 8,758 / 7332k17,732 / 8,840 / 507

Table IV. Post-synthesis Sampling Unit resources by WW and dd.

WW-dependent resource model in § 3-C. At W=4,096W=4{,}096, a Sampling Unit uses 4.8–11.2% of a Helios DUT’s LUTs and 10.9–25.7% of its FFs, with both ratios decreasing with dd.

Figure 2 shows measured Csample=Cfill/WC_{\mathrm{sample}}=C_{\mathrm{fill}}/W at pphys=10−3p_{\mathrm{phys}}=10^{-3}. Fitting (1) across all distances gives a=1.0027a=1.0027 and b=1.0014b=1.0014, both within 0.3% of unity, with a maximum relative residual of 0.63%. Thus, the measured implementation agrees with the one-cycle termination and firing costs in § 3-A. Doubling WW halves M/WM/W; costs are at most 1.161Λ1.161\Lambda and 1.082Λ1.082\Lambda for W=16,384W=16{,}384 and 32,76832{,}768.

Sampling Unit cycles/shot versus W

Figure 2. Sampling Unit cycles/shot versus WW at pphys=10−3p_{\mathrm{phys}}=10^{-3}, with fits to (1) as solid lines and Λ\Lambda as dashed lines.

On-FPGA alternatives. Table V compares the Sampling Unit at W=4,096W=4{,}096 with two on-FPGA alternatives at pphys=10−3p_{\mathrm{phys}}=10^{-3}. RISC-V software adds no logic, but generation takes 32–233×Cdec\times C_{\mathrm{dec}}, or 59–297×\times with MMIO delivery. A workload-matched 256-comparator array testing all MM mechanisms per shot, mapped as in [22], requires 6.1–6.3×\times more cycles and 6.1–13.3×\times more LUTs than the Sampling Unit. In contrast, the Sampling Unit requires only 3.79–26.27 cycles/shot, remaining faster than one DUT at every distance.

ddRISC-V sw. CyclesComparator array CyclesComparator array LUTsSampling Unit CyclesSampling Unit LUTs
71,297.02361,7353.794,635
93,212.65171,8578.386,301
117,522.59786,63215.6810,699
1315,550.4165108,19626.2717,835

Table V. Shot-generation cycles and post-synthesis LUT usage of on-FPGA alternatives at pphys=10−3p_{\mathrm{phys}}=10^{-3}.

Configuration and campaign throughput. In Table VI, Kres=20K_{\mathrm{res}}=20 at d=7d=7 and pphys=10−3p_{\mathrm{phys}}=10^{-3} exceeds the single-unit supply limit Cdec/Λ=16.64C_{\mathrm{dec}}/\Lambda=16.64, requiring N∗=2N^{*}=2; the other seven configurations use one Sampling Unit. The two-unit configuration supplies 53.1 Mshot/s against a 20-DUT demand of 49.5 Mshot/s, and the second unit costs only 0.4% of device LUTs while raising measured throughput to 49.2 Mshot/s, beyond the single-unit asymptotic ceiling of 41.2. At d=9d=9, K∗=8K^{*}=8 is below Cdec/Λ=9.45C_{\mathrm{dec}}/\Lambda=9.45, and W∗=16,384W^{*}=16{,}384 alone lifts single-unit supply to 8.2 DUTs from 5.9 at W=4,096W=4{,}096.

ddpphysp_{\mathrm{phys}}Cdec/ΛC_{\mathrm{dec}}/\LambdaKresK_{\mathrm{res}}N∗N^{*}K∗K^{*}W∗W^{*}LUT (%)Mshot/s
710−310^{-3}16.64202204,09685.049.16
75×10−45\times10^{-4}30.99201208,19284.452.82
910−310^{-3}9.4581816,38478.416.14
95×10−45\times10^{-4}17.608184,09678.317.31
1110−310^{-3}6.024148,19280.66.87
115×10−45\times10^{-4}11.184144,09680.57.39
1310−310^{-3}4.172124,09674.92.99
135×10−45\times10^{-4}7.692124,09674.93.24

Table VI. Selected configurations and measured throughput; LUT (%) denotes post-route device utilization.

At d=7d=7 and 99, CLB occupancy reaches 94.3–98.5% despite LUT headroom, indicating placement-limited KresK_{\mathrm{res}}. All eight configurations satisfy N∗/T(W∗)≥K∗/CdecN^{*}/T(W^{*})\ge K^{*}/C_{\mathrm{dec}}, and measured throughput agrees with K∗fclk/CdecK^{*}f_{\mathrm{clk}}/C_{\mathrm{dec}} within 0.62%, showing that generation, Mechanism Memory access, DIU dispatch, and scoring do not materially limit throughput. At pphys=5×10−4p_{\mathrm{phys}}=5\times10^{-4}, the reduced CdecC_{\mathrm{dec}} increases throughput at unchanged K∗K^{*}. For pphys=10−3p_{\mathrm{phys}}=10^{-3}, a 101010^{10}-shot campaign completes in 3.4 minutes at d=7d=7 and 56 minutes at d=13d=13.

Latency tails and logical failures. Figure 3 shows the fraction of shots with Tdec/fclk>tT_{\mathrm{dec}}/f_{\mathrm{clk}}>t per (d,pphys)(d,p_{\mathrm{phys}}), with circles at levels 0.5, 0.1, 10−310^{-3}, 10−610^{-6}, and 10−910^{-9}. From d=7d=7 to 13, the one-round (1 μ\mus) violation rate rises from 4.39×10−74.39\times10^{-7} to 3.02×10−53.02\times10^{-5} at pphys=10−3p_{\mathrm{phys}}=10^{-3} and from 1.43×10−81.43\times10^{-8} to 1.02×10−61.02\times10^{-6} at 5×10−45\times10^{-4}; only d=11d=11 and 13 at 10−310^{-3} exceed 2 μ\mus, at rates of 3×10−103\times10^{-10} and 1.3×10−91.3\times10^{-9}. Table VII reports LER from the same campaigns; because logical scoring is independent of deadline checks (Table I) and no shot exceeds the 8,192-cycle maximum wait, every shot, including late completions, receives a logical verdict. At d=13d=13 and pphys=5×10−4p_{\mathrm{phys}}=5\times10^{-4}, three failures give an LER of 3×10−103\times10^{-10}, with a 95% interval of [0.6,8.8]×10−10[0.6,8.8]\times10^{-10}. At pphys=10−3p_{\mathrm{phys}}=10^{-3}, each increase of dd by two reduces LER by 6.7×\times, 7.5×\times, and 8.1×\times; from d=7d=7 to 13, LER falls by 408×\times while the 1 μ\mus violation rate rises by 69×\times, with logical failures more frequent for d≤9d\le9 and deadline violations for d≥11d\ge11 in this DUT.

Fraction of shots per configuration with decoder latency greater than t

Figure 3. Fraction of 101010^{10} shots per configuration with Tdec/fclk>tT_{\mathrm{dec}}/f_{\mathrm{clk}}>t for d=7,9,11,13d=7,9,11,13 and both pphysp_{\mathrm{phys}} values.

ddpphys=10−3p_{\mathrm{phys}}=10^{-3} Failurespphys=10−3p_{\mathrm{phys}}=10^{-3} LERpphys=5×10−4p_{\mathrm{phys}}=5\times10^{-4} Failurespphys=5×10−4p_{\mathrm{phys}}=5\times10^{-4} LER
7535,1715.35×10−55.35\times10^{-5}34,0583.41×10−63.41\times10^{-6}
979,4087.94×10−67.94\times10^{-6}2,3842.38×10−72.38\times10^{-7}
1110,6271.06×10−61.06\times10^{-6}1361.36×10−81.36\times10^{-8}
131,3111.31×10−71.31\times10^{-7}33×10−103\times10^{-10}

Table VII. Logical failures and per-shot logical error rate (LER) measured over 101010^{10} shots.

Conclusion

The proposed CHEQ enables concurrent hardware evaluation of QEC decoders with on-chip circuit-level noise sampling. Geometric skipping processes sparse firing events, while batch-invariant sampling amortizes mechanism traversal and lets batch size trade memory for throughput without changing the target shot distribution. A throughput model selects the Sampling Unit count, batch size, and decoder count under FPGA resource constraints. Across evaluated conditions, the pooled one-sided 95% upper bound on the weighted RMS relative firing-rate difference from Stim is 0.16%, while a Sampling Unit uses only 4.8%–11.2% of a Helios decoder’s LUTs; on a VCU118, CHEQ sustains 49.2 million shots/s with 20 decoders and completes 101010^{10} shots in 3.4 minutes.

References

  1. [1]J. Preskill, “Quantum computing in the NISQ era and beyond,” Quantum, vol. 2, p. 79, Aug. 2018.DOI
  2. [2]P. Das, C. A. Pattison, S. Manne, D. M. Carmean, K. M. Svore, M. Qureshi, and N. Delfosse, “AFS: Accurate, fast, and scalable error-decoding for fault-tolerant quantum computers,” in 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA), Apr. 2022, pp. 259–273.DOI
  3. [3]J. Bausch, A. W. Senior, F. J. Heras, T. Edlich, A. Davies, M. Newman, C. Jones, K. Satzinger, M. Y. Niu, S. Blackwell, G. Holland, D. Kafri, J. Atalaya, C. Gidney, D. Hassabis, S. Boixo, H. Neven, and P. Kohli, “Learning high-accuracy error decoding for quantum processors,” Nature, vol. 635, no. 8040, pp. 834–840, Nov. 2024.DOI
  4. [4]“DATE 2026 opening keynotes,” in 2026 Design, Automation & Test in Europe Conference (DATE), Apr. 2026, pp. 1–2.DOI
  5. [5]Google Quantum AI and Collaborators, “Quantum error correction below the surface code threshold,” Nature, vol. 638, no. 8052, pp. 920–926, Feb. 2025.DOI
  6. [6]A. B. Ziad, A. Zalawadiya, C. Topal, J. Camps, G. P. Gehér, M. P. Stafford, and M. L. Turner, “Local clustering decoder as a fast and adaptive hardware decoder for the surface code,” Nature Communications, vol. 16, no. 1, p. 11048, 2025.DOI
  7. [7]L. Caune, L. Skoric, N. S. Blunt, A. Ruban, J. McDaniel, J. A. Valery, A. D. Patterson, A. V. Gramolin, J. Majaniemi, K. M. Barnes, T. Bialas, O. Buğdaycı, O. Crawford, G. P. Gehér, H. Krovi, E. Matekole, C. Topal, S. Poletti, M. Bryant, K. Snyder, N. I. Gillespie, G. Jones, K. Johar, E. T. Campbell, and A. D. Hill, “Demonstrating real-time and low-latency quantum error correction with superconducting qubits,” Nature Communications, vol. 17, no. 1, p. 7383, Jun. 2026.DOI
  8. [8]B. M. Terhal, “Quantum error correction for quantum memories,” Reviews of Modern Physics, vol. 87, no. 2, pp. 307–346, 2015.DOI
  9. [9]X. Tan, F. Zhang, R. Chao, Y. Shi, and J. Chen, “Scalable surface-code decoders with parallelization in time,” PRX Quantum, vol. 4, no. 4, p. 040344, Dec. 2023.arxiv.org/abs/2209.09219
  10. [10]Y. Ueno, M. Kondo, M. Tanaka, Y. Suzuki, and Y. Tabuchi, “QECOOL: On-line quantum error correction with a superconducting decoder for surface code,” in 2021 58th ACM/IEEE Design Automation Conference (DAC), 2021, pp. 451–456.
  11. [11]N. Liyanage, Y. Wu, S. Tagare, and L. Zhong, “FPGA-based distributed union-find decoder for surface codes,” IEEE Transactions on Quantum Engineering, vol. 5, pp. 1–18, 2024.DOI
  12. [12]B. Barker, K. M. Barnes, T. Bialas, O. Buğdaycı, E. T. Campbell, N. I. Gillespie, K. Johar, R. Rajan, A. W. Richardson, L. Skoric, C. Topal, M. L. Turner, and A. B. Ziad, “A real-time, scalable, fast and resource-efficient decoder for a quantum computer,” Nature Electronics, vol. 8, no. 1, pp. 84–91, Jan. 2025.
  13. [13]Y. Wu, N. Liyanage, and L. Zhong, “Micro Blossom: Accelerated minimum-weight perfect matching decoding for quantum error correction,” in Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS ’25). ACM, Mar. 2025, pp. 639–654.DOI
  14. [14]C. Gidney and M. Ekerå, “How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits,” Quantum, vol. 5, p. 433, Apr. 2021.
  15. [15]M. E. Beverland, P. Murali, M. Troyer, K. M. Svore, T. Hoeffler, V. Kliuchnikov, G. H. Low, M. Soeken, A. Sundaram, and A. Vashillo, “Assessing requirements to scale to practical quantum advantage,” arXiv preprint arXiv:2211.07629, 2022.arxiv.org/abs/2211.07629
  16. [16]R. W. J. O. Overwater, M. Babaie, and F. Sebastiano, “Neural-network decoders for quantum error correction using surface codes: A space exploration of the hardware cost-performance tradeoffs,” IEEE Transactions on Quantum Engineering, vol. 3, pp. 1–19, 2022.
  17. [17]S. Maurya, A. Molavi, A. Albarghouthi, and S. Tannu, “A case for elastic quantum error correction decoders,” in Proceedings of the 21st European Conference on Computer Systems (EuroSys ’26). ACM, Apr. 2026, pp. 514–531.DOI
  18. [18]A. S. Maan, F. M. Garcia Herrero, A. Paler, and V. Savin, “Decoding correlated errors in quantum LDPC codes,” Nature Communications, vol. 17, no. 1, p. 3965, Mar. 2026.DOI
  19. [19]F. Battistel, C. Chamberland, K. Johar, R. W. J. Overwater, F. Sebastiano, L. Skoric, Y. Ueno, and M. Usman, “Real-time decoding for fault-tolerant quantum computing: progress, challenges and outlook,” Nano Futures, vol. 7, no. 3, p. 032003, Aug. 2023.DOI
  20. [20]S. Maurya, J. Viszlai, N. Raveendran, P. Das, and S. Tannu, “decoder-bench: Mechanism decoders for quantum error correction,” in 2025 IEEE International Symposium on Workload Characterization (IISWC), Oct. 2025, pp. 286–295.DOI
  21. [21]A. Molavi, F. Saad, and A. Albarghouthi, “Analyzing decoders for quantum error correction,” arXiv preprint arXiv:2603.20127, 2026.arxiv.org/abs/2603.20127
  22. [22]F. Garcia-Herrero, J. Valls, L. Vergara-Picazo, and V. Torres, “Diversity methods for improving convergence and accuracy of quantum error correction decoders through hardware emulation,” Quantum, vol. 10, p. 2071, Apr. 2026.
  23. [23]D. Báscones, F. Garcia-Herrero, and J. Valls, “Exploring the FPGA and ASIC design space of belief propagation and ordered statistics decoders for quantum error correction codes,” EPJ Quantum Technology, vol. 12, no. 1, p. 140, Nov. 2025.DOI
  24. [24]A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, “Surface codes: Towards practical large-scale quantum computation,” Physical Review A, vol. 86, no. 3, p. 032324, Sep. 2012.DOI
  25. [25]O. Higgott, T. C. Bohdanowicz, A. Kubica, S. T. Flammia, and E. T. Campbell, “Improved decoding of circuit noise and fragile boundaries of tailored surface codes,” Phys. Rev. X, vol. 13, p. 031007, Jul. 2023.DOI
  26. [26]C. Gidney, “Stim: a fast stabilizer circuit simulator,” Quantum, vol. 5, p. 497, Jul. 2021.DOI
  27. [27]S. Heulben, D. Winter, M. Rispler, and M. Müller, “Dynamical subset sampling of quantum error-correcting protocols,” Physical Review Research, vol. 6, no. 1, p. 013177, Feb. 2024.
  28. [28]C. Mayer, A. Ganti, U. Onunkwo, T. Metodi, B. Anker, and J. Skyrazlin, “Rare event simulation of quantum error-correcting circuits,” arXiv preprint arXiv:2509.13678, 2025.DOI
  29. [29]M. E. Beverland, M. Carroll, A. W. Cross, and T. J. Yoder, “Fail fast: techniques to probe rare events in quantum error correction,” arXiv preprint arXiv:2511.15177, 2025.arxiv.org/abs/2511.15177
  30. [30]A. de Marti i Olius, P. Fuentes, R. Orús, P. M. Crespo, and J. Etxezzareta Martinez, “Decoding algorithms for surface codes,” Quantum, vol. 8, p. 1498, Oct. 2024.
  31. [31]P.-J. H. S. Derks, A. Townsend-Teague, A. G. Burchards, and J. Eisert, “Designing fault-tolerant circuits using detector error models,” Quantum, vol. 9, p. 1905, Nov. 2025.
  32. [32]D. Blackman and S. Vigna, “Scrambled linear pseudorandom number generators,” ACM Transactions on Mathematical Software, vol. 47, no. 4, pp. 1–32, 2021.arxiv.org/abs/1805.01407
  33. [33]S. Choi, K. Lee, J.-J. Lee, and W. Lee, “Quantum at the edge: Scalable standalone FPGA emulator for QAOA-based weighted-maxcut,” IEEE Transactions on Computers, vol. 75, no. 11, pp. 3854–3868, 2026.DOI
  34. [34]S. Choi, K. Lee, J. Choi, C. Jung, and W. Lee, “Precision-aware fixed-point emulation of Grover’s algorithm: Asymptotic error bounds and design guidelines,” Quantum Information Processing, vol. 25, no. 7, p. 214, Jun. 2026.DOI
  35. [35]S. Park, K. Lee, M. Jeong, C. Jung, and W. Lee, “HSF-S: Speed-optimized compilation and acceleration for hybrid schrödinger–feynman quantum circuit emulation,” in IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2026. [Online]. Available: https://arxiv.org/abs/2607.10262
  36. [36]K. Asanović et al., “The Rocket Chip generator,” EECS Department, University of California, Berkeley, Tech. Rep. UCB/EECS-2016-17, Apr. 2016.
  37. [37]AMD, “Virtex UltraScale+ FPGA VCU118 evaluation kit,” https://www.amd.com/en/products/adaptive-socs-and-fpgas/evaluation-boards/vcu118.html, accessed: Sep. 20, 2026.

Paper details

vlnc:W_tcrkfrgt
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents