Wave-Based Dispatch for Circuit Cutting in Hybrid HPC--Quantum Systems
A new scheduling framework treats quantum circuit fragments like ordinary HPC jobs, making today's noisy quantum hardware easier to integrate into real supercomputer workflows.
The Thesis
Running useful quantum algorithms today requires splitting large circuits into smaller pieces — a technique called circuit cutting — because current quantum processors, known as NISQ (Noisy Intermediate-Scale Quantum) devices, can't reliably handle many qubits at once. The problem is that existing tools bundle the cutting logic tightly with the execution machinery, so HPC centers can't apply their mature job-scheduling policies to quantum workloads the way they do for ordinary computing jobs. This paper proposes DQR (Dynamic Queue Router), a runtime layer that wraps each circuit fragment in a standard descriptor and schedules it like any other task, enabling quantum and classical jobs to coexist in the same production queue. The catch: the demonstration is a single 32-qubit test circuit on one supercomputer, so the generality claims rest on a narrow experimental base.
Catalyst
Two things converged: real quantum hardware is now available as on-premises or cloud-accessible backend nodes at HPC centers (the paper uses both a local QPU at CESGA and IBM's cloud-based Torino processor), and circuit cutting has matured enough that its overhead is quantifiable and manageable. A year or two ago, neither the hardware access model nor the cutting libraries were stable enough to build a production scheduling layer on top of them.
What's New
Earlier frameworks such as Qiskit's circuit-cutting toolkit and Mitiq treat fragment generation and fragment execution as a single coupled pipeline, meaning the scheduler that runs the fragments must understand quantum circuit structure. DQR instead wraps each fragment in a backend-agnostic descriptor — a plain metadata envelope that exposes structural properties like qubit count and gate depth without requiring the scheduler to parse quantum code — so any standard HPC job queue can treat fragments as ordinary tasks. The claimed advantage is that HPC centers can apply existing resource-management policies, failover logic, and priority rules without modifying their quantum-aware code.
The Counter
DQR is solving a workflow integration problem, not a quantum computing problem. If NISQ hardware improves to the point where circuit cutting is no longer necessary — for instance, via better error correction — the entire scheduling layer becomes irrelevant. Even accepting that circuit cutting will remain necessary for years, the paper's performance numbers come from a single test case on a single machine, which is not enough to conclude that wave-based dispatch is the right abstraction for production HPC centers. HPC schedulers like SLURM are already highly configurable; it's not obvious that the bottleneck is the scheduling layer rather than the raw quality and availability of QPU time. The failover story also papers over a deep problem: if the local QPU can't handle a fragment, routing it to a classical simulator may cost more compute than the quantum approach was supposed to save. Finally, IBM, Quantinuum, and national labs all have their own integration roadmaps, and a two-institution academic prototype is unlikely to become the de facto standard without significant additional development and community adoption.
Longs
- IBM (NYSE: IBM) — IBM Torino QPU is one of the two backends directly tested in the paper, and DQR-style middleware increases the utility of IBM's cloud quantum access model.
Shorts
- Vendors selling vertically integrated quantum-classical middleware stacks (e.g., proprietary orchestration layers bundled with QPU access) lose differentiation if a lightweight open framework can replace their scheduling logic with standard HPC tooling.
Enablers (Picks & Shovels)
- Qiskit (IBM open-source quantum SDK) — provides the circuit-cutting primitives DQR wraps and schedules
- SLURM and PBS/Torque HPC job schedulers — the existing infrastructure DQR is designed to plug into without modification
- CESGA Qmio supercomputer — the specific on-premises testbed where the production integration is demonstrated
Private Watchlist
- Qedma — specializes in quantum error mitigation and circuit optimization, a natural complement to fragment scheduling middleware
- Classiq — builds quantum circuit compilation tools whose output fragments would be the direct input to a DQR-style scheduler
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. 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.