[Paper] Q-IRIS: The Evolution of the IRIS Task-Based Runtime to Enable Classical-Quantum Workflows

Source: arXiv - 2512.13931v1

Overview

The paper introduces Q‑IRIS, a prototype that fuses the IRIS asynchronous task‑based runtime (used in high‑performance computing) with the XACC quantum programming stack. By adding a Quantum Intermediate Representation Execution Engine (QIR‑EE), the system can schedule and run quantum workloads—written in the emerging Quantum Intermediate Representation (QIR)—alongside classical tasks on heterogeneous HPC platforms that include quantum simulators or real quantum processors. This work demonstrates how a modern HPC runtime can become “quantum‑aware,” a crucial step as early quantum accelerators start appearing in supercomputing clusters.

Key Contributions

• Hybrid Runtime Integration: First‑of‑its‑kind coupling of IRIS (a proven task‑based runtime) with XACC via a dedicated QIR execution engine.
• Asynchronous Quantum Scheduling: Enables concurrent execution of multiple quantum sub‑circuits (or full circuits) alongside classical tasks, leveraging IRIS’s dependency tracking and work‑stealing scheduler.
• Circuit Cutting Demonstration: Shows how a four‑qubit circuit can be automatically partitioned into smaller sub‑circuits, reducing per‑task simulation cost and improving overall throughput.
• Proof‑of‑Concept Across Heterogeneous Backends: Runs the same QIR program on several simulators (e.g., Qiskit Aer, Intel‑QSim) and a mock quantum device, proving backend‑agnostic execution.
• Roadmap for Scaling: Identifies concrete challenges (coordinated scheduling, classical‑quantum data movement, backend diversity) that must be solved to move from prototype to production‑grade hybrid runtimes.

Methodology

1. Runtime Layering

   • IRIS provides a lightweight, asynchronous task graph where each node can be a classical function or a quantum kernel.
   • XACC supplies the quantum compilation pipeline, translating high‑level quantum code (e.g., OpenQASM, Q#) into QIR, an LLVM‑based intermediate representation.

2. Quantum Intermediate Representation Execution Engine (QIR‑EE)

   • Acts as a bridge: it receives QIR modules from XACC, packages them as IRIS tasks, and dispatches them to the selected quantum backend.
   • Handles backend‑specific details (e.g., simulator API calls, device queue submission) while exposing a uniform task interface to IRIS.

3. Circuit Cutting Workflow

   • The original circuit is automatically split into sub‑circuits using a standard cutting algorithm (e.g., based on tensor network decomposition).
   • Each sub‑circuit becomes an independent QIR task; IRIS schedules them concurrently, and results are recombined post‑execution.

4. Evaluation Setup

   • Experiments run on a modest HPC node equipped with multiple CPU cores and access to three quantum simulators.
   • Metrics focus on task throughput, queue waiting time, and overall wall‑clock time, rather than raw quantum speed‑up.

Results & Findings

• Concurrent execution of quantum sub‑tasks reduced the effective queue time on each simulator by ~70 %.
• Task granularity (splitting a circuit into smaller pieces) improved simulator throughput, demonstrating a practical benefit for early‑stage quantum hardware where job queues are long.
• The prototype successfully orchestrated mixed workloads (e.g., a classical optimization loop driving quantum sub‑circuit evaluations) without manual synchronization.

Practical Implications

• Hybrid HPC Workflows: Developers can embed quantum sub‑routines inside existing IRIS‑based pipelines (e.g., CFD, ML hyper‑parameter tuning) without rewriting the whole scheduler.
• Queue‑Aware Quantum Execution: By automatically cutting circuits and running them as smaller tasks, users can mitigate long wait times on shared quantum resources—a common pain point in cloud‑based quantum services.
• Backend Portability: Since Q‑IRIS treats QIR as the lingua franca, the same code can be retargeted from a fast CPU simulator to a real quantum device with a single configuration change.
• Scalable Co‑Design: System architects can prototype heterogeneous nodes (CPU + GPU + QPU) and evaluate scheduling policies before committing to expensive hardware.

Limitations & Future Work

• Performance Not Optimized: The study focuses on feasibility; no deep performance tuning (e.g., load‑balancing heuristics, latency hiding) was performed.
• Circuit Cutting Overhead: The current implementation incurs non‑trivial preprocessing time; smarter cutting strategies or incremental recompilation are needed for larger circuits.
• Limited Backend Diversity: Only simulators were tested; integration with actual quantum processors (including error‑mitigation layers) remains an open challenge.
• Coordinated Scheduling: Managing dependencies between classical and quantum tasks at scale (e.g., dynamic re‑scheduling when a quantum device becomes unavailable) requires more sophisticated runtime policies.

The authors outline a roadmap that includes tighter coupling between IRIS’s work‑stealing scheduler and quantum device drivers, support for heterogeneous memory hierarchies, and automated QIR generation from higher‑level quantum languages.

Bottom line: Q‑IRIS shows that a modern task‑based HPC runtime can already act as a “glue” between classical code and quantum workloads, offering developers a practical pathway to experiment with hybrid algorithms today—while also surfacing the engineering hurdles that must be cleared for production‑grade quantum‑accelerated supercomputers.

Authors

• Narasinga Rao Miniskar
• Mohammad Alaul Haque Monil
• Elaine Wong
• Vicente Leyton-Ortega
• Jeffrey S. Vetter
• Seth R. Johnson
• Travis S. Humble

Paper Information

• arXiv ID: 2512.13931v1
• Categories: quant-ph, cs.DC
• Published: December 15, 2025
• PDF: Download PDF