⚛️ quantum physics

Towards Continuous Profiling and Optimization of Quantum-Classical Pipelines

This paper introduces LLQM, a profiling-driven meta-framework that decomposes and continuously monitors quantum-classical pipelines to enable dynamic, hardware-aware optimizations that improve fidelity and resource efficiency in the face of stochastic hardware noise.

Original authors: Ayush Bansal, Owen Cochell, Santiago Núñez-Corrales, Marcos Frenkel, Seetharami Seelam, Apoorve Mohan, Tianyin Xu

Published 2026-09-09

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Ayush Bansal, Owen Cochell, Santiago Núñez-Corrales, Marcos Frenkel, Seetharami Seelam, Apoorve Mohan, Tianyin Xu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computing promises to solve problems that are impossible for today's supercomputers, from designing new drugs to modeling complex chemical reactions. However, the machines that hold this promise are currently fragile. The tiny particles they use to store information, called qubits, are easily disturbed by heat, vibration, or even stray electromagnetic waves. This disturbance, known as noise, causes the computer to make mistakes. To get a useful answer, scientists do not just run a single calculation; they run a complex sequence of steps. They prepare the calculation, send it to the quantum machine, wait for the result, and then use a powerful classical computer to clean up the errors and interpret the data. This back-and-forth process is called a pipeline. For years, researchers have treated each step in this pipeline as a separate, static task, assuming that if they set the parameters correctly at the start, the job would run smoothly. But as these machines have grown larger and more complex, this assumption has begun to fail. The quantum hardware changes its behavior from minute to minute, and the classical steps required to fix errors vary wildly in how much time and memory they need.

A team of researchers at the University of Illinois Urbana-Champaign and IBM Research has built a new system to manage this complexity, called LLQM. Instead of treating a quantum job as a single, unchangeable block of work, LLQM breaks it down into tiny, individual tasks and watches them closely as they happen. The system acts like a continuous observer, measuring how much power, memory, and time each small step consumes while simultaneously tracking the changing health of the quantum hardware. This approach revealed that the old way of planning is insufficient. The researchers found that the best way to fix errors depends entirely on the specific moment the calculation is running. A technique that works perfectly on a calm day might fail completely when the hardware is slightly noisier, and a method that is fast on one type of problem could take hundreds of times longer on another.

The team tested their system on real quantum processors with up to 156 qubits, running calculations that involved millions of operations. They discovered that the classical computer, which handles the error correction, often becomes the bottleneck, not the quantum machine itself. In some cases, the classical computer spent 92 percent of the total time simply waiting in a loop for the quantum machine to finish, while other times it worked intensely for hours to process the results. The researchers also found that the choice of which physical qubits to use on the chip matters more than previously thought. Selecting a slightly degraded set of qubits could cause the accuracy of the result to collapse to near zero, or force the system to spend nearly twice as much time on the quantum machine to achieve the same result. These are not small variations; they are fundamental shifts that determine whether a calculation succeeds or fails.

One of the most striking findings was that there is no single "best" way to correct errors. The researchers tested several different error-mitigation techniques, which are methods used to guess what the correct answer should be despite the noise. They found that a technique called Probabilistic Error Cancellation, which is powerful for small circuits, could actually make large circuits worse, destroying the accuracy of the result. Conversely, a different technique called Zero-Noise Extrapolation worked consistently well across many different types of problems. However, even the best technique could fail if the hardware changed state during the long time it took to run. The system showed that the cost of running these corrections is not fixed; it depends on the size of the problem, the specific type of calculation, and the real-time condition of the machine.

The new system, LLQM, addresses this by creating a feedback loop. It does not just set a plan and hope for the best. Instead, it constantly checks the results. If the system detects that the accuracy is dropping below a required level, it can stop the current plan and restart with a different configuration. It can switch to a different error-correction method, choose a different set of qubits, or adjust how many times the calculation is repeated. This happens in real time, allowing the system to adapt to the drifting behavior of the quantum hardware. The researchers demonstrated that by making these dynamic adjustments, they could avoid wasting resources on plans that were doomed to fail and instead find the most efficient path to a correct answer for each specific job.

