EFaaS: A Quantum-Classical Serverless Entangled Scheduler for Hybrid Variational Algorithms

The paper introduces EFaaS, a novel serverless middleware that optimizes hybrid variational quantum algorithms by treating classical and quantum tasks as entangled, session-aware events to drastically reduce latency, eliminate hardware drift penalties, and accelerate convergence through calibration-aware routing and speculative execution.

The Gist

Imagine you are trying to solve a massive, complex puzzle. To do this, you have two helpers: a brilliant human strategist (the Classical CPU) and a super-fast but very fragile magic crystal ball (the Quantum Processor, or QPU).

The problem is that these two helpers work in a terrible loop.

1. The strategist thinks of a move.
2. They shout it to the crystal ball.
3. The crystal ball takes a moment to look, then whispers back the result.
4. The strategist thinks of the next move.

In the current "cloud" system, this process is broken. Every time the strategist shouts a move, they have to wait in a long, chaotic line (a batch queue) just to get the crystal ball's attention. While waiting, the crystal ball gets "cold" and forgets its settings. By the time the strategist finally gets to speak, the crystal ball has to stop, recalibrate itself, and then answer. This makes the whole process take days instead of minutes, and the answers become less accurate because the crystal ball is drifting out of tune.

EFaaS is a new, smart "middleman" designed to fix this broken loop. Here is how it works, using simple analogies:

1. The "Entangled" Session (No More Waiting in Line)

Instead of treating every move as a separate job that gets dumped in a queue, EFaaS treats the strategist and the crystal ball as a tightly coupled team.

• The Old Way: Like sending a letter via the post office. You drop it in a box, wait days for it to be sorted, and hope the recipient is still awake.
• The EFaaS Way: Like a video call. As soon as the strategist finishes thinking, the crystal ball is already waiting, ready to listen. The "middleman" keeps the crystal ball's settings "warm" and active so there is no waiting in line and no need to recalibrate.

2. The "Warm Cache" (Keeping the Crystal Ball Tuned)

Quantum computers are like delicate musical instruments; if you don't play them for a few minutes, they go out of tune (this is called Quantum Drift).

• The Problem: If the strategist takes too long to think, the crystal ball goes out of tune. When they finally ask for an answer, the instrument is broken, and the result is garbage.
• The EFaaS Solution: The middleman acts like a tuning fork. It keeps the crystal ball tuned to the exact frequency needed for the current puzzle. It knows exactly how long the strategist will take and ensures the crystal ball is ready the instant the strategist is done. This prevents the "cold start" penalty where the machine has to stop and fix itself.

3. The "Future-Proofing" Trick (Doing Two Things at Once)

Usually, the strategist has to sit perfectly still and wait for the crystal ball to finish its calculation before they can think of the next move.

• The EFaaS Innovation: They introduced a trick called "EF-QuantumFuture." It's like the strategist starting to draft the next move while the crystal ball is still working on the current one.
• As soon as the crystal ball finishes, the strategist is already halfway through the next step. This "speculative" work hides the waiting time, making the whole process feel instantaneous.

4. The "Fair but Fast" Traffic Cop

The system also has to make sure that while this specific puzzle is being solved, it doesn't ignore other people waiting to use the crystal ball.

• The Solution: EFaaS uses a smart traffic cop (called Dual-Resource Fair Queuing). It gives the "hot" puzzle (the one currently being solved) a green light to jump the line, but only if it's part of the same active session. Once that puzzle is done, the crystal ball is immediately available for the next person. This ensures the expensive crystal ball is never sitting idle while the strategist is thinking.

The Results: Why It Matters

The paper tested this system against the old ways (waiting in line, or paying to lock the crystal ball exclusively for yourself).

• Speed: It reduced the time between moves by 11% to 94%.
• Efficiency: It kept the crystal ball busy and working 2% to 15% more of the time compared to other methods.
• Accuracy: It almost completely eliminated the "drift" errors, meaning the answers are much more reliable.
• Cost: It solved the puzzle 83% to 98% faster than the standard methods, without needing to pay for an expensive, exclusive reservation of the machine.

In short: EFaaS turns a slow, broken, stop-and-start process into a smooth, continuous conversation between a human and a machine, ensuring the machine stays tuned and the human never has to wait.

Technical Summary

Technical Summary: EFaaS

Problem Statement

As quantum computing enters the "Utility Era," realizing near-term advantage relies heavily on Hybrid Variational Quantum Algorithms (VQAs) such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA). These algorithms operate via a tightly coupled, iterative loop where a classical CPU optimizer updates parameters based on cost function evaluations performed by a Quantum Processing Unit (QPU).

Current quantum cloud access models, which rely on decoupled batch-queue systems, create a critical bottleneck for these workflows. The primary issues identified are:

1. Time-to-Next-Shot (TTNS) Latency: The iterative loop is severed by queue wait times ($t_{queue}$), which can span seconds to minutes. For algorithms requiring thousands of iterations, this inflates convergence time from minutes to days.
2. Quantum Hardware Drift: Extended delays between iterations ("cold starts") allow QPU calibration data to become stale. This drift degrades measurement fidelity and destroys the coherence of the optimization landscape, forcing costly recalibrations or causing algorithmic failure.
3. Resource Inefficiency: Existing solutions are binary and inefficient. Static QPU reservations eliminate queue latency but waste scarce QPU resources during classical computation phases. Conversely, stateless Functions-as-a-Service (FaaS) models fail to maintain the session context required to prevent cold starts and drift.

Methodology

