betaFeedback

WorksPhysics and Astronomy

Quantum Data Processing Unit for Neutral-Atom Quantum Computers

Abstract

Quantum computers need real-time classical processing to convert measurement data into feedback within device-specific timing constraints. We introduce the quantum data processing unit (QDPU), an architecture between a quantum device and its controller. Its core is a machine-learned quantum data model (QDM), adapted to the measurement response and noise characteristics of the device. We implement an FPGA pipeline for neutral-atom array assembly that performs occupancy detection and rearrangement scheduling in FPGA logic. One calibrated matched-filter lane classifies a 50×5050\times50 array in 12.5 μμs. An atom-loss model using a software reference planner evaluates a 35×3535\times35 target with a 60 s trap lifetime and 0.1% loss per moved atom. Removing an assumed 150 ms host round trip raises the predicted assembly success from 8% to 85% and reduces the wall-clock time per successful assembly from 19 s to 0.16 s. A GPU-based outer loop is proposed for refitting model parameters between runs. Its NVQLink transport is measured on the board: over 10 GbE to an NVIDIA DGX Spark, the median FPGA-to-host-to-FPGA round trip is 2.74 μμs for 128-byte messages forwarded by a CPU core. A separate 12-bit learned qLDPC kernel is placed and routed for the same FPGA target, with a derived latency of 0.84 ms per round for a [[1122,148]][[1122,148]] lifted-product code under code-capacity noise. A quantised GraphMP ranking kernel for the same code runs on the board with a median host-to-FPGA-to-host latency of 50.5 μμs with one shot in flight, excluding host-side BP+OSD post-processing. Together, these implementations illustrate a shared architecture with workload-specific models and timing requirements.

Introduction

Quantum computation requires a classical processing layer that converts quantum measurement data into control decisions within the timing constraints of the device. Between a measurement and the next operation, the measurement record must be acquired, interpreted, and translated into an action that the controller can execute. The data may consist of fluorescence images, qubit readout signals, or parity measurement outcomes, while the resulting decisions may specify conditional operations or error corrections. These tasks differ in their computational structure and timing requirements, but share a common architectural role: processing quantum measurement data in real time to close the feedback loop between the quantum device and its controller.

We introduce the quantum data processing unit (QDPU) as a general architecture for this layer. The QDPU separates the computational task of interpreting measurement data from the interfaces through which measurements are acquired and control decisions are delivered. Its core computational capability is provided by quantum data models (QDMs): machine-learned models trained on quantum measurement data to produce estimates and decisions used in subsequent device operations. A QDM can be trained and refit to the measurement response and noise characteristics of the device it serves, while the QDPU provides the real-time execution environment and interfaces required to use that model in a feedback loop. This distinction allows the processing architecture to be specified and evaluated across workloads, while the models remain adapted to the task and the device. In the proposed feedback path, measurement inference and rearrangement scheduling run on the QDPU within the experiment’s latency budget.

We perform board-level tests on an AMD Zynq UltraScale+ RFSoC (xczu49dr, ZCU216 board), connected to an NVIDIA DGX Spark through NVQLink over 10 GbE. These tests measure FPGA–host round-trip latency and the performance of a quantised GraphMP ranking kernel running on the FPGA (§ 4 and § 5.2).

Measurement processing is needed in both noisy intermediate-scale quantum (NISQ) systems [1, 2] and fault-tolerant processors. In NISQ experiments, repeated executions produce measurement records that must be interpreted under changing device conditions. When these results determine subsequent operations, processing latency also affects the experimental cycle time. Fault-tolerant operation adds sustained syndrome processing and decoding to these tasks.

Quantum measurement data also impose requirements beyond low latency alone. Measurement records are intrinsically noisy, and the information available for inference depends on the time allocated to acquiring them. In neutral-atom systems, for example, short fluorescence exposures can yield noisy occupancy measurements. Measurements implemented through imperfect gates introduce a further complication: their records contain errors arising from the measurement circuit as well as the errors they are intended to reveal. Extracting useful information from these records under a fixed latency constraint is therefore an inference problem. Learned methods have demonstrated increasingly strong performance on quantum measurement tasks involving device data [3, 4], motivating QDMs as a central capability of the QDPU. Their advantage nevertheless depends on the task and operating conditions; for simpler inference tasks, the benefit over conventional methods may be limited or conditional, as discussed in § 3.5.

Neutral-atom arrays provide a concrete setting in which to develop and evaluate this architecture. Their scale has increased by approximately a factor of 1.5 per year over the past decade [5], as shown in Figure 1. The size of defect-free arrays prepared through atom rearrangement has grown from approximately 50 atoms in 2016 [6, 7] to 2,024 atoms [8]; arrays containing more than 3,000 atoms have also been maintained continuously for hours [9] in 2025. More recently, experiments have reported trapping 6,100 [10] and 11,000 [11] atoms. The community strategic plan identifies the “10,000 to 100,000 qubit level” as the next stage of development [12].

Growth of neutral-atom arrays, 2016 to 2026

Figure 1. Growth of neutral-atom arrays, 2016 to 2026. Each point is a published record, placed at the date of its first public report. Open circles: atoms trapped in one array under stochastic loading, without rearrangement [13, 14, 15, 10, 16, 11]. Filled squares: defect-free or rearranged arrays [6, 7, 17, 18, 19, 20, 21, 22, 15, 23, 24, 25, 8, 9, 26]. Diamonds: physical qubits in a fault-tolerance or logical-qubit experiment [27, 28, 29, 30]. The line is a fit to the tweezer defect-free records (optical-lattice results excluded), a factor of 1.5 per year; the community strategic plan reports about 1.8 per year for physical qubit number [12]. Dashed lines mark the 50 × 50 array implemented in this work and the 10410^{4}-site scale of the scaling analysis in Section G.10.

Larger arrays increase both the volume of imaging data and the work required for occupancy detection and rearrangement scheduling. The available processing time depends on the atom lifetime, which is affected by vacuum conditions, trap depth, and imaging light. Reported lifetimes range from minutes in room-temperature systems [10] to hours in cryogenic systems [31, 26]. Under a fixed total laser-power budget, increasing the number of traps reduces the power per trap and hence the trap depth, which can further limit atom lifetime [12]. Scaling the array therefore requires more measurement data and control decisions to be processed within the time available for preparation and feedback.

The number of trapped atoms should also be distinguished from the number of physical qubits used in fault-tolerance or logical-qubit experiments. The latter remains at the scale of a few hundred [28, 29, 30]. In Figure 1, these counts differ from the largest trapped arrays by more than an order of magnitude within a given year. Trapping capacity alone does not establish the scale at which atoms can be operated as computational qubits. This work addresses the classical processing needed for array preparation, evaluating occupancy detection and rearrangement scheduling through their latency and their modelled effect on atom retention.

Existing work on quantum control, interconnects, and real-time decoding provides important architectural foundations for this processing layer, particularly for superconducting processors. These devices operate with measurement cycles of approximately one microsecond [32] and are expected to generate measurement data at terabits per second at utility scale [33]. NVIDIA’s NVQLink proposes a vendor-neutral interconnect between the control system and an HPC resource [34]. Complementary architectural descriptions include a quantum microarchitecture [35], a decoder coprocessor [33], and a six-layer QEC stack [36]. These approaches provide terminology, interfaces, and implementations for different aspects of the control and processing stack. In a decoder-oriented specification, for example, the processing interface accepts a stream of binary measurement outcomes at a fixed cycle rate and returns corrections to the controller. Such a specification captures the requirements of a particular workload; a general processing architecture must also accommodate measurement and control tasks with different data representations and execution schedules.

The neutral-atom assembly loop illustrates these additional requirements. Its input is a fluorescence image, and image acquisition consumes part of the physical time budget: atoms are lost at the vacuum-limited rate during the exposure, with a smaller additional contribution from the imaging light under the model in Section E.1. Inference estimates occupancy, position, and loss from the detected photons, and the resulting estimates are used to construct a move schedule. Rather than following the fixed measurement-cycle rate of the superconducting decoder example, the assembly cycle depends on the time allocated to imaging, inference, and rearrangement. The allowed inference latency is therefore part of the operating-cycle design. Despite these differences, image-based array assembly and syndrome decoding occupy the same architectural position: both interpret measurement records within a device-imposed latency budget and return decisions that the controller translates into operations. This shared position motivates a processing-unit abstraction above any individual algorithm or its workload-specific input and output formats.

Real-time feedback without host software in the critical path has already been demonstrated for a hand-designed algorithm on a superconducting device. A clustering decoder implemented on an FPGA within the control system of an eight-qubit experiment enabled a conditional gate 9.6 μs after the last of nine measurement rounds [37]. This result establishes an important precedent for integrating real-time classical inference with quantum control. It does not, however, demonstrate a learned QDM in that loop or address the image-based measurement data produced by a neutral-atom array. These requirements motivate an implementation that combines device-adapted inference with the measurement and control interfaces needed for array assembly, while retaining an architectural description applicable to other workloads.

This work develops that description and realizes a neutral-atom QDPU on a single FPGA. The array-assembly pipeline combines occupancy detection with rearrangement scheduling, and its performance is evaluated in terms of both processing latency and modelled atom retention. To examine a distinct inference workload within the same framework, we also consider the learned qLDPC decoder developed in the companion paper [38]. Sampling workloads for quantum machine learning identify further tasks that the unit is specified to support; these prospective capabilities are distinguished from the array-assembly pipeline implemented here. The implementation thus serves as a concrete instance of the broader architecture, rather than defining that architecture through a single algorithm or qubit modality.

Section 2 derives the processing requirements from physical timing and measurement constraints; Section 3 develops the QDPU architecture and its three interfaces; Section 4 presents the single-FPGA implementation for neutral atoms; and Section 5 examines array assembly, learned qLDPC decoding, and the specified sampling workloads for quantum machine learning. Section 6 states the limitations of the present implementation and the remaining work, while Sections A to H report the implementation in full.

Requirements for the Classical Layer

The classical layer processes quantum measurement records and uses the results to guide subsequent operations. Its design must account for measurement noise, the time available for feedback, and the rate at which measurement data are generated. These considerations lead to the following requirements.

R1. Noise-aware and adaptive processing. In quantum experiments, measurement records are affected by noise in both the quantum device and the readout process. In neutral-atom systems, for example, fluorescence images are subject to photon-counting fluctuations and background light. In quantum error correction, finite gate fidelities and decoherence introduce errors that must be detected through repeated syndrome extraction. The extraction circuits are themselves imperfect: faulty gates can introduce additional data-qubit errors, while readout errors can corrupt the measured syndrome [39].

The statistics of these errors can also change during operation. In neutral-atom systems, changes in optical alignment, trap conditions, and background light affect fluorescence measurements. In error-corrected processors, changes in gate and readout performance alter the noise distribution relevant to decoding. The classical layer must therefore adaptively process noisy measurement records, with estimates or model parameters updated as device conditions change. Learned models provide one approach to this task, with applications to fluorescence classification [4] and quantum error correction [3, 40].

R2. Feedback latency. Classical processing forms part of the experimental feedback loop. An occupancy estimate determines which atoms are moved during rearrangement, and a mid-circuit measurement can determine a subsequent pulse [28, 41, 42]. In quantum error correction, decoding results determine updates to the Pauli frame and may be required before a measurement-dependent operation can proceed [39, 43].

These dependencies constrain the time available for classical processing. In neutral-atom preparation, longer processing times extend the preparation cycle and increase the probability of atom loss (Section E). During quantum computation, delays in conditional operations extend the time over which quantum information must be preserved. When such delays determine the rate of computation, execution is reaction-limited [43].

The relevant feedback latency includes measurement acquisition, data transfer, classical processing, and delivery of the resulting control instruction. Reported latencies may include different subsets of these stages, so a latency specification must identify both the available time and the stages included in its measurement.

R3. Keeping pace with measurement. The classical layer must process measurement data at least as fast as they are generated during sustained operation. Otherwise, unprocessed records accumulate and delay subsequent decisions. In repeated syndrome extraction, the required processing rate scales with the number of measured qubits and the extraction frequency [44, 45]. Estimates for utility-scale superconducting systems reach tens of megabits per second per logical qubit and multiple terabits per second in aggregate [33]. This sustained processing requirement is distinct from the feedback latency of an individual result.

Imaging-based readout also produces substantial data volumes. A single 2048×20482048 \times2048 sixteen-bit image contains 6.7×1076.7 \times10^{7} bits, whereas the occupancy map needed for rearrangement requires only one bit per atom site (Section G). Extracting this information close to the acquisition hardware reduces the amount of data transferred to subsequent control stages. The cost of data transfer is evident in a continuously operated neutral-atom array, where image transfer and rearrangement limit an 80 ms reloading cycle, and increasing the camera region adds 10–20 ms [9].

These requirements concern inference from noisy and changing measurement records, feedback latency, and sustained processing capacity. They must be considered across the path from measurement acquisition to control.

The QDPU

Definition

A quantum data processing unit (QDPU) is a real-time processing unit between a quantum device and its controller. It interprets quantum measurement data and produces feedback decisions within the latency budget of the experiment. Its learned inference model is the quantum data model (QDM), trained on measurement data and refitted as device conditions change (§ 3.2). The CNN occupancy detector of § 5.1 and the decoder of the companion paper [38] are the two QDMs considered here. The QDPU also includes the real-time blocks that supply their inputs and use their outputs, such as the rearrangement engine.

The QDPU is defined by its processing role and interfaces. Its implementation may use an FPGA, an FPGA coupled to a GPU, or an application-specific integrated circuit (ASIC), depending on the latency and throughput requirements of the workload (§ 5.2). The implementation considered here uses a single FPGA (§ 4).

Related functions appear in existing quantum-control architectures: a measurement discrimination unit within a quantum microarchitecture [35], a decoder coprocessor [33], and a separation between a decoder engine and a feedforward controller [36]. The QDPU abstraction groups measurement interpretation and feedback computation within a common processing stage, while allowing the data representations, models, and timing requirements to vary by workload.

Comparable processing stages occur in classical systems. Solid-state drive controllers interpret noisy NAND-flash measurements and manage device-dependent changes [46]. Coherent optical receivers use digital signal processing to compensate for channel impairments and recover transmitted data [47, 48]. These examples illustrate the separation of a physical device from the processing needed to interpret its output (Table 1).

QDPU (this work)Solid-state drive controller [46]Coherent optical receiver DSP [47, 48]
MediumAtom array, read out by fluorescence imagingNAND flash cell arrayOptical fibre span
Measurement impairmentsPhoton-counting fluctuations, background light, and atom loss during acquisitionOverlapping charge-level distributions and changes with wear, retention time, and temperatureDispersion, polarisation rotation, laser phase noise, and amplifier noise
OutputSite occupancy, a move schedule, gate-level feedbackCorrected user dataCorrected client bits
Jobs besides error correctionSite detection, array assembly, state discrimination; later calibration and mid-circuit controlRead-voltage optimisation, wear levelling, bad-block management, data placementTiming recovery, dispersion compensation, polarisation demultiplexing, carrier phase and frequency recovery
Adapts to the individual deviceModel retrained as optics, background and alignment drift (§ 3.2)Read reference voltages re-optimised per block as cells wearEqualisers and phase estimators adapt continuously

Table 1. Comparison of the proposed QDPU with two classical processing systems. Each combines interpretation of noisy device output with device-dependent adaptation and additional control or management tasks.

In these classical systems, error correction is one function within a broader processing stage that also performs detection, compensation, or calibration. This organisation provides a useful analogy for the QDPU. For neutral-atom feedback, the processing latency has an additional consequence: it extends the interval during which atoms can be lost before the next operation (Section E).

The controller generates waveforms and determines pulse timing; the QDPU supplies the decisions that condition those operations. The processing stage can support state discrimination, array assembly, and decoding, with calibration and mid-circuit control as further applications. Training and model updates belong to the outer loop, while inference runs in the inner loop under the workload’s latency and throughput constraints.

Two loops

The requirements in § 2 distinguish the execution of inference from adaptation to changing device conditions. In the proposed architecture (Figure 2), a trained QDM processes measurement records in the inner feedback loop, subject to the latency and sustained processing requirements of R2 and R3. An outer loop collects measurement data and labels and returns updated model parameters, addressing the device-adaptation requirement of R1. Its update interval depends on device drift and the availability of training data. Separating these tasks allows model training to proceed without delaying individual feedback decisions.

Figure 2. Proposed inner and outer loops of a QDPU. The inner loop processes measurement records and returns feedback decisions within the time available for subsequent operations. The outer loop collects measurement data and labels and supplies updated model parameters as device conditions change.

Three interfaces

A QDPU has three external interfaces (Figure 3). The device-side ingress receives measurement records, which may be camera frames, photon counts, digitised readout signals, or syndrome bits. The controller-side egress delivers results used in subsequent operations, such as an occupancy map and move schedule, a Pauli-frame update, or a branch selection. The outer-loop interface transfers measurement data and labels for training and receives updated model parameters. Unlike the feedback path, model updates need not be completed within an individual measurement cycle (Section G).

The QDPU between the QPU back-end and its controller

Figure 3. The QDPU between the QPU back-end and its controller. The atom array and its camera are drawn twice, once per loop. Red, array loading: atoms from the source (grey) fill sites at random (dark red, occupied; pale, empty); the frame goes to atom detection, then to atom rearrangement, whose move schedule returns through the Shuttle API. Green, computation: the assembled array (dark green, qubits in use; pale, empty) is read out as qubit states; the GraphMP decoder infers corrections from the syndromes. The circuit compiler uses the decoding results to generate instructions issued through the Control API (gates) and the Shuttle API (moves). Arrows follow the data in each loop; both pass through the QDPU. The outer loop to the training cluster is drawn in Figure 2.

Workloads

The two workloads evaluated here are array assembly and error decoding (§ 5.1 and § 5.2). Array assembly combines occupancy detection with rearrangement scheduling. Decoding interprets syndrome records to determine corrections or Pauli-frame updates. Both require measurement interpretation, but their input formats and timing constraints differ.

Further applications include state discrimination, calibration, and mid-circuit control. Mid-circuit readout and conditional pulses have been implemented using FPGA-based control [28, 49, 42], while automated calibration can run between experimental shots [50]. Task-specific models for these applications could share the QDPU’s execution environment and data interfaces. Quantum sampling for machine learning is a prospective workload, discussed in § 5.3.

Why learned inference

The benefit of learned inference depends on the workload and operating conditions. For atom readout, matched filters can achieve CNN-level readout error with substantially lower computational cost [51]. The array-assembly pipeline supports either a calibrated matched filter or a small CNN. The closed-loop evaluation uses the matched filter at the selected operating point; detector accuracy and implementation costs are reported in Sections B and D.

For decoding, the companion paper evaluates learned models across several qLDPC code families

and noise models (§ 5.2). Device drift also motivates recalibration or model updates, as discussed in R1. Learned models provide one approach to adapting inference to these changes. The array-assembly evaluation relates detection accuracy and processing latency to modelled atom loss, allowing the inference benefit to be assessed alongside its implementation cost.

A Neutral-Atom QDPU: Platform and Interfaces

Neutral-atom array preparation provides an initial application for the QDPU. Increasing array sizes expand the number of sites that must be imaged and classified (Figure 1). The preparation cycle also has a clear measurement-to-control sequence: a camera images the array, classical processing estimates occupancy and plans rearrangement, and acousto-optic deflectors move the atoms [9, 52]. The millisecond timescales of array preparation allow this sequence to be studied with an FPGA-based implementation.

Stochastic loading requires rearrangement to prepare a defect-free target, and subsequent atom loss can require further preparation. Zoned architectures also transport atoms between storage, interaction, and readout regions during computation [27, 28]. The present work addresses the initial array-assembly pipeline.

Platform. The FPGA target is an AMD Zynq UltraScale+ RFSoC xczu49dr on the ZCU216 evaluation board, a device class used in open-source quantum-control platforms [53]. The array-assembly pipeline meets a 200 MHz timing target after place-and-route with either detector, and with the matched filter it also closes as a complete ZCU216 bitstream with an on-chip self-test (Section D.3). With the matched filter used in the loop it uses 20.7% of the device’s LUTs and 1.5% of its DSP slices; with the 8×88 \times8 CNN, 23.2% and 13.7%. Forty fixed-template matched-filter lanes route on their own at 668 MHz (Section D). The learned qLDPC kernel described in Section F is included in a co-residency resource estimate. In that estimate, one matched-filter lane and the decoder use 40% of the DSP slices; four CNN cores and the decoder would use 93%, making DSP capacity the limiting resource for the CNN (Section D.6). Joint implementation is needed to validate this budget.

Interfaces. Table 2 maps the three interfaces onto a neutral-atom system. The proposed ingress receives a 2048×20482048 \times2048 region of interest from a Hamamatsu ORCA-Quest 2 qCMOS camera over CoaXPress [54]. The imaging simulator used for the detector evaluation is configured for this camera family [55, 56].

InterfaceInstrumentCarriesRate or sizeStatus
Ingress (device side)Hamamatsu ORCA-Quest 2 qCMOS [54] over CoaXPress2048 × 2048 × 16-bit frames; 8 × 8-pixel site windows extracted on chipquad CXP-6, 4 × 6.25 Gb/s (20 Gb/s payload); 6.7 × 10710^{7} bits per framespecified
Egress (controller side)Quantum Machines OPX1000 [57] via its OPNIC [58]: PCIe into server memory, then NVQLink to the controllerone occupancy bit per site; move stream as (from, to) site pairs2500 bits + moves per cyclespecified
Outer loopGPU in the same server over PCIe, or a GPU cluster over NVQLink [34, 59]; NVQLink transport measured at 10 GbE (Section G.5)site windows and labels out; QDM parameters in (detector template or CNN weights, Table 15; decoder)minutes to hours; matched filter: 64 int8 coefficients and one integer threshold; CNN: about 7.2 kB of 12-bit weights and biases; decoder: about 9.8 kB (Section F)open

Table 2. The three interfaces of the neutral-atom QDPU. Status describes the application interface: specified denotes a defined interface and open an interface still to be specified. NVQLink transport performance is measured independently (Section G.5). Section G.1 gives the channel-by-channel specification.

The egress connects to a Quantum Machines OPX1000 through an OPNIC interface card [57, 58]. The proposed topology places the QDPU, OPNIC, CPU, and GPU on one server’s PCIe fabric. Each cycle, the QDPU writes occupancy and a move schedule to server memory. Software using the OPNIC SDK forwards this record to the OPX1000 over the vendor’s NVQLink connection; the controller generates the AOD and gate waveforms (Section G.3).

The outer loop can use a GPU in the same server over PCIe, or a remote GPU cluster over NVQLink. A round-trip FPGA-to-GPU-to-FPGA latency of 3.96 μs3.96\,\mu\mathrm{s} and link rates up to 400 Gb/s have been reported for NVQLink [34, 59]. On the ZCU216, an NVQLink link to an NVIDIA DGX Spark over 10 GbE, built on NVIDIA’s Holoscan Sensor Bridge IP [60], has a median FPGA-to-host-to-FPGA round trip of 2.74 μs2.74\,\mu\mathrm{s} for 128-byte messages forwarded by a CPU core and 6.40 μs6.40\,\mu\mathrm{s} when forwarded by the GPU. The timestamp-to-MAC and MAC-to-timestamp logic contributes 0.52 μs0.52\,\mu\mathrm{s}, excluding the transceivers (Section G.5). Camera ingest and controller egress are specified but not implemented. The outer-loop transport has been measured with test traffic, but the traffic it is to carry has not.

Processing near acquisition. A 2048 × 2048 sixteen-bit frame contains 6.7 × 10710^{7} bits, whereas an occupancy map requires one bit per site. Extracting occupancy at the camera interface reduces the amount of image data transferred to subsequent control stages. Image transfer is a reported limitation in a continuously operated neutral-atom array [9]. The array-assembly evaluation in § 5.1 examines how processing latency affects modelled atom loss.

Workloads

This section evaluates array assembly and learned qLDPC decoding as two QDPU workloads. Array assembly converts images into occupancy estimates and move schedules; decoding converts syndrome records into correction information. Their implementations are assessed within a shared FPGA resource budget. The final subsection discusses quantum sampling for machine learning as a prospective extension.

Array assembly

The pipeline converts cropped site images into a stream of atom moves (Section A). A detector classifies each 8 × 8-pixel site window, and a row assembler packs the resulting occupancy bits into grid rows. The rearrangement engine reads the occupancy memory and target pattern and emits source–destination pairs until the pattern is complete or the array is declared infeasible.

Two detectors use the same one-bit-per-site interface: a matched filter, a template and threshold calibrated from labelled windows, with 64 multiply–accumulates per site, and a convolutional network with 226 944 multiply–accumulates per site, quantised to 12 bits (Sections B and C). On simulator data corrected for a readout defect (Section B), the network is more accurate only where photons are scarcest. At 2 ms exposure, eight detected photons per atom, the simulated per-site imaging fidelities are 91.6% for the matched filter and 95.4% for the CNN; at 5 ms they are 99.77% and 99.89%, and from 10 ms both exceed 99.99% (Table 16). The integrated pipeline meets a 200 MHz timing target on the xczu49dr with either detector at the 8×88 \times8 window. Detection of a 50×5050 \times50 array takes 12.5 μ\mus with one matched-filter lane and 22.5 ms with one CNN core; forty matched-filter lanes route on their own at 668 MHz (Section D).

ExposurePhotons per atomIdeal observerMatched filterCNN 1-8-16-16CNN 1-32-64-64
1 ms486.0981.9985.7387.11
2 ms896.5391.6395.4095.97
3 ms1299.0697.6998.7498.81
5 ms1999.9399.7799.8999.88
7 ms2799.99799.9699.9899.98
10 ms39>99.99>99.99>99.99>99.99
20 ms77>99.99>99.99>99.99>99.99
50 ms192>99.99>99.99>99.99>99.99

Table 16. Per-site imaging fidelity against exposure on a sparse array (4 µm pitch) with the 8×88 \times8 window{sup}[sim]. Fidelity is 1−(FP+FN)/21 - (\mathrm{FP} + \mathrm{FN})/2 on 43 120 test sites per row. The ideal observer is the Bayes-optimal detector of the independent-pixel Poisson–Gaussian model. An entry “>x” had no errors and gives the 95% bound. Photons are detected photoelectrons per atom inside the window. CNN columns are full-precision models trained per row; Table 18 gives the 12-bit models.

Previous work has accelerated several stages of this loop. An FPGA rearrangement engine computes moves for a 30×3030 \times30 target in a 50×5050 \times50 array in approximately 1 μ\mus [61], while an FPGA detection accelerator processes a 256×256256 \times256-pixel frame in 115 μ\mus [62]. A GPU system with direct memory access reports a 55.8 ms cycle for a 32×3232 \times32 array [52]. Other reported feedback times include 282 μ\mus for 24 tweezers [63] and 25.3 ms for a 16×1616 \times16 array [64]. A host-based system classifies 2400 sites in 85 μ\mus using 24 CPU cores and completes a 460 μ\mus cycle through a dedicated controller link [65].

These timings cover different parts of the measurement-to-control path. In a reported GPU system, image acquisition accounts for 46 ms of the 55.8 ms cycle [52]. Here, detection and rearrangement are integrated through place-and-route, and their timing provides inputs to the atom-loss model of Section E. This model uses a corrected software reference planner; the column-step correction has not yet been incorporated into the RTL. The model assumes a 150 ms host round trip (Table 29). This exceeds the approximately 10 ms host contribution reported for the GPU system with direct memory access [52], as well as the sub-millisecond feedback times of dedicated controller links [63, 65]. The predicted benefit of removing the host delay depends on this assumption; Section E.4 shows that the conclusion holds for any host round trip above a few milliseconds: at a trap lifetime of 60 s, 10 ms of host round trip already lowers the assembly success probability from 0.85 to 0.78.

ParameterValueRoleSource
Grid50×5050 \times50all closed-loop resultsthe array of the hardware design (Section D)
Targetcentred 35×3535 \times35 (1225 atoms)all closed-loop resultsthe target of the rearrangement engine’s schedule (Section A.4)
Trap fill probability0.6 (about 1500 atoms loaded)initial occupancysimulation setting, as in the engine sweep of Section A.4; the RTL verification runs of Section A.11 load 1270 of 2500 sites
Refillnoneno reservoir reload between cyclessimulation setting; a real apparatus reloads between assemblies, so assemblies per load compares configurations rather than predicting throughput
Attempts per configuration1000 (2000 for the operating-point sweep)statisticssimulation setting
Maximum cycles per attempt9abandon thresholdsimulation setting
Plannerrow sweep into the target columns, then column compressionmove schedulethe engine’s algorithm (Section A.4) with its column step corrected in the software reference to avoid moving onto an atom that stays; this correction is not in the RTL, whose original planner is compared in Table 32
τimg\tau_{\mathrm{img}}70 simaging-loss lifetimecalibrated to the imaging-survival baseline of [114][lit]; equivalent to 0.1% loss per 70 ms image
τvac\tau_{\mathrm{vac}}5–1380 s, ref. 60 svacuum-limited trap lifetime5–60 s: room-temperature glass cells; 1380 s: the 23 min of [10]; cryogenic systems (6000 s [31]) lie above the range[lit]
Transport loss0.1% per moved atom per path; lossless for comparisontransport channelassumed; moves over 610 μ\mum at about 99.95% fidelity are reported [10][lit]; at 1% no 35×3535 \times35 assembly completes
thostt_{\mathrm{host}}150 mshost round-trip in the host-in-loop configurationassumed: a PC in the loop with camera transfer and software analysis, swept over 10–150 ms (Figure 12); dedicated systems are faster: about 10 ms of host time [52], 282 μ\mus for 24 tweezers [63], about 0.5 ms per cycle [65][lit]
Exposure sweep7–12 ms; 21–33 ms at a third of the photon rateoperating-point searchsimulation setting
Imaging modelcaps-tum simulator, ORCA-Quest configuration [55, 56]photon floor, detector accuracyNA 0.65, 40 kHz, 1–50 ms, 0.43 e−^-, 0.4 μ\mum/px, 8×88 \times8 crop (Table 11)
Detector error ratesempirical per-class FP and FN from the sparse-array evaluation, whose balanced fidelity is summarised in Table 16; CNN rates use the full-precision 1-8-16-16 models; linear interpolation between exposuresdetection errorsSection B
Detection timematched filter 12.5 μ\mus; CNN 2.5 ms (8 × 8, one core)cycle wall-clockseparate RTL timing; the CNN cost is used as a proxy for the operating-point model, without streaming overlap (Section E.3)
Camera readout7.4 ms per cyclecycle wall-clock2048-row region of interest, standard scan (Section G.2)
Rearrangement0.15 ms per cycle, plus the attempt’s own minimum-jerk AOD transportcycle wall-clockSection E.3

Table 29. Parameters of the atom-loss model.

Under the assumed 150 ms host round trip, the host loop completes a 35×3535 \times35 assembly in 8% of attempts at a trap lifetime of 60 s; with the QDPU in the loop it completes 85%, and the wall-clock per successful assembly falls from 19 s to 0.16 s (Table 3). At this array size, the assumed host delay substantially reduces the probability of completing an assembly. At longer trap lifetimes, the host loop still takes approximately 11 times as long per successful assembly as the QDPU loop at 300 s, and 7.5 times as long at 1380 s. This comparison depends on the host delay, the trap lifetime and the transport loss; at 1% loss per moved atom, no configuration completes the assembly in the simulated trials.

ComparisonResultReference
Wall-clock → assemblyRemoving the assumed 150 ms host round trip raises the assembly success probability from 8% to 85% and cuts the wall-clock per successful assembly from 19 s to 0.16 s; with lossless transport, success rises from 23% to 100%. Dead time is 2–84% of all atom loss with the QDPU in the loop and 11–96% with a host, for trap lifetimes of 5–1380 s.Section E.4
Exposure and inference latencyAt the loop’s 10 ms exposure neither detector produced errors in the evaluated simulated samples, so the learned detector saves no exposure, and its 22.5 ms of inference on one core is dead time: success falls from 0.85 to 0.69 and the wall-clock per assembly rises from 0.16 s to 0.43 s. With no inference time the two give the same result.Section E.3
Inference cost → resourcesOne matched-filter lane takes 1.5% of the device’s DSP slices and keeps pace with the camera; one CNN core takes 13.7%. With the decoder resident, the totals are 40% and 93% (four CNN cores).Section D.6
Image → occupancy map6.7×1076.7 \times10^{7} image bits in, 2.5×1032.5 \times10^{3} occupancy bits out per frame; move descriptors are additional.Section G

