Triage: An Adaptive Parallel Window Decoding Scheduler for Real-time Fault-Tolerant Quantum Computation

Abstract: Fault-tolerant quantum computation (FTQC) critically depends on real-time classical decoding, which is rapidly emerging as a system bottleneck. As quantum systems scale, decoding latency and throughput limitations lead to exponential syndrome backlogs and logical operation stalls. While hardware accelerators and parallel windowing offer pathways to speed up decoding, dynamically deploying a finite pool of decoders across a vast quantum error correction architecture remains an unresolved resource allocation problem. To address this, we formulate FTQC decoding as a constrained dynamic scheduling problem by utilizing a spatio-temporal framework based on slices. We propose Triage, a dual-mode architecture that mitigates operation stalls by adaptively combining a cost-efficient heuristic scheduler with a priority-aware emergency mode to rapidly resolve the causal cone of critical operations. Our evaluation shows that Triage maintains low algorithm stalls and logical error rates even under scarce classical resource constraints. Across various benchmarks, Triage achieves an average logical error rate reduction of 52.6% compared to standard temporal parallelism, enabling an efficient classical control plane for scalable FTQC architectures.

• The paper formalizes and resolves the real-time decoder scheduling problem by introducing an adaptive parallel window decoding scheduler that reduces logical error rates by 52.6%.
• It implements dual modes—steady mode for routine backlogs and emergency mode for urgent tasks—thereby optimizing resource allocation under stringent constraints.
• The framework demonstrates robust performance gains and resilience to latency variations, setting a new baseline for resource-aware quantum error correction.

Triage: An Adaptive Parallel Window Decoding Scheduler for Real-time Fault-Tolerant Quantum Computation

Introduction

Scaling fault-tolerant quantum computation (FTQC) from academic demonstration to practical execution is increasingly impaired by classical decoding bottlenecks. Decoders must handle exponentially growing syndrome streams from large quantum error-correcting surface codes in real time. Classical resource limitations on decoder throughput now directly constrain achievable logical error rates (LER) and, by extension, the fidelity and speed of FTQC. The core contribution of "Triage: An Adaptive Parallel Window Decoding Scheduler for Real-time Fault-Tolerant Quantum Computation" (2605.04459) is the formalization and comprehensive resolution of the real-time decoder allocation and scheduling problem for FTQC systems under stringent resource constraints.

Quantum Error Correction and Decoding Constraints

Quantum error correction (QEC), particularly using surface codes, is the established route to robust qubit memories and computation. In these architectures, stabilizer measurements produce continuous syndrome streams that must be decoded to infer and correct errors. Efficient classical tracking via the Pauli frame is sufficient for Clifford gates; however, non-Clifford operations, especially the T-gate, induce synchronization points requiring resolved Pauli frames over large correlated regions to avoid deadlocks and logical stalls. The implementation of non-Clifford gates, notably magic state injection and gate teleportation, forces synchronous physical corrections, exacerbating decoding resource demands.

Figure 1: Triage’s spatio-temporal prioritization outperforms traditional decoding, minimizing resource-induced idle layers and operation stalls for resource-constrained FTQC architectures.

Window decoding techniques—temporal, spatial, or spatio-temporal—offer parallelism but also introduce complex resource allocation problems, especially when the decoder pool is limited ($M < N$, with $M$ decoders and $N$ logical patches). The bursty and correlated workload, especially near non-Clifford gates, render naive static or greedy decoder allocations suboptimal.

Scheduler Abstraction: Slices and Causal Cones

Triage introduces a fine-grained "slice" abstraction, in which the computation is decomposed into space-time tiles representing local decoding tasks bound by spatial and temporal dependency constraints. Each slice is associated with a state machine, evolving from syndrome generation (PENDING) through decoding (ASSIGNED) to completion (COMPLETED).

Critical to multi-qubit and non-Clifford operations is the emergence of large causal cones: spatio-temporal regions containing all unresolved slices required to update a Pauli frame. The causal cone framework formalizes synchronization dependencies, enabling the scheduler to recognize and dynamically prioritize time-sensitive decoding workloads.

Figure 3: Spatio-temporal partitioning of a lattice surgery; large operation volumes are decomposed into mutually constrained, parallelizable slices.

Figure 5: Illustration of a causal cone after a T-gate; this region encapsulates the minimum necessary set of slices that must be decoded to resolve a Clifford correction.

Triage Scheduler Design and Algorithmics

Triage comprises a dual-mode online architecture built on an offline analysis/compilation phase. The offline compiler emits a timeline of annotated slices and their dependency graph. During real-time execution, Triage manages decoder assignment via two tightly integrated modes:

• Steady Mode: Utilizes a parametric heuristic combining FIFO, EDF, and Min-Degree (MDF) priorities. The urgency and cost-efficiency of each slice dynamically determine selection. This mode clears backlogs in predictable, uncongested schedule regions.
• Emergency Mode: Triggered when a critical slice’s deadline nears, causing Triage to compute (via an $O(n\log n)$ coloring/event simulation) a decoding plan that resolves the urgent causal cone before synchronization is required. Emergency mode prioritizes minimum latency for critical operations at the expense of overall throughput, and its scope is adaptively limited (ScopeCap) to control scheduling overhead.

  Figure 7: High-level architecture of Triage’s scheduling stack, integrating static timeline analysis and dynamic event-driven scheduling for FTQC.

  

  Figure 2: State transition diagram for a slice’s lifecycle from syndrome generation to decoding completion within the Triage framework.

Key features include opportunistic backfilling, where idle decoders (unused in the emergency plan) are dynamically assigned causally disjoint slices to maximize system throughput without impacting synchronization-critical plans.

Figure 4: Decoder utilization and the benefit of opportunistic backfilling; unused decoders are dynamically scheduled with non-critical tasks to avoid compute waste.

Numerical Evaluation and Scheduler Frontier

Comprehensive simulation demonstrates significant gains of Triage on diverse FTQC benchmarks (arithmetic, variational, Clifford+T circuits):

• Idle Step Reduction & LER: Triage achieves a mean LER reduction of 52.6% over baseline parallel window decoders under resource-constraint scenarios ($M \ll N$ or $\tau_{dec} > \tau_{gen}$). The advantage is maximal where both decoder count and speed are limited.

Figure 6: LER and idle layer comparison across benchmarks. Triage consistently reduces logical error rates, particularly in resource-limited scenarios.

• Design Space Optimality: In decoder pools ranging from severely resource-constrained to ample, Triage defines a lower-bound performance frontier. SWIPER is competitive in parallelism-rich (resource-abundant) domains but is consistently outperformed by Triage as resources become limited or the workload is dominated by critical regions.

  Figure 8: Triage’s performance defines the lower boundary of inserted idle layers across all decoder count/throughput configurations (darker is worse performance).

  

  Figure 13: Scheduler optimality map—Triage (red) dominates in resource-constrained regimes, while speculative strategies outperform only in the high-resource limit.

• Stochastic Latency and Overhead: Triage exhibits robust resilience to heavy-tailed, real-world decoder latency variations. Scheduling overhead is controlled and sub-millisecond per logical layer, provided the ScopeCap is not breached. Empirically, Triage with ScopeCap avoids pathological slowdowns and outperforms baseline approaches even when scheduler computation latency is included in the critical path.

Figure 15: LER robustness of Triage under increasing decoder latency jitter; performance degrades gracefully with growing real-time unpredictability.

Figure 9: Computational overhead analysis—Triage’s planning time scales as $O(n\log n)$ and is bounded by demographic limits on emergency scope.

Practical and Theoretical Implications

The Triage scheduler transforms FTQC architectural design by:

• Enabling real-time FTQC with decoder pools orders of magnitude smaller than logical qubit count, critical for physical implementations far from hardware-optimal decoder platforms.
• Directly connecting classical scheduling policy to final quantum logical error rates, bridging previously uncoupled domains of resource-aware scheduling and quantum error correction.
• Enabling future classical-quantum co-design, where algorithm/architecture-aware compilers can further optimize scheduling by surfacing resource bottlenecks at compile time.

From a theoretical standpoint, the Triage abstraction provides a rigorous approach to FTQC workload analysis, offering a framework to formally characterize worst-case spike loads (from causal cones) and the efficacy of hybrid dynamic scheduling modes.

Future Directions

While demonstrated for surface-code architectures, the spatio-temporal window/slice model of Triage can generalize to more exotic QLDPC codes or subsystem codes. The next research avenue includes tight integration of quantum circuit compilers with classical resource-aware schedulers, allowing circuits to be compiled with explicit knowledge of decoding costs and classical resource bottlenecks. Further, real-hardware deployment may require specialized hardware accelerators or FPGA implementations of Triage’s scheduling policies.

Conclusion

The Triage framework, by precisely formalizing and efficiently solving the adaptive scheduling of window decoders for real-time FTQC, delivers substantial improvements in system-level fidelity and throughput under practical resource constraints. Its abstraction and scheduler architecture establish a new baseline for future FTQC platforms, supporting scalable, realistic quantum computing beyond theoretical feasibility.