Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems".
Jane: Here's the gist of the paper. Hybrid High-performance Computing (HPC)–quantum workloads based on circuit cutting decompose large quantum circuits into independent fragments, but existing frameworks tightly couple cutting logic to execution orchestration, preventing HPC centers from applying mature resource management policies to Noisy Intermediate-Scale Quantum (NISQ) workloads The framework introduces DQR (Dynamic Queue Router), a runtime framework that bridges this gap by treating circuit fragments as first-class schedulable units The Core Problem Addressed Circuit cutting decomposes large quantum circuits into smaller fragments evaluated independently and recombined via classical post-processing Existing frameworks tightly couple cutting logic to execution orchestration, preventing HPC centers from applying mature resource management policies to Noisy Intermediate-Scale Quantum (NISQ) workloads This coupling prevents the application of mature scheduling, fault tolerance, and heterogeneous routing policies to quantum workloads The paper presents a systems framework that bridges this gap by decoupling quantum circuit cutting from execution orchestration in hybrid HPC–QC environments The Proposed Solution Architecture The system introduces a standardized fragment abstraction, an immutable tuple representing structural properties like qubit count, depth, gates, and reconstruction coefficient This allows for backend-agnostic routing without requiring execution layers to parse quantum code The framework utilizes a wave-based coordinator that achieves pipeline concurrency via non-blocking polling and handles transient QC failures through retry/failover mechanisms The Wave-Based Dispatch Mechanism Execution proceeds in discrete dispatch waves via a fragment state machine where fragments transition from PENDING to DISPATCHED upon assignment to a backend The coordinator non-blocking polls completions from HPC and QC backends, handles failures by retrying transient errors or triggering failover for permanent ones Capacity is refreshed at each wave, and the planner generates a dispatch plan respecting fragment labels and routing policies The wave counter supports iteration-aware policies, prioritizing scarce QPU slots in later waves Performance Evaluation Findings Experiments on a 32-qubit Hardware-Efficient Ansatz (HEA) circuit demonstrate makespan improvements over a monolithic CPU baseline Policy A achieves a 1.11× makespan speedup over the monolithic CPU baseline while co-executing fragments on the high-latency IBM Torino (t̄QPU ≈ 13.0 s, Φ = 2.08) The DQR framework demonstrates that coordination overhead remains bounded at 5% of DQR-time for deeper circuits The sensitivity analysis confirms backend swapability, showing that substituting t̄QPU = 4.5–6.6 s (Qmio) reduces makespan by 104.
Title and authors: Tom: So let’s talk about that title again—"Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems"—and who wrote it. It immediately tells you this is focused on the orchestration layer for these hybrid setups, not just the quantum hardware itself.
Jane: The authors are from Barcelona, working with the Barcelona Supercomputing Center and the UOC, which suggests a strong focus on integrating cutting-edge classical high performance computing with quantum capabilities in one place.
Lu: What’s interesting is that they are presenting this solution as a production-ready implementation on the CESGA Qmio supercomputer, which means it’s not just some theoretical idea; it’s been tested in a real, large system environment.
Meng: From my side, I want to know how much overhead this adds when we try to run these fragments across different backends—does this framework introduce significant latency that hurts our overall throughput on the supercomputer?
Lalam: The paper mentions they introduced a standardized fragment descriptor, which is like an immutable tuple that describes structural properties like qubit count and circuit depth without needing the execution layers to parse the actual quantum code.
Tom: That sounds promising for backend agnostic routing because it lets you route based on structure rather than having to understand the specific quantum language of each backend.
The paper's summary: Jane: The core idea they’re pushing is that circuit cutting decomposes those large quantum circuits into independent fragments, and then these fragments are evaluated by different parts of the system independently before being put back together later.
Tom: And the key insight here is treating those pieces not as just data, but as first class schedulable units within this new DQR framework. This allows for much finer control over how they interact with the classical and quantum resources available.
Lu: The framework uses a wave-based coordinator that achieves pipeline concurrency through non-blocking polling, which means it can be working on one piece while simultaneously assigning another piece to a backend.
Meng: But what about reliability? Since we’re talking NISQ hardware, failures happen all the time, so how does this system handle those transient quantum computer failures when it’s mid-execution?
Lalam: They built in mechanisms for retry and failover during that process, which means if a piece fails on the quantum computer, the coordinator tries to send it somewhere else or retries it.
The paper's improvements: Tom: One of the biggest improvements they highlight is this wave-based dynamic orchestration, where you get pipeline concurrency via non-blocking polling, which means new dispatches can happen while prior fragments are still executing.
Jane: That’s important because it means the concurrency level isn't limited by just one thing; it’s bounded only by how many computational units you actually have available across the whole system.
Lu: They also introduced this fragment abstraction, which is that standardized immutable descriptor tuple we talked about earlier, exposing structural properties like depth and gates without needing any execution layers to parse quantum code.
Meng: That sounds like it solves the problem of being tied to a specific backend; if you have a new type of quantum chip tomorrow, you just need to define its properties in that descriptor and the routing layer handles it.
Lalam: And they showed that this system can perform transparent per-fragment failover recovery, rerouting tasks from the local quantum processor to classical simulators if there’s an incompatibility at the hardware level, all without having to restart the entire pipeline.
Conclusion: Tom: So wrapping things up on "Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems," this framework essentially decouples circuit cutting from execution orchestration by treating fragments as schedulable units and using a wave-based coordinator for dynamic scheduling.
Jane: The implication is that HPC centers can finally apply mature resource management policies to NISQ workloads, which means we can start deploying these complex quantum algorithms much more practically in existing production infrastructure.
Lu: For the long term, this approach allows us to evolve cutting algorithms or switch to different heterogeneous backend technologies without rebuilding the entire execution stack from scratch because of that standardized fragment descriptor.
Meng: From a deployment standpoint, it addresses the need for dynamic replanning when dealing with noisy backends by treating these fragments as explicit schedulable units with defined requirements, which is crucial for scaling up reliable AI workloads.
Lalam: I think what’s most striking is how this system adapts execution strategies to those different HPC-QC infrastructures by making the fragmented circuits first class schedulable units with explicit resource requirements, tackling that dynamic replanning issue on unreliable backends.
Universitat Oberta de Catalunya · Barcelona Supercomputing Center
cs.DC
Submitted: 2026-04-16
Updated: 2026-11-05
Journal ref: Future Generation Computer Systems, pp. 108903, Jan. 2026. ISSN: 0167-739X
DOI: 10.1016/j.future.2026.108903
Code: https://github.com/bsc-wdc/qdislib
License: http://creativecommons.org/licenses/by-nc-sa/4.0/
Importance score: 82/100
The gist: Hybrid High-performance Computing (HPC)–quantum workloads based on circuit cutting decompose large quantum circuits into independent fragments…
Key concepts
- Circuit Cutting
- This process breaks down a very large quantum circuit into many smaller, independent pieces or fragments. These fragments are evaluated separately and then put back together later. The goal is to make these smaller pieces easier to manage and schedule on different hardware.
- Fragment Abstraction
- A standardized, unchanging description (a tuple) that defines the essential structural properties of a quantum fragment, such as how many qubits it has or its depth. This abstraction allows the system to route fragments to any backend without needing complex code parsing for every single piece of quantum logic.
- Wave-Based Dispatch
- The execution process is organized into discrete 'waves.' The coordinator polls backends non-blockingly, and when a fragment is ready, it moves from pending to dispatched. This wave structure ensures that new tasks can be scheduled while previous ones are running, maximizing the use of available computational resources.
- Wave Counter Policy
- This mechanism controls how execution waves are prioritized. It allows planners to create iteration-aware policies that prioritize scheduling on scarce QPU slots in later waves, ensuring efficient resource allocation across the entire circuit during execution.
Terminology
Summary
Hybrid High-performance Computing (HPC)–quantum workloads based on circuit cutting decompose large quantum circuits into independent fragments, but existing frameworks tightly couple cutting logic to execution orchestration, preventing HPC centers from applying mature resource management policies to Noisy Intermediate-Scale Quantum (NISQ) workloads The framework introduces DQR (Dynamic Queue Router), a runtime framework that bridges this gap by treating circuit fragments as first-class schedulable units
The Core Problem Addressed
Circuit cutting decomposes large quantum circuits into smaller fragments evaluated independently and recombined via classical post-processing Existing frameworks tightly couple cutting logic to execution orchestration, preventing HPC centers from applying mature resource management policies to Noisy Intermediate-Scale Quantum (NISQ) workloads This coupling prevents the application of mature scheduling, fault tolerance, and heterogeneous routing policies to quantum workloads The paper presents a systems framework that bridges this gap by decoupling quantum circuit cutting from execution orchestration in hybrid HPC–QC environments
The Proposed Solution Architecture
The system introduces a standardized fragment abstraction, an immutable tuple representing structural properties like qubit count, depth, gates, and reconstruction coefficient This allows for backend-agnostic routing without requiring execution layers to parse quantum code The framework utilizes a wave-based coordinator that achieves pipeline concurrency via non-blocking polling and handles transient QC failures through retry/failover mechanisms
The Wave-Based Dispatch Mechanism
Execution proceeds in discrete dispatch waves via a fragment state machine where fragments transition from PENDING to DISPATCHED upon assignment to a backend The coordinator non-blocking polls completions from HPC and QC backends, handles failures by retrying transient errors or triggering failover for permanent ones Capacity is refreshed at each wave, and the planner generates a dispatch plan respecting fragment labels and routing policies The wave counter supports iteration-aware policies, prioritizing scarce QPU slots in later waves
Performance Evaluation Findings
Experiments on a 32-qubit Hardware-Efficient Ansatz (HEA) circuit demonstrate makespan improvements over a monolithic CPU baseline Policy A achieves a 1.11× makespan speedup over the monolithic CPU baseline while co-executing fragments on the high-latency IBM Torino (t̄QPU ≈ 13. p. 0 The framework introduces a backend-agnostic fragment descriptor to
expose structural properties without requiring execution layers to parse quantum code, a wave-based
coordinator that achieves pipeline concurrency via non-blocking polling, and a production-ready
implementation on the CESGA Qmio supercomputer integrating both QPUs local on-premises
(Qmio) and remote cloud (IBM Torino) backends. Experiments on a 32-qubit Hardware-Efficient
Ansatz (HEA) circuit demonstrate not only makespan improvements over a monolithic CPU baseline
but also transparent per-fragment failover recovery—specifically rerouting tasks from the local
QPU to classical simulators upon encountering hardware–level incompatibilities—without pipeline
restart. For deeper circuits, the coordination residual accounts for only 5% of the total execution
time, highlighting the framework’s scalability. These results show that DQR enables HPC centers
to integrate NISQ workloads into existing production infrastructure while preserving the flexibility to
adopt improved cutting algorithms or heterogeneous backend technologies. The framework introduces a backend-agnostic fragment descriptor to
expose structural properties without requiring execution layers to parse quantum code, a wave-based
coordinator that achieves pipeline concurrency via non-blocking polling, and a production-ready
implementation on the CESGA Qmio supercomputer integrating both QPUs local on-premises
(Qmio) and remote cloud (IBM Torino) backends. Experiments on a 32-qubit Hardware-Efficient
Ansatz (HEA) circuit demonstrate not only makespan improvements over a monolithic CPU baseline
but also transparent per-fragment failover recovery—specifically rerouting tasks from the local
QPU to classical simulators upon encountering hardware–level incompatibilities—without pipeline
restart.Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Dynamic Wave-Based Orchestration enables pipeline concurrency via non-blocking polling, allowing new dispatches to occur while prior fragments are executing, which achieves pipeline-level concurrency bounded only by available computational units.
-
Fragment Abstraction introduces a standardized immutable fragment descriptor tuple that exposes structural properties without requiring execution layers to parse quantum code, enabling backend agnostic routing and allowing cutting frameworks to evolve independently.
-
The system can perform transparent per-fragment failover recovery, specifically rerouting tasks from the local QPU to classical simulators upon encountering hardware level incompatibilities without pipeline restart.
-
The framework allows HPC centers to integrate NISQ workloads into existing production infrastructure while preserving the flexibility to adopt improved cutting algorithms or heterogeneous backend technologies.
-
The system can adapt execution strategies to heterogeneous HPC-QC infrastructures by treating fragmented quantum circuits as first class schedulable units with explicit resource requirements, addressing the need for
dynamic replanning in the face of noisy, unreliable QPU backends.
Abstract
Hybrid High-performance Computing (HPC)-quantum workloads based on circuit cutting decompose large quantum circuits into independent fragments, but existing frameworks tightly couple cutting logic to execution orchestration, preventing HPC centers from applying mature resource management policies to Noisy Intermediate-Scale Quantum (NISQ) workloads. We present DQR (Dynamic Queue Router), a runtime framework that bridges this gap by treating circuit fragments as first-class schedulable units. The framework introduces a backend-agnostic fragment descriptor to expose structural properties without requiring execution layers to parse quantum code, a wave-based coordinator that achieves pipeline concurrency via non-blocking polling, and a production-ready implementation on the CESGA Qmio supercomputer integrating both QPUs local on-premises (Qmio) and remote cloud (IBM Torino) backends. Experiments on a 32-qubit Hardware-Efficient Ansatz (HEA) circuit demonstrate not only makespan improvements over a monolithic CPU baseline but also transparent per-fragment failover recovery-specifically rerouting tasks from the local QPU to classical simulators upon encountering hardware-level incompatibilities-without pipeline restart. For deeper circuits, the coordination residual accounts for only 5% of the total execution time, highlighting the framework's scalability. These results show that DQR enables HPC centers to integrate NISQ workloads into existing production infrastructure while preserving the flexibility to adopt improved cutting algorithms or heterogeneous backend technologies.
Sources
- Describing Trotterized Time Evolutions on Noisy Quantum Computers via Static Effective Lindbladians
- Circuit knitting with classical communication
- Integration of Quantum Accelerators with High Performance Computing -- A Review of Quantum Programming Tools
- Integrating Quantum Computing Resources into Scientific HPC Ecosystems
- A Survey on Integrating Quantum Computers into High Performance Computing Systems
- High-Performance Computing with Quantum Processing Units
- Kubernetes-Orchestrated Hybrid Quantum-Classical Workflows
- The Optimization Landscape of Hybrid Quantum-Classical Algorithms: from Quantum Control to NISQ Applications
Related papers
- Programmable Probabilistic Computer with 1,000,000 p-bits
- BatchGen: An Architecture for Scalable and Efficient Batch Inference
- Seamless Reconfiguration for DAG-BFT (Technical Report)
- ELDR: Expert-Locality-Aware Decode Routing for PD-Disaggregated MoE Serving
- iScheduler: Reinforcement Learning-Driven Continual Optimization for Large-Scale Resource Investment Problems
- TIRx: A Unified Tile Primitive ML Compiler Across Heterogeneous Backends