Table 3. Latency, resource, and data-volume comparisons for the neutral-atom array-assembly workload. Atom-loss predictions use the model of Section E and the parameters of Table 29: 50×5050 \times50 array with a centred 35×3535 \times35 target, τvac=60\tau_{\mathrm{vac}} = 60 s and 0.1% loss per moved atom unless stated, each configuration at the exposure that minimises its wall-clock per assembly. The host round trip is assumed to be 150 ms.

The reference loop uses the matched filter at a 10 ms exposure, with 12.5 μ\mus of detection time. Detector choices and their inference costs are compared in Section E.3. At this operating point, camera readout and atom transport account for 64% of the 27.5 ms modelled cycle, including about 10 ms of transport.

Decoding

Belief propagation is widely used for classical low-density parity-check (LDPC) decoding, but short cycles and degeneracy can impair its performance on quantum LDPC codes [66]. Symmetric trapping sets provide one characterisation of failures in syndrome-based iterative decoding [67]. Ordered-statistics post-processing can substantially improve performance [68, 69]. For surface codes,

learned decoders have also been evaluated on experimental data and have outperformed matching and tensor-network decoders in the reported benchmarks [3, 40].

The companion paper [38] introduces GraphMP, a QDM for qLDPC decoding: a graph message-passing decoder in which a single trained model applies across decoding graphs of different size and structure. Its messages are computed by local, parallel operations on the Tanner graph, and it runs in two modes: a low-latency single pass, and a bounded-width search guided by the model’s probabilistic output that trades latency for stronger logical-error suppression without changing the model.

The model is trained through an iterative procedure called a decoder factory. In each iteration, the current model guides a wide search for corrections to difficult decoding cases. These corrections provide supervised training data for the next model, so that it learns to make better single-pass predictions from the results of the search.

Across qLDPC code families, sizes, physical error rates and noise models, the resulting decoder transfers to graphs it was not trained on and is competitive with strong classical decoders, and the same cycle refits it as the hardware noise evolves. Before device data exist, the training distribution can come from an emulator that models the processor, its atom-loss channels and the classical control flow together, such as the PPVM framework [70]. On the companion paper’s benchmark of twelve decoding tasks spanning bivariate-bicycle, generalised-bicycle, lifted-product and mitten codes, the search-enhanced decoder reaches a lower logical error rate than BP+OSD on all nine code-capacity tasks and is broadly competitive with Relay-BP; the single-pass model overtakes the belief-propagation teacher it was distilled from within one generation [38]. Separately, for the LP20 [[1122, 148, \le 20]] lifted-product code under code-capacity noise, the xczu49dr kernel configuration described in Section F has a post-route clock period of 3.514 ns, corresponding to a kernel latency of 0.84 ms per decoding instance. A partition across programmable logic and the AI Engine array of a Versal device has an estimated latency of approximately 0.2 ms per decoding instance. These timings apply to the stated decoding task and hardware configurations. Decoder hardware must satisfy both a sustained throughput requirement and the latency budget of dependent operations. Pauli-frame updates can often be deferred, whereas a conditional operation requires the relevant decoded result before it can proceed. Both uses can be supported by real-time decoding. Reported timings depend on the code, the syndrome history and the decoder implementation. Batched inference time per shot must also be distinguished from the full response time of a feedback operation.

Pauli-frame tracking. A Pauli correction need not be applied physically to the qubits; it can be recorded in a classical frame and incorporated into the interpretation of later measurements [71, 72]. The decoder must keep pace with syndrome generation on average, and the relevant frame information must be available before an operation that depends on it. Conditional operations in teleportation-based non-Clifford gates impose such dependencies [43]. If decoding persistently falls behind syndrome generation, the resulting backlog can cause an exponential slowdown of the computation [39, 45]. Parallel decoding of syndrome-history windows can increase throughput [45, 73]. In a neutral-atom experiment, fully connected neural decoders were used for distance-3 and distance-5 surface codes, with 3×33 \times3 and 5×55 \times5 data-qubit arrays, respectively, and four rounds of syndrome extraction. The Methods report an inference time of 0.33 μs0.33\,\mathrm{\mu s} per shot on an NVIDIA A100 GPU for batches of approximately 10410^4 shots [30]. This batch-oriented inference characterization emphasizes throughput; it does not establish single-shot feedback latency or scaling to larger codes. A GPU belief-propagation decoder reports latencies below 50 μs50\,\mathrm{\mu s} for a [[784, 24, 24]] code [74]. Syndrome records can also support post-processing. Virtual error cancellation combines the results of a low-latency in-loop decoder with those of a more computationally intensive decoder applied after execution, reducing bias in logical observables without modifying the quantum circuits [75]. A distance-5 surface-code experiment on a superconducting processor reported an average decoding latency of 63 µs while keeping pace with a 1.1 µs cycle for a million cycles. The decoder ran on a workstation, and its output was not fed back into the logical circuit [32].

Real-time decoding. Real-time decoding supports frame updates and, when required, supplies results for conditional operations during circuit execution. The decoder must sustain the syndrome rate and return the relevant result before each dependent operation. In teleportation-based implementations of non-Clifford gates, for example, a decoded measurement outcome can determine a conditional correction or a subsequent measurement basis [43]. Heralded erasures provide location information that can be incorporated into decoding [76]. In non-Abelian topological codes, recovery can require successive rounds of measurement and correction because fusion outcomes are nondeterministic. Intrinsic heralding provides additional syndrome information about the error path [77]. The feedback deadline is set by the next dependent operation; it does not require each syndrome round to be decoded within one QEC cycle. An FPGA Collision Clustering decoder integrated into a superconducting control system was tested on an eight-qubit stability experiment with four weight-two ZZZZ checks. Its syndrome-extraction circuit is equivalent to that of a circular repetition code. For the nine-round feedback experiment, the full response time from the final syndrome-extraction round to a conditional gate was 9.6 µs, comprising 6.5 µs of decoding and 3.1 µs of communication and control [37]. Standalone hardware implementations report 810 ns per round for a distance-21 surface code on simulated syndromes [78] and 11.5 ns per round for a distributed union-find decoder at distance 21 under phenomenological noise [79]. FPGA decoding of the gross code has also been reported [80].

The requirements in Table 4 motivate different hardware configurations. Low-latency processing supports conditional operations, while parallel and batched decoding can sustain the throughput needed for frame tracking. A heterogeneous QDPU could combine these capabilities through an FPGA–GPU interface. The reported 3.96 µs FPGA-to-GPU-to-FPGA round trip of NVQLink [34] provides a reference point for the communication cost of such a configuration. On the ZCU216, NVQLink to a DGX Spark at 10 GbE measures 2.74 µs through a CPU core and 6.40 µs through the GPU at the median. With one shot in flight, a quantised GraphMP ranking kernel for the LP20 code achieves a median host-to-FPGA-to-host latency of 50.5 µs, with bit-exact agreement against the PyTorch reference. This interval includes about 4–5 µs of link overhead and excludes host-side BP+OSD post-processing (Section G.5).

Pauli-frame trackingReal-time decoding
Decoder output isa Pauli correction recorded in a classical frame [71]a decoded outcome used to select a conditional operation [37]
Must meetsustained throughput sufficient to avoid a backlog [39]the throughput requirement and the deadline of each dependent operation [43, 37]
Failure modea growing backlog that delays operations requiring the frame [39, 45]a delayed conditional operation or a missed feedback deadline
Toleratesdeferred frame updates, batching, and parallel decoding windows, subject to future dependencies [45, 73]batching or windowing that respects the feedback deadline
Typical hardware emphasisthroughput through parallel processing on CPUs or GPUs [30, 74, 32]short response times through hardware acceleration and close controller integration [78, 79, 80, 37]

Table 4. Classical processing requirements for Pauli-frame tracking and real-time decoding with feedforward. The two uses can share a decoder and can both be supported within the QDPU processing architecture.

The relevant timing constraint depends on the experiment. The 0.84 ms decoder latency reported here exceeds both the 1.1 µs superconducting measurement cycle [32] and the time available in reported sub-millisecond neutral-atom mid-circuit feedback loops [28, 49]. Other neutral-atom operations have longer cycles. Preparation and reloading take tens of milliseconds in a continuously operated array [9]. In the repeated toric-code experiment of Atom Computing, syndrome-extraction cycles take approximately 80 ms and 150 ms for the two code sizes studied, or approximately 30 ms when measured ancillas are replaced rather than reloaded [81]. The decoder latency is shorter than these cycle times, although integration with a particular experiment requires matching its decoding task and feedback schedule. FPGA execution is therefore considered here for workloads with compatible timing budgets, with GPU-based frame tracking as a further option.

Quantum machine learning

Quantum sampling provides another potential workload. In several quantum machine-learning approaches, measurements from a quantum processor supply samples to a classical training procedure. Sampling tasks also underlie experimental demonstrations of quantum computational advantage [82], although these demonstrations do not by themselves establish an advantage for machine learning.

Proposed generative models include quantum circuit Born machines trained on ion-trap hardware [83], Born machines with worst-case classical-hardness results [84], quantum Boltzmann machines [85], and quantum generative adversarial networks [86]. Generative quantum models without barren plateaus have also been trained and sampled on a 68-qubit processor for distributions believed to be classically intractable [87]. A quantum Markov chain Monte Carlo method has shown convergence in fewer steps than its classical comparator in simulation and on a superconducting processor [88]. Neutral-atom demonstrations include quantum reservoir learning with up to 108 qubits [89] and a quantum GAN generator [90].

The practical advantage of these methods remains open. Classical algorithms have matched some proposed quantum speedups [91], and barren plateaus can make training difficult at scale [92]. Reviews discuss these limitations and the evidence needed to establish useful advantage [93, 94, 95].

Such workloads require classical processing at several timescales. A classical optimiser updates circuit parameters using accumulated samples [96, 2]. Changes in device conditions may also require recalibration or readout-model updates. Dynamic circuits impose a separate feedback constraint when mid-circuit measurements determine later gates within the coherence time [97, 98, 99, 100]. The QDPU interfaces could support measurement acquisition and conditional control in such workflows, alongside a classical training system [101]. Application-model training and adaptation of the QDPU’s measurement models remain distinct tasks. These sampling workloads are prospective extensions of the architecture and are not implemented here.

Discussion and Outlook

We introduced the QDPU as a processing architecture between quantum measurement acquisition and feedback control, with models fitted to the device and hardware chosen for the latency and throughput requirements of each workload. For neutral-atom array assembly, we implemented a pipeline combining occupancy detection, by a calibrated matched filter or a small CNN, with rearrangement scheduling and evaluated its FPGA timing and resource use after place-and-route. The atom-loss model relates detector performance and processing time to predicted atom retention, allowing inference gains to be assessed alongside their hardware cost. A separate implementation of learned qLDPC decoding provides a second workload for evaluating the architecture.

The detector evaluation uses simulated images rather than real camera frames. The simulator is configured for the ORCA-Quest camera family but has not been validated against the intended camera (Section B). We corrected a readout defect in the simulator; the uncorrected data had led earlier drafts of this work to the opposite conclusion about the detector.

The CNN pipeline is implemented out of context and excludes board-level I/O constraints. The matched-filter pipeline has also been built as a board bitstream with an on-chip self-test, but has not yet run on the board (Section D.3); the build found and fixed a move-loss defect in the rearrangement engine under controller backpressure. Camera ingest and the controller link are specified but not implemented (Section G). The outer-loop NVQLink transport has been measured on the board at 10 GbE with test traffic and a GraphMP ranking kernel, but has not been joined to the pipeline (Section G.5). The frame-to-schedule latency is therefore derived from implementation and simulation results, and the hand-off from server memory through the OPNIC software has not been measured. The vendor’s planning figure is approximately 1 µs per PCIe transfer inside the OPC, including memory-to-OPNIC transfer. The decoder has been placed and routed separately (Section F); its co-residency with the pipeline is a synthesis-based resource estimate pending joint place-and-route (Section D.6). The interface-integration evaluation covers two occupancy cases (Section A.11).

The evaluations also use different geometries: a 14×1414 \times14 array in a 256-pixel frame for imaging, and a 50×5050 \times50 array in a 2048-pixel region of interest, with a 35×3535 \times35 target, for the loop model and the FPGA design (Table 29 and Section B). The site pitch of the target apparatus is not yet fixed. The loop model uses detector error rates from the simulated 4 µm sparse array.

The loop results use a corrected software reference planner whose column step has not yet been incorporated into the RTL. Its full-array replanning on repair cycles increases transport loss, so the reported success probabilities and latency gains are conditional on this policy (Section E.4).

The next implementation step is to integrate the interfaces in Table 2 on the ZCU216 board and measure camera ingest with the ORCA-Quest 2 and feedback delivery to the OPX1000. Recorded frames will be used to evaluate the under-specified and experimental imaging conditions. Joint place-and-route of the pipeline and decoder is needed to validate the co-residency budget. Further work includes calibration, mid-circuit control, heralded-loss handling, and the sampling applications discussed in § 5.3. Their hardware configurations will depend on the latency, throughput, and resource requirements of each workload.

For neutral-atom QEC, the QDPU framework makes measurement inference and decoding explicit components of the system design. In particular, qLDPC implementations require code size and the length of syndrome histories to be evaluated alongside decoder accuracy, compute and memory resources, and feedback timing. The separate decoder implementation reported here provides an initial hardware reference for that assessment. Extending it to noisy syndrome extraction and atom-loss information, and measuring the complete feedback response, would help determine which code, decoder and hardware combinations are suitable for specific neutral-atom QEC protocols.

Acknowledgments

We thank Luis Fernandez Martinez, Wenchao Xu, Joonhee Choi, Yaniv Kurman, Brian Kain and Javier Duarte for helpful discussions and feedback.

This research was supported in part by grant NSF PHY-2309135 to the Kavli Institute for Theoretical Physics (KITP).

Provenance tags. Quantitative claims in the appendices carry a superscript tag naming their source: [meas-hw] measured after place-and-route; [meas-board] measured on the board; [meas-sim] measured in RTL simulation; [csynth] a C-synthesis estimate; [sim] the imaging simulator; [phys] the atom-loss model; [lit] a literature value; [roof] a projection from datasheets or standards; [algo] an algorithmic model or fit. Section H lists what remains open.

Rearrangement Pipeline: Architecture and Interface Contract

Scope

Throughout the appendices, the QDPU (quantum data processing unit, § 3) is the real-time unit between the camera and the controller that converts measurement data into gate-level feedback by learned inference; in this work it is realised on a single FPGA, and the rearrangement pipeline (hereafter the pipeline) is its first workload, the one implemented and evaluated here. The pipeline is the chain from cropped camera pixels to a stream of atom moves (Figure 4). It has four components:

Figure 4. Rearrangement pipeline block diagram. Shaded blocks are FPGA-resident. Edge labels give bus width and sustained rate.

  • Site detector (matched filter or CNN, Section B): takes the 8×88 \times8-pixel window around one site and emits one bit, occupied or empty.

  • Row assembler: packs the N2N^2 occupancy bits into NN words of NN bits each, one word per grid row.

  • Occupancy memory, with its loader and write-port multiplexer: a dual-port block RAM holding the current grid; the loader writes it one row per cycle before a run, and the multiplexer hands the write port to the engine once the run starts.

  • Rearrangement engine (tetris): reads the occupancy memory and the target pattern and emits a stream of moves, each a (from, to) pair of sites, ending in done_o or, if the array cannot be completed, abandoned_o.

The engine is a pre-existing block. The out-of-context builds of Table 22 use its RTL unchanged, and the board build adds one fix to its move FIFO (Section D.3); it implements a tetris-style compression algorithm [102] modified to minimise move distance [103]. The minimum distance can potentially reduce the atom loss associated with physically moving the atoms. The algorithm picks the shortest move distance from the list of possible moves for each row. The other three components are new to this work and were built to write the memory the engine already reads, so the engine’s behaviour is independent of how its occupancy arrives (Section A.1).

BlockLUTFFBRAMDSP
Matched filter (8×88 \times8, one lane, loadable)1 8451 866064
Rearrangement engine (tetris)85 76647 72900
Site row assembler2236200
Crop register / loader / atom-grid BRAM104220
Integrated pipeline, matched filter87 84449 699264
device utilisation20.7%5.8%0.1%1.5%
Integrated pipeline, CNN 8×88 \times8 (1–8–16–16, RF=8)98 79880 898107584
of which CNN29 16833 193105584
device utilisation23.2%9.5%5.0%13.7%
Integrated pipeline, CNN 12×1212 \times12, after phys_opt112 40481 300114648
of which CNN29 28433 532112648
device utilisation26.4%9.6%5.3%15.2%

Table 22. Post-place-and-route results for the integrated pipeline on the xczu49dr (ZCU216 board), Vivado 2026.1, out-of-context, 200 MHz[meas-hw]. Block rows are the matched-filter build. Percentages are device utilisation; BRAM in 18 K units.

Rearrangement is latency-critical for two reasons. Loading of the tweezer array is stochastic, and atoms are lost during a computation at stochastic times and sites, so a defect-free register has to be assembled before a circuit runs and re-assembled whenever loss is detected. Beyond initialisation, QEC (quantum error correction) cycles and the logical operations built on them require repeated rearrangement of atoms between zones: entangled atoms are shuttled coherently during the computation [27], and zoned architectures separate storage, entangling and readout regions that atoms move between every cycle [28]. Every rearrangement adds idle time in which the register accumulates decoherence and loss, so the throughput of the shuttling schedule and the circuit that consumes it bounds the useful clock rate of the machine. Therefore, both the shuttling algorithm and the circuit-level scheduling that generates the moves [104] have to be efficient. This work addresses the initialisation loop as the first step.

The chain is implemented for a 50 × 50 site array and taken through synthesis, placement and routing on the xczu49dr (Section D). The camera ingest and controller link of Section G are not part of it. Board-level integration, and the tests of the upstream (camera) and downstream (controller) interfaces specified in Section G, are the subject of a follow-on paper.

Occupancy contract

Detection and rearrangement communicate through one bit per site and one memory. The detector emits occupancy one grid row at a time as an NN-bit word (LSB = column 0) into an external simple dual-port block RAM (WIDTH = NN, DEPTH = NPADN_{\mathrm{PAD}}, one-cycle read) that the engine owns during a run. Only the write port is arbitrated: the loader drives it during preload, one row per cycle, and the engine during the run as it commits moves; a registered running flag selects the writer, so the two are never active in the same cycle. The engine owns the read port throughout. The target pattern enters through a separate port as (column, row) pairs, rows ascending within each column, before the start pulse; moves leave over a ready/valid handshake as from/to row and column descriptors. Table 5 lists the port groups.

Port groupDir.WidthSemantics
Crop input to detectorinP×8×8×16P \times8 \times8 \times16 bone 8×88 \times8 crop per lane per cycle, as built; P=1P = 1 for the CNN path
Occupancy write (bram_wr_*)in1+⌈log⁡2NPAD⌉+N1 + \lceil\log_{2} N_{\mathrm{PAD}} \rceil+ Nenable, row address, NN-bit row word (LSB = col. 0); loader during preload, engine during run
Write-port select (running)int.1registered; 0 = loader owns write port, 1 = engine owns it
Occupancy readint.⌈log⁡2NPAD⌉+N\lceil\log_{2} N_{\mathrm{PAD}} \rceil+ Nengine-owned; one-cycle read latency
Target pattern (tgt_init_*)in2⌈log⁡2N⌉2\lceil\log_{2} N \rceil(column, row) pairs, rows ascending per column; accepted before start_i only
Control (start_i, done_o, abandoned_o)in/out1 eachstart pulse; assembly complete; array infeasible
Move stream (move_*)out4⌈log⁡2N⌉4\lceil\log_{2} N \rceil + ready/validfrom/to row and column per accepted beat

Table 5. Port groups of the rearrangement pipeline at N=50N = 50.

Module inventory

Table 6 lists the implemented blocks. Three categories appear: the rearrangement engine and its submodules; the front-end blocks written to produce the occupancy the engine reads; and a small library of register, memory and arithmetic primitives shared across the project, instantiated explicitly rather than inferred.

BlockRole
tetrisTwo-phase engine top: per-row sweep, phase-2 handoff, shared move FIFO
row_assignCompile-time selection of the phase-1 assignment policy
row_assign_min_displacementMinimum-travel assignment; order-preserving dynamic program
row_assign_earliest_defectUrgency-ordered assignment; alternative policy
column_compressPhase 2: vertical compression, one column at a time
bitonic_sort64-wide, 21-stage pipelined sorter on the urgency key
source_col_encoderRow bitmap →\to ascending atom column indices
target_queue_storeNN per-column target-row queues in LUTRAM
site_row_assemblerPer-site detector decisions →\to NN-bit occupancy rows
atom_readoutOccupancy rows →\to grid-memory write port
tgt_pattern_loaderTarget pattern from ROM into the queue preload port
target_pattern_genGenerated target pattern, per-column ascending
atom_rearrangement_cnn_topSystem top: detector, assembler, loader, arbiter, memory, engine
matched_filter_detect / _arraySingle-site and PP-lane matched-filter detector (Section B.1)
BRAM_SDP, FIFO, MUX, DFF, DFFR, COUNTONES, COUNTERMemory, queue, arbitration, register and population-count primitives

Table 6. RTL inventory.

Table 5: Port groups of the rearrangement pipeline at N=50N = 50. Widths follow from NN and NPADN_{\mathrm{PAD}}, the width of the outer loading zone, set to twice the packed grid (NPAD=2NN_{\mathrm{PAD}} = 2N) in the experiments reported here; per-signal names follow the reference top. All port groups are implemented and exercised in RTL simulation (Section A.11).

Table 6: RTL inventory; Table 22 gives the resources of the active integrated configurations. Both detector configurations have been placed and routed, and parallel matched-filter variants have also been evaluated separately (Section D.1).

What the engine computes

The engine implements tetris-style compaction in two phases [102]. Phase 1 processes the grid row by row, assigning atoms to columns that still require them and moving the selected atoms horizontally. After a successful sweep, each target column contains the required number of atoms. Phase 2 moves atoms vertically within each column onto the target rows. Multiple atoms in one row or column can be transported in a single acousto-optic sweep. The number of sequential sweeps is therefore bounded by the rows and columns processed, rather than by the total number of atoms moved.

Both phases reduce to the same one-dimensional problem: pair an ascending list of source indices with an ascending list of destination indices so as to minimise total travel. By the rearrangement inequality the optimum for two lists of equal length is index-by-index matching, so no search is needed once the two lists are ordered; phase 2 therefore contains no sort at all, because the bit scan that reads the source and target masks produces both lists in ascending order by construction. Phase 1 is the harder case only because the two lists have different lengths: with KK atoms in the row and MM columns still needing atoms, one side must be subsetted, and which subset is chosen is the policy question of Section A.5.

Figure 5 gives the cost of this decomposition as a function of array size, measured on the reference implementation of the same algorithm. Sweeps grow as T0.49T^{0.49} in the number of target sites TT and moves as T1.06T^{1.06}: a defect-free 10410^4-atom array is assembled in one pass with about 218 sweeps and about 2T2T moves, every seed defect-free at a trap fill of 0.6[algo]. The sweep count is the latency-critical figure, because each sweep is one physical operation on the controller (Section G.11); the move count is the atom-loss exposure charged in Section E.4.

Figure 5. Cost of one assembly pass against target size for the algorithm the engine implements: acousto-optic sweeps (the sequential operations the controller must play) and total atom moves (the transport charged in atoms). Points are means over 20 seeds up to T=1764T = 1764 and 8 above, at trap fill 0.6, central region of interest, every point defect-free; dashed lines are power-law fits[algo]. The implemented 50×5050 \times50 design and the 10410^4-site scale of Section G.10 are marked.

Phase-1 assignment policies

Two policies are implemented behind one port list and selected at elaboration (Table 7). Minimum displacement is deployed. It orders the needy columns by urgency, pairs them with the row’s atoms so as to minimise ∑i∣srci−dsti∣\sum_i \lvert\mathrm{src}_i-\mathrm{dst}_i\rvert, and when the row holds more atoms than there are needy columns it runs an order-preserving dynamic program to choose which MM of the KK atoms to move. Earliest defect keeps the urgency order and pairs greedily. It needs no dynamic program, so its cost per row is the fixed K+N+27K+N+27 cycles: about twice the deployed policy’s fast path, and a third of its dynamic-program path, at the operating point of Figure 8. It does not minimise travel.

Minimum displacement (deployed)Earliest defect
ObjectiveMinimum total horizontal travel for the rowFill the column whose next unfilled row is highest up, first
Destination orderUrgency key (next needed row, then column index), from the bitonic sortThe same key and the same sorter
Subsetting when K>MK > MOrder-preserving dynamic program over the M×KM \times K table, then tracebackNone: the first KK sort outputs are taken
Cycles per rowK+27K+27 when K≤MK \le M; MK+K+M+N+28MK+K+M+N+28 when K>MK > MK+N+27K+N+27
Extra stateM×KM \times K take-matrix, 2×N2 \times N cost bufferNN-bit chosen mask
Verified againstMove-for-move equality with the software model (Section A.11)Co-simulation of done_o / abandoned_o only

Table 7. The two phase-1 assignment policies. KK is the number of atoms in the row and MM the number of columns whose target queue is still non-empty; N=50N=50 and the sort pipeline is GS =21=21 stages deep.

Figure 8. Phase 1 per row, fast path (K≤MK \le M), minimum displacement (deployed): 27 fixed per-row cost: sort pipeline (21) + overhead, 25 KK atoms in the row (emission or scan), 52 cycles. Phase 1 per row, DP path (K>MK > M), minimum displacement (deployed): 28 fixed per-row cost: sort pipeline (21) + overhead, 25 KK atoms in the row (emission or scan), MM columns still needing atoms, 50 NN-cycle serial scan, 200 dynamic-program fill, M×KM \times K cells, 311 cycles. Phase 1 per row, earliest defect (alternative): 27 fixed per-row cost: sort pipeline (21) + overhead, 25 KK atoms in the row (emission or scan), 50 NN-cycle serial scan, 102 cycles. Phase 2 per target column, column compression: 50 NN-cycle serial scan, 50 + one cycle per move phase-2 emission, one cycle per move. cycles at 200 MHz. Illustrative operating point: N=50N = 50, K=25K = 25 atoms in the row, M=8M = 8 columns still needing atoms; closed forms of the policy table. Figure 8: FSM state budgets, from the state tables of the RTL. Phase 1 costs the sort pipeline once per row whichever policy is selected; on the deployed policy the dynamic program is entered only when the row holds more atoms than there are columns still needing them, and it then dominates. Phase 2 is dominated by the serial column scan. Bars are design budgets from the closed forms of Table 7 at N=50N = 50, K=25K = 25, M=8M = 8, rather than a measurement of a particular run.

The deployed policy limits the number of pairs to min⁡(K,M)\min(K,M), so a row does not emit more assignments than there are columns requiring atoms. The earliest-defect variant instead pairs all KK atoms with the first KK entries of the sorted destination list, including padded entries for columns whose queues are empty. In the feasible co-simulation case of Section A.11, a 50×5050 \times50 array at a per-site loading probability of 0.7 contains approximately 1745 atoms, while the central 6×66 \times6 target requires 36. The variant emits 1584 moves before asserting done_o. A software model of the same rule emits 1637 moves, within 4% of the co-simulation count[algo]. Limiting assignments avoids these unnecessary moves and their associated transport loss (Section E.4).

Datapath blocks

Figure 6 shows the implemented blocks and what flows between them.

Figure 6. The implemented pipeline. Detection writes the occupancy grid one row at a time through an arbitrated write port; the engine owns the read port throughout a run and writes each row back as its moves commit. Phase 1 and phase 2 share one move FIFO, so the controller sees a single ordered move stream.

Source column encoder. Combinational. It turns the NN-bit row bitmap into the ascending list of columns holding atoms, as a prefix population count followed by a scatter, and reports KK. It is the smallest block in the engine and the one that sets its clock period (Section D.4).

Target queue store. NN independent circular queues in LUTRAM, one per column, holding that column’s still-unfilled target rows in ascending order. The pattern is pushed one entry per cycle before the start pulse; during a run the registered head of each queue is the column’s urgency, and a dequeue mask advances the heads of the columns that were assigned an atom. Holding the pattern per column, rather than as a bitmap, is what makes urgency a single-cycle read.

Bitonic sorter. A 64-wide, 21-stage pipelined sorting network on the 12-bit key formed from the head row and the column index, so columns needing an atom high in the array sort first and ties break by column. Columns with an empty queue take a sentinel key and sink to the tail. The network is generated by nested elaboration-time loops over the phase and sub-stage dimensions, and every per-element constant resolves at elaboration, so each cell synthesises to a comparator, a fixed-polarity multiplexer and a register, with no runtime control. The sorter is fed a new candidate set every row and costs the depth of its pipeline, 21 cycles, once per row.

Assignment. On the deployed path, the dynamic program fills one cell of the M×KM \times K table per cycle from two alternating cost buffers, records a take bit per cell, and walks the take matrix back to select the sources. The cost width is 12 bits, which covers the maximum cumulative travel N(N−1)=2450N(N-1) = 2450 for N=50N = 50. A final scan returns the chosen sources to ascending column order before pairing, which is what makes the emitted moves non-crossing.

Column compression. Phase 2 reads, for each column, the rows phase 1 assigned to it and the rows the target asks for, scans both masks together to produce two ascending lists, and emits one vertical move per differing pair. Columns with no target rows cost two cycles. Phase 1 guarantees the two lists have equal length when it completes without abandoning, and the block takes the shorter of the two defensively.

Move FIFO and grid memory. Both phases write one shared FIFO, 128 entries deep and 24 bits wide, one descriptor being the source and destination row and column; the consumer dequeues over ready/valid, and the depth absorbs about two and a half rows of moves before back pressure reaches the state machine. The occupancy grid is an external simple dual-port block RAM of 50-bit words and 64 entries, one-cycle read. Only its write port is arbitrated: a registered running flag hands it from the loader to the engine at the start pulse, and the read port belongs to the engine throughout, which is the mechanism behind the contract of Section A.2.

Front-end blocks and the target path

Three blocks were written so that the engine reads occupancy that a detector produced rather than occupancy a testbench injected.

The site row assembler packs detector decisions into an NN-bit occupancy row and presents each completed row for one cycle. In the matched-filter build it uses 223 LUT and 62 FF[meas-hw] (Table 22). The occupancy loader is combinational and drives these rows onto the grid memory’s write port. The target pattern loader reads a ROM and supplies one entry per cycle to the queue preload port, asserting done_o after Nentries+1N_{\mathrm{entries}} + 1 cycles. The default 30 ×\times 30 target uses 900 ROM entries generated from a configuration file; changing the target requires regenerating this ROM.

Two integration decisions in the system top are worth recording. The detector’s interface widths are parameters rather than constants, because the generated network’s output packing changes between builds: the deployed build gives each logit its own 64-bit lane, where the earlier one packed both into a single beat. And an occupancy source multiplexer selects between the detector and an external injection port, which is what allows the full-grid equivalence test of Section A.11 to run in seconds rather than in the twenty minutes a full grid through the detector would cost.

Design decisions

Three decisions follow from the loop (Section E.1) rather than from the detector (Table 8).

DecisionConstraintConsequence
Detector streams crops; no frame bufferA 2048×2048×162048 \times2048 \times16-bit ROI of the qCMOS sensor is 8 MB (18.9 MB for the full 4096×23044096 \times2304 frame), beyond on-chip memory; only the neighbourhood of each site (8×88 \times8 px in the evaluated configuration) carries informationOccupancy is emitted incrementally and detection overlaps camera readout
Interface carries one bit per siteThe engine consumes occupancy aloneMatched filter and CNN are drop-in replacements behind the same port
Engine reads an external memory rather than holding the gridRearrangement mutates the grid as moves are committed, so grid state must outlive any single blockLoader and engine share one representation with no copy; the next target pattern can be preloaded while the previous assembly drains

Table 8. Architectural decisions of the rearrangement pipeline and the loop constraint behind each.

Clocking and reset

The implemented block is one synchronous domain and one reset. A single clock port carries a 5.000 ns constraint; the generated detector core’s ap_clk and ap_rst_n are tied to that same clock and reset, and every library primitive the design instantiates (the grid memory, the move FIFO, the target queues, every register) is single-clocked. There is no clock-domain crossing anywhere in the design, and therefore no synchronizer in it.

