A Performance Model for Hybrid Quantum-Classical Workflows

arXiv:2607.15426 · quant-ph · Submitted 2026-07-16 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: I'm Kai.

Mira: And I'm Mira, here with Lev.

Kai: We're looking at the paper: "A Performance Model for Hybrid Quantum-Classical Workflows".

Paper summary: Kai: So we're looking at this paper called "A Performance Model for Hybrid Quantum–Classical Workflows". It tackles how to make sense of when and where quantum and classical computing need to talk to each other in a practical setup.

Mira: Exactly. The main idea here is that the quantum and HPC communities just don't have a shared way of thinking about when these integrations actually matter for performance or feasibility. This paper tries to fix that by setting up two different levels of analysis where the communication overhead plays a different role depending on what you're trying to achieve.

Lev: So it’s trying to separate the application level, where communication overhead impacts how fast things run, from the real-time level, which just tells you if it can actually finish on time. That distinction seems important when we think about building actual systems.

Kai: Right, because I'm thinking about building superconducting qubits and cryogenics; in that world, the physical constraints are huge. This model tries to avoid bias toward any specific qubit modality by separating workflow-intrinsic metrics from the hardware-dependent stuff.

Mira: And it does this by introducing a runtime model that breaks down the whole workflow execution into three parts: classical compute, quantum compute, and communication costs. It defines the total cycle time as Tcycle equals TC plus TQ plus Tcomm.

Lev: That decomposition is useful because it lets us look at the costs clearly. We can then look at application level diagnostics using a communication-to-computation ratio, Rcc equals Tcomm divided by that sum of quantum and classical compute times.

Kai: And when that Rcc is bigger than one, it means the workflow is communication-bound, and we should probably look at tightening up how those components talk to each other. But what about the real-time side? Does it actually work in time?

Mira: The real-time level has a feasibility constraint. This constraint checks if your total time for classical steps plus communication steps fits within the physical reaction time you need to meet, which we call tauphys. If that condition isn't met, the execution fails entirely before it even starts running correctly.

Lev: I see how that maps to real hardware constraints because control systems have strict timing requirements. The binding condition is TC step plus Tcomm step less than or equal to tauphys to keep things correct >

Kai: So this isn't just theoretical stuff about algorithms; it’s trying to give us a concrete way to judge if a hybrid workflow is going to work on the actual machine we're building. It helps us see where the friction is.

Mira: The paper applies both these diagnostics to some specific workflows, like Sample-based Quantum Diagonalization or Generative Quantum Eigensolver, and it shows how they behave at different integration tiers. For instance, in one case, the communication-to-computation ratio is negligible across all tiers because the quantum and classical compute times are just so big compared to any realistic overhead.

Paper summary: Lev: That makes sense for compute-intensive jobs where you’re just crunching numbers; you don't have much time to wait for data back and forth > But it gets interesting when we look at things like Quantum Enhanced Markov Chain Monte Carlo.

Kai: Because in that MCMC example, they found a high communication-to-computation ratio in remote access scenarios, which suggests that the sequential nature of the data dependence forces those exchanges to be irreducible.

Mira: So what this means for us on air is that even for seemingly straightforward algorithms, depending on how you set up the system—like whether you're running it on a single workstation or a huge HPC cluster—the communication costs can become the main bottleneck or even cause failure.

Lev: It changes how we design error correction and control loops because we have to worry about both performance at the application level and strict timing constraints at the real-time level > This framework helps us pinpoint exactly where those overheads land in terms of actual execution time on real hardware.

Kai: And looking ahead, the paper points out that co-locating quantum processors with HPC infrastructure might not give you much performance gain for compute-intensive applications right now. But it's crucial for things like quantum error correction needed for bigger computations > It suggests that how we evaluate integration needs could shift depending on what hardware comes out later.

Mira: Plus, the authors mention that future developments in hardware and algorithm design could fundamentally change these requirements. They suggest that quantum memory might alter the communication structure by allowing stateful execution models, potentially moving workflows from being a real-time issue to just an application level concern > It gives us a common quantitative language for making those integration decisions.

