Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems

summary

The gist

Hybrid High-performance Computing (HPC)–quantum workloads based on circuit cutting decompose large quantum circuits into independent fragments…

In short

Existing quantum circuit cutting methods are tightly linked to execution, blocking mature resource management for NISQ workloads in hybrid HPC-QC systems. This work introduces Dynamic Queue Router (DQR), a runtime framework that decouples cutting from orchestration by treating circuit fragments as schedulable units. It uses a wave-based dispatch mechanism to enable pipeline concurrency and handles backend failures transparently, allowing HPC centers to manage quantum tasks effectively.

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 used across episodes

This episode discusses

The paper

Wave-Based Dispatch for Circuit Cutting in Hybrid HPC-Quantum Systems · Read on arXiv

Universitat Oberta de Catalunya · Barcelona Supercomputing Center

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.

DOI: 10.1016/j.future.2026.108903

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.

More episodes

← Home