The blocks operate at different rates within this clock domain. The CNN detector completes one site every 1797 cycles, or 9.0 µs\textsuperscript{[meas-sim]}, and the matched-filter lane one site per cycle, while the row assembler can accept one site per cycle and the engine reads one grid row per cycle. Handshakes coordinate these rates: ready/valid on the move stream, ap_start/ap_done for each crop, and the registered running flag for write-port ownership. These interfaces allow the implemented pipeline to use a single processing clock.

The constraint set. The implementation constrains one clock to 5.000 ns. It specifies no additional clock uncertainty, input or output delays, generated clocks, or false-path and multicycle exceptions\textsuperscript{[meas-hw]}. The setup and hold slacks of the current 8×88 \times8 matched-filter and CNN builds are reported in Section D.1; the earlier 12×1212 \times12 closure sequence is retained in Section D.4. Recovery and removal are not reported. The 200 MHz result therefore applies to the out-of-context block. Board-level I/O timing, clock distribution and reset-release checks must be included in the integrated implementation. The board build of Section D.3 adds the board clock through an MMCM and reports recovery and removal; both are met.

Reset. The register primitive used throughout asserts asynchronously on an active-low reset and releases asynchronously as well: there is no reset synchroniser in the block. Within a single domain this is benign in simulation and unchecked in implementation, because asynchronous release is exactly what recovery and removal checks exist to catch and those checks are unreported. A board-level wrapper should assert reset asynchronously and release it synchronously, once per domain, and the implementation run should report recovery and removal alongside setup and hold. The board build of Section D.3 does both: reset asserts when the MMCM loses lock and releases through a three-stage synchroniser, and recovery and removal are met with 0.254 ns and 0.097 ns of slack over 15 631 endpoints[meas-hw]. The memories are deliberately not reset. The grid memory and target queues have undefined contents until the preload protocol of Section A.2 writes every grid row and target entry before the start pulse. The preload protocol therefore establishes the initial state. RTL simulation establishes cycle counts but does not validate board-level timing or asynchronous reset release. The testbenches use a nominal 10 ns clock; reported latencies are obtained by converting the simulated cycle counts at the implemented 200 MHz clock[meas-sim].

Board-level clock domains. The external interfaces introduce additional clock domains (Section G). Each CXP-6 lane recovers a clock at approximately 156.25 MHz, corresponding to a 6.25 Gb/s line rate, 8b/10b coding, and a 32-bit transceiver interface[roof]. Elastic buffers align the lanes before bonding them into a single stream, which crosses into the processing domain through an asynchronous FIFO. The controller link uses the PCIe hard block’s user clock. Waveform playback and converter clocks belong to the controller and are outside the QDPU (Section G.11).

DomainSourceRateWhat runs in it
Processing clockBoard oscillator through a PLL in the board wrapper200 MHz constrained; ceiling unmeasuredDetector core, row assembler, loader, write-port arbiter, grid memory, engine, move FIFO
CXP recovered clocksPer-lane clock recovery in one GTY quad≈ 156.25 MHz per lane, 4 lanesLane alignment, deskew, bonding, link layer
Ingest crossingAsynchronous FIFO, bonded stream to fabric—Pixel stream into region-of-interest extraction
PCIe user clockHard block, fixed by link width and generationSet by the configurationOccupancy and move stream to the controller
Outer-loop linkThe PCIe user clock when the GPU shares the server; the Ethernet PCS user clock for NVQLink over 10 GbE (Sections G.5 and G.6)as above; 156.25 MHzSite windows and labels out, model weights in
AOD sample clockThe controller’s converters—Waveform playback; outside this device —

Table 9. Clock structure, implemented and specified. Rates for the unbuilt domains follow from the link standards and are not measurements[roof].

Figure 7. Clock structure. (a) The implemented block: one 200 MHz domain, one asynchronously asserted reset, no crossing. (b) The board-level design: four recovered camera clocks aligned and bonded before a single crossing into the processing clock, and a second crossing into the controller link’s user clock. The rates in (b) follow from the link standards1.

Sizing the ingest crossing. Four CXP-6 lanes carry 25 Gb/s of line rate and, after 8b/10b coding, 20 Gb/s of payload1. A 128-bit word in the processing clock carries 25.6 Gb/s at 200 MHz, so the crossing is a width conversion into the clock the pipeline already runs at rather than a reason to raise that clock1. Full-frame buffering is not possible on chip. A 2048 × 2048 sixteen-bit frame is 6.7×1076.7 \times10^7 bits against 38.9 Mb of block RAM and 23.0 Mb of UltraRAM on the device, so the frame does not fit on chip even if the pipeline used none of it1. This capacity limit motivates the streaming design of Table 8. The site windows do fit: at 2500 sites of 8 × 8 sixteen-bit pixels they are 2.56 Mb, 6.6% of the device’s block RAM1. The crossing therefore delivers pixels, region-of-interest extraction discards the 96% of the frame that lies between sites, and only the windows are retained.

The required crop-buffer capacity depends on the detector service rate and the camera delivery pattern. An 8 × 8 window of sixteen-bit pixels contains 1024 bits, equivalent to 0.0512 µs of payload at 20 Gb/s. The matched filter accepts one window per 200 MHz cycle; the serial CNN invocation takes about 9.0 µs per site (Section D.2). The standard-scan readout of a 2048-row ROI takes about 7.4 ms, giving a frame-average interval of 2.96 µs per site. Buffer sizing must also account for bursts within a site row. All 2500 crops occupy 2.56 Mb, so crop buffering is distinct from retaining a full raw frame. The line buffer and its delivery pattern remain to be implemented. The loop budget charges kernel time after crop acquisition and does not credit overlap with the proposed streaming ingest.

Cycle accounting

The engine is a state machine per row and per column, so its cost is a sum of state residencies rather than a pipeline throughput. Figure 8 gives the per-row and per-column budgets at an illustrative operating point, and Table 7 the closed forms.

Three properties follow. The per-row cost is dominated by fixed work, not by the number of atoms moved: at N=50N = 50 and half fill, 26 of the 52 cycles of a row are the sort pipeline and the fixed overhead, and the emission of 25 moves costs 26. The dynamic program is the only superlinear term, M×KM \times K cycles, and it is entered only in the late part of a sweep, when the queues have drained enough that the row holds more atoms than the remaining columns need. And phase 2 costs a serial scan of NN cycles per target column whether or not that column has anything to move, so its total grows as N2N^2 over a sweep although it performs no search at all (Figure 5).

For the array of Section A.11 (1270 atoms at half fill, a 961-site target), the measured engine time is 29 184 cycles[meas-sim], about 0.15 ms at 200 MHz; this is the reference engine run listed in Table 26.

StageCyclesTimeProvenance
Camera exposure (matched-filter operating point)—10.0 msphys
Sensor readout + CXP ingest, 2048-row ROI—7.4 ms (standard scan) or 36 ms (ultra quiet)datasheet; Table 39
Detection, matched filter, P=1P = 1 (2500+92500 + 9)2 50912.5 µsmeas-sim
Detection, CNN 8×88 \times8, 1 core (2500×17972500 \times1797)4 492 50022.5 msmeas-sim
Detection, CNN 8×88 \times8, 4 cores≈1 123 1255.6 msderived
Row assembler + loader preload≈ 1 000< 0.01 msderived: one row or queue entry per cycle (Section A.2)
Rearrangement engine29 1840.15 msmeas-sim
Egress to controller: FPGA to server memory, OPNIC SDK stream, NVQLink to the OPX1000—about 1 µs per PCIe transfer inside the OPC, memory to OPNIC included (vendor figure); stream hand-off unmeasured; vendor round trip < 4 µs [112]spec, unmeasured
Atom transport (modelled schedule)—about 10 ms, varying by cyclephys

Table 26. Component timings for the 50 × 50 design at 200 MHz; these are not an end-to-end feedback measurement. The engine row is the separate 961-site target verification run. Exposure and mean transport refer to the corrected-planner loop model (Section E.3); transport varies with each cycle’s schedule.

Functional verification

Integration is verified end to end in RTL simulation before silicon: a cocotb testbench drives the reference top (loader, write-port multiplexer, occupancy BRAM, engine) under Verilator, with occupancy produced by the detector rather than injected by the testbench. Two cases exercise the occupancy contract of Section A.2, one on each side of the feasibility boundary.

  • Feasible array: the engine completes the pattern. On an array holding more atoms than the target pattern requires, the engine consumes the detector’s occupancy and asserts done_o after emitting 1584 moves for one of the testcases. Each of the 1584 is checked against the occupancy state at the moment it is issued, on three conditions: the source site holds an atom, the destination site belongs to the target pattern, and both lie within the array bounds. All 1584 pass. Similar test patterns were generated and verified to be functionally correct for each generated move.

  • Infeasible array: the engine declines cleanly. On an array holding fewer atoms than the target

target pattern requires, the engine asserts abandoned_o rather than done_o. It neither hangs nor emits a partial plan, so the downstream controller is never handed a move schedule it cannot complete.

One further check bounds what the integration itself changed. In the feasible case the move count is identical to that of the standalone engine driven from the same occupancy by a software harness, so the engine cannot distinguish occupancy that reached it through the shared memory from occupancy injected directly by a testbench: the three blocks placed in front of it (Section A.1) are transparent to it. The rearrangement algorithm is common to both paths, and the standalone and integrated engines have byte-identical port lists.

LevelWhat it drivesWhat it establishes
Directed unit testsEight cases on the engine: reset, empty grid, atoms with no targets, single horizontal move, atom already placed, vertical move, several atoms in one row, back pressure held throughoutEach state-machine path is entered and leaves the move interface in a defined state; back pressure stalls emission rather than dropping moves
Move-for-move equivalenceSeeded random cases in two testbenches, up to a full 50×5050 \times50 grid: occupancy injected through the bypass port, the target preloaded, the plan captured beat by beatThe multiset of emitted moves equals the software model’s exactly, and applying either to the initial grid yields the same final grid
Interface co-simulationOccupancy through the loader, the write-port arbiter and the external memory into the engine, feasible and infeasible arraysThe arbitrated path reproduces the engine’s standalone behaviour; done_o on a feasible array, abandoned_o with no partial plan on an infeasible one
Detector in the loopSimulated site images through the generated detector netlist into the assemblerThe assembled occupancy matches ground truth on the sampled rows, 98% against a 88% gate[meas-sim]; a logit-packing or adapter error collapses this to chance

Table 10. Verification levels. All simulation is Verilator with cocotb; the software model is the reference implementation of the same two-phase algorithm.

The move-equivalence tests use a cocotb harness with Verilator. Each test case is specified by NumPy occupancy and target arrays, which are converted into the row bitmasks and queue-preload entries required by the RTL. The same arrays are passed to the reference Python implementation, run_tetris_plan, using the minimum-displacement policy. The hardware and reference model are therefore evaluated on the same inputs.

The comparison checks the emitted moves as a multiset and verifies that applying the two plans produces the same final occupancy grid. Move ordering is not asserted. These tests cover seeded cases up to a full 50×5050 \times50 grid; they do not establish equivalence for all possible inputs. Further verification could use bounded formal analysis of a row assignment or constrained-random testing with coverage of the assignment policy.

In the full-grid equivalence case, the 50×5050 \times50 array contains 1270 atoms and the centred 31×3131 \times31 target contains 961 sites. The hardware and software plans contain identical move multisets, and both produce a defect-free target[meas-sim]. This test evaluates the assignment policy in addition to individual move legality. Occupancy is injected through the bypass port; the detector and row assembler are tested separately at the fourth verification level. A single simulation of all 2500 sites through both detection and rearrangement has not been performed.

Detector Datapath and Detection Accuracy

Two detectors sit behind the occupancy contract: a calibrated matched filter and a small CNN. Both have measured cycle counts and integrated place-and-route results at 200 MHz (Section D). The 668 MHz standalone result applies to forty fixed-template matched-filter lanes. The loop model uses the runtime-loadable matched filter (Section E.2); the comparisons below also report CNN performance.

Data. All training and evaluation images are generated with an open-source neutral-atom imaging simulator [55, 56], configured for the Hamamatsu ORCA-Quest qCMOS sensor. The simulator models Poissonian shot noise, dark current, structured (row, column, flicker) readout noise, background illumination, and a diffraction PSF with Zernike aberrations; its authors note that it characterises aberrations once across the field, places atoms only at discrete sites, and does not reproduce every CMOS effect [55]. No real camera frames are used (§ 6). Table 11 lists the configuration; every camera parameter is set explicitly. The scattering rate is close to a previously reported 41 kHz [105].

ParameterValue
Atom, imaging line88Sr{}^{88}\mathrm{Sr}, 461 nm
Scattering rate Γ\Gamma40 000 photons/s
Objective NA; collection η=(1−1−NA2)/2\eta= (1-\sqrt{1-\mathrm{NA}^{2}})/20.65; 0.120
Quantum efficiency0.86
Detected photon rate per atom4.13 ms−1^{-1}
SensorORCA-Quest qCMOS, 4.6 μ\mum pixels
Object-plane sampling0.4 μ\mum/px (magnification 11.5)
Read noise0.43 e−^{-} rms (Standard scan)
Row, column, flicker noise0.02 e−^{-}, 0.02 e−^{-}, 0.01 e−^{-}
Gain, bias0.11 e−^{-}/ADU, 200 ADU
PSFdiffraction-limited with device Zernike terms, 0.31 μ\mum atom blur
Background3 e−^{-}/px/s; 100 e−^{-}/px/s (high)
Arrays14 ×\times 14 at 4 μ\mum; 28 ×\times 28 at 2 μ\mum; 36 ×\times 36 at 1.5 μ\mum
Fill, survival0.5, 1 (clean labels)
Exposure1–50 ms
Window8 ×\times 8 px (3.2 μ\mum)
Sites per point43 120 train, 43 120 test (sparse array)

Table 11. Imaging-simulator configuration for all detector results.

We correct one defect in the simulator’s CMOS readout. It holds each pixel’s photoelectron count in an integer and adds the real-valued row, column and flicker noise to it, so every addition truncates toward zero; at a few photoelectrons per pixel this discards most of the signal (59% of an atom’s detected photons at 30 ms in our earlier configuration). We hold the count in floating point until readout, a one-line change; the unmodified build reproduces our earlier data (27.6 against 25.6 detected photons per atom at 30 ms), and the patched build delivers the photons the configuration implies. Every detector result in this paper uses the patched build. Earlier drafts used the unmodified build with an earlier configuration (0.1 μm/px0.1\,\mu\mathrm{m}/\mathrm{px} sampling, the simulator’s default structured noise at about eight times the sensor datasheet), which together left about a fifth of the detected photons per atom at a given exposure; their accuracy figures are superseded.

Crop size. The detector operates on a fixed-size pixel window centred on each calibrated site position. The window size is a compile-time parameter set by the imaging geometry: it must hold the atom’s image with margin and should exclude the neighbouring sites. At the 0.4 μm/px0.4\,\mu\mathrm{m}/\mathrm{px} object-plane sampling of Table 11 (4.6 μm\mu\mathrm{m} camera pixels at 11.5× magnification) we use 8×88 \times8 pixels, 3.2 μm3.2\,\mu\mathrm{m}. The window extends at least 3 px (1.2 μm1.2\,\mu\mathrm{m}) from the site in every direction, about four times the 0.31 μm0.31\,\mu\mathrm{m} rms width of the simulated atom image, and it excludes the neighbouring sites at 2 μm2\,\mu\mathrm{m} pitch and above.

Earlier drafts used 12×1212 \times12 pixels, chosen when the simulated sampling was 0.1 μm/px0.1\,\mu\mathrm{m}/\mathrm{px}, where that window spanned 1.2 μm1.2\,\mu\mathrm{m}. At the present sampling a 12×1212 \times12 window spans 4.8 μm4.8\,\mu\mathrm{m}: at 2 μm2\,\mu\mathrm{m} pitch it contains the neighbouring sites, and at every pitch it adds background and read-noise pixels that carry little signal. We ran every configuration of this appendix at both sizes[sim]. The 8×88 \times8 window holds about 95% of the photons the 12×1212 \times12 one does. The matched filter is insensitive to the change, because its template falls to near zero away from the atom: its fidelity moves by at most 0.4% between the two windows at 3 ms and above. The CNN is not: the smaller window raises the 1–8–16–16 network from 94.05% to 95.40% at 2 ms on the sparse array and from 95.13% to 98.29% at 1.5 μm1.5\,\mu\mathrm{m} pitch and 5 ms, because a network whose global average pool discards where in the window the light falls cannot separate a neighbour inside the window from the atom at its centre.

For the matched filter the optimum is broad. Table 13 adds a 7 ×\times 7 window to the two above: from 3 ms on, the three sizes are within 0.4% of one another in every configuration, and no size is best in all of them, because a template estimated from labelled windows gives pixels without signal a weight near zero whatever the window holds. Accuracy therefore does not fix the size, and three other considerations do. The window must leave margin for an atom image broader than the simulated one (real optics add aberration and defocus) and for a site centre that drifts by a fraction of a pixel between calibrations; 8 ×\times 8 leaves at least 3 px on every side, and windows below 7 ×\times 7 begin to cut into the image itself. It should not reach the neighbouring site, which at 2 μ\mum pitch is 5 px away: windows up to 9 ×\times 9 keep it out, and 10 ×\times 10 or more brings it in. And it should suit the learned lane, which shares the region-of-interest extraction and gains markedly from a smaller window (above). 8 ×\times 8 meets all three, and its 64-term dot product is a six-level adder tree; the DSP cost, 61 slices per lane as built (Table 23) against at most 49 for 7 ×\times 7, is immaterial because one lane keeps pace with the camera (Section B.2). An even window cannot be centred on a pixel: the site pixel sits at index 4 of 0 to 7, three pixels from one edge and four from the other, and the region-of-interest extraction must use the convention the template was calibrated with.

Table 13. Matched-filter fidelity (%) against window size[sim]. Configurations as in Table 17; each window is generated, calibrated and tested separately.

Configuration7×77 \times78×88 \times812×1212 \times12
4 μm4\,\mu\mathrm{m}, 3 ms97.6897.6997.32
4 μm4\,\mu\mathrm{m}, 5 ms99.6599.7799.79
4 μm4\,\mu\mathrm{m}, high bg., 5 ms98.0697.8698.13
2 μm2\,\mu\mathrm{m}, 5 ms99.6599.5799.60
1.5 μm1.5\,\mu\mathrm{m}, 5 ms98.4498.2298.19

Table 23: Out-of-context place-and-route of the matched-filter datapath, xczu49dr-ffvf1760-2-e, Vivado 2026.1, 2.0 ns constraint, through route[meas-hw]. The harness rows feed the pixel inputs from registers, as the ROI line buffer will, and report the detector’s resources without the harness; the plain out-of-context rows drive the inputs from unconstrained ports. No harness build has a failing hold endpoint, and the constant-template harness builds none failing setup; the loadable P=20P = 20 and P=40P = 40 builds miss the 2.0 ns target and are quoted at their Fmax⁡F_{\max}. Cycles are ⌈104/P⌉+L\lceil10^{4}/P\rceil+ L for a 100×100100 \times100 array. Percentages are device utilisation.

BuildLane RTLWNS (ns)Fmax⁡F_{\max}DSPLUTFF
12×1212 \times12 window
1 lanecombinational (original)−5.39135 MHz1382 1772
P=20P = 20combinational (original)−5.77129 MHz2 76043 49821
1 lanepipelined, adders in DSP+0.09523 MHz21064140
P=20P = 20pipelined, adders in DSP−3.14195 MHz4 200 (98%)1 2802 847
1 lanepipelined, adders in fabric+0.52674 MHz1384 1434 413
P=20P = 20pipelined, adders in fabric+0.43636 MHz2 760 (65%)82 860 (19%)88 051 (10%)
P=20P = 20, harnesspipelined, adders in fabric+0.46651 MHz2 76082 94086 771
8×88 \times8 window, recalibrated template, harness
1 lanepipelined, adders in fabric+0.52674 MHz611 8511 877
P=20P = 20pipelined, adders in fabric+0.51673 MHz1 220 (29%)37 040 (9%)38 329 (5%)
P=40P = 40pipelined, adders in fabric+0.50668 MHz2 440 (57%)74 080 (17%)76 649 (9%)
8×88 \times8 window, runtime-loadable template, harness
1 lanepipelined, adders in fabric+0.45646 MHz641 8461 866
P=20P = 20pipelined, adders in fabric−0.34428 MHz1 280 (30%)36 269 (9%)37 174 (4%)
P=40P = 40pipelined, adders in fabric−1.11322 MHz2 560 (60%)72 474 (17%)74 289 (9%)

Table 23.

Misregistration does not separate the candidates either (Table 12)[sim]. Windows of 5 ×\times 5 to 10 ×\times 10 were cut from the 12 ×\times 12 crops, the template and threshold calibrated on centred windows, and the test windows shifted. A half-pixel shift costs 0.1–1.3%, a one-pixel shift 0.8–5.2% and a two-pixel shift 16–28%, nearly the same at every window size, because the loss comes from the atom’s image moving off the template’s peak, which a larger window does not help. What the matched filter needs is site registration to a fraction of a pixel, which places the requirement on the calibration of site positions rather than on the window.

Table 12. Matched-filter balanced fidelity (%) under site misregistration, by window[sim]. Template and threshold calibrated on centred windows; “±0.5” and “±1” are the worst of the four shifts along the axes by that many pixels. Half-pixel shifts are emulated by averaging the two neighbouring integer-shifted windows, which also averages pixel noise and slightly flatters those columns. Windows above 10×1010 \times10 leave no room for a shift inside the 12×1212 \times12 crop.

WindowSparse, 5 ms centred±0.5±11.5 μm1.5\,\mu\mathrm{m}, 5 ms centred±0.5±1High bg, 5 ms centred±0.5±1
5×55 \times599.7499.6198.9598.6397.6694.1498.0697.4794.22
6×66 \times699.7799.6198.9598.5297.2693.3698.0697.4294.14
7×77 \times799.7999.6298.9398.3997.3093.7098.1197.5394.65
8×88 \times899.7899.6498.8598.3597.2393.5898.1497.5494.62
9×99 \times999.7999.6798.9998.2397.0893.5398.1397.5494.65
10×1010 \times1099.7999.6499.0098.2397.0593.5398.1297.5894.73

Published per-site readout networks use comparable windows: 10 ×\times 10 pixels [4] and 28 ×\times 28 crops with a boundary parameter swept from 2 to 14 px [51]. Changing the window size changes the

multiply–accumulate count quadratically: at 8 × 8 the matched filter is 64 multiply–accumulates per site and the CNN 226 944, 45% of the 12 × 12 count. The implemented RTL of both detectors (Section D) is built for the 8 × 8 window.

Positioning. Matched filters can reach CNN-level readout error with two orders of magnitude fewer parameters and four orders of magnitude fewer multiplications [51][lit]. Classical estimators have also been compared against a Cramér–Rao bound using the same simulator [106][lit]. This appendix reports the corresponding accuracy comparison for our configuration; Section D gives the implemented cost of each detector, and Section E converts the difference into atoms per assembly. A global non-linear least-squares estimator fits site photon counts through the optical point-spread function using weighted Gauss–Newton iterations. The study reports its largest advantage at long exposures and discusses its computational cost [106][lit]. We use the matched filter as the hardware baseline in this work. The global estimator has not been implemented or benchmarked in the present FPGA flow.

Matched-filter lane

One site’s decision is a dot product of the site window against a calibrated template and a threshold, occ⁡=(∑ipixi⋅tmpli)>Θ\operatorname{occ} = \left(\sum_i \mathrm{pix}_i \cdot\mathrm{tmpl}_i\right) > \Theta; at the 8 × 8 window this is 64 multiply-accumulates and one comparison. The template is the difference between mean occupied and mean empty crops and the threshold the one that minimises PFP+PFNP_{\mathrm{FP}} + P_{\mathrm{FN}} on labelled windows; both are calibrated in the outer loop and stored as int8 coefficients and one integer. Recalibration for a new optical setup replaces 64 coefficients and one threshold. The lane is built in two forms. With the constants fixed at synthesis, a ROM and a parameter, the tool folds the constant multiplies, but recalibration is a rebuild. With LOADABLE set, each lane holds its coefficients and threshold in registers written through a configuration port, 65 register writes between frames and no rebuild, at the cost of 64 general multipliers per lane (Table 23). The loop needs the second form, since the outer loop refits the template as the device drifts, and the integrated pipeline uses it (Section D.1). The calibration used here, on the sparse 5 ms data of Section B, scales the template to int8 and picks the best integer threshold on the training split; the integer filter scores 99.770% on the test split against 99.773% in floating point[meas-sim]. The template is the simplest learned model the QDPU hosts: it is fit from labelled measurement data and refit as the device drifts, exactly as the CNN’s weights would be, with no gradient training.

The array wrapper instantiates PP lanes and accepts PP crops per cycle. Fixed-template lanes trade area for throughput at approximately constant Fmax⁡F_{\max}. In the loadable variants, the shared configuration-control path also affects timing as PP grows (Table 23). Each lane is fully pipelined: an input register, a product register, one register per level of the adder tree and a registered compare, nine cycles from window to bit at 8 × 8 (six adder levels) and eleven at 12 × 12. The multipliers map to DSP slices and the adder tree to fabric; letting the tool pack the adders into DSP slices as well fails timing at P=20P = 20 (Section D.1). The input bus grows as P×pixels×16P \times\mathrm{pixels} \times16 bits, 40 960 bits per cycle at P=40P = 40 for the 8 × 8 build, and must be driven from registers, which the ROI line buffer does by construction; a line buffer delivering forty windows per cycle is not yet built.

Throughput law and bit-exactness

A full nn-site sweep costs ⌈n/P⌉+L\lceil n/P\rceil+ L cycles, where LL is the lane’s pipeline depth, nine cycles for the 8 × 8 lane. The law holds at every point of Table 14 under Verilator with a cocotb harness (twelve configurations, n∈{2500,10000}n \in\{2500, 10000\} and PP from 1 to 40) with the calibrated 8 × 8 template and threshold[meas-sim]; the earlier single-register lane (L=1L = 1) and the pipelined 12 × 12 lane (L=11L = 11) obeyed it in the same harness. Every lane decision matches a software golden model evaluating (dot⁡(crop,tmpl)>Θ)(\operatorname{dot}(\mathrm{crop},\mathrm{tmpl}) > \Theta) in integer arithmetic, with zero mismatches; the test crops are concentrated around the decision boundary, where an arithmetic error would show. The runtime-loadable lane (Section B.1) passes the same test at P∈{1,20,40}P \in\{1,20,40\} with the template written through its configuration port, and again after a second, unrelated template and threshold are written in its place[meas-sim]. Bit-exactness is the relevant criterion because the output bit is treated as ground truth downstream.

ArraySites nnLanes PPCyclesMismatchesSweep time
50 × 502 50012 509012.5 µs
50 × 502 50021 25906.30 µs
50 × 502 500463403.17 µs
50 × 502 500832201.61 µs
50 × 502 5001025901.30 µs
50 × 502 5002013400.67 µs
50 × 502 500407200.36 µs
100 × 10010 000110 009050.0 µs
100 × 10010 00042 509012.5 µs
100 × 10010 000101 00905.05 µs
100 × 10010 0002050902.55 µs
100 × 10010 0004025901.30 µs

Table 14.

The sweep is never the bottleneck. At 500 MHz a 100×100100 \times100 array is classified in ⌈104/20⌉+9=509\lceil10^{4}/20\rceil+ 9 = 509 cycles, 1.02 µs, at P=20P = 20 and in 259 cycles, 0.52 µs, at P=40P = 40; a 2048×2048×162048 \times2048 \times16-bit region of interest requires at least 3.4 ms of payload transfer at 20 Gb/s, before packet overhead. The sensor-readout budget is longer (Table 39), so a single lane (P=1P = 1, 5.0 µs for 2500 sites) already keeps pace with the camera.

ReadoutBits / frameLink timeSensor, standardSensor, ultra quiet
2048 × 2048 ROI6.7×1076.7 \times10^{7}3.4 ms7.4 ms36 ms
4096 × 2304 full1.5×1081.5 \times10^{8}7.5 ms8.3 ms40 ms

Table 39. Ingress bandwidth and time per frame, 16-bit pixels, four CXP-6 lanes (20 Gb/s payload after 8b/10b, before packet overhead). The sensor readout times are scaled from the datasheet frame rates by rows read1.

The two array sizes in Table 14 bracket current practice. Arrays of 1225 and 2000 sites are loaded and rearranged in published systems [23, 25], a 6100-site tweezer array has been demonstrated [10], and 10410^{4} sites is the scale at which Section G.10 locates the limits of the present data structures and of the optics. Sweep cost is linear in nn at fixed PP, for the matched filter here and for the CNN (Section G.10), so the n=10 000n = 10\,000 rows give the cost of the same hardware one array generation out.

Table 14: Measured cycle counts for the pipelined 8×88 \times8 matched-filter lane with the calibrated template (L=9L = 9). ⌈n/P⌉+9\lceil n/P\rceil+ 9 holds exactly with zero lane mismatches against the software golden[meas-sim]. Wall-clock is quoted at the 200 MHz of the integrated design (Section D)[roof]; the lane routes at 668 MHz to 674 MHz (Table 23). Sweep time is the time to classify all nn sites at once.

Learned lane: CNN

Sub-pixel position jitter and neighbour crosstalk can reduce the accuracy of a fixed linear template (Section B.5). We therefore evaluate a small CNN, Conv⁡(1–8–16–16)\operatorname{Conv}(1\text{–}8\text{–}16\text{–}16) with global average pooling and a two-layer dense head, as the learned readout model (§ 3.1). It uses 226 944 MACs per site; Table 15 gives its layer structure. The network takes one 8×88 \times8 crop and returns an occupancy decision. All tensors use 12-bit per-tensor quantisation (Section C).

LayerOutput shapeParametersMACs
Input crop8×8×18 \times8 \times1––
Conv 3×33 \times3, 8 ch, same pad, BN, ReLU8×8×88 \times8 \times880 + 324 608
Conv 3×33 \times3, 16 ch, same pad, BN, ReLU8×8×168 \times8 \times161 168 + 6473 728
Conv 3×33 \times3, 16 ch, same pad, BN, ReLU8×8×168 \times8 \times162 320 + 64147 456
Global average pool (8×88 \times8)16–
Dense, 64 outputs, ReLU641 0881 024
Dense, 2 outputs2130128
Total4 946226 944

Table 15. Layer structure of the CNN for an 8×88 \times8 input window, from the model definition (atom_readout/model/deploy/qat_train.py, QAT_CONV=8,16,16, QAT_CROP=8, first-layer stride 1). Every convolution is followed by batch normalisation and ReLU. MACs are per site and count the convolution and dense multiply–accumulates; batch normalisation is a per-channel scale and shift and is not counted. Parameters do not depend on the window and include the four batch-normalisation values per channel (scale, shift, running mean and variance), 160 in all, of which 80 are trained. The same topology at 1-32-64-64 gives 3 561 600 MACs, 15.7× more; at the earlier 12×1212 \times12 window the two are 509 184 and 8 008 320.

Channel width has little influence on accuracy. The 1–32–64–641\text{–}32\text{–}64\text{–}64 network, 15.7× the MACs, is within 0.1% of the 1–8–16–161\text{–}8\text{–}16\text{–}16 network on every sparse configuration from 3 ms up, in full precision and under 12-bit quantisation-aware training (Table 16 and Table 18)[sim]. It leads only below 3 ms, by up to 1.4% at 1 ms, and by 0.4% at 1.5 µm pitch (Table 17). Accuracy is exposure-limited rather than capacity-limited.

ConfigurationPhotons per atomIdeal observerMatched filterCNN 1-8-16-16CNN 1-32-64-64
4 μm\mu\mathrm{m}, 5 ms1999.9399.7799.8999.88
4 μm\mu\mathrm{m}, high bg., 5 ms1998.2597.8697.5897.61
2 μm\mu\mathrm{m}, 5 ms1999.8599.5799.6799.69
1.5 μm1.5\,\mu\mathrm{m}, 5 ms1999.3498.2298.2998.70
4 μm\mu\mathrm{m}, 10 ms39>99.99>99.99>99.99>99.99
4 μm\mu\mathrm{m}, high bg., 10 ms3899.9099.8799.8499.83
2 μm\mu\mathrm{m}, 10 ms3899.99999.99899.99599.995
1.5 μm1.5\,\mu\mathrm{m}, 10 ms3999.9999.8199.8599.93

Table 17.