Lev: The paper’s limitation is that it focuses on modeling the workflow execution based on these abstract metrics, so it doesn't necessarily tell you exactly how much latency you'll see on a specific piece of hardware yet > It provides the model, but you still need to run the experiments to see how sensitive things are.

Kai: So what we’ve seen is that this model gives us a way to systematically test hybrid workflows against both performance and feasibility constraints using a single set of metrics, rather than looking at them separately > It's about giving researchers a shared language for discussing these complex integration decisions.

Mira: The authors, Pooja Rao, Dimitar Trenev, Jerome Gonthier, Taylor Patti, Sebastian Stern, Tyler Takeshita, Yuri Alexeev, Cedric Lin, Sam McArdle, Justin Lietz Katherine Klymko Ermal Rrapaj Norm Tubman and Krysta Svore put this model forward. It’s a way to structure the entire hybrid quantum-classical workflow analysis >

Lev: It really helps us understand that we can't just optimize the quantum part in isolation; we have to design the whole loop, including how fast it talks back and forth > That’s what this paper is about.

Conclusion: Kai: So we've seen how this paper sets up two ways to look at hybrid quantum classical workflows using application level diagnostics and real time feasibility constraints, right?

Mira: Right. It’s a model that breaks down the total cycle time into classical compute plus quantum compute plus communication costs.

Lev: That decomposition is key because it lets us separate what actually matters for performance from what just matters for whether you can finish something correctly in time.

Kai: The authors, Pooja Rao and her team, they built this framework to give the quantum and HPC communities a shared language for deciding where integration overhead actually hurts things the most.

Mira: Exactly. It moves away from just guessing if you need tight coupling based on your intuition about an algorithm.

Lev: What it means for me is that before I start building control systems or error correction protocols, I have a way to check if my proposed workflow timing will even be feasible on real hardware under those strict physical reaction time limits.

Kai: And for the broader field, it suggests that we need to stop looking at all these hybrid setups the same way.

Mira: It points toward figuring out specific crossover conditions where things shift depending on what kind of quantum hardware comes out next or how fast communication can actually become.

Lev: It also shows that in some cases, like those remote access scenarios with Markov chains, the sequential data dependence forces a communication overhead that you just can't ignore.

Kai: So ultimately, this model is about giving us a quantitative way to make tough choices about how tightly we should couple quantum and classical resources.

Mira: It sets the stage for understanding what kind of system you’re building before you even start optimizing the quantum gates themselves.

Pooja Rao, Dimitar Trenev, Jerome Gonthier, Taylor Patti, Sebastian Stern, Tyler Takeshita, Yuri Alexeev, Cedric Lin, Sam McArdle,  Justin Lietz,  Katherine Klymko, ®rmal Rrapaj, łNorm Tubman, ᵊ Krysta Svore, Peter Komar, Elica Kyoseva

NVIDIA Corporation · Amazon Braket · AWS Worldwide Specialist Organization · AWS Quantum Technologies · National Energy Research Scientific Computing Center · łNASA Ames Research Center

quant-ph

Submitted: 2026-07-16

Updated: 2026-11-18

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 83/100

The gist: Hybrid quantum–classical workflows are expected to underpin practical quantum computing applications…

Key concepts

Runtime Model Decomposition
This model breaks down total workflow time (Tcycle) into three components: classical compute time (TC), quantum compute time (TQ), and communication blocking time (Tcomm). This allows researchers to analyze performance based on where the bottleneck occurs, separating intrinsic workflow metrics from hardware specifics.
Application Level Diagnostics
This analysis uses a communication-to-computation ratio (Rcc) to judge if a workflow is limited by data transfer or processing power. If Rcc is much greater than 1, the workflow is communication-bound, suggesting that improving integration can significantly boost performance.
Real-Time Feasibility Constraint
This constraint checks if a task can meet strict timing requirements necessary for correct execution. It uses a physical reaction time ($ au_{phys}$) to ensure that the sum of classical and communication steps does not exceed this limit, preventing incorrect results in real-time scenarios.

Terminology

Summary

