CONQURE: A Co-Execution Environment for Quantum and Classical Resources

This paper introduces CONQURE, an open-source co-execution framework that bridges the gap between quantum and classical computing by enabling seamless offloading of OpenMP quantum kernels to QPUs, efficient resource scheduling, and low-overhead result integration, demonstrated by achieving a 3.1X runtime reduction in parallelized VQE runs on an ion-trap device.

The Gist

Imagine you are running a massive, high-speed kitchen (a Supercomputer or HPC). Right now, this kitchen is incredibly fast at chopping vegetables and stirring pots using standard chefs (CPUs) and super-fast blenders (GPUs). But, there's a new, magical ingredient arriving: Quantum Computing.

Quantum computing is like a crystal ball that can solve specific, incredibly complex puzzles (like designing new medicines or optimizing global shipping) much faster than any normal chef. However, there's a problem: The crystal ball speaks a completely different language, it's located in a different room, and the kitchen staff doesn't know how to talk to it or when to use it.

This is where the paper introduces CONQURE.

The Problem: A Language Barrier and a Traffic Jam

Currently, if a supercomputer wants to use a quantum computer, it's like trying to send a fax to a crystal ball.

1. No Common Language: The kitchen staff (classical computers) use tools like OpenMP (a standard way to tell many chefs to work together). The crystal ball (Quantum Processor) uses its own weird code. There's no translator.
2. No Traffic Controller: If you have 100 chefs and only 2 crystal balls, who gets to use them? When? How do you get the results back? Currently, there's no open, free system to manage this traffic.
3. The "Stop-and-Go" Issue: Usually, the kitchen has to stop everything, wait for the crystal ball to think, get the answer, and then start again. This wastes a lot of time.

The Solution: CONQURE (The Universal Translator & Traffic Cop)

The authors built CONQURE, which acts as a super-smart restaurant manager that sits between the kitchen and the crystal ball.

Here is how it works, using simple analogies:

1. The Modular Architecture (The "Lego" System)

Imagine CONQURE is built like a set of Lego blocks.

• The Front Door: You can walk in wearing any shoes (using different software like Qiskit or Cirq).
• The Translator: If you speak French (Qiskit), the manager translates your order into the specific language the crystal ball speaks (hardware instructions).
• The Queue: It puts your order in a line, prioritizing the most important dishes.
• The Control Room: It talks directly to the crystal ball to make sure the magic happens.
• The Best Part: If you get a new type of crystal ball tomorrow, you just swap out one Lego block. You don't have to rebuild the whole restaurant.

2. The "Reverse Offloading" (The "Cooking While Waiting" Trick)

This is the paper's coolest innovation.

• Old Way: The chef shouts, "Make this quantum dish!" The kitchen goes silent and waits 10 minutes for the answer. Then the chef resumes.
• CONQURE Way (OpenMP-Q): The chef shouts, "Start making this quantum dish!" and immediately turns around to chop onions, stir soup, and grill steak while the crystal ball is working.
• The Magic: As soon as the crystal ball finishes one small step, it whispers the result back to the chef. The chef instantly uses that info to adjust the next step of the soup, without ever stopping the chopping. This is called Reverse Offloading. It keeps the kitchen moving 100% of the time.

3. The Parallel Power-Up (The "Team of Crystal Balls")

Imagine you have a problem that requires trying 6 different guesses to find the best solution.

• Without CONQURE: You try guess #1, wait for the result. Try guess #2, wait. It takes 6 hours.
• With CONQURE: You send all 6 guesses to 6 different crystal balls (or simulators) at the exact same time. The kitchen manager coordinates them all.
• The Result: Instead of 6 hours, it takes 2 hours. The paper showed a 3.1x speedup using this method.

The Real-World Test

The researchers didn't just build this on a computer; they tested it on a real Ion-Trap Quantum Computer (a machine that uses trapped atoms as qubits) at Duke University.

• They proved the system is fast (adding only about 12 milliseconds of delay, which is like a blink of an eye).
• They proved it works with real hardware, not just simulations.

Why Should You Care?

Think of CONQURE as the USB-C port for the future of computing.
Right now, plugging a quantum computer into a supercomputer is like trying to plug a USB-C cable into an old cassette tape player. It's messy, requires adapters, and often doesn't work.

CONQURE provides the universal adapter that lets the world's fastest computers talk to the world's most powerful quantum machines seamlessly. This means in the future, your doctor might use a supercomputer to design a cure for a disease, using a quantum "crystal ball" to solve the chemistry part instantly, all without the computer ever "stopping" to wait.

In short: CONQURE is the bridge that finally lets our current supercomputers and future quantum computers work together as one super-team.

Technical Summary

Here is a detailed technical summary of the paper "CONQURE: A Co-Execution Environment for Quantum and Classical Resources."

1. Problem Statement

The integration of quantum computing into High-Performance Computing (HPC) and Machine Learning (ML) workflows faces significant barriers:

• Lack of Open-Source Infrastructure: While classical HPC relies on standards like OpenMP, MPI, and CUDA, there is no equivalent open-source software infrastructure for quantum offloading. Current solutions are often proprietary or fragmented.
• Interoperability Issues: The quantum ecosystem is fragmented across hardware (superconducting, ion-trap, neutral atoms) and software (Qiskit, Cirq, Tket). Users must choose specific libraries based on hardware, creating a "lock-in" effect and hindering portability.
• Sequential Execution Limitations: Existing middleware often supports only sequential operations. This fails to leverage parallelism, which is crucial for mitigating qubit decoherence and maximizing throughput on devices like neutral atom systems.
• Hybrid Workflow Bottlenecks: Algorithms like the Variational Quantum Eigensolver (VQE) require iterative loops between classical solvers and quantum processors. Current systems suffer from high latency, poor resource scheduling, and a lack of abstraction for managing these hybrid jobs in HPC environments.

2. Methodology: The CONQURE Framework

The authors propose CONQURE, a fully open-source, modular co-execution environment designed to bridge classical HPC and quantum resources.

A. Architecture (5-Layer Stack)

CONQURE employs a modular, five-layer architecture to ensure flexibility and hardware agnosticism:

1. User Interface Layer: Supports various frontends (Qiskit, Cirq, Tket) for specifying quantum kernels and orchestrating workflows.
2. Translation Layer: Converts platform-agnostic operations into hardware-specific instructions via interchangeable adapters (e.g., QisDAX for ion-traps). It abstracts vendor-specific compilation.
3. Workload Manager: Handles cloud queuing, job scheduling, and resource management. It supports priority-based policies and hybrid coordination.
4. Database (DB): Maintains job metadata, circuit definitions, and execution results for persistence and tracking.
5. Quantum Control Layer: A device-agnostic interface for pulse-level control (e.g., interfacing with ARTIQ for FPGAs), supporting diverse qubit technologies via pluggable drivers.

B. Cloud Queue API

CONQURE provides an API compatible with AWS Cloud Queue specifications (create_work, get_results) but operates within a private cloud environment. This allows researchers to:

• Submit jobs asynchronously without waiting for completion.
• Track job status and retrieve historical results.
• Scale across multiple labs and devices using SLURM for resource utilization.

C. OpenMP-Q Extension (Quantum Offloading)

A core innovation is OpenMP-Q, an extension to the OpenMP standard that enables quantum offloading.

• Mechanism: It allows C++ code to offload quantum kernels to QPUs using #pragma omp target directives.
• Reverse Offloading: Unlike traditional offloading where the host waits, OpenMP-Q supports "reverse offloading." The quantum kernel remains active while the host performs asynchronous classical computation (e.g., parameter updates).
• Implementation:
  • Uses LLVM-Clang to intercept OpenMP directives.
  • Generates Python scripts at runtime based on the mapped quantum operations.
  • Utilizes Unix pipes for bidirectional communication between the C++ host and the Python quantum execution environment.
  • Supports Multi-QPU execution, allowing different threads to execute distinct circuits on separate QPUs simultaneously.

3. Key Contributions

1. Open-Source Framework: Creation of a modular, open-source stack for managing quantum resources and workloads, filling the gap left by proprietary solutions.
2. OpenMP-Q Standard Extension: Proposal and implementation of a quantum extension to OpenMP, enabling seamless integration of quantum kernels into existing HPC C/C++ codebases.
3. Hybrid Workflow Optimization: Demonstration of "reverse offloading" and parallel execution strategies to reduce idle time in iterative algorithms like VQE.
4. Real-World Validation: Successful deployment and testing on an experimental ion-trap device at the Duke Quantum Center, alongside simulator testing.

4. Experimental Results

The authors evaluated CONQURE using simulators and a 6-qubit ion-trap device.

• API Overhead:

  • The create_work API call (job submission) averaged 12.69 ms (real device) and 12.82 ms (simulator).
  • The get_results API call showed even lower overhead, as it primarily involves reading from the database.
  • Conclusion: The framework introduces minimal latency, suitable for HPC integration.

• VQE Performance (Parallelization):

  • Scenario: A Max-Cut problem on a 7-vertex graph using VQE.
  • Serial Execution: Running 6 VQE iterations sequentially took 228 seconds.
  • Parallel Execution (OpenMP-Q): Running 6 VQE iterations in parallel across 6 threads/QPUs took 71 seconds.
  • Speedup: Achieved a 3.1× reduction in total runtime, demonstrating linear speedup potential when scaling threads to available QPUs.

5. Significance

• Bridging the Gap: CONQURE addresses the critical disconnect between quantum algorithm development and practical HPC integration by providing a standardized, open-source interface.
• Scalability: By leveraging OpenMP, the framework allows HPC applications to scale quantum workloads across multiple QPUs and nodes without rewriting code for specific hardware backends.
• Efficiency: The ability to perform reverse offloading and parallel execution directly addresses the "barren plateau" and local minima issues in VQE by allowing multiple initial states to be explored concurrently, significantly accelerating convergence.
• Future-Proofing: The modular design ensures that as new quantum hardware (e.g., neutral atoms, new superconducting chips) emerges, the system can adapt by swapping the control layer without disrupting the user interface or scheduling logic.

In summary, CONQURE represents a significant step toward making quantum acceleration a practical, accessible, and efficient component of next-generation HPC systems.