ConfigurationMatched filter1–8–16–16 FP321–8–16–16 12-bit1–8–16–16 12-bit band1–32–64–64 FP321–32–64–64 12-bit
4 µm, 3 ms97.6998.7498.9398.5398.8198.98
4 µm, 5 ms99.7799.8999.9299.7999.8899.94
4 µm, 7 ms99.9699.9899.9899.7599.9899.98
4 µm, high bg., 5 ms97.8697.5897.8496.9197.6197.83
2 µm, 5 ms99.5799.6799.7398.8299.6999.70
1.5 µm, 5 ms98.2298.2998.8698.5098.7099.00

Table 18. Model-selection accuracy (%) for the 8 × 8 readout configurations[sim]. The QAT models use this evaluation split for early stopping, so these are validation diagnostics rather than independent test-performance estimates. Per configuration means one model per row; band means one model for all six rows.

The network must also be trained for the exposure it will see. One model trained on every configuration and exposure from 1 to 50 ms together reaches 96.7% overall, and its accuracy on the sparse array falls as exposure grows (98.7% at 10 ms, 96.7% at 50 ms), every error a false positive: at 50 ms an empty window collects about eight electrons of stray light, more than a 1 ms atom delivers, so a decision rule sensitive enough for short exposures calls long-exposure empties occupied. Restricting training to the 3–7 ms training band closes most of the gap, and one model per configuration closes it entirely (Section C.1); a model trained in one band fails outside it (52% on the sparse array at 50 ms for the band model), so a CNN deployment requires one parameter set, with its input normalisation, per exposure and configuration. The matched filter has the same requirement in the form of one template and threshold per configuration, at 64 coefficients rather than 4946 parameters.

Reducing the MAC count primarily reduces DSP usage; at fixed reuse factor, it has little effect on the per-crop latency of the streaming implementation (Section D.2). The resulting resource margin can instead support lower reuse factors or replicated detector cores. These choices are evaluated within the shared budget for detection, rearrangement, and decoding (Section D.6).

Accuracy against the photon limit

We report accuracy as per-site imaging fidelity, the probability of identifying a site’s occupancy correctly, balanced over the two classes: F=1−(PFP+PFN)/2F = 1 - (P_{\mathrm{FP}} + P_{\mathrm{FN}})/2. At the fill fraction of 0.5 used throughout it equals the plain fraction of sites classified correctly.

The reference is an ideal observer for an independent-pixel model. In pixel ii, the reading in electrons is xi=ki+nix_i = k_i + n_i, with ki∼Poisson⁡(μic)k_i \sim\operatorname{Poisson}(\mu_i^c) and ni∼N(0,σ2)n_i \sim\mathcal{N}(0,\sigma^2), where σ=0.43 e−\sigma= 0.43\,\mathrm{e}^{-} and μic\mu_i^c is the mean over training sites of class cc. Thresholding ∑ilog⁡[p(xi∣μi1)/p(xi∣μi0)]\sum_i \log[p(x_i \mid\mu_i^1)/p(x_i \mid\mu_i^0)] is Bayes-optimal under this specified model. Its reference fidelity is estimated by Monte Carlo with 10510^{5} samples per class.

The detector accuracies are evaluated on the imaging simulator, which also contains structured noise and other dependencies absent from this independent-pixel reference. The reference is therefore not a strict upper bound on the tabulated detector fidelities; the CNN can exceed it, as in the 1 ms row of Table 16. In dense arrays, neighbour occupancy also enters the reference only through its mean. Earlier drafts used an independent-Gaussian reference; that value was not a bound on the correlated simulator data and is not used here.

Table 16 compares the detectors with the ideal observer as a function of exposure{sup}[sim]. Below about twelve detected photons per atom (3 ms) every detector is photon-limited and the CNN stays closer to the ideal observer than the matched filter: at 2 ms, 95.4% (1–8–16–16) and 96.0% (1–32–64–64) against the filter’s 91.6% and the ideal observer’s 96.5%. At 5 ms, nineteen photons per atom, the CNN reaches 99.89% and the filter 99.77%, against 99.93% for the ideal observer; both detectors pass 99.9% by 7 ms and 99.99% by 10 ms. The CNN’s advantage is therefore confined to the photon-starved end, where no detector is accurate enough to assemble an array (Section E.2), and amounts to about 1 ms of exposure at the fidelities the loop needs. Imaging loss grows as 1−exp⁡(−texp/τimg)1 - \exp(-t_{\mathrm{exp}}/\tau_{\mathrm{img}}) per image (Section E.1), so the exposure a detector saves is paid back in atoms; Section E converts the difference, and the inference time spent to obtain it, into atoms.

Crosstalk and background

Table 17 varies the site pitch from 4 µm to 1.5 µm and raises the background thirty-fold, at the two exposures where detectors still differ{sup}[sim]. With the 8×88 \times8 window neither moves the detectors far apart. At 2 µm crosstalk costs every detector about 0.2% at 5 ms and almost nothing at 10 ms. At 1.5 µm, where the neighbours fall inside the window, the 1–32–64–64 network leads the matched filter by 0.5% at 5 ms (98.70% against 98.22%) and the 1–8–16–16 network by 0.1%; at 10 ms every detector is above 99.8%. Under high background the matched filter leads both networks by 0.3% at 5 ms. The 12-bit models trained per configuration (Table 18) widen the dense-array margin to 0.6–0.8% at 1.5 µm and close the background gap. Crosstalk is the one regime in which the learned lane holds a consistent, if small, accuracy advantage; whether it is worth its inference time there is a question for Section E, which models only the sparse array. With the earlier 12×1212 \times12 window the order was reversed at 1.5 μm1.5\,\mu\mathrm{m}, with the 1–8–16–16 network 3% behind the filter (Section B, crop size).

Table 17: Per-site imaging fidelity by array pitch and background with the 8×88 \times8 window[sim]; columns and conventions as in Table 16. High background is 100 e−^{-}/px/s, the baseline 3 e−^{-}/px/s. At 2 and 1.5 μm1.5\,\mu\mathrm{m} the ideal observer treats neighbour light as its mean and is optimistic.

Quantisation and Toolflow

As machine learning (ML) models grow in parameter count, their on-chip resource usage and latency grow with them, which makes some models infeasible for latency-bound tasks. Quantisation reduces the precision of the arithmetic (weights, biases and activations) with little loss in accuracy [107, 108]. The CNN, the readout QDM, is therefore trained with High Granularity Quantization 2 (HGQ2, built on Keras 3), a differentiable fixed-point quantisation scheme that learns bit widths against the training loss [109]. The resulting model is exported to Vitis High-Level Synthesis through hls4ml, a hardware/software co-design tool for implementing machine-learning models on FPGAs [107, 108, 110]. This appendix summarises the workflow and the findings from these tools.

Per-tensor quantisation-aware training (QAT)

The network is specified in Table 15. Weights and activations use one ap_fixed<W,I> format per tensor, homogeneous across every axis, at 12 bits.

Table 18 reports the selected 12-bit models on the corrected data. The QAT runs train for up to 40 epochs with early stopping on the evaluation split, whereas the full-precision runs use a fixed 30 epochs. That split therefore participates in QAT model selection and is treated here as validation data. The comparison describes the selected configurations; it does not establish a quantisation-induced accuracy gain or an unbiased estimate of held-out performance. The input normalisation is fitted from each model’s training data and stored with its weights.

Per-tensor quantisation matches the format organisation of the generated RTL. Numerical agreement between a selected model and its implementation must still be checked through the toolflow; format organisation alone does not establish bit-exact equivalence.

The per-configuration and band-trained scores document the dependence on exposure and background. A CNN deployment requires the corresponding parameter set and normalisation constants. The current CNN weights are compiled into the bitstream; runtime updates require the changes described in Section G.9.

Precision floor

The tested toolflow and quantisation configurations did not provide an eight-bit implementation with accuracy comparable to the higher-precision baseline. Two issues were identified.

Finding 1: ap_fixed<W,I> with I≤0I \le0 is mishandled in csim. Observed with the tool versions of Section C.4. Reproduction: hold fractional resolution fixed and vary only the sign of II. The positive-II configuration scores 87%; the non-positive-II configuration scores 48.95%, i.e. chance[sim]. The failure is silent. In ap_fixed<W,I>, WW is the total number of bits and II the number of them to the left of the binary point, so II sets the range a tensor can represent and W−IW-I its resolution. A tensor whose largest value is 0.19 never uses an integer bit; with I≤0I \le0 every bit, and for I<0I < 0 some implied leading zeros as well, goes to resolution. Small-magnitude layers can require additional fractional precision. In the first convolution, ∣w∣max⁡=0.19\lvert w\rvert_{\max} = 0.19, so a positive-II format allocates bits to an unused integer range and reduces fractional precision at a fixed total width.

Finding 2: accuracy depends on the chosen precision and range. Independently of Finding 1, a positive-II global weight sweep on the earlier, photon-starved data (Section B, Data) gives 90.8% at 12 bits, 87.3% at 10, 76.0% at 9, and 56.3% at 8[sim]. The cause is a dynamic-range conflict that one per-tensor format cannot resolve: accumulators and batch-norm scales reach ≈31\approx31 and need six integer bits, while kernels lie within ±0.45\pm0.45 and need fractional bits. The deployed configuration is weights ap_fixed<12,2> and data ap_fixed<12,6>, at 90.30%, indistinguishable from the 18-bit baseline (90.2%) on that data; the corrected-data model-selection comparison is reported separately (Table 18). On the corrected selection split, the same format sensitivity is observed (Table 19)[sim]: deploying the per-configuration 8 × 8 networks at weights ap_fixed<W,2> and data ap_fixed<W,6>, 12 bits stays within 0.2% of the 18-bit result in every configuration, 11 bits loses up to 0.7%, 10 bits up to 2.1%, 9 bits up to 7.3%, and 8 bits fails, most of all where the margin is thinnest (high background, 1.5 µm pitch). Twelve bits remains the deployed width.

Configuration891011121418
Sparse, 3 ms83.4997.2398.3398.7598.7998.8298.84
Sparse, 5 ms93.2199.1899.8299.9099.9099.9299.92
1.5 µm, 5 ms52.5892.7098.2198.5698.8198.8598.84
High background, 5 ms50.0090.5495.6797.1297.6397.7297.79

Table 19. Balanced fidelity (%) of the 8 × 8 1-8-16-16 networks of Table 18 deployed at WW bits (weights ap_fixed<W,2>, data ap_fixed<W,6>, accumulators ap_fixed<32,16>), hls4ml C simulation on the model-selection split, 43 120–44 064 windows per configuration[sim].

Hardware-aware quantisation has enabled a 10-bit implementation for a different network and application [111][lit]. The precision required in a particular design depends on the model, arithmetic formats, and acceptable accuracy loss.

Resource cost of precision

Table 20 gives the HLS-synthesis resource change from 18-bit to per-tensor 12-bit on the reference network (1-32-64-64, RF=64, Resource strategy) used for the precision study[csynth]. Accuracy is held; BRAM falls 30%, LUT 22%, FF 20%, DSP 11%.

Resource18-bit12-bit per-tensorΔ
BRAM_18K1 113 (51%)775 (35%)−30%
LUT112 519 (26%)87 641 (20%)−22%
FF117 890 (13%)93 981 (11%)−20%
DSP1 158 (27%)1 030 (24%)−11%
Accuracy (earlier data)90.2%90.3%—

Table 20. HLS synthesis on xczu49dr for the reference network 1-32-64-64 at RF=64, Resource strategy, 18-bit versus per-tensor 12-bit[csynth]. Percentages are device utilisation.

The ordering follows from what each resource holds: BRAM is weight ROM and scales with operand width; LUT and FF scale with datapath width; the DSP count is set by the multipliers the reuse factor leaves unrolled, and a 12-bit operand still occupies a slice. Lowering precision therefore saves memory and logic; DSP savings come from the reuse factor (Section D.2).

Table 21 compares HLS estimates with place-and-route results for the earlier 12 × 12 CNN. HLS predicts DSP usage exactly and overestimates LUT and FF usage.

Resourcecsynth[csynth]place-and-route[meas-hw]Note
DSP648648exact
LUT50 62429 284logic optimisation in synthesis and implementation
FF47 34833 532logic optimisation in synthesis and implementation

Table 21. HLS estimate versus place-and-route for the earlier 12 × 12 CNN (1-8-16-16, RF=8, 12-bit).

Toolflow constraints

The following constraints were observed with HGQ2, hls4ml, Vitis HLS and Vivado 2026.1 on Keras 3 and shaped the deployed configuration. They document the path taken with those versions: later releases may behave differently, and none of the four was pursued beyond the workaround noted.

  • QGlobalAveragePooling2D raised an ndim assertion in the bit_exact pass; QAveragePooling2D(pool_size) followed by Flatten exported bit-exactly and is used instead. Whether the assertion reflects a limitation of the pass or a usage error on our side was not investigated.

  • Under io_stream, hls4ml accepted only homogeneously quantised activations; heterogeneous activation quantisation was accepted only under io_parallel. This constraint, rather than any accuracy result, set the fully per-tensor configuration.

  • C-synthesis of the fully unrolled io_parallel convolution for the deployed network did not complete in the time allowed and was not pursued further; io_stream synthesis of the same network completed. Whether io_parallel would complete given more time or a different strategy was not tested. Under io_stream the pixel-streaming loop rather than the MAC count sets latency (Section D.2).

  • With WRAP quantisers, exports made without trace_minmax calibration carried incorrect ranges and raised no error; calibration is applied throughout.

In this evaluation, global normalisation preserves the absolute brightness information used for occupancy classification. On the earlier data, at the compared exposure, per-crop normalisation gave 67% accuracy, compared with 100% for global normalisation[sim]. We therefore use global normalisation for this detector. The global mean and scale are fit from each model’s training data and stored with it; normalisation constants from one data set applied to another are a silent source of error.

Implementation Results

Place-and-route

Table 22 gives post-place-and-route results for the integrated pipeline on the xczu49dr (ZCU216 board), Vivado 2026.1, out-of-context[meas-hw], with each of the two detectors at the 8×88 \times8 window and, for reference, with the earlier 12×1212 \times12 CNN. The block rows are the hierarchy of the matched-filter run and sum to its total. Both 8×88 \times8 builds meet 200 MHz without a post-route optimisation pass: WNS 0.067 ns and WHS 0.042 ns with the matched filter, 0 of 55 993 endpoints failing, its worst path inside the rearrangement engine; WNS 0.158 ns and WHS 0.028 ns with the CNN, 0 of 153 233. The 12×1212 \times12 CNN build needed phys_opt_design to close (Section D.4). The only constraint is the 5.000 ns clock period; no additional clock uncertainty or input jitter is specified, so Vivado’s default uncertainty applies. LUTs are dominated by the rearrangement engine and all DSPs belong to the detector. The engine’s LUT count varies between implementation runs of the same RTL, from 69 404 to 85 766 across the three builds here, so differences in the totals of that order are tool variation rather than design; the detector rows are stable.

The matched-filter pipeline takes one site window per cycle on a registered crop input, which stands in for the output register of the region-of-interest line buffer; the line buffer itself is not built. In RTL simulation the integrated top, with the calibration written through its configuration port, assembles all 2500 sites of a 50×5050 \times50 array bit-exact against the software golden, 2510 cycles from the first window to the last occupancy row[meas-sim]. The CNN pipeline is the same back end with the CNN of Section D.2 in place of the lane.

The matched-filter datapath (Section B.1) was also placed and routed on its own, out of context, on the same part and tool version, at a 500 MHz target (Table 23)[meas-hw]: first at the earlier 12×1212 \times12 window, 144 multipliers per lane with the template of the earlier calibration, where the lane was pipelined, then at 8×88 \times8 with the template and threshold recalibrated on the data of Section B, with the constants fixed at synthesis and runtime-loadable.

The original lane computed the 144-term dot product combinationally, 26 to 27 logic levels, and reached 135 MHz. Pipelining it (Section B.1) closes the lane at 674 MHz, but only if the adder tree is kept out of the DSP slices: with the adders packed into DSPs a lane takes 210 slices, twenty lanes take 98% of the device, and DSP-to-DSP routing fails at 195 MHz. With the adders in fabric, twenty lanes route at 636 MHz with 65% of the DSP slices. The plain out-of-context build reports a hold violation of about 0.08 ns on some 2000 paths from input ports straight into the first register, an artefact of driving the inputs from ports with zero delay; in a harness that feeds the pixel inputs from registers the P=20P = 20 build has no failing setup or hold endpoint among 308 183, with a worst setup slack of 0.46 ns and a worst hold slack of 0.028 ns. Integration must feed the lane from registers.

At the 8×88 \times8 window the same RTL, with 64 coefficients, needs 61 DSP slices per lane, because the tool folds the three zero coefficients of the calibrated template, and Fmax⁡F_{\max} is flat in PP: 674 MHz for one lane, 673 MHz for twenty and 668 MHz for forty, the critical path being the same multiply or first adder in every build. Twenty lanes take 44% of the DSP slices and 45% of the LUTs of the 12×1212 \times12 build. Forty lanes, which do not fit at 12×1212 \times12 (5520 DSP slices against 4272), take 57% of the DSP slices and classify 10410^4 sites in 259 cycles, 0.52 μs at 500 MHz, with 0.5 ns of setup slack.

The runtime-loadable lane costs 64 DSP slices instead of 61, since no coefficient can be folded, and about the same fabric. One lane routes at 646 MHz. Replicated, it slows: 428 MHz for twenty lanes and 322 MHz for forty, the worst path running from the shared configuration-address register to the clock enables of the multipliers’ coefficient registers in every lane. That path is a fan-out of a quasi-static control signal and could be pipelined per lane; as built, forty loadable lanes classify 10410^4 sites in 0.80 μs at 322 MHz. The loop needs none of this: the ROI payload alone requires at least

3.4 ms of transfer time, so one lane is enough, classifying 2500 sites in 12.5 μ\mus at 200 MHz for 64 DSP slices, 1.5% of the device, and that is the lane integrated in Table 22.

Per-crop latency and reuse factor

Except where the 8 × 8 build is named, every figure in this subsection was measured on the 12 × 12 build of the CNN. Under io_stream the pixel-streaming loop sets the per-crop kernel latency, the cycles from ap_start to ap_done. The kernel is invoked once per site and invocations are serialised, so this latency is also the effective initiation interval; in a continuously streaming deployment the two would separate. Reducing the network 15.7× (Section B.3) leaves the latency essentially unchanged at fixed reuse factor. Across three C-synthesis estimates,

L(RF)≈1626+220 RF cycles per crop,(1)L(\mathrm{RF}) \approx1626 + 220\ \mathrm{RF}\ \text{cycles per crop}, \tag*{(1)}

reproducing the estimates to within 2%[csynth]: 15 682 cycles at RF=64, 3334 at 8, 2550 at 4. The fitted constant term is line-buffer fill plus datapath register depth. For the deployed RF=8 configuration, RTL simulation measures 3246 cycles per crop[meas-sim], 3% below the C-synthesis estimate of 3334 and 4% below the fit’s 3386; the measured value is the one quoted for the 12 × 12 build, and the loop uses the 8 × 8 measurement below.

The floor makes reuse factor an inefficient lever below RF=8: RF=4 improves latency 1.31× at 1.9× the DSP. RF=8 is the deployed operating point.

The window, not the network, sets the constant. The 8 × 8 build, the 1–8–16–16 network trained for the sparse 5 ms data (Table 18) at the same precision and RF=8, reports 1602 cycles per crop against 3334 at 12 × 12[csynth], close to the ratio of pixel counts, 64/144, plus a fixed overhead; its hls4ml C simulation agrees with the floating-point model on all of 2000 test windows, and its RTL co-simulation passes. In RTL simulation[meas-sim], with each crop started as the previous one completes, the 8 × 8 network takes 1797 cycles per crop; the same harness gives 3286 for the 12 × 12 build, within 1.2% of the 3246 measured in the integrated pipeline, and both builds’ logits match the Vitis co-simulation. Over 2500 sites at 200 MHz this is 22.5 ms per core, against 40.6 ms for the 12 × 12 build; the network itself takes 584 DSP slices against 648.

Crops need not wait for the previous one to finish: the dataflow design accepts the next window while the last layers of the previous one are still running. Driven back to back, the measured interval between results is 1165 cycles at 8 × 8 and 2651 at 12 × 12[meas-sim], which would bring one 8 × 8 core to 14.6 ms per array. The loop figures below use the serialised 22.5 ms, the convention of the 12 × 12 measurements.

This initialisation overhead occurs 2500 times per frame. Taking the fitted constant of Equation (1) as the fill, 2500 × 1626 ≈ 20.3 ms[csynth], about half of the 12 × 12 build’s 40.6 ms one-core detection time, is attributable to line-buffer refill; the constant is the fit’s intercept at RF = 0, not a measured fill time.

Board build of the matched-filter pipeline

The out-of-context top of Table 22 has about 5200 I/O bits: the 50 × 50 target input, the 50 × 50 assigned-rows output and the 1024-bit crop bus, more than the package has pins. For a board bitstream it is therefore wrapped in an on-chip self-test. The wrapper generates every input on chip: the matched filter’s calibration writes, the target preload and 2500 synthetic crops per iteration. It folds the occupancy rows, the moves and the assigned rows into a CRC-32 signature. The 300 MHz board oscillator (Si570) drives an MMCM that generates the 200 MHz clock; reset asserts when the MMCM loses lock and releases synchronously. Status is shown on the board’s LEDs. Iterations alternate between checked runs, which reseed the generators and must reproduce a fixed signature, and free runs on new stimulus; each kind runs with the move stream always accepted and with it accepted on about one cycle in sixteen, which models a slow controller.

Simulation. In eight iterations covering all four kinds (Verilator and cocotb), the assembled occupancy is bit-exact against the matched filter’s threshold rule and the RTL moves equal the engine’s golden model in every iteration, 1874–1906 moves each. The checked signature is identical with and without backpressure. The engine takes 24 694 cycles unthrottled and 45 865 throttled on the checked stimulus[meas-sim].

Implementation. The bitstream closes 200 MHz in context, with board pins and the MMCM clock tree (Table 24). The worst setup path is inside the engine, from its row-assignment logic into the grid memory’s data input. The bitstream has not yet been loaded on the board.

Out of contextBoard bitstream
Setup slack (WNS)0.067 ns0.095 ns
Hold slack (WHS)0.042 ns0.016 ns
Recovery / removal slacknot reported0.254 ns / 0.097 ns
Timing endpoints, failing of total0 of 55 9930 of 92 077
LUT: matched filter18451847
LUT: rearrangement engine85 76672 293
LUT: site row assembler223533
LUT: self-test wrapper—about 1430
LUT, total (device share)87 844 (20.7%)76 302 (17.9%)
FF, total (device share)49 699 (5.8%)52 123 (6.1%)
BRAM_18K / DSP2 / 642 / 64
Bonded I/O / MMCM—30 / 1
Power, Vivado estimate—2.39 W

Table 24. Matched-filter pipeline as a ZCU216 bitstream with on-chip self-test, Vivado 2026.1, 200 MHz[meas-hw], against the out-of-context build of Table 22.

The detector is unchanged between the two builds, and the extra flip-flops are the wrapper’s: its generators, the 2500-bit target register, the signature and counters. The engine’s LUT count falls by 13 473. That is within the range of 69 404–85 766 seen across earlier implementation runs of the same RTL (Section D.1), but the two builds differ in two ways that have not been separated: the board build includes the fix below, and the engine’s inputs come from on-chip logic instead of ports.

Engine fix found by the self-test. The backpressure iterations exposed a defect in the rearrangement engine. Both of its phases decide a move-FIFO write in one cycle and register it in the next, but they tested the FIFO’s full flag without counting the write already in flight. With one slot left, a second write could be decided and land on a full FIFO, which drops it. With a slow consumer, 595 of 1906 moves were lost. Every earlier test held the move stream always ready and never reached this state. Both phases now stall when the FIFO holds depth − 1 entries. All moves are recovered, unthrottled runs are unchanged cycle for cycle, and the engine’s existing tests pass. The loop-model results of Section E use the software planner and are not affected.

Timing closure

Cause. At a 5.000 ns constraint the initial implementation reached ≈115\approx115 MHz with 13 307 failing endpoints. The 21-level critical path ran from the source-column encoder’s ripple prefix-popcount and N×NN \times N scatter into the dynamic-programming cell arithmetic and the take-matrix scatter; the encoder output depends only on the latched input row and was being recomputed on every one of the M×KM \times K cycles of the dynamic-program fill (KK atoms in the row, MM columns still needing atoms, Table 7).

Fix. Registering the encoder output splits the path.

Cost. Latency: none. The downstream consumer first reads the registered value 22 cycles after the start pulse, so the added stage lies within existing slack; cycle counts and the golden move-plan match are unchanged. Area: +13 503 LUT for 300 registers. The register is an optimisation barrier: the scatter can no longer be collapsed into the downstream 50:1 dynamic mux, so all slots are materialised.

Result. WNS improves from −3.708-3.708 ns to −0.100-0.100 ns; a post-route phys_opt_design pass closes the remaining 0.1 ns for 14 LUTs (Table 25). Fmax⁡F_{\max} is reported as ≥200\ge200 MHz, the constraint having been met and the clock never swept above it. The remaining limiter is the encoder’s ripple prefix-popcount. A prefix-sum tree could reduce its depth from approximately 50 serial additions to about six levels. This alternative was not implemented because registering the encoder output already met the 200 MHz target without changing the simulated cycle count: the extra stage is hidden behind the sort flush. The tree’s benefit at higher clock targets remains to be evaluated.

baseline+register+phys_opt
WNS (ns)−3.708-3.708−0.100-0.1000.0000.000
Failing endpoints13 307890
Fmax⁡F_{\max} (MHz)≈115\approx115≈196\approx196≥200\ge200
CLB LUTs98 901112 390112 404

Table 25. Timing closure at 5.000 ns[meas-hw].

Latency budget

Table 26 decomposes FPGA-side latency per assembly cycle for the 50×5050 \times50 array at 200 MHz. Detection and rearrangement serialise. The row assembler signals completion (occ_done_o) after the last occupancy row is written, and the controller pulses the engine’s start_i only after it: on start the engine takes the occupancy memory’s write port (Section A.2), so a row written after that point would be lost. The stages therefore add.

Co-residency with a real-time decoder

Table 27 combines the implemented array-assembly pipeline (Table 22) with the separately evaluated four-round decoder specified in Section F. That decoder has a C-synthesis clock estimate of 3.270 ns and a standalone post-route period of 3.514 ns, corresponding to a derived kernel latency of 0.84 ms.

Table 27: Co-residency budget: implemented pipeline[meas-hw] with the qLDPC decoder[csynth], all at the 8×88 \times8 window. The one-lane matched-filter and one-core CNN rows are the integrated builds of Table 22; the others replace the one lane by the separately routed loadable lanes of Table 23, or replicate the routed CNN core, and are derived[roof]. Percentages use 425 280 LUT, 4272 DSP and 2160 BRAM_18K on the target device [113].

ConfigurationDetectLUTDSPBRAM
Matched filter, P=1P = 1, no decoder12.5 µs20.7%1.5%0.1%
Matched filter, P=1P = 1, + decoder12.5 µs61.0%40.2%37.4%
Matched filter, P=20P = 20, + decoder0.67 µs69.1%68.7%37.4%
Matched filter, P=40P = 40, + decoder0.36 µs77.6%98.7%37.4%
CNN, 1 core, no decoder22.5 ms23.2%13.7%5.0%
CNN, 6 cores, no decoder3.7 ms57.5%82.0%29.3%
CNN, 1 core + decoder22.5 ms63.6%52.4%42.2%
CNN, 2 cores + decoder11.2 ms70.4%66.1%47.1%
CNN, 4 cores + decoder5.6 ms84.2%93.4%56.8%
CNN, 6 cores + decoder3.7 ms97.9%120.8%66.5%

Table 27.

Its resource figures are the C-synthesis estimates in Table 34. The budget uses one loadable matched-filter lane for the loop and replicated CNN cores as alternative hardware-sizing cases.

xczu49dr, PL onlyxcve2802, PL + AIE
Clock, estimated3.270 ns[csynth]2.77 ns[csynth]
Clock, post-route3.514 ns[meas-hw]3.327 ns[meas-hw]
Latency per shot0.84 ms[roof]192–202 μ\mus[meas-sim]
LUT171 635 (40.4%)[csynth]163 021 (31.3%)[meas-hw]
FF186 815 (22.0%)[csynth]195 258 (18.7%)[meas-hw]
DSP1655 (38.7%)[csynth]704 (53.7%)[meas-hw]
BRAM_18K805 (37.3%)[csynth]558 (46.5%)[meas-hw]
AIE tiles—25 (17 bit, 8 check)

Table 34. The decoder on the two targets at a 3.33 ns target. Utilisation as a share of each device.

  1. The matched-filter configuration leaves component-level margin. One loadable lane and the decoder total 61.0% LUT, 40.2% DSP and 37.4% BRAM. Twenty or forty lanes add throughput that the camera does not require; forty lanes already reach 98.7% DSP before interfaces.

  1. CNN replication consumes the interface margin. Each additional core uses 584 DSP slices. Four cores and the decoder total 84.2% LUT and 93.4% DSP, excluding ingress and egress. These totals do not establish that the complete design fits (Section G.9). The loop comparison uses one CNN core (Table 30); the replicated rows here are resource projections.

DetectorDetectCycle0.1% per move Success0.1% per move Wall-clock0.1% per move Lostlossless transport Successlossless transport Wall-clock
Matched filter, 1 lane0.01 ms27.5 ms0.8460.16 s11.01.0000.05 s
CNN, 1 core22.5 ms49.7 ms0.6860.43 s16.30.9830.14 s
CNN, no detection time—27.4 ms0.8460.16 s11.01.0000.05 s

Table 30. Cycle time and assembly outcome including inference latency (τvac=60\tau_{\mathrm{vac}} = 60 s, 35×3535 \times35 target in the 50×5050 \times50 array, detector on the FPGA, 10 ms exposure)[phys]. Cycle time is the mean loop period of Figure 10. The CNN is the 8×88 \times8 build on one core; its error rates are per class (Table 29). Wall-clock: per successful assembly. Lost: atoms per attempt, standard error 0.1–0.3.

  1. Synthesis estimates require implementation checks. Decoder resources are planning inputs, not guaranteed upper bounds. Joint placement and routing may change resource use, timing and routing feasibility.

The estimates exclude camera ingest, its GTY interface and the PCIe block. The decoder has not been placed and routed together with the pipeline.

Power

Vivado’s post-route power estimate for the matched-filter board build of Section D.3 at 200 MHz is 2.39 W on chip: 1.17 W device static and 1.22 W dynamic[meas-hw] (Table 28). The rearrangement engine accounts for 0.94 W, 77% of the dynamic power, and the matched filter for 0.04 W. The estimate is vectorless: no switching activity from simulation was supplied, so internal nodes run at the tool’s default toggle rates, and Vivado rates its confidence as low. It also assumes the engine switches continuously, whereas in the loop it is active only while planning, about 0.12 ms per plan (24 694 cycles, Section D.3). An estimate from simulated activity, and estimates for the CNN and the CNN-plus-decoder configurations, remain open (Section H).

By blockWBy resourceW
Rearrangement engine0.938Logic (LUT, FF, carry)0.429
Site row assembler0.087Signals (routing)0.347
Matched filter0.040Clocks0.313
Self-test wrapper0.036MMCM0.098
Clocking, I/O and top level0.113DSP, I/O, BRAM0.028
Dynamic1.215Dynamic1.215
Device static1.170
Total on chip2.385

Table 28. Post-route power estimate, matched-filter pipeline as a ZCU216 bitstream with on-chip self-test, 200 MHz, vectorless, Vivado confidence low[meas-hw].

Atom-Loss Model and Closed-Loop Evaluation

This appendix evaluates atom loss during array assembly. It defines the loss model and operating points, decomposes the cycle time, and estimates the contribution of each loss channel to array lifetime.

Model and parameters

An assembly cycle images the array, decides occupancy per site, and moves atoms into the target sites; if the assembly is incomplete the cycle repeats. Four channels remove atoms:

Imaging per-readout survival exp⁡(−texp/τimg)\exp(-t_{\mathrm{exp}}/\tau_{\mathrm{img}}); reduced by shorter exposure.

Transport a fixed loss probability per moved atom; reduced by fewer moves and fewer rearrangement cycles.

Collision an atom moved onto an occupied trap loses both atoms. It arises when the detector misses an atom and the planner moves another atom onto its site; reduced by fewer missed atoms.