The study also highlighted that the number of qubits a machine has is not the best way to predict how long a job will take or how accurate it will be. Instead, the total number of operations, or gates, in the calculation is the true driver of cost and quality. A calculation with fewer qubits but many operations could take longer and be less accurate than a calculation with many qubits but fewer operations. This distinction is crucial for planning, as it means that simply counting the number of particles in the machine does not tell the whole story. The researchers showed that by focusing on the actual operations and the real-time state of the hardware, they could build a much more accurate model of what a job will cost and how long it will take.

This work suggests that the future of quantum computing lies in systems that are aware of their own environment. Just as a driver adjusts their speed based on the road conditions, a quantum system must adjust its strategy based on the noise and behavior of the machine. The researchers found that without this continuous awareness, even the most advanced quantum computers will struggle to produce reliable results. The new framework provides the tools to make these adjustments automatically, turning a fragile, unpredictable process into something that can be managed and optimized. It moves the field away from treating quantum jobs as static recipes and toward treating them as living systems that must be watched and guided from start to finish.

The implications of this research extend beyond just fixing errors. It changes how scientists think about the relationship between the quantum machine and the classical computer that supports it. They are not separate entities working in isolation; they are deeply intertwined, with decisions in one part of the system affecting the other in complex ways. The study shows that optimizing one part without considering the whole leads to wasted time and money. By breaking the job down into its smallest parts and watching them all together, the researchers have uncovered a new way to think about efficiency. They have shown that the path to useful quantum computing is not just about building bigger machines, but about building smarter systems that can understand and adapt to the machines they run on.

The researchers are now working to make this system available to others as an open-source project, allowing the wider community to test and improve these ideas. They believe that as quantum technology continues to evolve, the ability to continuously profile and optimize these pipelines will become essential. The goal is to create a future where the complexity of the hardware is hidden from the user, and the system automatically finds the best way to run any calculation, regardless of how the machine behaves on that day. This shift from static planning to dynamic adaptation represents a significant step forward in making quantum computing a practical reality.

Technical Summary: Towards Continuous Profiling and Optimization of Quantum-Classical Pipelines

Problem Statement

Quantum applications have evolved from small-scale experiments to utility-scale computations involving tens to hundreds of physical qubits. However, current Quantum Processing Units (QPUs) suffer from decoherence, gate imperfections, and readout errors that compound exponentially with circuit depth. Consequently, producing usable results requires executing applications as multi-stage quantum-classical pipelines. These pipelines interleave QPU computation with classical stages such as circuit generation, transpilation, qubit mapping, Quantum Error Mitigation (QEM), and post-processing.

Existing workflow frameworks treat these stages as static, isolated components, optimizing the QPU rather than the entire pipeline. This approach fails because:

Dynamic Hardware State: QPU error rates drift on timescales of minutes. A noise model or qubit layout calibrated at the start of a campaign may be stale by the time a job executes.
Stochastic Stage Behavior: Different techniques within the same stage (e.g., different QEM algorithms) exhibit drastically different classical resource requirements (CPU/GPU, memory) and interact differently with the underlying hardware.
Coupled Decisions: Decisions regarding qubit mapping, QEM selection, and resource provisioning are tightly coupled through execution fidelity and resource consumption, yet are typically made independently or statically.
Non-Stationary Objectives: The cost to recover fidelity is a function of the noise it must cancel. Therefore, a single characterization does not suffice; profiling must be continuous to adapt to evolving device states.

Current frameworks lack visibility into the interactions between individual pipeline stages, classical resource behavior, and real-time hardware states, leading to suboptimal fidelity and wasted resources.

Methodology: LLQM (Low-Level Quantum Machine)

The authors present LLQM, a profiling-driven meta-framework designed to decompose quantum-classical pipelines into fine-grained tasks and continuously profile them alongside real-time hardware states.

Core Architecture

LLQM does not prescribe specific optimization policies but provides a runtime abstraction and a common profiling substrate. It decomposes applications into a directed acyclic graph (DAG) of typed tasks (CPU, GPU, or QPU work) across five pipeline stages:

Workload Classification: Identifies the workload family (e.g., VQE, Ising, Trotter) to determine applicable techniques.
Pre-processing: Selects a backend and physical qubit layout using an Expected Success Probability (ESP) metric, then commits to a QEM technique and configuration.
Job Queuing & Scheduling: Holds tasks in heterogeneous queues (CPU, GPU, QPU) and co-schedules them to prevent resource idleness.
Execution: Dispatches tasks to external backends (e.g., IBM Quantum, local simulators) via a unified interface.
Post-processing & Feedback: Fuses outputs, calculates fidelity, and feeds telemetry back into the system.