Hybrid quantum–classical workflows are expected to underpin practical quantum computing applications, yet the quantum and HPC communities lack a shared framework for reasoning about where and when their integration requirements matter most Such a framework must separate two distinct levels of analysis: the application level, where communication overhead affects runtime performance, and the real-time level, where it determines feasibility The model introduces a runtime model that decomposes workflow execution into quantum compute, classical compute, and communication costs

The Runtime Model Decomposition

The runtime model separates workflow-intrinsic metrics from hardware-dependent parameters to avoid bias towards any particular qubit modality The model addresses a classical host connected to a quantum execution resource, whose endpoints depend on the level of analysis, ranging from a single workstation to a leadership-class HPC system paired with an application-facing logical QPU at the application level, and from a low-latency control system paired with the physical QPU at the real-time level The model defines the total cycle time as Tcycle = TC + TQ + Tcomm, where TC is classical compute time, TQ is quantum compute time, and Tcomm captures blocking quantum-classical communication

Application Level Diagnostics

At the application level, a communication-to-computation ratio from this decomposition quantifies whether a workflow is communication-bound or compute-bound This ratio is defined as Rcc = Tcomm / (TQ + TC) = F(L + V /B), where F is the communication frequency, L is the round-trip latency, and B is the available interconnect bandwidth When Rcc ≫ 1, the workflow is communication-bound and can benefit significantly from tighter integration

Real-Time Feasibility Constraint

At the real-time level, a feasibility constraint determines whether timing requirements can be met at all, with the reaction time setting the logical clock speed of fault-tolerant computation once they are The binding condition is TC,step + Tcomm,step ≤ τphys to preserve correctness Failure to meet this condition prevents correct execution entirely

Illustrative Workflow Analysis

The model applies these diagnostics to representative workflows, such as Sample-based Quantum Diagonalization (SQD), Generative Quantum Eigensolver (GQE), and Quantum Enhanced Markov Chain Monte Carlo (QE-MCMC) For SQD, the communication-to-computation ratio Rcc is found to be negligible across all integration tiers, as the two hours of combined quantum and classical compute dwarf any realistic communication overhead Conversely, QE-MCMC exhibits a high Rcc in remote access scenarios, indicating that sequential data dependence forces each exchange (F is irreducible)

Integration Implications and Outlook

Co-location of quantum processors with HPC infrastructure offers negligible performance benefit for compute-intensive applications today, while tight integration remains crucial for real-time tasks such as quantum error correction needed for large scale quantum computations The model allows researchers to identify specific crossover conditions where assessments may shift with hardware evolution, illustrating how the reaction time can set application-level performance under fault tolerance Quantum memory could fundamentally alter the communication structure of workflows by allowing stateful execution models, potentially shifting workflows from real-time level to application-level analysis The model provides a common quantitative language for hybrid quantum–classical integration decisions

Contributions

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Application level performance assessment can be refined by identifying crossover conditions where hardware evolution shifts assessments, as even at the application level these assessments may shift with hardware evolution. This allows system designers to anticipate when co-location offers negligible benefit versus when tighter integration becomes crucial for real-time tasks like quantum error correction.

  2. Real-time feasibility constraints can be explicitly formulated using the binding condition "TC,step + Tcomm,step <= τphys to preserve correctness, allowing for a direct check on whether timing requirements can be met at all. This determines if the classical processing must complete within physical qubit coherence times."

  3. Workflow classification can be improved by explicitly separating bottlenecks based on the communication-to-computation ratio (Rcc), noting that When Rcc ≫ 1, the workflow is communicationbound and can benefit significantly from tighter integration. This guides architectural decisions toward either tight integration for latency-bound tasks or HPC scaling for compute-bound tasks.

  4. The model enables a more nuanced understanding of quantum error correction requirements by separating application level analysis (where real-time classical feedback needed for logical qubit stability is absorbed into the logical QPU abstraction) from real-time level analysis (where classical processing must complete within a timescale set by the physical quantum device).

  5. System design can be informed by hardware evolution forecasts, as the paper demonstrates how to identify specific crossover conditions where integration requirements change, providing actionable guidance for system design based on factors like shot budget reductions or structural communication changes.

Sources

Related papers