Dead time survival exp⁡(−tcycle/τvac)\exp(-t_{\mathrm{cycle}}/\tau_{\mathrm{vac}}) over the whole cycle wall-clock, including any host round-trip; reduced by removing the host from the feedback path.

Table Table 29 lists the parameters. The model is calibrated against a published survival and exposure baseline [114][lit]. Every attempt is simulated on the 50×5050 \times50 array the hardware is built for, with a centred 35×3535 \times35 target, and charged the transport time of its own move schedule. The reference point is τvac=60\tau_{\mathrm{vac}} = 60 s and 0.1% loss per moved atom; lossless transport is the comparison case.

Metrics. An attempt succeeds when the target is defect-free within nine detect–rearrange cycles. The figures reported are the success probability PdfP_{\mathrm{df}} and the wall-clock per successful assembly, the mean time per attempt, failed attempts included, divided by PdfP_{\mathrm{df}}. Atoms lost per attempt, all channels, are reported alongside. At 1225 target atoms a slow loop does not lose a few atoms more per assembly; it fails to complete the target, because the atoms lost during each cycle must be re-supplied by the next.

Geometries. The results of this paper are produced at three geometries, and each quantity below is labelled by the one it belongs to. The detector accuracies of Section B come from the imaging simulator: a 14 × 14 array at 4 μm pitch sampled at 0.4 μm/px, 10 px per site, read through an 8×88 \times8-pixel crop (Table 11). The closed-loop results of this appendix, and every hardware figure of Section D, are for the 50×5050 \times50 array with a 35×3535 \times35 target; only Figure 9, a study of how the required detector fidelity scales with target size, uses smaller grids. The site pitch of the target apparatus is not yet fixed. The 2048-pixel region of interest of the FPGA design is a sizing assumption: at the 0.40.4 µm/px of Table 11 the simulated 44 µm pitch is 10 px per site, and a 50×5050 \times50 array at that pitch spans about 500 pixels. The detector is therefore evaluated at the simulated pitch only, and a re-simulation at the apparatus’s pitch is left until that pitch is known (§ 6).

Detection-fidelity requirement for defect-free assembly (multi-cycle loop, vs target size)

Figure 9. Multi-cycle defect-free assembly probability PdfP_{\mathrm{df}} against per-site detection fidelity for 5×55 \times5, 8×88 \times8 and 10×1010 \times10 targets[phys]. Detection is modelled as a symmetric error, each site’s occupancy read wrongly with probability 1−f1 - f; moves are planned on the detected map with a parallel Hungarian planner and executed on the true array; an assembly succeeds when the target is defect-free within nine detect–rearrange cycles. Targets are centred in 11×1111 \times11, 18×1818 \times18 and 22×2222 \times22 grids, with no atom loss and no refill; 600 shots per point.

All closed-loop results come from one model (atom_readout/simcheck/loop50.py), run at the operating points by loop50_opt.py; configurations that appear in more than one table report the same values.

Closed-loop operating points

Assembly can require multiple cycles because detection errors and atom loss leave defects after rearrangement. With every site read correctly and no loss, the planner completes the 35×3535 \times35 target from a 60% load in a single cycle in every attempt. A missed atom is moved onto, losing two atoms, and a site read as occupied when it is empty is used as a source that delivers nothing; either leaves a defect for the next cycle. The per-site detection fidelity required for a given multi-cycle defect-free probability rises with target size (Figure 9): at Pdf=0.99P_{\mathrm{df}} = 0.99, from about 97.5% for 25 atoms to about 99.5% for 100 atoms.

Each configuration runs at the exposure that minimises its wall-clock per successful assembly at the reference point (τvac=60\tau_{\mathrm{vac}} = 60 s, 0.1% loss per move), found by sweeping 7–12 ms[phys][sim]. Longer exposures cost imaging loss and cycle time, and detection errors cost cycles, each of which makes about 1300 lossy moves. For the matched filter on the FPGA the wall-clock per assembly falls

from 0.34 s at 7 ms to 0.157 s at 10 ms and rises again to 0.177 s at 12 ms; the CNN on one core has its minimum at the same 10 ms (0.43 s), and the matched filter behind the host at 11 ms, where its success probability is flat within the sampling error from 10–12 ms. Neither detector produced errors in the evaluated simulated samples at exposures of 10 ms or longer. At these exposures, the loop model assigns zero detection error to both; their assembly outcomes therefore differ only through inference latency. An earlier rule, the least exposure reaching Pdf≥0.99P_{\mathrm{df}} \ge0.99 without vacuum or transport loss, put the operating points at 7.5 ms (matched filter) and 7.0 ms (CNN). It favoured the CNN, whose lower miss rate at those exposures saves cycles, but under transport loss neither detector is at its best there: the matched filter at 7.5 ms succeeds in 58% of attempts at 0.28 s, against 85% at 0.16 s at 10 ms. Earlier drafts placed the operating points at 70 and 120 ms, and later at 4.0 and 5.0 ms on an 11 × 11 grid with a 25-atom target; the first came from the photon-starved data that Section B supersedes, the second from a geometry at which a single cycle was rarely enough.

Loop wall-clock decomposition

The CNN evaluates one crop at a time, at 1797 cycles per crop for the 8 × 8 build[meas-sim] (Section D.2), on one core: over 2500 sites at 200 MHz this is 22.5 ms, against 40.6 ms for the 12 × 12 build. One matched-filter lane classifies the same array in 12.5 µs at 200 MHz (Section D.1). Every cycle is charged its exposure, the 7.4 ms camera readout, the detector’s datapath time once the crops are in memory, 0.15 ms of rearrangement (29 184 cycles) and the minimum-jerk AOD transport of that cycle’s own move schedule, about 10 ms. At the reference point the mean loop period is therefore 27.5 ms with the matched filter and 49.7 ms with the CNN, 45% of it detection (Figure 10). With the matched filter the loop is bound by camera readout and atom transport, which together take 64% of the period.

Figure 10. Mean loop period per assembly cycle, 50 × 50 array with a 35 × 35 target, with one matched-filter lane and with the 8 × 8 CNN on one core, each at its operating exposure of 10 ms (Section E.2)[phys]. Camera readout is 7.4 ms; detection is the CNN’s serialised 22.5 ms, and the matched filter’s 12.5 µs is not visible at this scale; transport is the mean over cycles of each cycle’s own schedule (τvac=60\tau_{\mathrm{vac}} = 60 s, 0.1% loss per move).

Table 30 charges the CNN’s inference time against its accuracy. At its operating exposure the CNN has no accuracy to offer: with its detection time set to zero it reproduces the matched filter’s outcome exactly. Its 22.5 ms per cycle is therefore pure dead time, and it lowers the success probability from 0.85 to 0.69 and nearly triples the wall-clock per assembly (0.43 s against 0.16 s); with lossless transport both complete almost every attempt, the CNN at 0.14 s against 0.05 s.

Table 30: Cycle time and assembly outcome including inference latency (τvac=60\tau_{\mathrm{vac}} = 60 s, 35×3535 \times35 target in the 50×5050 \times50 array, detector on the FPGA, 10 ms exposure)[phys]. Cycle time is the mean loop period of Figure 10. The CNN is the 8×88 \times8 build on one core; its error rates are per class (Table 29). Wall-clock: per successful assembly. Lost: atoms per attempt, standard error 0.1–0.3.

Loss channels and array lifetime

Imaging. At τimg=70\tau_{\mathrm{img}} = 70 s one 10 ms image of 1500 atoms costs about 0.21 atoms; over an attempt, failed attempts included, imaging costs about one atom (1.02 with the matched filter, 1.25 with the CNN at the reference point)[phys]. It is the smallest channel at every trap lifetime.

Transport and collisions. An attempt makes about 1300 moves per cycle, so 0.1% per move costs 6.7 atoms per attempt with the matched filter on the FPGA, three fifths of all loss at the reference point, and 1% per move, about 13 atoms per cycle, prevents any assembly from completing. With both detectors error-free at the operating exposure, the corrected planner makes no collisions; the planner as built makes about 45 per attempt (Table 32).

ConfigurationSuccessCyclesCycle timeWall-clock / successLost
0.1% loss per moved atom
Matched filter, 10 ms, on-FPGA0.8464.1027.5 ms0.16 s11.0
CNN, 10 ms, 1 core, on-FPGA0.6864.4949.7 ms0.43 s16.3
Matched filter, 11 ms, host in loop0.0825.24178 ms19 s51.1
CNN, 10 ms, 1 core, host in loop0.0615.26200 ms29 s56.3
Matched filter, 10 ms, on-FPGA, planner as built0.9434.5926.4 ms0.14 s54.7
Lossless transport
Matched filter, 10 ms, on-FPGA1.0001.8029.3 ms0.05 s1.6
CNN, 10 ms, 1 core, on-FPGA0.9832.6350.8 ms0.14 s4.0
Matched filter, 11 ms, host in loop0.2254.84178 ms6.4 s37.1
Matched filter, 10 ms, on-FPGA, planner as built0.9953.4126.5 ms0.09 s47.5

Table 32. Rearrangement figures of merit at τvac=60 s[phys]\tau_{\mathrm{vac}} = 60\,\mathrm{s}^{[\mathrm{phys}]}: 50 × 50 array, centred 35 × 35 target, 60% fill, no refill, at most nine cycles, 1000 attempts per row, corrected planner unless stated, each configuration at its operating exposure, the CNN on one core. Success: target complete within nine cycles. Cycles: mean over successful attempts. Cycle time: mean over all cycles. Wall-clock per success: mean time per attempt, failed attempts included, divided by the success probability. Lost: atoms lost per attempt, all channels.

Dead time. The dead-time channel is the one the readout path controls. At τvac=60\tau_{\mathrm{vac}} = 60 s the FPGA loop loses 3.3 atoms per attempt to it with the matched filter and 7.2 with the CNN on one core; with the 150 ms host round-trip it loses 37.8, and the assembly succeeds in 8.2% of attempts instead of 84.6%[phys]. Each cycle with the host costs about 4.4 atoms of the 1500 to vacuum, more than three of them in the target, and they must be re-supplied in the next cycle, which costs as many again. Over τvac∈[5,1380]\tau_{\mathrm{vac}} \in[5, 1380] s dead time is 2–84% of all loss with the matched filter on the FPGA and 11–96% with the host in the loop (Figure 11, Table 31).

τvac\tau_{\mathrm{vac}}5 s10 s20 s60 s300 s1380 s
Success probability
Matched filter, 10 ms, on-FPGA0.0030.0960.4470.8460.9450.963
CNN, 10 ms, 1 core, on-FPGA0.0000.0070.1150.6860.9250.956
Matched filter, 11 ms, host in loop0.0000.0000.0000.0820.7900.937
Wall-clock per successful assembly
Matched filter, 10 ms, on-FPGA82 s2.4 s0.44 s0.16 s0.11 s0.10 s
CNN, 10 ms, 1 core, on-FPGA—64 s3.7 s0.43 s0.22 s0.19 s
Matched filter, 11 ms, host in loop———19 s1.2 s0.77 s

Table 31. Assembly success probability and wall-clock per successful assembly against trap lifetime, 35×3535 \times35 target in the 50×5050 \times50 array, 0.1% loss per moved atom, no refill[phys]. Each configuration runs at its own operating exposure (Section E.2); the CNN runs on one core. —: no attempt of 1000 succeeded.

Figure 11. Atom loss per attempt by channel (left) and assemblies per stochastic load (right) against trap lifetime τvac\tau_{\mathrm{vac}}[phys]. Stacked from the bottom: imaging (solid), transport (dotted) and dead-time (hatched) loss; the corrected planner makes no collisions at these exposures. 50 ×\times 50 array at 60% fill with a centred 35 ×\times 35 target, at most nine detect–rearrange cycles per attempt, no refill, 0.1% loss per moved atom, 1000 attempts per point; per-class detector errors from the imaging simulator (8 ×\times 8 window) at each configuration’s operating exposure, the CNN on one core, τimg=70\tau_{\mathrm{img}} = 70 s. Assemblies per load is the number of attempts the 275 atoms loaded beyond the target would last: (loaded − 1225) / atoms lost per attempt.

Table 31: Assembly success probability and wall-clock per successful assembly against trap lifetime, 35×3535 \times35 target in the 50×5050 \times50 array, 0.1% loss per moved atom, no refill[phys]. Each configuration runs at its own operating exposure (Section E.2); the CNN runs on one core. —: no attempt of 1000 succeeded.

Net. At the reference point the pipeline with the matched filter on the FPGA completes the 35×3535 \times35 target in 85% of attempts at 0.16 s per successful assembly; with the 150 ms host round-trip it completes 8% at 19 s, about 120 times the wall-clock (Table 32). The host loop catches up only as the trap lifetime grows: at 300 s it succeeds in 79% of attempts, at 11× the wall-clock, and at 1380 s in 94%, at 7.5× (Table 31). With lossless transport the ordering is the same: 100% against 23% at 60 s. The CNN on one core succeeds less often than the matched filter at every lifetime and takes about twice its wall-clock from 300 s, nearly three times at 60 s.

Sensitivity. The dead-time conclusion depends on the host round-trip thostt_{\mathrm{host}}, which has not been measured on the target apparatus; the 150 ms used above is an assumption. At the reference point every millisecond counts (Figure 12): 10 ms of host round-trip lowers the success probability from 0.85 to 0.78, 25 ms to 0.66, 50 ms to 0.47 and 100 ms to 0.18; at 20 s the host loop completes fewer than 4% of attempts from 50 ms, and only at 1380 s is the penalty small at every round-trip studied. The CNN’s 22.5 ms of inference acts as dead time of the same kind: at 20 s and 60 s it costs about as much success as a 25 ms host round-trip. The conclusions also hold at a photon rate three times below that of Table 11, closer to the exposures laboratories report, with each configuration re-optimised over 21–33 ms: the matched filter on the FPGA succeeds in 70% of attempts at 0.40 s (30 ms), the CNN on one core in 51% at 0.91 s (28.5 ms), and the host loop in 6% at 30 s. Measuring thostt_{\mathrm{host}} on the existing host pipeline, from frame arrival to trigger, fixes the size of the penalty.

Figure 12. Assembly success against the host round-trip thostt_{\mathrm{host}} added to every cycle, at four trap lifetimes[phys]: matched filter at 10 ms (solid, markers at the simulated round-trips; the 150 ms point at its own operating exposure of 11 ms) and, for comparison, the CNN at 10 ms on one FPGA core with no host (dashed, same shade). 50×5050 \times50 array, centred 35×3535 \times35 target, 60% fill, no refill, at most nine cycles per attempt, 0.1% loss per moved atom, 1000 attempts per point. τvac=1380\tau_{\mathrm{vac}} = 1380 s is the 23 min lifetime of [10].

Figures of merit. Table 32 gives the figures of merit usually reported for rearrangement at the reference point[phys]. The FPGA loop completes a 35×3535 \times35 assembly in 0.16 s of wall-clock with the matched filter and 0.43 s with the CNN on one core, against 19 s with the matched filter behind the host and 29 s with the CNN behind it. The planner as built, compared at the same 10 ms, loses 45 atoms per attempt to collisions, all from its column step since detection is error-free, against none with the corrected step. With lossless transport it is the worse of the two (0.995 against 1.000 success, 3.4 cycles against 1.8, 0.09 s against 0.05 s per assembly); at 0.1% per move it succeeds more often (0.943 against 0.846, 0.14 s against 0.16 s). The difference lies in the repair cycles. Both planners re-plan the whole array from the detected map every cycle, a full row sweep and column compression, so after the first cycle they fill the two or so remaining holes by shifting atoms already in place: about 1130 moves per repair cycle with the corrected step and 670–940 as built, nearly all of atoms that start inside the target (300 attempts per planner). At 0.1% per move a repair cycle then loses about one atom with the corrected step and 0.7 as built, each opening a new hole; the corrected planner completes a repair cycle without loss about a third of the time, the planner as built about half. The planner as built makes nearly all of its collisions in the first cycle, where the 275 spare atoms absorb them. With error-free detection, the failures under transport loss in Table 32 therefore come from this repair-cycle churn, not from detection or dead time. Every configuration uses the same planner, so the comparisons between configurations stand, but the absolute success under transport loss is that of a full re-plan. A planner that fills holes directly from the reservoir in repair cycles, in tens of moves rather than a thousand, would raise it; this is left as future work for the engine (Section A.4).

Decoder Implementation on Two FPGA Targets

This appendix maps the 12-bit learned message-passing model specified in Section F.1 to two FPGA targets: the xczu49dr RFSoC as a programmable-logic (PL) kernel, and the Versal AI Edge xcve2802, with arithmetic split between the PL and the AI Engine (AIE) array. The builds use Vitis HLS and, for the Versal partition, the AIE tools of Vitis 2026.1 at a 3.33 ns (300 MHz) target. The trained checkpoint has a logical error rate of 0.98% in software evaluation at $p = 0.01】【。 under code-capacity noise. The hardware implementations reproduce the integer reference on the validation vectors described in Section F.1. A separate quantised GraphMP ranking kernel with a min-sum stage runs at 250 MHz on the xczu49dr, receiving syndromes over NVQLink (Section G.5). Each benchmark shot processes one syndrome input; the message-passing rounds below are internal algorithmic iterations.

Model and bit-exact contract

The decoder targets the LP20 [[1122, 148, ≤20\le20]] lifted-product code. Its Tanner graph has C=990C = 990 check nodes, F=2244F = 2244 bit nodes and E=7920E = 7920 edges. Each of R=4R = 4 rounds gathers check-to-bit messages, updates every bit node, gathers bit-to-check messages and updates every check node, in that order. A node update is a residual MLP on the node’s feature and its aggregate, LN⁡(x+W2ReLU⁡(W0[x,agg⁡]))\operatorname{LN}(x + W_2 \operatorname{ReLU}(W_0[x,\operatorname{agg}])), with hidden width H=32H = 32, followed by a normalisation. The layer is weight-tied across rounds, so one physical update unit per direction is iterated four times, and the model has about 6.5k parameters, all on chip. Weights and activations are quantised to 12 bits (W12A12) after training. The reciprocal square root of the normalisation is replaced by GateNorm, a lookup table indexed by the bit fields of the variance, which removes every division and square root from the datapath.

Numerical agreement is checked in stages: the trained model agrees with a NumPy reference to within 10−310^{-3} in the logits; the reference produces the same decoded outputs as an integer model; and the HLS kernel reproduces the integer model’s logits exactly on golden vectors (8 shots, 17 952 logits). Every kernel change below was required to pass those C-simulation checks, and the final designs were re-checked in RTL co-simulation and, for the AIE, in the cycle-accurate simulator.

Programmable-logic kernel on the xczu49dr

The first synthesisable kernel did not fit the device: 287% of its LUTs and 275% of its BRAM[csynth], with a 17.40 ns critical path and a 13 h C-synthesis. Five bit-exact changes, listed in Table 33, brought it inside the part at the target clock.

ChangeCycles/shotLatencyEffect
Variance accumulator from double to exact 64-bit integer——critical path 17.40 ns → 2.33 ns
GateNorm index read from IEEE-754 bit fields——GateNorm 76 → 40 cycles
Adjacency as CSR data walked by a rolled loop4 823 57815.77 msfits: LUT 11.2%, BRAM 24.5%
Node updates batched as two GEMMs per round401 4661.31 ms8.3 → 99 MAC/cycle
Gather streamed as one flat CSR edge loop238 1260.78 msgathers at II=1 over 7920 edges

Table 33. Decoder on the xczu49dr: bit-exact changes and their effect[csynth]. Latency at 3.33 ns.

  1. Timing. The 17.40 ns path is a single double multiply–accumulate in the recurrence of an II=1 pipeline. An exact integer accumulator bound to one DSP multiply removes this path. Vitis HLS does not strength-reduce the double multiplication by a power of two in this configuration, so the GateNorm index is computed from IEEE-754 bit fields.

  1. Area. Replicated gather-index ROMs account for 97% of the BRAM. The fully unrolled gather reads every entry in one cycle, requiring HLS to duplicate the ROMs for read ports and giving a storage efficiency of 0.56%. Storing adjacency as CSR data and traversing it with a rolled loop reduces BRAM 9.0-fold, LUT 28.6-fold, and C-synthesis time from 13 h to 33 s.

  1. Latency. Because the layer is weight-tied, a round is two matrix–matrix products, (N×2H)(2H×H)(N \times2H)(2H \times H) and (N×H)(H×H)(N \times H)(H \times H), which hold 99.8% of the arithmetic. Node-by-node execution required pipeline fill and drain 12 936 times per shot. Batching each phase into one flattened pipeline reduced latency by a factor of 12.0. Streaming the gather as one edge loop, with a flag on each destination’s final edge, provided a further latency reduction by a factor of 1.69.

The resulting design, with MLP_LANES = 8 output neurons per cycle per update unit, is given in Table 34. Doubling the lanes reaches 0.53 ms at 82% LUT and 77% DSP, and 32 lanes do not fit[csynth]. Place-and-route of the standalone kernel misses 300 MHz at 3.514 ns[meas-hw], so the achievable latency is 0.84 ms per shot. This is the design budgeted in Table 27; its 1655 DSPs are what bind detector replication when the two share the part.

PL and AI Engine partition on the xcve2802

Why a partition. Moving the PL-only kernel to an AIE-equipped Versal part does not help by itself: those parts trade fabric DSPs for the AIE array, and the kernel needs 132% of the xcve2802’s 1312 DSPs[csynth]. Moving only the node-update GEMMs to the AIE does not help much either. A round on the xczu49dr spends 44% of its cycles in the GEMMs, 28% in the floating-point normalisation and 27% in the gathers[csynth], which caps the speed-up from offloading the GEMMs with the stages still in sequence at about 1.8×. The gain comes from streaming each half-round so that the gather, the AIE hand-off and the normalisation overlap.

Architecture. The AIE tiles run the two GEMMs of each node update, which are 99.8% of the MACs; the PL keeps the CSR gathers and the normalisation, with arithmetic unchanged from the PL-only kernel. Each half-round is one dataflow region,

gather→dispatch⇒AIE tiles⇒collect→stats→LN,\text{gather} \to\text{dispatch} \Rightarrow\text{AIE tiles} \Rightarrow\text{collect} \to\text{stats} \to\text{LN},

where ⇒\Rightarrow marks a bank of AXI4-Stream ports. Nodes are dealt round-robin over 17 tiles for the bit direction (2244 = 17 × 132) and 8 tiles for the check direction (990 padded to 992), one 128-bit PLIO pair per tile. Each node crosses as eight row-major beats, and the tile’s DMA scatters them into the 4 × 4 operand tiles of aie::mmul<4,4,4>, so neither side transposes in logic. The AIE kernel takes 715 cycles per four-node call, 0.57 μs at 1.25 GHz, which out-runs the gather by about 1.4× in both directions[meas-sim]. Two further bit-exact changes fold the initialisation and the readout into the first and last half-rounds, and drop the final check half-round, whose output the readout never reads.

Timing closure. The first dataflow build had a 23.66 ns estimated clock and 80% LUT[csynth]. Every failing path was in loop control rather than datapath: a 17-input adder counting finished ports in one cycle, an OR tree of busy flags, and a 17:1 select feeding a counter. Replacing per-port 4096-bit buffers by a node round-robin with one row buffer per port halved the LUTs, and running the dispatch loop at II=2, which throughput allows since rows arrive at least three cycles apart, brought the estimate to 2.77 ns. Place-and-route closes at 3.327 ns, WNS 0.003 ns, WHS 0.010 ns[meas-hw].

Latency. RTL co-simulation, with the AIE results pre-loaded into the input streams, gives 7950 cycles per bit half-round and 8056 per check half-round, within 1.6% of a bare gather: everything downstream of the gather is hidden behind it[meas-sim]. A shot is four bit and three check half-rounds, 55 968 PL cycles or 186.6 μ\mus, plus an AIE tail of 5–15 μ\mus, so 192–202 μ\mus per shot.

Findings

  1. The partition is 4.2×\times faster per shot than the PL-only kernel at its post-route clock, at 2.4×\times fewer fabric DSPs. It comes from overlapping the stages of a half-round rather than from AIE throughput: once the GEMMs leave the PL, the gathers, at one edge per cycle, are 88% of the latency, and AIE compute is off the critical path.

  1. Resource and timing attribution. Analysis of the HLS scheduler and per-array memory reports identified the recurrence arithmetic responsible for the timing failure and ROM replication responsible for the BRAM overflow on the xczu49dr.

  1. Post-route timing differs from HLS estimates. The estimated periods of 3.270 ns and 2.77 ns became 3.514 ns and 3.327 ns after place-and-route on the xczu49dr and xcve2802, respectively. The 7–20% increase illustrates the need to confirm synthesis estimates through implementation, as also observed for detector resources (Table 21).

  1. The AIE tools have simulator-only failure modes. A register split of a 32-lane int16 vector (aie::filter_even/filter_odd) is correct in the functional x86 simulator but halts the AIE-ML core in the cycle-accurate simulator; it was found by bisection and avoided by moving all tiling into the DMA. The dense int16 GEMM shapes also differ between AIE generations, so the kernel as built targets AIE-ML only.

Platform Boundary

The QDPU sits between two commercial instruments: a Hamamatsu ORCA-Quest 2 camera upstream and a Quantum Machines OPX1000 controller downstream (Figure 13). In a conventional deployment a frame grabber, a server and a feedback card occupy this position, and every frame crosses the server’s software on its way to the controller; the QDPU is specified to take all three roles on one device. Physically the device is a PCIe endpoint in the server that also hosts the controller’s interface card, the OPNIC, and the outer loop’s GPU: Quantum Machines’ OPC (OP-Central), the vendor’s validated host, or any PCIe server of the same topology. The server’s CPU configures the system and allocates the memory the devices exchange data through, and runs the vendor’s OPNIC software that streams the QDPU’s output to the controller (Section G.3). This appendix specifies each boundary and its implementation status.

Figure 13. QDPU boundary. Fluorescence is digitised by the camera and enters the QDPU over CoaXPress. The QDPU, the OPNIC, the CPU and the GPU share the PCIe fabric of one server, Quantum Machines’ OPC or an equivalent host. Once per cycle the QDPU writes occupancy and the move stream into host or GPU memory; a stream defined with the vendor’s OPNIC SDK, running on the CPU or GPU, carries the record to the OPNIC, which forwards it to the OPX1000 over NVQLink; the OPX1000 synthesises the AOD and gate waveforms. Dashed blocks are specified but not implemented.

Interface specifications

Tables 36 to 38 specify the three external interfaces of the QDPU. Status is one of implemented (in the place-and-routed design), specified (defined, not implemented) or open (undefined).

Camera ingest

The imaging camera is a Hamamatsu ORCA-Quest 2 qCMOS (C15550-22UP): 4096×23044096 \times2304 effective pixels, 4.6 μm4.6\,\mu\mathrm{m} pixel pitch, 0.30 e−0.30\,e^{-} readout noise and 25 fps at full frame in ultra quiet scan [54]. The pipeline is evaluated on a 2048×20482048 \times2048 sub-array readout of this sensor; the simulator used for all detector results models this camera family [55]. The camera streams over CoaXPress as a quad CXP-6 device: four lanes at 6.256.25 Gb/s, 25 Gb/s raw and 20 Gb/s of payload after 8b/10b coding [54] …

LinkPeerPHY / protocolLine rateFPGA resourcesStatus
IngressORCA-Quest 2 (C15550-22UP)CoaXPress 1.1, 4×CXP-6, 75 Ω coax; GenICam control4 × 6.25 Gb/s1 GTY quad; CXP host IP; DDR4 frame buffer (optional)specified
EgressOPX1000 via OPNICPCIe Gen3 (x4–x8) DMA into server memory; OPNIC SDK stream; NVQLink to the controllerup to 63 Gb/s (x8)PCIE4 hard block; 1–2 GTY quadsspecified
Outer loopNVIDIA GPU in the same server (variant: GPU cluster via ConnectX NIC)PCIe, GPUDirect RDMA into GPU memory (variant: NVQLink, RoCEv2 over 10 or 25 GbE; 10 GbE measured, Section G.5)shared with egress (variant: 10 or 25 Gb/s per SFP28 cage)shared PCIE4 block (variant: Ethernet PCS/PMA and MAC, RoCE engine, 1–4 SFP28 lanes)open

Table 35. Summary of the three links. Rates are line rates; payload rates after encoding are in the per-link subsections. Status as in Section G.1.

ChannelDir.PayloadWidth / rateLatency budgetStatus
Video downlinkin2048 × 2048 × 16-bit ROI frames (sensor 4096 × 2304)quad CXP-6, 4 × 6.25 Gb/s (20 Gb/s payload)readout-bound: 7.4 ms standard / 36 ms ultra quiet per ROIspecified
ROI extractionint.8 × 8 × 16-bit crops, 2500 per frame (2.6 Mb)line-buffered, 8 lines; no frame buffer8 lines behind the stream: 0.03–0.14 ms by scan modespecified
Exposure triggerouttrigger pulseOPX1000 digital output to the camera’s external trigger input (default); CXP low-speed uplink as alternativecamera trigger latency, to be measured at bring-upspecified
Transceivers——4 GTY lanes (one quad)—specified

Table 36. Camera interface (upstream).

ChannelDir.PayloadWidth / rateLatency budgetStatus
Data collectionoutcrops or occupancy with labels; syndromes≤2.6\le2.6 Mb per frame (all crops), 2500 b per frame (occupancy)min to hropen
Policy updateindetector template and threshold, or CNN weights; decoder parametersmatched filter: 64 int8 coefficients plus one integer threshold; CNN: 4786 weights and biases at 12 bits, 7179 B when packed (about 7.2 kB), plus normalisation constants; decoder: about 9.8 kBmin to hropen
Physical link——NVQLink/RoCEv2 — at 10 GbE, measured on the board (Section G.5); alternative paths in Section G.4implemented

Table 37. Outer-loop interface (GPU cluster).

The two scan modes trade read noise for readout time: 0.30 e−e^{-} rms at 25 fps full frame in ultra quiet scan, 0.43 e−e^{-} rms at 120 fps in standard scan, which for the 2048-row ROI is about 36 ms against 7.4 ms of readout (Table 39). The imaging simulator’s read noise of 0.43 e−e^{-} (Table 11) corresponds to the standard scan, so the 7.4 ms figure is the one the detector results assume; Table 26 carries both. The link requires multi-gigabit transceivers, budgeted at one GTY quad of the sixteen on the target device, with per-lane clock recovery, lane deskew and bonding, and a CXP link layer including the low-speed uplink that carries the exposure trigger. The uplink is what allows the loop to close on-chip. The ingest datapath is specified and not implemented; closing the loop on the device depends on it.

Protocol stack. CoaXPress is asymmetric. The downlink (camera to host) carries stream packets at the lane rate; the uplink (host to camera) is a low-speed channel, 20.83 Mb/s in CXP 1.1, that carries register reads and writes (the GenICam control plane) and trigger packets [115]. The FPGA-side stack is:

  1. Analog front-end. A CoaXPress equaliser/driver per lane between the coax and the GTY, with the low-speed uplink superimposed on the same conductor, and, if required, PoCXP 24 V injection. The ZCU216 has no CoaXPress connector, so this is an FMC card (commercial CXP-host FMC, or a custom one).

  1. Transceivers. Four GTY receivers at 6.25 Gb/s with 8b/10b decode and comma alignment, 32-bit user width, recovered user clock 6.25 GHz/40 = 156.25 MHz per lane.

  1. CXP link layer. Packet deframing, CRC-32 check, lane deskew and bonding into one stream, stream-packet reassembly into image lines, and the uplink encoder. Licensed rather than written (Section G.8); the core presents an AXI4-Stream of pixels with start-of-frame / end-of-line sideband, plus an AXI4-Lite port for the control plane.

  1. Control plane. GenICam register access (ROI, scan mode, exposure, trigger source) is driven by the RFSoC’s Arm cores through the CXP core’s AXI4-Lite port. It is configured once per run and is not in the per-cycle path.

  1. Pixel path. The AXI4-Stream crosses from the 156.25 MHz recovered-clock domain into the 200 MHz processing domain through an asynchronous FIFO (Section G.6) and feeds the ROI extractor of Section A.2 directly, line by line.

