Towards Continuous Profiling and Optimization of Quantum-Classical Pipelines

AI summary

Overview

Research area: Quantum computing systems — specifically performance profiling, resource management, and runtime optimization of hybrid quantum–classical application pipelines.

Technical level: Advanced. The paper assumes familiarity with quantum circuit execution, quantum error mitigation (QEM) techniques such as Zero-Noise Extrapolation (ZNE), Probabilistic Error Cancellation (PEC) and readout error mitigation (REM), plus classical HPC concepts such as IPC, DRAM bandwidth, task graphs, and scheduling.

Scope (one sentence): The paper introduces LLQM, a profiling-driven meta-framework that decomposes quantum–classical pipelines into fine-grained typed tasks, continuously profiles their CPU/GPU, memory, QPU, and queue behavior against live device calibration state, and uses that telemetry to drive qubit-layout selection, QEM selection, and resource provisioning — demonstrated on IBM 156-qubit Heron r2 processors with circuits up to 100 qubits and 10^7 transpiled gates.

What This Paper Is About

Real quantum applications do not run as a single circuit: they run as pipelines that interleave QPU execution with classical stages such as circuit generation, transpilation, qubit mapping, error mitigation, and post-processing. Existing frameworks either optimize the QPU alone or orchestrate jobs without exposing how individual stages interact with classical resources and with drifting hardware noise, so decisions like which qubits to use and which mitigation technique to run are made statically or independently.

The paper's goal is to make continuous profiling the missing runtime primitive for these pipelines, so that hardware-, fidelity-, and workload-aware decisions can be made — and compared fairly — against the actual device state at execution time.

Key Contributions

1. Identifies continuous profiling as a missing runtime primitive. The authors argue that classical HPC profiling assumptions break for quantum workloads because QPU error rates drift on timescales of minutes, so a characterization taken once does not transfer to later executions.

2. Introduces LLQM (Low-Level Quantum Machine). LLQM is a meta-framework, not another workflow runtime: it decomposes a pipeline into independent typed tasks across five stages (classification, pre-processing, job queuing, execution, post-processing) spanning eleven steps, records per-phase classical and quantum resource behavior alongside the calibration snapshot used, and closes two feedback loops — an intra-job loop that revisits a decision when fidelity falls short, and an inter-job loop that updates cost models for subsequent jobs.

3. Defines common interfaces for three real-resource decisions. These are hardware-aware qubit mapping using an Expected Success Probability (ESP) metric (alongside a circuit-weighted average error metric), QEM technique and configuration selection, and classical resource provisioning — with fidelity targets and resource budgets (quantum time, classical time, memory ceiling, shot caps) as inputs. LLQM deliberately does not prescribe the policy; it supplies the substrate under which policies can be implemented and compared on identical workloads, hardware states, and budgets.

4. Delivers a characterization of QEM using the framework. The study exposes interactions among hardware state, mitigation effectiveness, qubit layout, execution fidelity, and quantum–classical resource consumption. LLQM is maintained as an open-source project.

Main Findings

• No single QEM technique is universally effective. ZNE, configured per circuit, improved fidelity consistently by +0.10 to +0.55 over the unmitigated baseline. REM was near-neutral and occasionally negative. PEC improved the two smallest circuits and then collapsed fidelity to 0.00 on every larger circuit it ran on.

• The collapse metric can understate harm. Because the unmitigated baseline itself falls with gate count, PEC's identical collapse to 0.00 registers as a progressively smaller change: −0.71 on ising_n26 down to −0.21 on basis_trotter_n4.

• Hardware state can invert the ranking of techniques. On slightly degraded qubits for the vqe_n4 circuit, open-source PEC's fidelity collapsed to 0.500, performing worse than simple REM at 0.628.

• Classical resources, not the QPU, can be the bottleneck. PEC's circuit sampling reached roughly 1.3 × 10^4 s, which is 25–290 times the ZNE cost for the same circuit. QPU time is irreducible by provisioning; PEC's classical sampling cost is not.