The authors propose EFaaS (Entangled Function-as-a-Service), a novel serverless middleware designed to co-schedule classical parameter optimization and quantum circuit execution as "entangled, session-aware events." The architecture sits between the classical cloud orchestrator and the Quantum Control Plane, fundamentally redefining the relationship between the two domains.

The system relies on three core technical innovations:

1. Session Awareness and Calibration Caching

EFaaS introduces a Session Awareness Engine that treats QPU shots and CPU functions as a continuous session rather than isolated jobs.

• Mechanism: When a hybrid algorithm is submitted, the middleware negotiates a high-priority window with the Quantum Control Plane. It asserts a session flag ($E_s = 1$) to instruct the control plane to hold calibration data ($C_q$) in a localized cache.
• Logic: The scheduler ensures that the time between iterations ($\Delta t$) remains within the quantum coherence/drift threshold ($\tau_{drift}$). As long as the classical CPU returns the next circuit within this window, the QPU executes immediately without recalibration, driving $t_{queue} \to 0$ and $\delta \to 0$ (where $\delta$ indicates a cold start).

2. Calibration-Aware Placement Strategy

Unlike standard affinity policies based on software invariants (e.g., container liveness), EFaaS employs a placement strategy based on physical coherence-time thresholds.

• The scheduler tracks the calibration state of physical hardware.
• For active "Hot Iterators" (sessions where the CPU is computing the next parameters), the placement engine routes the circuit to the specific QPU holding the valid, warm calibration data.
• If the drift threshold is exceeded, a localized, partial recalibration is triggered before resuming the session, avoiding full system recalibration.

3. Dual-Resource Fair Queuing (DRFQ) and EF-QuantumFuture

To maximize Quantum Duty Cycle (QDC) without starving other workloads, EFaaS implements a Dual-Resource Fair Queuing scheduler.

• Priority Scoring: The scheduler assigns a dynamic priority score ($\rho_i$) to jobs, heavily weighting active sessions ($\alpha$) and the urgency of the calibration window ($\beta$). This ensures that returning circuits from active loops preempt standard batch jobs.
• EF-QuantumFuture Abstraction: To mask classical computation latency, the system introduces a speculative execution primitive. The middleware returns an asynchronous "Future" object immediately upon circuit submission. This allows the classical optimizer to speculatively execute non-dependent tasks (e.g., hyperparameter updates) while the QPU executes the current shot.
• Latency Reduction: The effective iteration latency is reduced to $L_{ent} = \max(t_{cpu} - t_{async}, 0) + t_{qpu} + t_{net}$, effectively overlapping classical and quantum execution.

Key Contributions

The paper claims the following specific contributions:

1. EFaaS Execution Model: A hybrid serverless model that co-schedules quantum circuits and classical optimization as session-coupled events, drastically reducing TTNS.
2. Calibration-Aware Placement: A routing strategy that prevents cold starts by directing circuits to QPUs with valid, iteration-specific calibration data, reformulating affinity validity from software invariants to physical drift dynamics.
3. Dual-Resource Fair Queuing (DRFQ): A scheduling policy that extends Dominant Resource Fairness to a setting where one resource (QPU shots) is subject to physical staleness constraints, maximizing QDC while preserving fairness for classical workloads.
4. EF-QuantumFuture: A speculative-execution primitive that enables non-blocking dispatch and a defined speculation/commit/abort contract over the classical optimizer state, a feature not present in prior hybrid frameworks.

Experimental Results

The authors evaluated EFaaS against four baselines: Standard Batch-Queue (SBQ), Pure FaaS (PF), Static Reservation (SR), and Pilot-Quantum (PQ). The evaluation used a discrete-event simulator with 31 benchmark circuits (2–16 qubits) running VQE-style workloads.

• TTNS Reduction: EFaaS achieved a mean TTNS of 3.6 s, representing a 92.5% reduction compared to SBQ (48.4 s) and 93.4% compared to PF (54.5 s). Compared to SR and PQ, EFaaS showed modest but consistent improvements (11.4%–14.9%) by leveraging speculative execution to reduce CPU-block wait times.
• Quantum Duty Cycle (QDC): EFaaS achieved a mean QDC of 23.4%, outperforming SBQ and PF by over 14 percentage points. It also exceeded SR by 2.2 percentage points, as SR's exclusive locking forces the QPU to idle during classical optimization steps, whereas EFaaS overlaps these phases.
• Convergence Speedup: End-to-end convergence time was reduced by 83.2%–98.3% across the benchmark suite. EFaaS converged in a mean of 22.9 s, compared to 213 s for SBQ and 320 s for PF.
• Drift Penalties: EFaaS accumulated zero drift events across the entire benchmark suite (with one statistical outlier in a complex circuit at maximum simulation time). In contrast, SBQ, PF, and PQ accumulated 95, 69, and 89 drift events respectively, forcing costly recalibrations. SR achieved zero drift but at the cost of resource efficiency.
• Scalability: The performance advantages remained durable as circuit complexity increased from 2 to 16 qubits, with TTNS remaining constant and QDC staying above 22%.

Significance and Claims

The paper argues that the scheduling layer is currently the dominant bottleneck for hybrid quantum workloads. The significance of EFaaS lies in its ability to simultaneously achieve low latency and calibration integrity without requiring the economically unscalable practice of exclusive QPU reservation.

By treating classical and quantum resources as entangled, session-aware entities, EFaaS resolves the "systems-level friction" that currently prevents VQAs from scaling effectively. The authors claim that their approach makes drift penalties "mechanistically impossible under normal operating conditions" through proactive TTL-aware cache renewal, while maintaining serverless elasticity and multi-tenant fairness. The results suggest that calibration-aware serverless scheduling is a necessary evolution for the "Utility Era" of quantum computing.