Streaming, not buffering. The ROI extractor needs only the 8 image rows that span one row of sites before it can emit that row’s 8 × 8 crops, so the pixel path requires a line buffer of 8 × 2048 × 16 bits = 262 kb (about 8 of the device’s block RAMs) rather than a frame buffer. Detection can then start roughly one site-row’s worth of lines after the first pixel instead of after the last. A DDR4 frame buffer in the PL memory is still useful, but off the critical path: it holds raw frames for the outer loop’s data collection (Section G.4) and for debugging.

Bandwidth and readout time. Table 39 gives the arithmetic. Four CXP-6 lanes carry at most 4×6.25×0.8=204 \times6.25 \times0.8 = 20 Gb/s of payload before packet overhead. A 2048×20482048 \times2048 ROI at 16 bits is 6.7×1076.7 \times10^{7} bits and needs 3.4 ms of link time; the full sensor needs 7.5 ms. In either case the link is faster than the sensor in its low-noise mode, so sensor readout, not the CoaXPress link, sets the ingest time: the ultra-quiet scan at 25 fps full frame reads a 2048-row ROI in about 2048/2304×402048/2304 \times40 ms ≈36\approx36 ms, while the standard scan at 120 fps reads it in about 7.4 ms[roof]. This is the ingest row of Table 26, and which of the two values applies depends on the scan mode the imaging simulator assumes.

Trigger. The exposure trigger can reach the camera in two ways: over the CXP uplink as a trigger packet, which keeps the whole loop on one cable but carries a protocol-dependent latency and jitter; or as a TTL edge on the camera’s external trigger input, driven by a PL GPIO or, more naturally, by the OPX1000 digital output that already sequences the imaging light (Section G.7). The second keeps the OPX1000 as the single time reference for the experiment and is the specified default.

The OPX1000 is a modular hybrid controller: each of its front-end modules carries a pulse processor that synthesises analogue waveforms, DC to 750 MHz on the low-frequency module and up to 10.5 GHz on the microwave module, under a program written in QUA, the vendor’s pulse-level language, which the pulse processor executes with deterministic timing [57]. It is the instrument that physically moves and gates the atoms. The link specified here carries decisions rather than waveforms: once per cycle, occupancy and the move stream leave the FPGA over PCIe into server memory and reach the OPX1000 through the OPNIC’s NVQLink hop; the OPX1000 owns AOD waveform playback and gate pulses and turns the schedule into waveforms itself.

Controller. The OPX1000 owns everything that must be nanosecond-deterministic: AOD and Rydberg waveform playback, gate pulses, and the imaging and trigger timing [57]. Its pulse processor can branch on classical values delivered to the running QUA program. The QDPU therefore does not synthesise waveforms (Section G.11); it delivers two things per cycle, the occupancy vector and the move schedule, and the OPX1000 turns the schedule into multi-tone chirps.

Physical path. Quantum Machines’ route for low-latency data into a running QUA program is the OP-Network Interface Card (OPNIC): a PCIe card installed in the server, carrying its own FPGA, that links to the OPX1000 over a dedicated fibre connection and exchanges data with the server’s CPU and GPU memory by DMA [58]. The vendor describes the OPNIC’s data network as NVQLink-compatible [58], and the OPNIC to OPX1000 hop is the NVQLink hop of this system; its round trip is under 4 μs [112]. The OPNIC, the CPU, the GPU and the QDPU share the PCIe fabric of one server, about 1 μs between any two of them; that server is the vendor’s OPC, its validated host, or any PCIe server of the same topology.

The vendor-supported integration transfers data through server memory. The OPNIC exchanges data with host memory and, through GPUDirect RDMA [116], GPU memory. The supported solution does not include a peer-to-peer path from a third-party endpoint to the OPNIC. The vendor gives a planning estimate of approximately 1 μs for a PCIe transfer inside the OPC, including the transfer from server memory to the OPNIC. The OPNIC behaves as a network interface: its operation and its data streams are defined in software through the vendor’s SDK [58], and that software, on the CPU or the GPU, is what carries data between server memory and the card. The FPGA therefore never addresses the OPNIC. It writes the cycle record of Table 40 into a buffer in server memory that the host allocates once at start-up, and a stream defined with the SDK carries the record from there to the OPNIC:

RegionContentsSizeStatus
Headercycle ID, move count, CRC-32, detector version16 Bspecified
Occupancy2500 bits, row-major, padded to 79 words316 Bspecified
Move listper move: (rfrom,cfrom,rto,cto)(r_{\mathrm{from}}, c_{\mathrm{from}}, r_{\mathrm{to}}, c_{\mathrm{to}}) 6 b each, group tag, valid4D4D bytesspecified
Doorbellcycle ID written last; checked by whichever agent forwards the record, and again by the QUA program4 Bspecified

Table 40. Egress payload per cycle, 50×5050 \times50 array, and its layout in server memory. Word size 32 bits.

  • Path A, host memory (primary). The FPGA’s DMA engine writes the record into a pinned buffer in host memory, and a stream run on the CPU hands it to the OPNIC. Two PCIe hops, no GPU in the path, and the standard use of the AMD DMA subsystem, so this is the path the bring-up of Section G.8 takes.

  • Path B, GPU memory (variant). The FPGA writes the record into a GPU buffer through GPUDirect RDMA, and a stream run on the GPU hands it to the OPNIC. The hop count is the same; it becomes the natural choice once a GPU-resident step (Section G.4) sits between detection and the controller.

  • FPGA side. The xczu49dr’s PCIE4 hard block as endpoint, Gen3 x4 or x8, with the AMD DMA/Bridge subsystem (XDMA or QDMA) turning the egress AXI4-Stream of Section A.2 into 256 B posted writes at the buffer’s bus address, programmed once by the host. User clock 250 MHz.

The latency of the stream hand-off, from the record landing in memory to its departure through the OPNIC, is set by the vendor’s software. The vendor’s planning figure for the memory-to-OPNIC transfer is about 1 µs; the hand-off has not been measured (Section H).

Payload. Table 40 gives the record layout for one cycle of the 50×5050 \times50 array. The occupancy map contains 2500 bits, padded to 316 B, and each move descriptor occupies one 32-bit word. Including the header and doorbell, the record contains 336+4D336 + 4D bytes for DD descriptors emitted across both rearrangement phases. At the modelled operating point of about 1300 moves per cycle (Section E.4), this is approximately 5.5 kB, or 0.20 MB/s at the 27.5 ms mean cycle period (Section E.3). At this operating point, low hand-off latency is the principal egress requirement; sustained bandwidth demand is modest.

Ordering. PCIe posted writes from one requester arrive in memory in order, so writing the doorbell last is sufficient: any reader that sees the doorbell match the expected cycle ID sees a complete record. The stream that hands the record to the OPNIC reads the doorbell before it sends, and the QUA program checks it again on arrival. The CRC guards against a stale or partially overwritten record if the OPX1000 falls behind; the QUA program rejects a mismatched CRC and leaves the array unmoved for that cycle. The group tag marks moves that may run concurrently, and its maximum group size is the AOD tone count the controller can sustain (Section G.11).

Hard-wired side channel. Two OPX1000 digital lines complement the PCIe path: one OPX1000 output tells the FPGA the frame it is about to receive belongs to cycle kk (so both ends agree on the cycle ID without a round trip), and one FPGA output to an OPX1000 digital input raises a “schedule ready” edge for programs that wait on an input rather than polling.

Outer loop: GPU in the server, or over NVQLink

NVLink versus NVQLink. NVLink is NVIDIA’s GPU-to-GPU and GPU-to-CPU fabric. It is not exposed on AMD FPGAs: the only route for third-party silicon onto NVLink is NVLink Fusion, licensed to a small set of ASIC and CPU partners [117], and the xczu49dr has no NVLink PHY. The FPGA reaches a GPU in one of two ways. A GPU in the same server is reached over the PCIe fabric of Section G.3, with GPUDirect RDMA placing the FPGA’s writes in GPU memory [116]; this is the configuration of the vendor’s OPC and the primary one here. A GPU in another chassis is reached over NVQLink, NVIDIA’s open architecture for coupling quantum controllers to GPUs [59, 34], whose FPGA-facing side is Ethernet with remote DMA into GPU memory. NVLink still appears in the system, one level up: it connects the GPUs to each other, so that the outer loop’s training and any GPU-resident decoding scale across a node without passing through host memory (Table 41).

ClassDir.PayloadRateDeadlineStatus
Crops + labelsout2500×8×8×162500 \times8 \times8 \times16 b26 Mb/snoneopen
Raw framesout4096×2304×164096 \times2304 \times16 b1.5 Gb/snoneopen
QDM weightsindetector + decoder parametersper refitmin to hropen
GPU inferencebothworkload-specificworkload-specificμ\musopen
GPU–GPU (NVLink)—gradients, decoder statenode-internalnoneopen

Table 41. Outer-loop traffic, 50×5050 \times50 array. Rates at a 10 Hz cycle for scale[roof].

Physical path. Inside the server the path is

FPGA (PCIE4 block, DMA engine)→PCIe fabric→GPUDirect RDMA→GPU memory\mathrm{FPGA\ (PCIE4\ block,\ DMA\ engine)} \to\mathrm{PCIe\ fabric} \to\mathrm{GPUDirect\ RDMA} \to\mathrm{GPU\ memory}

the same endpoint and DMA engine as the egress of Section G.3 with a second buffer, in GPU memory, as the target; the outer loop then costs no additional transceivers. Across chassis the NVQLink path is

FPGA (RoCE engine, 10 or 25 GbE MAC)→SFP28→ConnectX NIC→GPUDirect RDMA→GPU memory\mathrm{FPGA\ (RoCE\ engine,\ 10\ or\ 25\ GbE\ MAC)} \to\mathrm{SFP28} \to\mathrm{ConnectX\ NIC} \to\mathrm{GPUDirect\ RDMA} \to\mathrm{GPU\ memory}

with the NIC and GPU on the same PCIe switch so that RDMA writes land in GPU memory without a host-memory copy [116]. On the FPGA the transport is RoCEv2: UDP/IP over an Ethernet MAC, with an RDMA engine that issues RDMA WRITE operations into buffers registered in advance. NVIDIA’s Holoscan Sensor Bridge FPGA IP implements this sensor-to-GPU path [60]; it is the configuration built and measured in Section G.5. The ZCU216 carries four SFP28 cages and no QSFP28 [113], two cages to a quad on quads 128 and 129. A 100 GbE CAUI-4 port, whose four lanes must share one quad, cannot be formed from them, so this variant runs one to four independent 10 or 25 GbE links through a breakout to the NIC’s QSFP28. 100 GbE would need a QSFP28 card on the FMC+ slot, whose lanes the camera and PCIe links already take (Table 45).

LinkLanesBoard routeNote
CoaXPress, 4×CXP-64FMC+ DP0–3RX only at line rate; uplink via FMC front-end
PCIe Gen3 x4 to the server4FMC+ DP4–7cable adapter to a server slot; x8 would take all eight FMC+ lanes
10 or 25 GbE to ConnectX (variant)1–4SFP28 cagesone independent link per cage, 10.3125 or 25.78 Gb/s; CAUI-4 cannot span quads 128 and 129; one 10 GbE link measured (Section G.5)
Not routed4quads 128/129, ch2–3one to the clock device, one to a test connector, two unconnected
Total16

Table 45. GTY budget, xczu49dr on the ZCU216 (16 GTY lanes in 4 quads; board routing from the user guide [113]).

What crosses the link. The outer loop has no per-cycle deadline (§ 3.3), but the microsecond round trip of either path makes a second, faster use possible, so the link is specified for two traffic classes (Table 41).

  • Data collection and policy update (the outer loop proper). Out: 8×8×168 \times8 \times16-bit crops, 1024 b per site, 2.6×1062.6 \times10^{6} bits per 50×5050 \times50 frame, with the detector’s output and, when available, a label from a second image; optionally whole raw frames. In: QDM weights for the detector (1-8-16-16, 12-bit, Table 15) and the decoder. Even raw full frames at 10 Hz require about

1.5 Gb/s, approximately 15% of the measured 10 GbE line rate before protocol overhead. Weight updates are written to a shadow copy of the weight memories and swapped at a cycle boundary, so the detector never runs on a half-written model.

  • GPU-in-the-loop inference (optional). For a workload too large for the FPGA, the FPGA streams its inputs to the GPU and waits for the result inside the cycle. At a few microseconds round trip this fits the millisecond budgets of Section E; its candidates are the 10 000-site rearrangement of Section G.10 and decoders larger than the resident one. The result returns by a write into an FPGA-side buffer, GPU DMA over PCIe or RDMA WRITE over NVQLink, and joins the egress path of Section G.3.

NVQLink link measured on the ZCU216

The NVQLink variant has been built and measured on a ZCU216 board linked to an NVIDIA DGX Spark (GB10: Grace CPU and integrated GPU, ConnectX-7 NIC). The design is a link test, separate from the pipeline of Table 22: a test source and, in a second build, a GraphMP decoding kernel stand in for the QDPU’s traffic. It ports the RFSoC 4x2 reference design of NVIDIA’s Holoscan Sensor Bridge (HSB) FPGA IP, release 3.0.0 [60], to the xczu49dr.

Link. The reference design uses a 100 GbE hard MAC, which the ZCU216’s SFP28 cages cannot carry (Section G.4). The measured link is 10GBASE-R on one SFP28 cage, through a QSFP28-to-SFP28 breakout into a ConnectX-7 port. The PHY is AMD’s xxv_ethernet in its PCS/PMA-only mode, which needs no licence; AMD’s 10G/25G MAC does, so the MAC is eth_mac_10g from the open-source verilog-ethernet library. The HSB datapath is 64 bits wide at 156.25 MHz with one sensor channel, and the FPGA’s clock locks to a PTP master on the host. The build closes timing at WNS 1.69 ns[meas-hw]. HSB’s software reset must not reach the PCS: resetting the PCS stops the 156.25 MHz clock that HSB needs to release its own reset, which deadlocked the first build.

Round trip. A RAM player in the FPGA sends 128-byte messages stamped with the PTP-locked FPGA time; the host returns each one, and a timestamp logic analyser records its arrival at 10 ns resolution. The host forwards either on one pinned Grace core (HSB’s cpu_roce_loopback) or on the GPU through DOCA GPUNetIO (gpu_roce_loopback). Packet logic analysers on both sides of the MAC split the round trip into its FPGA and off-FPGA parts (Table 42). Over full captures of 16 384 round trips, the CPU path ranges from 2.54–7.19 μ\mus and the GPU path from 6.13 μ\mus to about 650 μ\mus[meas-board].

StageCPU forwarding medianCPU forwarding p99GPU forwarding medianGPU forwarding p99
FPGA transmit: timestamp to MAC frame start0.240.240.250.250.240.240.250.25
Between MAC-side measurement points: transceivers, cable, NIC, host2.212.212.512.515.875.87244244
FPGA receive: MAC frame start to timestamp0.280.280.290.290.280.280.290.29
Round trip2.742.743.033.036.406.40245245

Table 42. FPGA-to-host-to-FPGA round trip over NVQLink at 10 GbE, 128-byte messages, ZCU216 to DGX Spark, about 8200 joined round trips per path at 20.7 μ\mus spacing[meas-board]. Values in μ\mus.

  1. FPGA packet-processing logic contributes 0.52 μ\mus. This covers the timestamp-to-MAC and MAC-to-timestamp intervals; transceivers are included in the intermediate segment of Table 42.

  1. CPU forwarding gives lower latency and a tighter tail. The CPU and GPU medians are 2.74 μ\mus and 6.40 μ\mus, respectively, with p99 values of 3.03 μ\mus and 245 μ\mus.

  1. The GPU latency tail persists at both tested message rates. Similar tails were observed at message spacings of 10 μ\mus and 20.7 μ\mus. These measured distributions favour CPU forwarding for latency-sensitive feedback messages on this DGX Spark configuration.

  1. The HSB 3.0.0 host software needed fixes for the GPU path. Its GPU RoCE operator was built but not registered for Python, was not compiled position-independent, and passed a device function where a kernel was expected; NVIDIA’s GPU loopback benchmark also needed a smaller frame and a default clock to run.

A GraphMP kernel over the link. A second build places an LP20 decoding kernel behind HSB: GraphMP in a quantised ranking configuration with a min-sum stage, built as an HLS kernel alongside the configurations of Section F. It runs at 250 MHz behind asynchronous FIFOs and width converters, and the build closes at WNS 0.24 ns[meas-hw]. For each shot the host sends the 990-bit syndrome as one 128-byte RDMA SEND, and the FPGA returns a 4800-byte record, holding a score for each of the 2244 bit nodes, the min-sum hard decision and a convergence flag, as one RDMA WRITE of four packets. BP+OSD post-processing stays on the host. The host client drives HSB’s CPU transceiver from one pinned Grace core without a polling thread. Every result was compared byte for byte with the PyTorch golden record: all 2100 test shots, five passes at each of five pipeline depths, 52 500 results, all bit-exact (Table 43).

Shots in flightMedian (µs)p99 (µs)Throughput (shots/s)
150.569.719 220
287.5126.122 176
4175.6252.522 176
8351.8505.422 176
16704.31011.222 175

Table 43. GraphMP ranking kernel (LP20) over NVQLink at 10 GbE: latency from host submission to receipt of the FPGA result, excluding host-side BP+OSD post-processing. CPU forwarding; 10 500 results per row (five passes over 2100 test shots), all bit-exact[meas-board].

Single-shot latency is the kernel’s compute, 44–65 μ\mus depending on the number of min-sum iterations; the link adds about 4–5 μ\mus, of which 3.9 μ\mus is serialising the 4800-byte result at 10 Gb/s. Throughput saturates at about 22 200 shots/s, the kernel’s compute bound of about 45 μ\mus per shot; the results use about 106 MB/s of the link’s 1.2 GB/s, so deeper pipelines add only queueing delay. The same kernel fed through the board’s processing-system Ethernet over TCP took about 1.5 ms per shot and reached 8700 shots/s. For shots that terminate at the min-sum stage, returning only the hard decision and status would avoid transferring the score vector.

Not yet measured. The link test does not carry the traffic of Table 41: crops, labels and weights need the crop_tap and weight_loader blocks of Table 47, and the pipeline has not been joined to the link. The decoding kernel’s results land in host memory rather than GPU memory, and 25 GbE has not been built.

Table: New FPGA blocks, continued: outer loop and common blocks. Conventions as in Table 46.

BlockKindRoleDomain
Outer loop (GPU)open
Second DMA channel of egress_dmaRTLcrops and decisions into a GPU buffer on the same server (GPUDirect RDMA); shares the PCIE4 block with the egresspcie_user
Ethernet PCS/PMA + MACAMD + open sourceNVQLink variant: xxv_ethernet in its licence-free PCS/PMA mode and the verilog-ethernet 10G MAC, 64-bit AXI4-Stream; built and measured at 10 GbE (Section G.5)eth_usr
RoCEv2 enginelicensed or AMDNVQLink variant: UDP/IP, queue pairs, RDMA WRITE initiator and target: Holoscan Sensor Bridge IP [60], built and measured (Section G.5), or AMD ERNICeth_usr
crop_tapRTLlossy tee of detector-input crops and decisions into the TX FIFO, with a drop counterclk
weight_loaderRTLPCIe or RDMA target buffer → shadow weight memories; checksum; swap request at a cycle boundaryclk
Common
Clocking and resetAMD + RTLMMCM for clk; GTY reference clocks; per-domain reset synchronisers and ordered release after link-upall
qdpu_csrRTLAXI4-Lite register file: configuration, site table, record buffer address, deadlines, status and error counters, timestamp counteraxil
Integrated logic analysersAMDbring-up only; removed from the timing-closure buildper link

Table 47. New FPGA blocks, continued: outer loop and common blocks. Conventions as in Table 46.

Clock domains and transceiver budget

The implemented pipeline uses a single 200 MHz clock domain. The proposed external interfaces use separate clocks and communicate with the processing domain through asynchronous FIFOs (Table 44). These crossings isolate link timing from the processing clock. Their integration and the timing of the complete design require verification after the interface blocks are added.

DomainSourceFrequencyCrossing into processingStatus
clkboard oscillator / MMCM200 MHz—implemented
cxp_rxGTY recovered clock, one lane, others deskewed to it156.25 MHzasync FIFO, pixel stream, ≥ 12-line depth upstreamspecified
pcie_userPCIE4 block250 MHzasync FIFO, egress record; crops out / weights in when the GPU shares the serverspecified
eth_usrEthernet PCS TX clock, 10 GbE; built in the link test of Section G.5156.25 MHzasync FIFOs to the 250 MHz ranking kernel (link-test configuration)implemented
axilPS100 MHzregister slices, control plane onlyspecified

Table 44. Clock domains. In the pipeline only the 200 MHz domain is implemented; the Ethernet domain is implemented in the separate NVQLink link test (Section G.5).

Table 45 budgets the transceivers against what the board exposes. The xczu49dr has 16 GTY lanes in four quads, but the ZCU216 routes twelve of them to connectors: eight to its single FMC+ slot (quads 130 and 131) and four to its SFP28 cages (two each on quads 128 and 129) [113]. The board has no PCIe edge connector, so the PCIe link also leaves through the FMC+ slot. With the GPU in the server the design needs eight lanes, CoaXPress x4 and PCIe x4, which the FMC+ slot provides; the NVQLink variant adds one to four lanes on the SFP28 cages. The egress payload allows PCIe x4 by a wide margin.

Per-cycle handshake

The proposed assembly cycle uses the OPX1000 as its timing reference. Time zero is the imaging trigger, and the following steps coordinate acquisition, processing, and transport.

  1. Arm. The OPX1000 raises the cycle-ID line to the FPGA and fires the camera’s external trigger together with the imaging light.

  1. Expose and read out. The camera exposes (10 ms at the matched-filter operating point, Table 26) and streams the ROI over CoaXPress as it reads out (Table 39).

  1. Detect. The ROI extractor emits crops as soon as each site-row’s 8 lines have arrived; the detector classifies them; the row assembler builds the occupancy of Section A.2. In parallel, crops are copied to the outer-loop transmit FIFO for data collection; that copy is lossy by design and never back-pressures detection.

  1. Plan. After the last row, the rearrangement engine reads the occupancy and emits the move stream.

  1. Hand off. The DMA engine writes header, occupancy and moves into server memory, then the doorbell, and raises the “schedule ready” line. The OPNIC SDK stream carries the record to the OPNIC, which forwards it to the OPX1000 over NVQLink.

  1. Move. The QUA program receives the record, checks cycle ID and CRC, and plays the moves group by group. If the cycle ID is stale or the CRC fails, it skips the move and re-images.

  1. Refit (asynchronous). The GPU accumulates crops and labels, refits the QDM, and at some later cycle writes new weights over PCIe into the FPGA’s shadow memories and sets a swap flag honoured at the next cycle boundary.

Steps 1–6 are the fast loop and involve the camera, the FPGA, server memory, the vendor’s OPNIC stream and the OPX1000; step 7 is the slow loop, and nothing in steps 1–6 waits on it.

Watchdog. If step 5 has not completed by a deadline set from Table 26, the FPGA writes an empty schedule with an error code, so the OPX1000 is never left waiting on a lost frame. A missed CXP packet (CRC error) poisons the frame, and the same path reports it.

Bring-up order

The proposed bring-up sequence validates each interface and measures its contribution to the latency budget in Table 26.

  1. CXP interface. Stream the actual ORCA-Quest 2 into a PL capture buffer through a commercial CXP-host FMC and licensed CXP IP. This step validates the analogue front-end and measures trigger-to-first-pixel and readout time in the chosen scan mode.

  1. Pixel path into the pipeline. Connect the stream to the ROI extractor through the CDC FIFO and check bit-exactness against the simulator crops for recorded frames. Yields the “CXP ingest + ROI extraction” row.

  1. PCIe into server memory. Bring up the PCIE4 endpoint and the DMA engine, through the FMC+ cable adapter, against a pinned buffer in host memory. This verifies PCIe enumeration and DMA for path A.

  1. OPNIC stream. Define the stream with the OPNIC SDK and close the loop with a QUA program that echoes the doorbell on a digital output. Yields the “egress to controller” row as the FPGA-write-to-OPX-edge time, measured on a scope, including the stream hand-off of Section H.

  1. GPU path. Retarget the data-collection DMA to a GPU buffer through GPUDirect RDMA in the same server, first for data collection, then weight swap. For a GPU in another chassis, bring up the Ethernet link and RoCE engine against a ConnectX NIC instead; this has been done at 10 GbE with test traffic (Section G.5).

Steps 1–4 close the fast loop; step 5 is needed only for the outer loop and can proceed in parallel after step 2.

Required FPGA-side additions

The place-and-routed design of Table 22 ends at two internal boundaries: it takes 8×88 \times8 crops on an input port and delivers occupancy and moves on an output port (Section A.2). Everything between those ports and the three cables is new. This subsection lists it: the new blocks (Table 46 and Table 47), the changes it forces on existing blocks, the resource cost (Table 48), and the board, software, constraint and verification work that comes with it. Each new block is one of three kinds: licensed IP from a third party, AMD IP wrapping a hard block or shipped with Vivado, or RTL to be written in this repository in the style of Table 6.

BlockKindRoleDomain
Ingress (camera)
GTY transceiver wizard, 4 lanesAMD6.25 Gb/s RX, 8b/10b, comma align, 32-bit user widthcxp_rx
CXP host corelicenseddeframe, CRC, lane bonding, stream reassembly, uplink encoder, AXI4-Lite control portcxp_rx
async_fifoRTLGray-code dual-clock FIFO, AXI4-Stream wrapper; the library FIFO is single-clockany pair
roi_line_bufferRTL8-line circular buffer, 8×2048×168 \times2048 \times16 b in BRAM; emits an 8-row column slice per pixel clockclk
roi_crop_genRTLsite-coordinate table (x0x_0, y0y_0 per site row and column, loaded from PS) →8×8\to8 \times8 crops into the detector input port, in site orderclk
frame_tap + AXI DMARTL + AMDoptional raw-frame copy to PL DDR4 for data collection and debug; never back-pressures the pixel pathclk
cxp_frame_monitorRTLframe/line counters, CRC-error and lane-loss flags, frame-poison signal to the watchdogclk
Egress (OPX1000)
PCIE4 block + DMA/Bridge Subsystem (XDMA or QDMA)AMDGen3 x4 endpoint through the FMC+ adapter; AXI4 slave for host access to the CSRs and shadow weight memories, AXI4 master for FPGA-initiated DMA into server memorypcie_user
egress_packerRTLoccupancy rows and move stream →\to 32-bit words of Table 40; running CRC-32; move count and group tagsclk
egress_dmaRTLwords →\to AXI4 burst writes into the record buffer at its host-programmed bus address, in host or GPU memory; moves streamed as produced, header written after the last move, doorbell lastpcie_user
cycle_syncRTLtwo-flop synchronisers on the OPX1000 digital lines; latches cycle ID at arm; drives “schedule ready”clk
loop_watchdogRTLper-cycle deadline counter; on timeout or frame poison, forces an empty record with an error codeclk

Table 46. New FPGA blocks, by link: ingress and egress. Names in typewriter are proposed module names for blocks to be written. Domain as in Table 44. All specified except where marked open.

Block groupLUTBRAM_18KDSPHard blocks
CXP host core + GTY wrapper10–20k10–2004 GTY
ROI line buffer + crop generator2–5k22–300—
Frame tap + AXI DMA + PL DDR4 controller10–15k10–200PL DDR4 I/O
PCIe DMA/bridge + write engine + packer15–30k20–400PCIE4, 4 GTY
Ethernet PCS/MAC + RoCEv2 engine (variant)20–50k40–10001–4 GTY
Crop tap, weight loader, CSR, sync, watchdog2–5k5–200—
Total, additions60–125k110–2300
share of device14–29%5–11%0%
Matched-filter pipeline (Table 22)87 844264
CNN 8 × 8 pipeline (Table 22)98 798107584

Table 48.

Changes to existing blocks. Three of the implemented blocks change.

  • CNN detector: runtime weights. The hls4ml flow of Section C.4 compiles the detector’s weights into the bitstream as constants, which the synthesis tool folds into LUTs and DSP coefficients. A refit from the GPU then requires a new bitstream, and § 3.3’s “parameters in” is not a runtime operation. Runtime weights mean re-generating the detector with its weights in writable memories (double-buffered, so the swap is atomic at a cycle boundary), which removes constant folding. That costs LUTs and possibly DSPs, and it changes the per-crop latency of Section D.2, so it has to go back through place-and-route. Until then, the outer loop can collect data and deliver a refit as a partial or full reconfiguration between runs.

  • Detector input: from a port to a stream. The system top (atom_rearrangement_cnn_top) currently reads crops from a testbench-driven port. It gains back-pressure from the detector cores

to roi_crop_gen, and roi_line_buffer must never overflow while the cores stall. A stall-free design sizes the line buffer for the worst case: the time to classify one site row against the time the camera takes to deliver the next 8 lines. The matched-filter lane classifies a row of 50 sites in 59 cycles, 0.3 µs, and keeps pace with the camera. One CNN core takes 50×1797/200 MHz=0.45 ms50 \times1797/200\ \mathrm{MHz} = 0.45\ \mathrm{ms} per row, while 8 lines of the ultra-quiet scan arrive in about 0.14 ms, so the CNN falls behind the camera and either the buffer grows to most of a frame or the detector is allowed to finish after readout1.

  • Engine output: record framing. The move FIFO of tetris feeds egress_packer instead of a testbench sink. The engine itself is unchanged; the end of the move stream must be signalled so the packer knows when to write the header and doorbell. tetris already exposes done_o and abandoned_o: the first triggers the header and doorbell, and the second is written into the header as an error code, so the QUA program can tell an infeasible target from a lost frame.

Resource cost. Table 48 gives order-of-magnitude planning estimates for the proposed interfaces. Actual resources depend on the configured IP and optional blocks and require implementation checks. The listed interface blocks are budgeted without DSP slices, but their LUT and BRAM requirements still affect feasibility.

One matched-filter lane and the decoder occupy about 61.0% of LUTs and 37.4% of BRAM before interfaces (Table 27). Adding the table’s 14–29% LUT range leaves component-level margin for that configuration. Four CNN cores and the decoder already use about 84.2% LUT; the same range would bring the total to approximately 98–113%. The complete four-core configuration is therefore not established as feasible. Transceiver routing is a further constraint (Table 45), and joint place-and-route is required for each topology.

Table 48: Estimated resource cost of the additions on xczu49dr (425 280 LUT, 2160 BRAM_18K and 4272 DSP [113])1. Ranges are planning estimates, not measurements. Totals include optional frame capture and the remote-GPU Ethernet variant; the selected topology determines which blocks are present.

Board-level hardware. Two additions are physical, not logic.

  • CoaXPress FMC. Four CXP equaliser/driver channels, uplink injection, DIN 1.0/2.3 or micro-BNC connectors matching the camera, and PoCXP if the camera draws power over the coax. Its FMC lanes must route to one GTY quad. A commercial CXP-host FMC is the first choice

for bring-up (Section G.8); a card that shares the slot with the PCIe adapter (below) is the deployment step.

  • PCIe path into the server. The ZCU216 is a bench board with no PCIe edge connector [113]; it reaches the server’s PCIe fabric through a cable adapter in any slot of the server that hosts the OPNIC, CPU and GPU (Section G.3). The board has one FMC+ slot, so the CoaXPress front-end and the PCIe link share it on a single carrier with four GTY lanes each: four CXP-6 receivers (Section G.2) and a PCIe Gen3 x4 link to the server. Four lanes are ample for egress (≈31 Gb/s\approx31\,\mathrm{Gb/s} against a move list of tens of kilobits per shot), and the camera keeps its native coax link with no media converter in the latency path. Moving the camera onto the SFP28 cages over CoaXPress-over-Fibre is the fallback if no such carrier is available; it frees the FMC+ for PCIe but adds a coax-to-fibre converter and a different host IP core.

The SFP28 cages serve the NVQLink variant of the outer loop, and the OPX1000 digital lines need only level-compatible I/O on a board header.

Processor-side software. Detection and rearrangement scheduling execute in FPGA logic. Configuration and run control use the RFSoC’s Arm cores, running bare-metal software or Linux:

  • GenICam camera configuration through the CXP core: ROI, scan mode, exposure, trigger source, pixel format;

  • site-coordinate table for roi_crop_gen, written after each optical calibration;

  • for the NVQLink variant, RoCE queue-pair setup and memory-key exchange with the GPU host, over the PS Ethernet port;

  • run control through qdpu_csr: arm, deadlines, error counters, and a status readout for the experiment’s sequencer.