• Phases within one technique have different resource personalities. PEC representation generation is memory-bound and NUMA-sensitive, moving up to 1.16 GB/s of DRAM read traffic at 38% physical IPC; circuit sampling is compute-bound and highly parallelizable at 54% IPC over 423 seconds; the QPU execution/queuing phase stalled classical host CPUs in polling loops for 5,100 seconds (92% of total wall-time) at roughly 31% IPC. By contrast, ZNE classical folding took less than one second for vqe_n4.

• The host can idle for most of wall-time. The classical host sat in polling loops for up to 92% of wall-time waiting on the device, then spent 25–290 times longer in classical mitigation than in the quantum execution itself.

• Qubit layout alone has first-order effects on both fidelity and QPU cost. Mapping a 4-qubit state-preparation circuit onto degraded physical qubits caused ZNE fidelity to collapse from 0.910 to near zero, rendering the QPU run useless. PEC recovered high fidelity (0.891) on the same degraded qubits, but inflated QPU execution time by 1.8 times, from 278 s to 498 s, because more physical noise requires a larger sampling overhead γ² (Equation 1: γ = ∏ exp(2λ_k) = exp(2 Σ λ_k)).

• PEC's degradation has an explainable mechanism, not random noise. On large, higher-fault circuits the raw unclipped estimator diverges far outside the measurement range [0, 2]. Each such PEC point required roughly 3–4 hours of sampling, long enough for hardware drift to invalidate the learned Pauli-Lindblad noise model, so the generated samples no longer cancel the true noise.

• Transpiled gate count predicts cost and fidelity better than qubit count. Measured QPU time follows transpiled gate count, with each technique tracing its own near-monotonic trajectory (PEC highest and steepest); plotted against qubit count the same measurements collapse into a band with no usable trend. The 4-qubit basis_trotter_n4 consumed more total execution time than the 98-qubit ising_n98, and reached lower fidelity.

• The right configuration cannot be chosen statically. The best and worst QEM choices often determine whether a result is useful, but the optimum depends on workload family, circuit width and gate count, and the device's real-time noise profile.

Methodology in Plain English

The authors built a system that breaks a quantum application into small independent pieces of work, tags each piece by the hardware it runs on (QPU, CPU, or GPU), and measures what each piece actually consumes — time, memory traffic, processor efficiency, queue wait versus execution — while also recording the device's calibration data at the moment the piece ran. Because the pieces are independent by construction, a measurement can be attributed to one phase of one technique on one circuit instead of being averaged across an entire job.

Those measurements feed a cost model that predicts quantum time, classical time, and peak memory for a candidate configuration given program features, qubit layout, and device state. Layout is chosen first, because it changes which mitigation configurations are even feasible; candidate layouts are scored with ESP and a circuit-weighted average error, drawing on a portfolio of mapping algorithms (Identity, SABRE, GreedyV/E and R-SMT, VQA/VQM, JIT). Then a QEM configuration is chosen as the cheapest member of a feasible set that satisfies the user's fidelity floor and budgets (no mitigation, REM, ZNE, and PEC are currently supported). Finally, resources are provisioned per task, with a ready set spanning all jobs so wait time becomes schedulable capacity.

For evaluation they used QASMBench circuits spanning VQE, UCCSD-VQE, Ising, and Trotter families, from 4 to 98 qubits in the motivating studies (up to about 100 qubits and 10^7 transpiled gates overall), on IBM 156-qubit Heron r2 processors. To measure fidelity without exponential state-vector simulation, each circuit U was converted into a mirror circuit by appending U† so the ideal output is all-zeros; fidelity was computed from the spatial average of single-qubit Pauli-Z expectation values as max(0, 1 − |M̂ − 1|). All classical mitigation work ran single-threaded on one core of an Intel Xeon Platinum 8474C to establish a conservative, parallelization-free per-task cost, with DRAM bandwidth and IPC collected separately via Linux perf so profiling overhead would not perturb timings.