Key Mechanisms

Continuous Closed-Loop Profiling: LLQM establishes two feedback loops:
- Intra-job: If fidelity falls short, the system revisits decisions (e.g., increasing shot counts or restarting).
- Inter-job: Completed tasks update cost models with the latest device states for subsequent jobs.
Task-Level Granularity: Unlike job-level averaging, LLQM profiles per-phase resource behavior (e.g., distinguishing between memory-bound representation generation and compute-bound sampling in PEC). This allows resource attribution to specific stages and techniques.
Hardware-Aware Decisions:
- Qubit Layout: Scores layouts using Circuit-Weighted Average (CWA) error and ESP metrics derived from calibration snapshots.
- QEM Selection: Selects techniques (No mitigation, REM, ZNE, PEC) based on a predicted cost vector (quantum time, classical time, memory) and user-defined fidelity constraints.
- Resource Provisioning: Assigns tasks to CPU or GPU based on their intensity class (memory-bound vs. compute-bound) identified during profiling.

Key Contributions

Identification of Continuous Profiling: The authors identify continuous profiling as a missing runtime primitive for quantum-classical pipelines, demonstrating that static optimizations are insufficient when stage behavior depends on dynamic device states.
LLQM Framework: Development of a meta-framework that decomposes pipelines into typed tasks, records per-phase resource behavior alongside runtime device states, and provides interfaces for hardware-, fidelity-, and workload-aware policies.
Characterization of QEM: Using LLQM, the authors provide a detailed characterization of QEM, exposing interactions among hardware state, mitigation effectiveness, qubit layout, execution fidelity, and resource consumption.
Open-Source Implementation: LLQM is maintained as an open-source project.

Experimental Results

The framework was evaluated on IBM 156-qubit Heron r2 processors using circuits up to 100 qubits and $10^7$ transpiled gates (from QASMBench). Key findings include:

Non-Uniform QEM Performance: No single QEM technique is universally effective. For example, Probabilistic Error Cancellation (PEC) improved fidelity on small circuits but collapsed to near-zero fidelity on larger circuits, while Zero-Noise Extrapolation (ZNE) provided consistent gains. Misconfigured techniques can degrade fidelity below the unmitigated baseline.
Hardware State Sensitivity: Slight degradations in hardware qubit quality caused ZNE fidelity to collapse, whereas PEC could recover high fidelity but at the cost of inflating QPU execution time by 1.8× due to increased sampling overhead.
Classical Resource Bottlenecks: Classical resources, not the QPU, can be the primary execution bottleneck. PEC's classical sampling phase can take 25–290× longer than ZNE's classical folding phase. Furthermore, classical hosts can sit idle in polling loops for up to 92% of wall-time while waiting for the QPU.
Transpiled Gate Count as a Predictor: Transpiled gate count is a superior predictor for both cost and fidelity compared to qubit count. Techniques scale differently with gate count, whereas qubit count alone fails to predict execution time or fidelity trends.
Fidelity Constraints: Fidelity acts as a constraint rather than a currency. Below a target fidelity, resources are wasted; above it, extra fidelity has no value to the user but consumes expensive QPU time.

Significance and Claims

The paper argues that treating quantum jobs as black boxes obscures where fidelity and resources are lost. By decomposing jobs into typed tasks and continuously profiling them, LLQM shifts optimization from a fixed recipe to a measurable, evolving system.

The authors claim that:

Static optimization is insufficient: Decisions regarding QEM and layout cannot be made correctly ahead of execution without dynamic profiling due to hardware drift and workload variability.
Holistic optimization is necessary: Local configuration choices (QEM algorithm, parameters, qubit selection) have first-order effects on both fidelity and quantum-classical resource usage.
The boundary is blurring: As quantum applications become more sophisticated, the distinction between quantum algorithm design and systems optimization becomes increasingly difficult to draw.

LLQM provides the substrate for autonomous quantum systems where techniques and configurations are inferred from the circuit and constraints, reducing dependence on manual tuning of mitigation techniques or device intricacies. The paper positions LLQM as a step toward systems that can continuously understand, adapt, and optimize evolving quantum-classical computations.