Three host-side pieces run on the server: a start-up utility that enumerates the FPGA, allocates and pins the record buffer in host or GPU memory and programs its bus address into qdpu_csr; the vendor’s OPNIC SDK stream, on the CPU or GPU, that carries each record to the OPNIC (Section G.3); and, on the GPU, the receive buffers, the refit job and the weight push.

Constraints and timing closure. The crossings in Table 44 use asynchronous FIFOs or synchronisers, with constraints for the asynchronous clock groups and crossing paths. The Ethernet user domain, 156.25 MHz at 10 GbE and 390.625 MHz at 25 GbE, sets the timing target for the RoCE engine and its FIFOs; the 10 GbE link test closes at WNS 1.69 ns (Section G.5). Transceiver, PCIe, and Ethernet locations follow the board routing (Table 45). The complete design requires in-context implementation because the results in Table 22 exclude board-level I/O and clock-tree effects.

Verification. Each link gets a simulation model in the existing Verilator and cocotb framework before any hardware:

  • a CXP stream model that replays simulator frames as the CXP core’s AXI4-Stream output, so roi_line_buffer and roi_crop_gen are checked crop-for-crop against the simulator’s own crops;

  • an AXI4 slave model of the record buffer, checking record layout, CRC, write ordering and the doorbell-last rule, including watchdog and poisoned-frame cases;

  • a loopback model of the RoCE engine for crop_tap and weight_loader, checking that a weight swap takes effect only at a cycle boundary;

  • formal proofs for async_fifo alongside the library’s existing FIFO proofs.

The vendor IP (CXP core, PCIe, Ethernet MAC, RoCE) is not simulated at the protocol level here; it is replaced by these models in simulation and exercised on hardware in the bring-up order of Section G.8.

Scaling to 10000 sites

Throughout this subsection nn is the number of sites and NN the number of sites along one side of the square array. Thus n=N2n = N^2, as in Sections A and B.2: the implemented design is N=50N = 50, n=2500n = 2500, and the next array generation is taken as n=104n = 10^4 (Section B.2). Three quantities scale differently with nn, and only one of them is a property of the pipeline as built.

  • Detection time scales linearly in nn and stays negligible with the matched filter. One lane classifies n=104n = 10^4 sites in 104+910^4 + 9 cycles, 50 µs at 200 MHz, against at least 3.4 ms to transfer the 2048×20482048 \times2048 ROI payload; four fixed-template lanes (244 DSP slices) reduce detection to about 12.5 µs. The CNN’s 22.5 ms for n=2500n = 2500 at one core would become ≈90\approx90 ms, more than half the 150 ms host round-trip whose removal is the largest gain in Section E.4, and four cores with the decoder resident already take 93% of the DSP slices (Table 27). A learned detector at 10410^4 sites therefore needs a larger DSP budget, a cheaper network per site, or a shorter per-crop latency than the 1797 cycles of Section D.2.

  • Rearrangement operates on row- and column-sized data structures. For n=N2n = N^2 sites, each row-assignment problem has at most NN sources and NN target columns. Its M×KM \times K take-bit matrix therefore contains at most N2=nN^2 = n bits. At n=104n = 10^4 sites, this matrix occupies at most 1.25 kB. The sorter ranks NN column priorities; padding N=100N = 100 to 128 inputs gives a 28-stage bitonic network with 1792 compare–exchange pairs. These structural counts follow from the row-wise architecture of Section A.6[algo].

  • The sensor fixes the product of sites across and pixels per site pitch; where to sit on that curve is a choice. At a site pitch of SS sensor pixels, the 4096×23044096 \times2304 sensor images at most ⌊4096/S⌋×⌊2304/S⌋\lfloor4096/S \rfloor\times\lfloor2304/S \rfloor sites. The evaluated configuration (Table 11) samples the atom plane at 0.4 µm/px, so the 4 µm pitch of the sparse array is S=10S = 10 px and the sensor holds up to 409×230409 \times230 sites; a 100×100100 \times100 array fits in a 1000×10001000 \times1000-pixel region at that pitch, and a 2048×20482048 \times2048 region holds 204×204204 \times204 sites. Denser pitches trade sites across for crosstalk, whose cost Table 17 measures with the 8×88 \times8 window. This is an instrument trade; the pipeline itself is unaffected.

Waveform synthesis, on the controller side

Moves leave the QDPU as (from, to) site pairs. Their conversion to AOD drive, multi-tone chirped DDS, is the controller’s task and lies outside the QDPU. It enters this specification as a constraint on the egress: the tone count the controller can sustain bounds the number of atoms moved concurrently, and therefore the parallelism the rearrangement schedule may assume.

Open Items

The following are open at the time of writing. They are listed so that the provenance tags of the appendices can be read against them.

  1. Hardware status. The matched-filter pipeline closes 200 MHz as a ZCU216 bitstream with an on-chip self-test, with recovery and removal met for its synchronous-release reset (Section D.3). The CNN pipeline is place-and-routed out of context only (Section A.1).

  1. Region-of-interest line buffer. Both 8×88 \times8 pipelines close 200 MHz with a registered crop input standing in for it (Table 22); build the line buffer that cuts the windows from the camera stream and feeds the detector from registers. Decide whether the CNN is driven back to back (1165 rather than 1797 cycles per crop, Section D.2).

  1. Ingest and egress latency. The sensor-readout and egress rows of Table 26 are derived from the camera datasheet and the link specification and await measurement after integration (Section G); the scan mode the imaging simulator assumes decides which readout time applies.

  1. Measurements not yet made. The Fmax⁡F_{\max} ceiling of the pipeline above the 200 MHz constraint (Section D.4); per-lane pipelining of the matched filter’s configuration port, which limits loadable lanes at P≥20P \ge20 (Table 23); csynth LUT/FF for the 8×88 \times8 CNN; a power estimate from simulated switching activity, and power estimates for the CNN and CNN-plus-decoder configurations. The vectorless estimate for the matched-filter pipeline is 2.39 W (Section D.7).

  1. Host round trip. The 150 ms host-in-loop round trip of Table 29 is an assumption. With the detector charged its inference time there is no break-even round trip, and the conclusion holds for any host round trip above a few milliseconds (Section E.4); the round trip has not been measured on the target apparatus.

  1. Simulator-conditional accuracy. No detection-accuracy figure was measured on a real camera frame; fixed-pattern noise is the leading sim-to-real risk (§ 6).

  1. Interfaces. The Shuttle and Control APIs of Table 38 are undefined in this iteration. The latency of the hand-off from server memory through the vendor’s OPNIC stream to the controller has not been measured; the vendor’s planning figure is about 1 μs1\,\mu\mathrm{s} for any PCIe transfer inside the OPC, so it does not change the millisecond-scale conclusions of Section E (Section G.3).

ChannelDir.PayloadWidth / rateLatency budgetStatus
Occupancyout2500 bits per framePCIe Gen3 x4, 316 B per cycle (Table 40)< 2 µs link time; < 4 µs vendor round trip to the controller [112]specified
Move streamoutfrom/to (row, col) per move, ready/valid24-bit coordinates packed into a 32-bit word per move; 4D4D bytes for DD move descriptors (Table 40)within the same transferspecified
Shuttle APIoutundefined in this iteration (Section H)——open
Control APIoutcorrections and measurement selection from the decoder, real-time regime (§ 5.2); undefined in this iteration——open
Server memory and SDK stream—the cycle record of Table 40host memory (path A) or GPU memory (path B), written by FPGA DMA; a stream defined with the OPNIC SDK carries it to the OPNIC (Section G.3)about 1 µs per PCIe hop; stream hand-off unmeasuredspecified
OPNIC to OPX1000—the same recordvendor fibre link (NVQLink); no FPGA resource< 4 µs round tripspecified

Table 38. Controller interface (downstream, OPX1000 + OPNIC).

  1. Board route. The ZCU216 has one FMC+ slot and no PCIe edge connector, so the camera link and the PCIe link share one FMC+ carrier with four GTY lanes each; that carrier has yet to be sourced or built, with CoaXPress-over-Fibre into the SFP28 cages as the fallback (Section G.9), which would then share the cages with NVQLink.

  1. NVQLink. The outer-loop transport is measured at 10 GbE with test traffic and a GraphMP ranking kernel (Section G.5). Open: 25 GbE; the GPU path’s tail latency on the DGX Spark and the proxy-free path of a discrete GPU; and the crop, label and weight traffic of Table 41.

Glossary of Special Terms and Acronyms

  • AIE = AI Engines.

  • AMD = FPGA manufacturer.

  • AOD = Acousto-Optic Deflectors.

  • ap_fixed⟨W,I⟩ap\_fixed\langle W,I\rangle = "ap_fixed with WW bitwidth and II integer bits" fixed-point datatype.

  • ASIC = Application-Specific Integrated Circuit.

  • AXI-stream = FPGA on-chip communication protocol.

  • BP = Belief Propagation.

  • BRAM = "Block RAM" FPGA resource.

  • BRAM_SDP = Simple dual-port block RAM: one write port and one read port, a library cell of the rearrangement engine.

  • CRC = Cyclic Redundancy Check, an error-detecting checksum (CRC-32 on the CoaXPress link and on each move list sent to the controller).

  • CSR = Compressed Sparse Row, a storage format for sparse graphs (the decoder’s adjacency); also Control and Status Register, a host-accessible FPGA register.

  • clk = Clock.

  • CPU = Central Processing Unit.

  • CMAC = AMD’s integrated 100 Gb/s Ethernet MAC/PCS block.

  • CNN = Convolutional Neural Network.

  • CoaXPress = A high-speed interface standard for transmitting image data and control signals between a camera and a host.

  • CXP-6 = A CoaXPress rate class with a line rate of 6.25 Gb/s per lane.

  • DDR = "Double Data Rate" is technology used in modern memory chips with SDRAM.

  • DGX Spark = NVIDIA desktop system with a GB10 chip (Grace CPU and integrated GPU) and a ConnectX-7 network card.

  • DMA = Direct Memory Access.

  • DOCA GPUNetIO = NVIDIA library that lets GPU code send and receive network packets directly.

  • DSP = Digital signal processing; in the FPGA resource tables, a DSP slice is a dedicated arithmetic block supporting operations such as multiplication and accumulation.

  • FF = "Flip-flop" FPGA resource.

  • FIFO = "First in, first out" FPGA concept for memory handling.

  • FMC = "FPGA Mezzanine Card" provides fixed I/O for FPGA board.

  • FPGA = Field-Programmable Gate Array.

  • fps = Frames per Second.

  • GAN = Generative Adversarial Network.

  • GbE = ’Gigabit Ethernet" port.

  • GEMM = General Matrix Multiplication.

  • GPU = Graphics Processing Unit.

  • GraphMP = The learned message-passing decoder introduced in the companion paper [38].

  • GTY = A family of AMD high-speed serial transceivers.

  • HLS = High Level Synthesis.

  • HPC = High Performance Computing.

  • HSB = Holoscan Sensor Bridge, NVIDIA’s open-source FPGA IP and host software that move sensor data into CPU or GPU memory over RoCE; the FPGA side of NVQLink’s reference transport.

  • II = Initiation Interval, the number of clock cycles between the starts of successive loop iterations or inputs in a pipelined design.

  • IP = Intellectual Property.

  • I/O = Input/output.

  • LP[[1122,148,≤20]]\mathrm{LP}[[1122, 148, \le20]] = A lifted-product code with 1122 physical qubits, 148 logical qubits, and code distance at most 20; the distance is not the number of correctable errors.

  • LSB = Least Significant Bit.

  • LUT = "Look-up Table" FPGA resource.

  • LUTRAM = LUT as RAM.

  • MAC = Multiply–accumulate in arithmetic and resource counts; Media Access Control in Ethernet descriptions.

  • MLP = Multi-Layer Perceptron.

  • NAND = "NOT AND" boolean logic gate.

  • NIC = "Network Interface Card" converts data to electrical signal and transfers to classical computer chips.

  • NVQLink = NVIDIA’s interconnect platform for integrating quantum systems with GPU computing.

  • OPC = OP-Central, Quantum Machines’ validated host server for the OPX1000.

  • OPNIC = Quantum Machines’ PCIe interface card connecting the host server to the OPX1000 controller.

  • OPX1000 = Quantum Machines’ controller device for large scale quantum computers.

  • ORCA-Quest 2 qCMOS = Camera device used to image atoms.

  • OSD = Ordered Statistics Decoding.

  • PCIe = Peripheral Component Interconnect Express.

  • PL = Programmable Logic.

  • PLIO = Programmable Logic I/O, the AXI4-Stream interface between the programmable logic and the AI Engine array on Versal devices.

  • PPVM = "Programmable Pauli Virtual Machine" simulation framework.

  • PTP = Precision Time Protocol, used to lock the FPGA clock to the host’s.

  • QAT = Quantization-aware training.

  • QEC = Quantum Error Correction.

  • QDPU = Quantum Data Processing Unit.

  • QDM = Quantum Data Model.

  • qLDPC = Quantum Low Density Parity Check

  • QDMA = Queue-based Direct Memory Access.

  • QPU = Quantum Processing Unit.

  • QSFP = Quad Small Form-factor Pluggable.

  • QUA = Pulse-level-control programming language for quantum devices.

  • RAM = Random Access Memory.

  • RDMA = Remote DMA.

  • RF = "Reuse Factor" knob to be set in the HLS code (not to be confused with "RF" in RFSoC)

  • rms = Root Mean Square.

  • RoCE = RDMA over Converged Ethernet; RoCEv2 carries it over UDP/IP.

  • ROI = Region of Interest.

  • ROM = Read-Only Memory.

  • RTL = "Register Transfer Level" hardware design.

  • SDK = Software Development Kit.

  • SDRAM = "Synchronous Dynamic Random-Access Memory" concept used in modern chips.

  • SFP28 = Small Form-factor Pluggable cage for one 25 Gb/s lane.

  • texpt_{\mathrm{exp}} = Exposure time: how long the camera collects fluorescence for one image.

  • tcyclet_{\mathrm{cycle}} = Duration of one detect–rearrange cycle: exposure, camera readout, detection, rearrangement planning, atom transport and, with a host in the loop, the host round trip.

  • τimg\tau_{img} = Imaging-loss lifetime: an atom survives one image with probability exp⁡(−texp/τimg)\exp(-t_{exp}/\tau_{img}).

  • τvac\tau_{vac} = Vacuum-limited trap lifetime: an atom survives a time tt in its trap with probability exp⁡(−t/τvac)\exp(-t/\tau_{vac}).

  • tetris = The atom rearrangement engine (RTL module tetris), named after the Tetris-style compaction algorithm it implements.

  • TNS = Total Negative Slack.

  • TTL = Transistor-Transistor Logic.

  • Versal AI Edge = AMD adaptive SoC family; the xcve2802 is the target device for the PL–AIE decoder implementation in this work.

  • W12A12 = Weights and activations captured by 12 bits.

  • WNS = Worst Negative Slack.

  • Zynq UltraScale+ RFSoC ZCU216 = FPGA board used in this work, part number xczu49dr.

  • ZZ check = A weight-two parity check that measures the product Z⊗ZZ \otimes Z of two data qubits.