Why This Matters

Impact on research. The paper reframes quantum error mitigation and qubit mapping as pipeline-level resource problems rather than isolated algorithmic choices, and provides a shared measurement substrate so competing policies can be compared under identical workloads, hardware states, and budgets — addressing what the authors describe as the anecdotal comparisons common in prior work. It also produces, as a by-product of running jobs, the (configuration, layout, device-state) triples annotated with achieved fidelity and true cost that a fidelity predictor would need for training.

Real-world applications (as framed in the paper):

• Quantum chemistry, including UCCSD-VQE workloads in the benchmark suite.
• Drug discovery.
• Many-body dynamics simulation, including transverse-field Ising model circuits.
• Optimization workloads such as QAOA, named among the workload families the classifier must recognize.

Industry relevance. The work is co-authored with IBM Research and evaluated on IBM's 156-qubit Heron r2 processors, and it targets shared, multi-tenant deployments where classical budgets matter. It addresses integration with classical HPC infrastructure and existing orchestrators such as QFw and CUDA-Q, and its findings — that QPU-centric schedulers leave large classical work unaccounted for and let hosts idle in polling loops for up to 92% of wall-time — are directly actionable for cloud quantum service operators and HPC centers adding QPUs to their fleets.

Future Directions

• Building the fidelity predictor. The paper states plainly that no sound construction of the predicted-fidelity function is known; profiling makes the constraints and the cost vector cheap, but this term remains the open challenge, and the community still lacks guidelines on when to apply a given technique.

• Bounding technique duration by calibration decay. The staleness gate cannot catch drift that occurs after submission, and the paper notes PEC campaigns running for hours, long enough for the device to drift away from the noise model learned at startup. Bounding a technique's sampling duration by its calibration-decay timescale is named as a requirement the profiler does not yet measure.

• Expanding the QEM and mapping portfolios. The authors plan to add support for more QEM techniques, including PNA, SQD, and QuePP, and note that the layout portfolio's static scores rank output layouts rather than the algorithms themselves — no mapping algorithm is known to be best a priori.

• Resolving the probe problem. Mirror circuits are roughly twice as deep, use a different observable, obscure workload-specific techniques (U U† destroys the chemistry structure SQD exploits), and each probe incurs full QPU cost, leaving its return on investment an open question. The paper's later discussion of open problems and its system comparison table (Table III, Section VIII) fall beyond the truncated content provided.

Target Audience

Researchers and engineers working on quantum systems software, quantum-classical workflow orchestration, and HPC–QPU integration; performance engineers and profiler developers; quantum error mitigation practitioners who need to choose and configure techniques under real hardware constraints; and operators of shared or cloud quantum platforms who must budget QPU time, classical CPU/GPU time, and memory across many users. Readers without a background in quantum error mitigation terminology will find the paper demanding, as it assumes working knowledge of ZNE, PEC, REM, and Pauli-Lindblad noise models.

Authors’ abstract

Quantum applications increasingly execute as multi-stage quantum-classical pipelines, interleaving QPU computation with classical stages like circuit generation, transpilation, layout mapping, quantum error mitigation (QEM), and post-processing. These stages have diverse resource requirements and exhibit stochastic behavior under drifting hardware noises, yet existing workflow frameworks treat them as static, isolated components. We present LLQM (Low-Level Quantum Machine), a profiling-driven meta-framework for quantum-classical pipelines. LLQM decomposes pipelines into fine-grained tasks and continuously profiles their CPU/GPU, memory, QPU, and queue dependencies alongside real-time hardware states. This unified runtime abstraction captures cross-stage resource dependencies and reveals how classical and quantum decisions interact, enabling characterization of their impact on fidelity and resource consumption. We evaluate LLQM using QEM as a representative pipeline stage, on IBM 156-qubit Heron r2 processors with circuits up to 100 qubits and 1e7 transpiled gates. Our results show that continuous profiling exposes runtime bottlenecks and enables hardware-, fidelity-, and workload-aware optimizations.