References

  1. [1]John Preskill. Quantum Computing in the NISQ era and beyond. Quantum, 2:79, 2018. https://doi.org/10.22331/q-2018-08-06-79.
  2. [2]Kishor Bharti, Alba Cervera-Lierta, Thi Ha Kyaw, Tobias Haug, Sumner Alperin-Lea, Abhinav Anand, Matthias Degroote, Hermanni Heimonen, et al. Noisy intermediate-scale quantum algorithms. Reviews of Modern Physics, 94:015004, 2022. https://doi.org/10.1103/RevModPhys.94.015004.
  3. [3]Johannes Bausch, Andrew W. Senior, Francisco J. H. Heras, Thomas Edlich, Alex Davies, Michael Newman, Cody Jones, Kevin Satzinger, Murphy Yuezhen Niu, Sam Blackwell, George Holland, Dvir Kafri, Juan Atalaya, Craig Gidney, Demis Hassabis, Sergio Boixo, Hartmut Neven, and Pushmeet Kohli. Learning high-accuracy error decoding for quantum processors. Nature, 635(8040):834–840, 2024. https://doi.org/10.1038/s41586-024-08148-8.
  4. [4]L. Phuttitarn, B. M. Becker, R. Chinnarasu, T. M. Graham, and M. Saffman. Enhanced measurement of neutral atom qubits with machine learning. Physical Review Applied, 22:024011, 2024. https://doi.org/10.1103/PhysRevApplied.22.024011.
  5. [5]Mark Saffman. Neutral atom quantum computing. arXiv preprint, 2026. arXiv:2608.30783.arxiv.org/abs/2608.30783
  6. [6]Manuel Endres, Hannes Bernien, Alexander Keesling, Harry Levine, Eric R. Anschuetz, Alexandre Krajbenbrink, Crystal Senko, Vladan Vuletić, Markus Greiner, and Mikhail D. Lukin. Atom-by-atom assembly of defect-free one-dimensional cold atom arrays. Science, 354(6315):1024–1027, 2016. https://doi.org/10.1126/science.aab3752.
  7. [7]Daniel Barredo, Sylvain de Léséleuc, Vincent Lienhard, Thierry Lahaye, and Antoine Browaeys. An atom-by-atom assembler of defect-free arbitrary two-dimensional atomic arrays. Science, 354(6315):1021–1023, 2016. https://doi.org/10.1126/science.aah3778.
  8. [8]Rui Lin, Han-Sen Zhong, You Li, Zhang-Rui Zhao, Le-Tian Zheng, Tai-Ran Hu, Hong-Ming Wu, Zhan Wu, Wei-Jie Ma, Yan Gao, Yi-Kang Zhu, Zhao-Feng Su, Wan-Li Ouyang, Yu-Chen Zhang, Jun Rui, Ming-Cheng Chen, Chao-Yang Lu, and Jian-Wei Pan. AI-Enabled Parallel Assembly of Thousands of Defect-Free Neutral Atom Arrays. Physical Review Letters, 135(6):060602, 2025. https://doi.org/10.1103/2ym8-vs82.
  9. [9]Neng-Chun Chiu, Elias C. Trapp, Jinen Guo, Mohamed H. Abobeih, Luke M. Stewart, Simon Hollerith, Pavel L. Stroganov, Marcin Kalinowski, Alexandra A. Geim, Simon J. Evered, Sophie H. Li, Xingjian Lyu, Lisa M. Peters, Dolev Bluvstein, Tout T. Wang, Markus Greiner, Vladan Vuletić, and Mikhail D. Lukin. Continuous operation of a coherent 3,000-qubit system. Nature, 646(8087):1075–1080, 2025. https://doi.org/10.1038/s41586-025-09596-6.
  10. [10]Hannah J. Manetsch, Gyohei Nomura, Elie Bataille, Kon H. Leung, Xudong Lv, and Manuel Endres. A tweezer array with 6100 highly coherent atomic qubits. Nature, 647:60–67, 2025. https://doi.org/10.1038/s41586-025-09641-4.
  11. [11]Yuqing Wang, Zhongchi Zhang, Tao Zhang, Yuxuan Liao, Hanteng Wang, Ye Tian, Binjie Ji, Yujia Wu, Luming Ma, Chen Qing, Chengshu Li, Wei Zhang, Yidong Huang, Wenjun Zhang, Xue Feng, Wenlan Chen, and Hui Zhai. Trapping 11,000 Atoms in a Tweezer Array Generated by a Single Metasurface. arXiv:2606.02715, 2026.arxiv.org/abs/2606.02715
  12. [12]Adrian J. Menssen, Tout Wang, Michael Gullans, Tom Manovitz, Jacob M. Taylor, Jason Cong, et al. Strategic plan for neutral atom quantum computation. arXiv preprint, 2026. arXiv:2607.21554.arxiv.org/abs/2607.21554
  13. [13]Aaron W. Young, William J. Eckner, William R. Milner, Dhruv Kedar, Matthew A. Norcia, Eric Oelker, Nathan Schine, Jun Ye, and Adam M. Kaufman. Half-minute-scale atomic coherence and high relative stability in a tweezer clock. Nature, 588(7838):408–413, 2020. https://doi.org/10.1038/s41586-020-3009-y.
  14. [14]Renhao Tao, Maximilian Ammenwerth, Flavien Gyger, Immanuel Bloch, and Johannes Zeiher. High-Fidelity Detection of Large-Scale Atom Arrays in an Optical Lattice. Physical Review Letters, 133(1):013401, 2024. https://doi.org/10.1103/PhysRevLett.133.013401.
  15. [15]Lars Pause, Lukas Sturm, Marcel Mittenbühler, Stephan Amann, Tilman Preuschoff, Dominik Schäffner, Malte Schlosser, and Gerhard Birkl. Supercharged two-dimensional tweezer array with more than 1000 atomic qubits. Optica, 11(2):222–226, 2024. https://doi.org/10.1364/OPTICA.513551.
  16. [16]Jiawen Zhu, Changfeng Chen, Li Zhou, Xiangru Xie, Chenyang Jiang, Zhuoli Ding, Fan Wu, Fan Yang, Guoqing Wang, Qi-huang Gong, Peng Zhang, Sheng Zhang, and Pai Peng. High-Efficiency Loading of 2400 Ytterbium Atoms in Optical Tweezer Arrays. Physical Review Letters, 137(6):063201, 2026. https://doi.org/10.1103/bp6k–8zmd.
  17. [17]Daniel Barredo, Vincent Lienhard, Sylvain de Léséleuc, Thierry Lahaye, and Antoine Browaeys. Synthetic three-dimensional atomic structures assembled atom by atom. Nature, 561(7721):79–82, 2018. https://doi.org/10.1038/s41586-018-0450-2.
  18. [18]Daniel Ohl de Mello, Dominik Schäffner, Jan Werkmann, Tilman Preuschoff, Lars Kohfahl, Malte Schlosser, and Gerhard Birkl. Defect-Free Assembly of 2D Clusters of More Than 100 Single-Atom Quantum Systems. Physical Review Letters, 122(20):203601, 2019. https://doi.org/10.1103/PhysRevLett.122.203601.
  19. [19]Sepehr Ebadi, Tout T. Wang, Harry Levine, Alexander Keesling, Giulia Semeghini, Ahmed Omran, Dolev Bluvstein, Rhine Samajdar, Hannes Pichler, Wen Wei Ho, Soonwon Choi, Subir Sachdev, Markus Greiner, Vladan Vuletić, and Mikhail D. Lukin. Quantum phases of matter on a 256-atom programmable quantum simulator. Nature, 595(7866):227–232, 2021. https://doi.org/10.1038/s41586-021-03582-4.
  20. [20]Pascal Scholl, Michael Schuler, Hannah J. Williams, Alexander A. Eberharter, Daniel Barredo, Kai-Niklas Schymik, Vincent Lienhard, Louis-Paul Henry, Thomas C. Lang, Thierry Lahaye, Andreas M. Läuchli, and Antoine Browaeys. Quantum simulation of 2D antiferromagnets with hundreds of Rydberg atoms. Nature, 595(7866):233–238, 2021. https://doi.org/10.1038/s41586-021-03585-1.
  21. [21]S. Ebadi, A. Keesling, M. Cain, T. T. Wang, H. Levine, D. Bluvstein, G. Semeghini, A. Omran, J.-G. Liu, R. Samajdar, X.-Z. Luo, B. Nash, X. Gao, B. Barak, E. Farhi, S. Sachdev, N. Gemelke, L. Zhou, S. Choi, H. Pichler, S.-T. Wang, M. Greiner, V. Vuletic, and M. D. Lukin. Quantum optimization of maximum independent set using Rydberg atom arrays. Science, 376(6598):1209–1215, 2022. https://doi.org/10.1126/science.abo6587.
  22. [22]Kai-Niklas Schymik, Bruno Ximenez, Etienne Bloch, Davide Dreon, Adrien Signoles, Florence Nogrette, Daniel Barredo, Antoine Browaeys, and Thierry Lahaye. In situ equalization of single-atom loading in large-scale optical tweezer arrays. Physical Review A, 106(2):022611, 2022. https://doi.org/10.1103/PhysRevA.106.022611.
  23. [23]M. A. Norcia, H. Kim, W. B. Cairncross, M. Stone, A. Ryou, M. Jaffe, M. O. Brown, K. Barnes, P. Battaglino, T. C. Bohdanowicz, A. Brown, K. Cassella, C.-A. Chen, R. Coxe, D. Crow, J. Epstein, C. Griger, E. Halperin, F. Hummel, A. M. W. Jones, J. M. Kindem, J. King, K. Kotru, J. Lauigan, M. Li, M. Lu, E. Megidish, J. Marjanovic, M. McDonald, T. Mittiga, J. A. Muniz, S. Narayanaswami, C. Nishiguchi, T. Paule, K. A. Pawlak, L. S. Peng, K. L. Pudenz, D. Rodríguez Pérez, A. Smull, D. Stack, M. Urbanek, R. J. M. van de Veerdonk, Z. Vendeiro, L. Wadleigh, T. Wilkason, T.-Y. Wu, X. Xie, E. Zalys-Geller, X. Zhang, and B. J. Bloom. Iterative assembly of 171Yb atom arrays with cavity-enhanced optical lattices. PRX Quantum, 5:030316, 2024. https://doi.org/10.1103/PRXQuantum.5.030316.
  24. [24]Flavien Gyger, Maximilian Ammenwerth, Renhao Tao, Hendrik Timme, Stepan Snigirev, Immanuel Bloch, and Johannes Zeiher. Continuous operation of large-scale atom arrays in optical lattices. Physical Review Research, 6(3):033104, 2024. https://doi.org/10.1103/PhysRevResearch.6.033104.
  25. [25]Grégoire Pichard, Desiree Lim, Étienne Bloch, Julien Vaneecloo, Lilian Bourachot, Gert-Jan Both, Guillaume Mériaux, Sylvain Dutartre, Richard Hostein, Julien Paris, Bruno Ximenez, Adrien Signoles, Antoine Browaeys, Thierry Lahaye, and Davide Dreon. Rearrangement of individual atoms in a 2000-site optical tweezer array at cryogenic temperatures. Physical Review Applied, 22:024073, 2024. https://doi.org/10.1103/PhysRevApplied.22.024073.
  26. [26]Desiree Lim, Hadriel Mamann, Grégoire Pichard, Lilian Bourachot, Arvid Lindberg, Clotilde Hamot, Hugo Le Bars, Florian Fasola, Siddhy Tan, Gwennolé Cournez, Sylvain Dutartre, Thierry Catry, Sylvain Lemaitre, Richard Hostein, Julien Paris, Franck Ferreyrol, Andréa Collardey, Adrien Signoles, Thierry Lahaye, Corentin Monmeyran, and Bruno Ximenez. Defect-Free Arrays at the Thousand-Atom Scale in a 4-K Cryogenic Environment. PRX Quantum, 7(3):033032, 2026. https://doi.org/10.1103/4St1-vl5y.
  27. [27]Dolev Bluvstein, Harry Levine, Giulia Semeghini, Tout T. Wang, Sepehr Ebadi, Marcin Kalinowski, Alexander Keesling, Nishad Maskara, Hannes Pichler, Markus Greiner, Vladan Vuletić, and Mikhail D. Lukin. A quantum processor based on coherent transport of entangled atom arrays. Nature, 604:451–456, 2022. https://doi.org/10.1038/s41586-022-04592-6.
  28. [28]Dolev Bluvstein, Simon J. Evered, Alexandra A. Geim, Sophie H. Li, Hengyun Zhou, Tom Manovitz, Sepehr Ebadi, Madelyn Cain, Marcin Kalinowski, Dominik Hangleiter, J. Pablo Bonilla Ataides, Nishad Maskara, Iris Cong, Xun Gao, Pedro Sales Rodriguez, Thomas Karolýshyn, Giulia Semeghini, Michael J. Gullans, Markus Greiner, Vladan Vuletic, and Mikhail D. Lukin. Logical quantum processor based on reconfigurable atom arrays. Nature, 626:58–65, 2024. https://doi.org/10.1038/s41586-023-06927-3.
  29. [29]Ben W. Reichardt, Adam Paetznick, David Aasen, Ivan Basov, Juan M. Bello-Rivas, Parsa Bonderson, Rui Chao, Wim van Dam, Matthew B. Hastings, Ryan V. Mishmash, Andres Paz, Marcus P. da Silva, Aarthi Sundaram, Krysta M. Svore, Alexander Vashchillo, Zhenghan Wang, Matt Zanner, William B. Cairncross, Cheng-An Chen, Daniel Crow, Hyosub Kim, Jonathan M. Kindem, Jonathan King, Michael McDonald, Matthew A. Norcia, Albert Ryou, Mark Stone, Laura Wadleigh, Katrina Barnes, Peter Battaglino, Thomas C. Bohdanowicz, Graham Booth, Andrew Brown, Mark O. Brown, Kayleigh Cassella, Robin Coxe, Jeffrey M. Epstein, Max Feldkamp, Christopher Griger, Eli Halperin, Andre Heinz, Frederic Hummel, Matthew Jaffe, Antonia M. W. Jones, Eliot Kapit, Krish Kotru, Joseph Lauigan, Ming Li, Jan Marjanovic, Eli Megidish, Matthew Meredith, Ryan Morshead, Juan A. Muniz, Sandeep Narayanaswami, Ciro Nishiguchi, Timothy Paule, Kelly A. Pawlak, Kristen L. Pudenz, David Rodríguez Pérez, Jon Simon, Aaron Smull, Daniel Stack, Miroslav Urbanek, René J. M. van de Veerdonk, Zachary Vendeiro, Robert T. Weverka, Thomas Wilkinson, Tsung-Yao Wu, Xin Xie, Evan Zalys-Geller, Xiaogang Zhang, and Benjamin J. Bloom. Fault-tolerant quantum computation with a neutral atom processor. arXiv:2411.11822, 2024.arxiv.org/abs/2411.11822
  30. [30]Dolev Bluvstein, Alexandra A. Geim, Sophie H. Li, Simon J. Evered, J. Pablo Bonilla Ataides, Gefen Baranes, Andi Gu, Tom Manovitz, Muqing Xu, Marcin Kalinowski, Shayan Majidy, Christian Kokail, Nishad Maskara, Elias C. Trapp, Luke M. Stewart, Simon Hollerith, Hengyun Zhou, Michael J. Gullans, Susanne F. Yelin, Markus Greiner, Vladan Vuletić, Madelyn Cain, and Mikhail D. Lukin. A fault-tolerant neutral-atom architecture for universal quantum computation. Nature, 649(8095):39–46, 2026. https://doi.org/10.1038/s41586-025-09848-5.
  31. [31]Kai-Niklas Schymik, Sara Pancaldi, Florence Negrette, Daniel Barredo, Julien Paris, Antoine Browaeys, and Thierry Lahaye. Single Atoms with 6000-Second Trapping Lifetimes in Optical-Tweezer Arrays at Cryogenic Temperatures. Physical Review Applied, 16:034013, 2021. https://doi.org/10.1103/PhysRevApplied.16.034013.
  32. [32]Google Quantum AI and Collaborators, Rajeev Acharya, Dmitry A. Abanin, Laleh Aghababaie-Beni, Igor Aleiner, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita Astrakhantsev, Juan Atalaya, Ryan Babbush, Dave Bacon, Brian Ballard, Joseph C. Bardin, Johannes Bausch, Andreas Bengtsson, Alexander Bilmes, Sam Blackwell, Sergio Boixo, Gina Bortoli, Alexandre Bourassa, Jenna Bovaird, Leon Brill, Michael Broughton, David A. Browne, Brett Buchea, Bob B. Buckley, David A. Buell, Tim Burger, Brian Burkett, Nicholas Bushnell, Anthony Cabrera, Juan Campero, Hung-Shen Chang, Yu Chen, Zijun Chen, Ben Chiaro, Desmond Chik, Charina Chou, Jahan Claes, Agnetta Y. Cleland, Josh Cogan, Roberto Collins, Paul Conner, William Courtney, Alexander L. Crook, Ben Curtin, Sayan Das, Alex Davies, Laura De Lorenzo, Dripto M. Debroy, Sean Demura, Michel Devoret, Agustin Di Paolo, Paul Donohoe, Ilya Drozdov, Andrew Dunsworth, Clint Earle, Thomas Edlich, Alec Eickbusch, Aviv Moshe Elbag, Mahmoud Elzouka, Catherine Erickson, Lara Faoro, Edward Farhi, Vinicius S. Ferreira, Leslie Flores Burgos, Ebrahim Forati, Austin G. Fowler, Brooks Foxen, Subhas Ganjam, Gonzalo Garcia, Robert Gasca, Élie Genois, William Giang, Craig Gidney, Dar Gilboa, Raja Gosula, Alejandro Grajales Dau, Dietrich Graumann, Alex Greene, Jonathan A. Gross, Steve Habegger, John Hall, Michael C. Hamilton, Monica Hansen, Matthew P. Harrigan, Sean D. Harrington, Francisco J. H. Heras, Stephen Heslin, Paula Heu, Oscar Higgott, Gordon Hill, Jeremy Hilton, George Holland, Sabrina Hong, Hsin-Yuan Huang, Ashley Huff, William J. Huggins, Lev B. Ioffe, Sergei V. Isakov, Justin Iveland, Evan Jeffrey, Zhang Jiang, Cody Jones, Stephen Jordan, Chaitali Joshi, Pavol Juhas, Dvir Kafri, Hui Kang, Amir H. Karamlou, Kostyantyn Kechedzhi, Julian Kelly, Trupti Khaire, Tanuj Khattar, Mostafa Khezri, Seon Kim, Paul V. Klimov, Andrey R. Klots, Bryce Kobrin, Pushmeet Kohli, Alexander N. Korotkov, Fedor Kostritsa, Robin Kothari, Borislav Kozlovskii, John Mark Kreikebaum, Vladislav D. Kurilovich, Nathan Lacroix, David Landhuis, Tiano Lange-Dei, Brandon W. Langley, Pavel Laptev, Kim-Ming Lau, Loïck Le Guevel, Justin Ledford, Joonho Lee, Kenny Lee, Yuri D. Lensky, Shannon Leon, Brian J. Lester, Wing Yan Li, Yin Li, Alexander T. Lill, Wayne Liu, William P. Livingston, Aditya Locharla, Erik Lucero, Daniel Lundahl, Aaron Lunt, Sid Madhuk, Fionn D. Malone, Ashley Maloney, Salvatore Mandrà, James Manyika, Leigh S. Martin, Orion Martin, Steven Martin, Cameron Maxfield, Jarrod R. McClean, Matt McEwen, Seneca Meeks, Anthony Megrant, Xiao Mi, Kevin C. Miao, Amanda Mieszala, Reza Molavi, Sebastian Molina, Shirin Montazeri, Alexis Morvan, Ramis Movassagh, Wojciech Mruczkiewicz, Ofer Naaman, Matthew Neeley, Charles Neill, Ani Nersisyan, Hartmut Neven, Michael Newman, Jiun How Ng, Anthony Nguyen, Murray Nguyen, Chia-Hung Ni, Murphy Yuezhen Niu, Thomas E. O’Brien, William D. Oliver, Alex Opreomcak, Kristoffer Ottosson, Andre Petukhov, Alex Pizzuto, John Platt, Rebecca Potter, Orion Pritchard, Leonid P. Pryadko, Chris Quintana, Ganesh Ramachandran, Matthew J. Reagor, John Redding, David M. Rhodes, Gabrielle Roberts, Eliott Rosenberg, Emma Rosenfeld, Pedram Roushan, Nicholas C. Rubin, Negar Saei, Daniel Sank, Kannan Sankaragomathi, Kevin J. Satzinger, Henry F. Schurkus, Christopher Schuster, Andrew W. Senior, Michael J. Shearn, Aaron Shorter, Noah Shutt y, Vladimir Shvarts, Shraddha Singh, Volodymyr Sivak, Jindra Skrz umy, Spencer Small, Vadim Smelyanskiy, W. Clarke Smith, Rolando D. Somma, Sofia Springer, George Sterling, Doug Strain, Jordan Suchard, Aaron Sz asz, Alex Stein, Douglas Thor, Alfredo Torres, M. Mert Turunbalci, Abeer Vaishnav, Justin Vargas, Sergey Vdovichev, Guifre Vidal, Benjamin Villalonga, Catherine Vollgraff Heidweiller, Steven Waltman, Shannon X. Wang, Brayden Ware, Kate Weber, Travis Weidel, Theodore White, Kristi Wong, Bryan W. K. Woo, Cheng Xing, Z. Jamie Yao, Ping Yeh, Bicheng Ying, Juhwan Yoo, Noureldin Yosri, Grayson Young, Adam Zalcman, Yaxing Zhang, Ningfeng Zhu, and Nicholas Zobrist. Quantum error correction below the surface code threshold. Nature, 638(8052):920–926, 2025. Published online 9 December 2024. https://doi.org/10.1038/s41586-024-08449-y.
  33. [33]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, 7(3):032003, 2023. https://doi.org/10.1088/2399-1984/aceba6.
  34. [34]Shane A. Caldwell, Moein Khazraee, Elena Agostini, Tom Lassiter, Corey Simpson, Omri Kahalon, Mrudula Kanuri, Jin-Sung Kim, Sam Stanwyck, Muyuan Li, Jan Olle, Christopher Chamberland, Ben Howe, Bruno Schmitt, Justin G. Lietz, Alex McCaskey, Jun Ye, Ang Li, Alicia B. Magann, Corey I. Ostrove, Kenneth Rudinger, Robin Blume-Kohout, Kevin Young, Nathan E. Miller, Yilun Xu, Gang Huang, Irfan Siddiqi, John Lange, Christopher Zimmer, and Travis Humble. Platform Architecture for Tight Coupling of High-Performance Computing with Quantum Processors. arXiv:2510.25213, 2025.arxiv.org/abs/2510.25213
  35. [35]X. Fu, M. A. Rol, C. C. Bultink, J. van Someren, N. Khammassi, I. Ashraf, R. F. L. Vermeulen, J. C. de Sterke, W. J. Vlothuizen, R. N. Schouten, C. G. Almudever, L. DiCarlo, and K. Bertels. An Experimental Microarchitecture for a Superconducting Quantum Processor. In Proceedings of the 50th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO-50), 2017. arXiv:1708.07677.DOI
  36. [36]Yaojian Chen, Chun-Yang Luan, Peilin Zheng, Xianghong Zeng, Jia-Yi Hou, Zhuo Fu, Yirong Jin, Fei Wang, Guangwen Yang, and Dingshun Lv. Real-Time Quantum Error Correction System Stack: Architecture, Algorithms, and Engineering Practice. arXiv:2605.30765, 2026.arxiv.org/abs/2605.30765
  37. [37]Laura Caune, Luka Skoric, Nick S. Blunt, Archibald Ruban, Jimmy McDaniel, Joseph A. Valery, Andrew D. Patterson, Alexander V. Gramolin, Joonas Majaniemi, Kenton M. Barnes, Tomasz Bialas, Okan Buğdaycı, Ophelia Crawford, György P. Gehér, Hari Krovi, Elisha Matekole, Canberk Topal, Stefano Poletto, Michael Bryant, Kalan Snyder, Neil I. Gillespie, Glenn Jones, Kauser Johar, Earl T. Campbell, and Alexander D. Hill. Demonstrating real-time and low-latency quantum error correction with superconducting qubits. Nature Communications, 17:7383, 2026. https://doi.org/10.1038/s41467-026-73331-6.
  38. [38]EdenCode. Distilling knowledge from search: Decoder model factory for quantum LDPC codes. Manuscript in preparation, 2026.
  39. [39]Barbara M. Terhal. Quantum error correction for quantum memories. Reviews of Modern Physics, 87(2):307–346, 2015. https://doi.org/10.1103/RevModPhys.87.307.
  40. [40]Boris M. Varbanov, Marc Serra-Peralta, David Byfield, and Barbara M. Terhal. Neural network decoder for near-term surface-code experiments. Physical Review Research, 7(1):013029, 2025. https://doi.org/10.1103/PhysRevResearch.7.013029.
  41. [41]William Huie, Lintao Li, Neville Chen, Xiye Hu, Zhubing Jia, Won Kyu Calvin Sun, and Jacob P. Covey. Repetitive Readout and Real-Time Control of Nuclear Spin Qubits in ¹⁷¹Yb Atoms. PRX Quantum, 4:030337, 2023. https://doi.org/10.1103/PRXQuantum.4.030337.
  42. [42]M. A. Norcia, W. B. Cairncross, K. Barnes, P. Battaglino, A. Brown, M. O. Brown, K. Cassella, C.-A. Chen, R. Coxe, D. Crow, J. Epstein, C. Griger, A. M. W. Jones, H. Kim, J. M. Kindem, J. King, S. S. Kondov, K. Kotru, J. Lauigan, M. Li, M. Lu, E. Megidish, J. Marjanovic, M. McDonald, T. Mittiga, J. A. Muniz, S. Narayanaswami, C. Nishiguchi, R. Notermans, T. Paule, K. A. Pawlak, L. S. Peng, A. Ryou, A. Smull, D. Stack, M. Stone, A. Suchich, M. Urbanek, R. J. M. van de Veerdonk, Z. Vendeiro, T. Wilkason, T.-Y. Wu, X. Xie, X. Zhang, and B. J. Bloom. Microcircuit Qubit Measurement and Rearrangement in a ¹⁷¹Yb Atomic Array. Physical Review X, 13:041034, 2023. https://doi.org/10.1103/PhysRevX.13.041034.
  43. [43]Craig Gidney and Austin G. Fowler. Flexible layout of surface code computations using AutoCCZ states. arXiv:1905.08916, 2019.arxiv.org/abs/1905.08916
  44. [44]Adam Holmes, Mohammad Reza Jokar, Ghasem Pasandi, Yongshan Ding, Massoud Pedram, and Frederic T. Chong. NISQ+: Boosting quantum computing power by approximating quantum error correction. In 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA), pages 556–569, Valencia, Spain, 2020. IEEE. https://doi.org/10.1109/ISCA45697.2020.00053.
  45. [45]Luka Skoric, Dan E. Browne, Kenton M. Barnes, Neil I. Gillespie, and Earl T. Campbell. Parallel window decoding enables scalable fault tolerant quantum computation. Nature Communications, 14:7040, 2023. https://doi.org/10.1038/s41467-023-42482-1.
  46. [46]Yu Cai, Saugata Ghose, Erich F. Haratsch, Yixin Luo, and Onur Mutlu. Error Characterization, Mitigation, and Recovery in Flash-Memory-Based Solid-State Drives. Proceedings of the IEEE, 105(9):1666–1704, 2017.arxiv.org/abs/1706.08642
  47. [47]Seb J. Savory. Digital Coherent Optical Receivers: Algorithms and Subsystems. IEEE Journal of Selected Topics in Quantum Electronics, 16(5):1164–1179, 2010. https://doi.org/10.1109/JSTQE.2010.2044751.
  48. [48]Jian Zhao, Yaping Liu, and Tianhua Xu. Advanced DSP for Coherent Optical Fiber Communication. Applied Sciences, 9(19):4192, 2019. https://doi.org/10.3390/app9194192.
  49. [49]Tsai-Chen Lee, Jacquelyn Ho, Yue-Hui Lu, Tai Xiang, Nathaniel B. Vilas, Zhenjie Yan, and Dan M. Stamper-Kurn. Rapid Cavity-Based Mid-Circuit Measurement and Feedforward in a Neutral Atom Array. arXiv:2606.24869, 2026.DOI
  50. [50]Julian Kelly, Peter O’Malley, Matthew Neeley, Hartmut Neven, and John M. Martinis. Physical qubit calibration on a directed acyclic graph. arXiv:1803.03226, 2018.arxiv.org/abs/1803.03226
  51. [51]Robert M. Kent, Linipun Phuttitarn, Chaithanya Naik Mude, Swamit Tannu, Mark Saffman, Gregory Lafyatis, and Daniel J. Gauthier. Efficient measurement of neutral-atom qubits with matched filters. Physical Review Applied, 25(4):044048, 2026. https://doi.org/10.1103/x3h2-nz8y.
  52. [52]Amir H. Dadpour, Timur Khayrullin, Fouad Afiouni, Remy El Sabeh, Amer E. Mouawad, Izzat El Hajj, and Alexandre Cooper. Low-latency control system for feedback experiments with optical-tweezer arrays. Physical Review Applied, 24:024062, 2025. https://doi.org/10.1103/svtr-1rmd.
  53. [53]Leandro Stefanazzi, Kenneth Treptow, Neal Wilcer, Chris Stoughton, Collin Bradford, Sho Uemura, Silvia Zorzetti, Salvatore Montella, Gustavo Cancelo, Sara Sussman, Andrew Houck, Shefali Saxena, Horacio Arnaldi, Ankur Agrawal, Helin Zhang, Chunyang Ding, and David I. Schuster. The QICK (Quantum Instrumentation Control Kit): Readout and control for qubits and detectors. Review of Scientific Instruments, 93(4):044709, 2022. https://doi.org/10.1063/5.0076249.
  54. [54]Hamamatsu Photonics K.K. ORCA-Quest 2 qCMOS camera C15550-22UP. https://www.hamamatsu.com/us/en/product/cameras/qcmos-cameras/C15550-22UP.html, 2024.
  55. [55]Jonas Winklmann, Dimitrios Tsevas, and Martin Schulz. Realistic neutral atom image simulation. In Proceedings of the 2023 IEEE International Conference on Quantum Computing and Engineering (QCE), 2023. https://doi.org/10.1109/QCE57702.2023.00153.
  56. [56]Chair of Computer Architecture and Parallel Systems, TUM. neutral-atom-imaging-simulation: C library and python package for generating images of an array of neutral atoms. https://github.com/caps-tum/neutral-atom-imaging-simulation, 2024. LGPL-2.1.
  57. [57]Quantum Machines. OPX1000: High-Density Quantum Controller. https://www.quantum-machines.co/products/opx1000/. accessed September 2026.
  58. [58]Quantum Machines. OPNIC Hybrid Link – QUA Documentation. https://docs.quantum-machines.co/1.3.1/docs/Guides/OPNIC_Guide/. accessed September 2026.
  59. [59]NVIDIA Corporation. Scale Quantum Processing Unit Development With NVIDIA NVQLink. https://www.nvidia.com/en-us/solutions/quantum-computing/nvqlink/. accessed September 2026.
  60. [60]NVIDIA Corporation. Holoscan Sensor Bridge: FPGA IP Overview. https://docs.nvidia.com/holoscan/sensor-bridge/fpga-ip/overview. accessed October 2026.
  61. [61]Xiaorang Guo, Jonas Winklmann, Dirk Stober, Amr Elsharkawy, and Martin Schulz. Design of an FPGA-based neutral atom rearrangement accelerator for quantum computing. In Design, Automation and Test in Europe Conference (DATE), 2025. arXiv:2411.12401.arxiv.org/abs/2411.12401
  62. [62]Jonas Winklmann, Yian Yu, Xiaorang Guo, Korbinian Staudacher, and Martin Schulz. Highly-Parallel Atom-Detection Accelerator for Tweezer-Based Neutral Atom Quantum Computers. In Proceedings of the 63rd ACM/IEEE Design Automation Conference (DAC), 2026. https://doi.org/10.1145/3770743.3804354.
  63. [63]Ya-Dong Hu, Dong-Qi Ma, Tian-Yang Zhang, Liang Chen, Yi-Chen Zhang, Xiao-Kang Zhong, Wen-Yi Zhu, Hong-Jie Fan, Qing-Xuan Jie, Yan-Lei Zhang, Gang Li, Xi-Feng Ren, Xu-Liang Zhang, Guang-Can Guo, Zhu-Bo Wang, and Chang-Ling Zou. Low-latency FPGA-based electronic control system for fast preparation of defect-free atom arrays. arXiv preprint, 2026. arXiv:2607.08687.arxiv.org/abs/2607.08687
  64. [64]Xiaorang Guo, Jonas Winklmann, Vengkeat Chea, and Martin Schulz. AtomFlow: An End-to-End FPGA-Based Control Architecture for Neutral Atom Quantum Computers. arXiv:2607.11490, 2026. Accepted for IEEE QCE 2026.arxiv.org/abs/2607.11490
  65. [65]Unnati Akhouri. Classically Accelerated Readout for Neutral Atoms with CPU/GPU Integration. https://www.quantum-machines.co/blog/classically-accelerated-readout-neutral-atoms-cpu-gpu-readout/, 2026. Quantum Machines blog, June 2026; accessed October 2026.
  66. [66]David Poulin and Yeojin Chung. On the iterative decoding of sparse quantum codes. Quantum Information and Computation, 8(10):987–1000, 2008.arxiv.org/abs/0801.1241
  67. [67]Nithin Raveendran and Bane Vasić. Trapping Sets of Quantum LDPC Codes. Quantum, 5:562, 2021. https://doi.org/10.22331/q-2021-10-14-562.
  68. [68]Pavel Panteleev and Gleb Kalachev. Degenerate Quantum LDPC Codes With Good Finite Length Performance. Quantum, 5:585, 2021. https://doi.org/10.22331/q-2021-11-22-585.
  69. [69]Joschka Roffe, David R. White, Simon Burton, and Earl Campbell. Decoding across the quantum low-density parity-check code landscape. Physical Review Research, 2:043423, 2020. https://doi.org/10.1103/PhysRevResearch.2.043423.
  70. [70]Xiu-Zhe Luo, David Plankensteiner, Kai-Hsin Wu, Rob Patterson, Alexander Schuckert, Oriol Rubies-Bigorda, Refaat Ismail, Jonhas Colina, Neelay Fruitwala, Danylo Lykov, Tyson Jones, Stefan Krastanov, Rafael Haenel, Stefan Ostermann, and Sheng-Tao Wang. PPVM: A circuit simulation framework for digital twins of quantum processors. arXiv preprint, 2026. arXiv:2610.18225.arxiv.org/abs/2610.18225
  71. [71]E. Knill. Quantum computing with realistically noisy devices. Nature, 434(7029):39–44, 2005. https://doi.org/10.1038/nature03350.
  72. [72]L. Riesebos, X. Fu, S. Varsamopoulos, C. G. Almudever, and K. Bertels. Pauli Frames for Quantum Computer Architectures. In Proceedings of the 54th Annual Design Automation Conference 2017 (DAC ’17), pages 1–6, Austin, TX, USA, 2017. ACM. Article 76. https://doi.org/10.1145/3061639.3062300.
  73. [73]Xinyu Tan, Fang Zhang, Rui Chao, Yaoyun Shi, and Jianxin Chen. Scalable Surface-Code Decoders with Parallelization in Time. PRX Quantum, 4(4):040344, 2023. https://doi.org/10.1103/PRXQuantum.4.040344.
  74. [74]Oscar Ferraz, Bruno Coutinho, Gabriel Falcao, Marco Gomes, Francisco A. Monteiro, and Vitor Silva. GPU-Accelerated Syndrome Decoding for Quantum LDPC Codes below the 63 μs Latency Threshold. In 2025 59th Asilomar Conference on Signals, Systems, and Computers, pages 1878–1882, Pacific Grove, CA, USA, 2025. IEEE. https://doi.org/10.1109/IEEECONF67917.2025.11443687.
  75. [75]Oles Shtanko, Saswata Roy, Shashwat Kumar, and Zlatko Minev. Measure now, mitigate later: Virtual error cancellation for logical quantum circuits. arXiv preprint, 2026. arXiv:2610.12400.arxiv.org/abs/2610.12400
  76. [76]Yue Wu, Shimon Kolkowitz, Shruti Puri, and Jeff D. Thompson. Erasure conversion for fault-tolerant quantum computing in alkaline earth Rydberg atom arrays. Nature Communications, 13:4657, 2022. https://doi.org/10.1038/s41467-022-32094-6.
  77. [77]Dian Jing, Pablo Sala, Liang Jiang, and Ruben Verresen. Intrinsic heralding and optimal decoders for non-Abelian topological order. Physical Review Letters, 2026. https://doi.org/10.1103/ccj7-ctd8.
  78. [78]Ben Barber, Kenton M. Barnes, Tomasz Bialas, Okan Buğdaycı, Earl T. Campbell, Neil I. Gillespie, Kauser Johar, Ram Rajan, Adam W. Richardson, Luka Skoric, Canberk Topal, Mark L. Turner, and Abbas B. Ziad. A real-time, scalable, fast and highly resource efficient decoder for a quantum computer. Nature Electronics, 8(1):84–91, 2025. https://doi.org/10.1038/s41928-024-01319-5.
  79. [79]Namitha Liyanage, Yue Wu, Alexander Deters, and Lin Zhong. Scalable Quantum Error Correction for Surface Codes Using FPGA. In 2023 IEEE International Conference on Quantum Computing and Engineering (QCE), pages 916–927, Bellevue, WA, USA, 2023. IEEE. https://doi.org/10.1109/QCE57702.2023.00106.
  80. [80]Thilo Maurer, Markus Bühler, Michael Kröner, Frank Haverkamp, Tristan Müller, Drew Vandeth, and Blake R. Johnson. Real-time decoding of the gross code memory with FPGAs. arXiv preprint, 2025. arXiv:2510.21600.arxiv.org/abs/2510.21600
  81. [81]Atom Computing and Collaborators. Quantum error correction with the toric code. arXiv:2606.04079, 2026.arxiv.org/abs/2606.04079
  82. [82]Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C. Bardin, Rami Barends, et al. Quantum supremacy using a programmable superconducting processor. Nature, 574:505–510, 2019. https://doi.org/10.1038/s41586-019-1666-5.
  83. [83]Marcello Benedetti, Delfina Garcia-Pintos, Oscar Perdomo, Vicente Leyton-Ortega, Yunseong Nam, and Alejandro Perdomo-Ortiz. A generative modeling approach for benchmarking and training shallow quantum circuits. npj Quantum Information, 5:45, 2019. https://doi.org/10.1038/s41534-019-0157-8.
  84. [84]Brian Coyle, Daniel Mills, Vincent Danos, and Elham Kashefi. The Born supremacy: quantum advantage and training of an Ising Born machine. npj Quantum Information, 6:60, 2020. https://doi.org/10.1038/s41534-020-00288-9.
  85. [85]Mohammad H. Amin, Evgeny Andriyash, Jason Rolfe, Bohdan Kulchytskyy, and Roger Melko. Quantum Boltzmann Machine. Physical Review X, 8:021050, 2018. https://doi.org/10.1103/PhysRevX.8.021050.
  86. [86]Christa Zoufal, Aurélien Lucchi, and Stefan Woerner. Quantum Generative Adversarial Networks for learning and loading random distributions. npj Quantum Information, 5:103, 2019. https://doi.org/10.1038/s41534-019-0223-2.
  87. [87]Hsin-Yuan Huang, Michael Broughton, Norhan Eassa, Hartmut Neven, Ryan Babbush, and Jarrod R. McClean. Generative quantum advantage for classical and quantum problems. arXiv:2509.09033, 2025.arxiv.org/abs/2509.09033
  88. [88]David Layden, Guglielmo Mazzola, Ryan V. Mishmash, Mario Motta, Pawel Wocjan, Jin-Sung Kim, and Sarah Sheldon. Quantum-enhanced Markov chain Monte Carlo. Nature, 619:282–287, 2023. https://doi.org/10.1038/s41586-023-06095-4.
  89. [89]Milan Kornjača, Hong-Ye Hu, Chen Zhao, Jonathan Wurtz, Phillip Weinberg, Majd Hamdan, et al. Large-scale quantum reservoir learning with an analog quantum computer. arXiv:2407.02553, 2024.arxiv.org/abs/2407.02553
  90. [90]Nicholas S. DiBrita, Daniel Leeds, Yuqian Huo, Jason Ludmir, and Tirthak Patel. ReCon: Reconfiguring Analog Rydberg Atom Quantum Computers for Quantum Generative Adversarial Networks. In Proceedings of the 43rd IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2024. https://doi.org/10.1145/3676536.3676697.
  91. [91]Ewin Tang. A quantum-inspired classical algorithm for recommendation systems. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC), pages 217–228, 2019. https://doi.org/10.1145/3313276.3316310.
  92. [92]Jarrod R. McClean, Sergio Boixo, Vadim N. Smelyanskyi, Ryan Babbush, and Hartmut Neven. Barren plateaus in quantum neural network training landscapes. Nature Communications, 9:4812, 2018. https://doi.org/10.1038/s41467-018-07090-4.
  93. [93]Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd. Quantum machine learning. Nature, 549:195–202, 2017. https://doi.org/10.1038/nature23474.
  94. [94]M. Cerezo, Guillaume Verdon, Hsin-Yuan Huang, Lukasz Cinicio, and Patrick J. Coles. Challenges and opportunities in quantum machine learning. Nature Computational Science, 2:567–576, 2022. https://doi.org/10.1038/s43588-022-00311-3.
  95. [95]Maria Schuld and Nathan Killoran. Is quantum advantage the right goal for quantum machine learning? PRX Quantum, 3:030101, 2022. https://doi.org/10.1103/PRXQuantum.3.030101.
  96. [96]M. Cerezo, Andrew Arrasmith, Ryan Babbush, Simon C. Benjamin, Suguru Endo, Keisuke Fujii, Jarrod R. McClean, Kosuke Mitarai, Xiao Yuan, Lukasz Cincio, and Patrick J. Coles. Variational quantum algorithms. Nature Reviews Physics, 3:625–644, 2021. https://doi.org/10.1038/s42254-021-00348-9.
  97. [97]Antonio D. Córcoles, Maika Takita, Ken Inoue, Scott Lekuch, Zlatko K. Minev, Jerry M. Chow, and Jay M. Gambetta. Exploiting Dynamic Quantum Circuits in a Quantum Algorithm with Superconducting Qubits. Physical Review Letters, 127:100501, 2021. https://doi.org/10.1103/PhysRevLett.127.100501.
  98. [98]Elisa Bäumer, Vinay Tripathi, Derek S. Wang, Patrick Rall, Edward H. Chen, Swarnadeep Majumder, Alireza Seif, and Zlatko K. Minev. Efficient Long-Range Entanglement Using Dynamic Circuits. PRX Quantum, 5:030339, 2024. https://doi.org/10.1103/PRXQuantum.5.030339.
  99. [99]Michael Foss-Feig, Arkin Tikku, Tsung-Cheng Lu, Karl Mayer, Mohsin Iqbal, Thomas M. Gatterman, Justin A. Gerber, Kevin Gilmore, et al. Experimental demonstration of the advantage of adaptive quantum circuits. arXiv:2302.03029, 2023.
  100. [100]Mohsin Iqbal, Nathanанант Tანტivasadakarn, Ruben Verresen, Sara L. Campbell, Joan M. Dreiling, Caroline Figgatt, John P. Gaebler, Jacob Johansen, et al. Non-Abelian topological order and anyons on a trapped-ion processor. Nature, 626:505–511, 2024. https://doi.org/10.1038/s41586-023-06934-4.
  101. [101]Yuri Alexeev, Maximilian Amsler, Paul Baity, Marco Antonio Barroca, Sanzio Bassini, Torey Battelle, Daan Camps, David Casanova, et al. Quantum-centric supercomputing for materials science: A perspective on challenges and future directions. Future Generation Computer Systems, 160:666–710, 2024. https://doi.org/10.1016/j.future.2024.04.060.
  102. [102]Shuai Wang, Wenjun Zhang, Tao Zhang, Shuyao Mei, Yuqing Wang, Jiazhong Hu, and Wenlan Chen. Accelerating the assembly of defect-free atomic arrays with maximum parallelisms. Physical Review Applied, 19:054032, 2023. https://doi.org/10.1103/PhysRevApplied.19.054032.
  103. [103]Cheng Sheng, Jiayi Hou, Xiaodong He, Peng Xu, Kunpeng Wang, Jun Zhuang, Xiao Li, Min Liu, Jin Wang, and Mingsheng Zhan. Efficient preparation of 2D defect-free atom arrays with near-fewest sorting-atom moves. Physical Review Research, 3:023008, 2021. https://doi.org/10.1103/PhysRevResearch.3.023008.
  104. [104]Daniel Bochen Tan, Dolev Bluvstein, Mikhail D. Lukin, and Jason Cong. Compiling quantum circuits for dynamically field-programmable neutral atoms array processors. Quantum, 8:1281, 2024. https://doi.org/10.22331/q-2024-03-14-1281.
  105. [105]Jacob P. Covey, Ivaylo S. Madjarov, Alexandre Cooper, and Manuel Endres. 2000-times repeated imaging of strontium atoms in clock-magic tweezer arrays. Physical Review Letters, 122(17):173201, 2019. https://doi.org/10.1103/PhysRevLett.122.173201.
  106. [106]Jonas Winklmann, Andrea Alberti, and Martin Schulz. Comparison of atom detection algorithms for neutral atom quantum computing. In Proceedings of the 2024 IEEE International Conference on Quantum Computing and Engineering (QCE), 2024. https://doi.org/10.1109/QCE60285.2024.00124.
  107. [107]Javier Duarte, Song Han, Philip Harris, Sergo Jindariani, Edward Kreinar, Benjamin Kreis, Jennifer Ngadiuba, Maurizio Pierini, Ryan Rivera, Nhan Tran, and Zhenbin Wu. Fast inference of deep neural networks in FPGAs for particle physics. Journal of Instrumentation, 13:P07027, 2018. https://doi.org/10.1088/1748-0221/13/07/P07027.
  108. [108]Thea Aarrestad, Vladimir Loncar, Nicolò Ghielmetti, Maurizio Pierini, Sioni Summers, Jennifer Ngadiuba, Christoffer Pettersson, Hampus Linander, Yutaro Iiyama, Giuseppe Di Guglielmo, Javier Duarte, Philip Harris, Dylan Rankin, Sergo Jindariani, Kevin Pedro, Nhan Tran, Mia Liu, Edward Kreinar, Zhenbin Wu, and Duc Hoang. Fast convolutional neural networks on FPGAs with hls4ml. Machine Learning: Science and Technology, 2:045015, 2021. https://doi.org/10.1088/2632-2153/ac0ea1.
  109. [109]Chang Sun, Zhiqiang Que, Thea K. Årrestad, Vladimir Loncar, Jennifer Ngadiuba, Wayne Luk, and Maria Spiropulu. HGQ: High granularity quantization for real-time neural networks on FPGAs. In Proceedings of the 2026 ACM/SIGDA International Symposium on Field Programmable Gate Arrays (FPGA ’26), 2026. https://doi.org/10.1145/3748173.3779200.
  110. [110]Claudionor N. Coelho, Aki Kuusela, Shan Li, Hao Zhuang, Thea Aarrestad, Vladimir Loncar, Jennifer Ngadiuba, Maurizio Pierini, Adrian Alan Pol, and Sioni Summers. Automatic heterogeneous quantization of deep neural networks for low-latency inference on the edge for particle detectors. Nature Machine Intelligence, 3, 2021. https://doi.org/10.1038/s42256-021-00356-5.
  111. [111]Katya Govorkova, Julian Garcia Pardinas, Vladimir Loncar, Victoria Nguyen, Sebastian Schmitt, Marco Pizzichemi, Loris Martinazzoli, and Eluned Anne Smith. Enabling low-latency machine learning on radiation-hard FPGAs with hls4ml. Machine Learning: Science and Technology, 7:045024, 2026. https://doi.org/10.1088/2632-2153/ae8218.
  112. [112]Quantum Machines. Accelerated Quantum Supercomputing with NVIDIA DGX Quantum: Real-Time GPU-CPU-QPU Integration from the Dirac Lab. https://www.quantum-machines.co/resources/blog/accelerated-quantum-supercomputing-nvidia-dgx-quantum/, 2025. accessed September 2026.
  113. [113]Advanced Micro Devices, Inc. ZCU216 Evaluation Board User Guide (UG1390), v1.2. https://docs.amd.com/r/en-US/ug1390-zcu216-eval-bd, 2023. accessed October 2026.
  114. [114]Alessandro Muzi Falconi, Riccardo Panza, Sara Sbernardori, Riccardo Forti, Ralf Klemt, Omar Abdel Karim, Matteo Marinelli, and Francesco Scazza. Microsecond-scale high-survival and number-resolved detection of ytterbium atom arrays. Physical Review Letters, 135:203402, 2025. https://doi.org/10.1103/n3bg-7yw7.
  115. [115]Japan Industrial Imaging Association (JIIA). CoaXPress Standard, Version 2.1 (JIIA CXP-001-2021). https://jiia.org/en/coaxpress-standard-version-2-1-has-been-released/, 2021. accessed October 2026.
  116. [116]NVIDIA Corporation. GPUDirect RDMA – CUDA Documentation. https://docs.nvidia.com/cuda/gpudirect-rdma/. accessed October 2026.
  117. [117]NVIDIA Corporation. NVIDIA NVLink Fusion. https://www.nvidia.com/en-us/data-center/nvlink-fusion/. accessed October 2026.

Paper details

vlnc:W_yansr55g
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