A System Aware Resource Allocation for Distributed Workflows in Quantum Computing Environments
arXiv:2605.17944v1 [quant-ph] 18 May 2026
Abhishek Sawaika, Udaya Parampalli, Rajkumar Buyya Quantum Cloud Computing and Distributed Systems (qCLOUDS) Lab, School of Computing and Information System, The University of Melbourne, Australia [email protected], (udaya, rbuyya)@unimelb.edu.au
Abstract—Rapid advancements in cloud based platforms providing access to quantum computing capabilities have opened up several challenges for efficient usage of these highly delicate and costly devices. Although most of the current systems use a priority based access protocol, they are unable to fully support reliable, efficient, and scalable execution of larger-scale applications. To overcome this limitation, we propose a comprehensive solution for efficient allocation of quantum programs to appropriate quantum devices, considering all the relevant cost metrics into account including, fidelity, execution time and communication overhead. We also formulate use-cases for distributed quantum workflow and propose modified graph based algorithms to solve for allocation of such use-cases, assuming a hybrid classicalquantum network. Since hardware advancements in large standalone devices is an ongoing process, it is critical to investigate such distributed workflows to maximize the best utilization of current NISQ devices. Our empirical study shows that the proposed techniques perform better than state-of-the-art methods for almost all evaluation parameters, with average improvements of approximately 5% in execution time, 30% in communication overhead, 40% in wait time and 2% in fidelity, providing better solutions to efficient allocation strategies. Index Terms—resource allocation, quantum, workflow, greedy, isomorphism, soft, distributed, system aware, fidelity, network, communication cost, error
use of natural resources for computing applications [5]. So, it is only reasonable to develop strategies for efficient and sustainable use of available resources. Motivated by this we surveyed and identified that the resource consumption for quantum computers are also very high [6]. This work doesn’t propose a direct solution to optimize for their natural resource consumptions, rather an indirect approach is taken.
q0 q1 q2 q3 q4 meas
H 5
0
1
2
3
4
I. I NTRODUCTION
Fig. 1: A sample quantum circuit (GHZ state preparation) with 5 qubits, depth=6, 1 single qubit operation (H), four 2qubits operations (CNOT) and 5 measurements, representing a quantum program.
Quantum computing is an emerging technology based on fundamental principles of quantum mechanics [1]. Although in its nascent stages, QC research over the last two decades has shown potential for several practical applications [2]. This includes a wide range of problems such as factoring, search, material & chemical simulations, optimization, etc. [3]. A quantum algorithm can be modeled and simulated into a physical quantum system either through continuous-analog evolution or, using a sequence of discrete-digital operations in a quantum circuit [1]. Figure. 1 shows a quantum circuit for GHZ state preparation algorithm having CNOT and Hadamard gate operations in a specific sequence [1]. Where, qubits are the smallest units of information in quantum computing, powered by properties such as superposition and entanglement. It is known that the resources available on earth is limited [4], and due to its unregulated exploitation we’ll soon be left with nothing! This is also applicable to the unprecedented
With current hardware being noisy and prone to error [7], it becomes difficult to execute large scale problems on a standalone device. So, to effectively utilize the current state of these systems, it becomes important to form a distributed workflow for such large scale problems, and thereby solve them on a distributed environment. Hence, distributed quantum computing has got some traction over the past few years [8]. Different approaches have been proposed to formalize such distributed systems [9] and program execution [10]–[12]. Some of these uses classical communication between devices [12], [13], while other assume quantum communication [14], [15]. As mentioned in [23], [24], there are several challenge and open questions involving such systems, including but not limited to, networking, optimal program distribution and qubit mapping, efficient resource allocation and scheduling,
TABLE I: Related works and their comparison with our proposed solution Related work [16] [17] [18] [19] [20] [21] [22] Ours
Hybrid system ✓ ✓ ✓ ✓ ✗ ✗ ✓ ✓
Distributed workflow ✗ ✗ ✗ ✗ ✗ ✗ ✗ ✓
Error ✓ ✗ ✓ ✓ ✗ ✗ ✗ ✓
Completion time ✓ ✓ ✓ ✓ ✓ ✗ ✗ ✓
etc. This work looks into the problem of efficient resource allocation on a distributed quantum system. We assume a hybrid quantum-classical network [25] and abstract out the the need to distribute a single program, which is different from most of the work in [19]–[21]. Implementation source code can be found at https://github.com/z-ax-qsc/RADIQS. Major contributions of this work include the following: 1) We propose the concept of a distributed quantum workflow having an interlinked process of individual quantum programs. 2) We use all the relevant cost metrics that defines current systems, such as execution time, errors, and communication cost, together for the resource allocation problem. 3) We propose heuristic-based and randomized algorithms to solve the problem, and perform comprehensive experiments to evaluate them against baselines and stateof-the-art algorithms. The rest of the paper is organized as follows: Section II presents an overview of the existing work related to the similar problem domain as ours. Section III presents a detailed model of the designed system, optimization problem and the proposed algorithm. Section IV reports about the experimental setup and the analysis of results. Finally, some concluding remarks and future opportunities are provided in Section V. II. R ELATED W ORK Resource allocation has been a well known problem for operating systems research [26], [27]. It is also applicable to distributed architectures [28]–[30], cloud based systems [31], [32] and HPC environments [33], [34]. It is crucial for largescale computing pipelines to efficiently allocate resources over the available devices. Current developments towards the new quantum computing paradigm has challenges that need to be addressed specifically for such environments [35]. Being a combinatorial optimization problem [36] which can be modeled using some of the common mathematical formulations, see section III-B, it is observed that most of the existing works have also used some of the well known algorithms to solve them, see Table I, with certain modifications specific to quantum systems. Although, most of the recent work [16]–[20] addresses ”completion time” in their formulation of resource allocation problem, to the best of our knowledge and as presented in Table I, none of them have tackled for all the three cost parameters, including runtime, error (fidelity) and network
Network cost
Method used
✗ ✗ ✗ ✗ ✓ ✓ ✓ ✓
Binary linear programming Deep reinforcement learning Genetic algorithm Reinforcement learning Community detection in graphs Game theory Mixed integer linear programming Graph isomorphism based matching
costs together. For a robust allocation in the current NISQ era it is important to handle all of these metrics together, and our work strategically combines them in the cost function, see Equation 4. With monolithic quantum devices in their early stages of development, in terms of quality and quantity of qubits and gate operations, it is reasonable to study these systems under a distributed setup for practical execution of large-scale problems [8]. Where some of the recent work in [20]–[22] do address this problem within a networked environment, most of them in [16]–[19] considers a group of standalone quantum devices working collaboratively for the assigned tasks. While [19] assumes a classical network, [20]–[22] assumes a quantum network between distributed devices. All of these works assume a single quantum program (circuit) and divide it into multiple chunks for distributed execution. This is different from our use case, where we consider a distributed workflow of standalone quantum programs working in synergy for a larger computational task, see section III-A1. Since the new quantum systems will only supplement existing computing infrastructure and solve large-scale complex problems that are currently intractable, it should be noted that most of the computing tasks will be hybrid in nature [25], where some part is executed on quantum devices and others on classical machines. The authors in [37] provide a middleware to manage such problems in a quantum-classical hybrid environment. III. S YSTEM M ODEL AND P ROBLEM F ORMULATION This section provide details about the formulations of the designed system, optimization problem, constraints, decision metrics, and underlying assumptions for our use case. A. System Model We will first introduce the individual components of our system, followed by more details on problem model in the following subsection. 1) Distributed quantum system: An architecture of a cloud based quantum service manager with distributed quantum resources and multiple clients is shown in Figure 2. For completeness it also demonstrates a purely quantum interconnect model, but since these are more complex and has not been practically realized, we use the hybrid system for our formulations. Each input task is represented by a quantum
QPU
Quantum Resource Manager
Quantum Memory
QPU
QPU
Quantum Memory
Quantum Memory
Quantum Network Queue
Result Result Storage
End Users Input Tasks
Controller
Allocator
Allocated Tasks
Scheduler
Hybrid Network
Fig. 2: System Architecture
workflow as described in sub section III-A2. The main roles of the service provider (resource manager) include: A storage to store user requests and computational results. An allocator module to manage the allocation of user requests to appropriate devices. • A scheduler to send tasks to quantum devices based on a decided schedule and availability. • A controller to manage the network and other requirements of distributed quantum systems.
• •
This work propose new strategies for efficient allocation and assume standard setup for other modules. i.e. as the user requests reach the resource manager, it assigns them optimally to the required set of quantum machines and then schedules them based on their availability. Once a machine processes a user task, the resource manager temporarily stores this result and sends them back to the user once all the tasks in the requested workflow are processed. 2) Quantum workflow: A quantum workflow Ti is defined by (Gi , ti ), Where, Gi = (QCij , Ei ) is the graph with nodes representing individual tasks QCij (quantum circuit) and Ei representing dependency between these tasks. ti is the arrival time of the workflow request Ti , ∀i ∈ [1, M ] & ∃j ∈ {2, N }. Where, M is the total number of workflows and N indicates the maximum allowable task per request Ti . Properties relevant to a task represented by QCij : qbij - Number of qubits cdij - Circuit depth 2 • gij - Number of 2-qubit gates • mqij - Number of measured qubits • shtij - Number of shots • •
Examples of sample task workflows are shown in Figure 3. Each example represents a user request with multiple tasks. A simplest use case for a size two workflow (N=2) represents a graph state initialization followed by a QNN task . 3) Quantum nodes: A quantum node Qk is defined by (g, e, m, qb, rt), where: • gk - Set of local gate operations r • ek - Error model including; readout error (ek ), average 1 2 2-qubit error (ek ), average 1-qubit error (ek ). • mk - Qubit connectivity at hardware level • qbk - Number of qubits • rtk - Runtimes including; T 1k coherence time, T 2k coherence time, average single qubit gate runtime (rt1k ), average two qubit gate runtime (rt2k ) and readout time (rtrk ) • d1cpsk - Depth-1 circuit layer operations per second. • natk - Next available time. The set of available QPUs (Quantum Processing Units) is defined by Q = {Qk }, ∀k ∈ [1, K]. The network of available quantum nodes Q is defined using an undirected graph GQ = (Q, E Q ), where links are predefined using a hybrid quantumclassical network. B. Problem definition Having described the low level components of the designed system, this subsection formally lays out the optimization formulation for the resource allocation problem. Let, at a given simulation time (t) the task set chosen for allocation is defined by T t = {Ti | ti <= t} and the available QPUs by the set Q, then our objective is to find an injective mapping F : T t → Q, where F(Ti ) = Qi = {(QCi1 , Qx ), (QCi2 , Qy ), ...}j
(1)
such that, ∀ Ti ∈ T t → Qi ⊆ Q, and |Qi | = |Ti | & Gi ⊆ GQi (Connectivity constraint)
(2)
(∀Qk ∈ Qi & QCij ∈ Ti ) → qbij ≤ qbk (Qubit constraint) (3) and, minimize the weighted cost function min ζAi + (1 − ζ)(αEi + βRi + γNi ) , ∀Ti ∈ T t (4) such that, ∀Qk ∈ Qi & QCij ∈ Ti , •
Next available time (Ai ) = max({natk })
•
Total error (Ei ) =
•
Total runtime (Ri ) =
P
j,k E(QCij , Qk )
P
j,k R(QCij , Qk )
Total network cost (Ni ) = N (Ti , Qi ) Where, weights ζ ≤ 1, α + β + γ = 1 and E, R, N measures the cost associated to the execution of assigned task on the chosen machine. It is to be noted that the constraints in equations 2, 3 indicate that the assigned quantum machines should have enough qubits to execute the program and the connectivity between these QPUs should match that of requested workflow. •
It is essentially a combination of errors associated with 1,2qubit gate operations and the readout error for executing the quantum circuit QCij onto the quantum machine Qk . We define, E(QCij , Qk ) = 1 − (1 − e1k )cdij ∗ (1 − e2k )
√ 2
gij
∗ (1 − erk )qbij
(5)
2) Runtime: As mentioned in [40], the runtime of a quantum program can be characterized by its quantum volume and the speed of the quantum computer usually defined by CLOPS (Circuit Layer Operations Per Seconds). Since the current NISQ devices are error prone, it is also important to consider the number of shots for statistical significance. We use a simplified version of the formulation described in [40], using the circuit depth and D1CPS(Depth-1 Circuit Layer Operations Per Second) as a proxy of quantum volume and CLOPS, respectively. s.t. R(QCij , Qk ) =
cdij ∗ shtij d1cpsk
(6)
3) Communication latency: As mentioned earlier, we assume a hybrid quantum-classical network between quantum devices. Such that, N (Ti , Qi ) = X
N q (j, j ′ , k, k ′ ) + N c (j, j ′ , k, k ′ )
(j,j ′ )∈Ei & (k,k′ )∈E Qi Amplitude Estimation
QNN
DeutschJozsa
Graph State
N=2
Phase Estimation
N=3
QFT
GHZ state
Ground State
Random Circuit Two Local
Shor's
Grover's
QAOA VQE
N=4 N=5
Fig. 3: Sample quantum workflows of different sizes, where ’N’ denote the number to tasks in each workflow.
C. System Cost Metrics Sub section III-B have already hinted about the three main cost functions, namely E, R, N . Here, we provide more details on their definition and mathematical formulations. 1) Error: The error of executing a task on a quantum computer is defined by properties of both the participating entities. The following formulation is constructed, derived and taken from the estimates and work presented in [38], [39].
s.t. q q N (QC ij , Qk ) + N (QCij ′ , Qk′ ) N q (j, j ′ , k, k ′ ) = 2 & N c (QCij , Qk ) + N c (QCij ′ , Qk′ ) N c (j, j ′ , k, k ′ ) = (7) 2 Where, N q (j, j ′ , k, k ′ ) is the cost of quantum link between nodes Qk and Qk′ executing tasks QCij , QCij ′ , respectively. Similarly, N c (j, j ′ , k, k ′ ) is the cost of classical link. As proposed in some of the recent works, such as in [41] , [42], [43], quantum networks are mainly realized using EPR (Einstein-Podolsky-Rosen) pair generation and BSM (Bell state measurements) over interconnected nodes with single or multi-hop transfer links (switches). Based on this, N q (QCij , Qk ) =
ϱ ∗ 10 ∗ qbij ∗ rt2k HM (T 1k , T 2k ) ∗ η ns
(8)
where, ϱ is connection success probability, η is transmission efficiency, ns number of switch between links, HM (T 1k , T 2k ) is harmonic mean of the two coherence times. Whereas, the characteristics of the classical information transfer are derived from the work done in [44] and [45] for an interconnected system of distributed quantum machines. s.t., N c (QCij , Qk ) = ρ ∗ mqij Where, ρ is the classical communication latency.
(9)
D. Key Assumptions This work assumes the following properties about the designed system: 1) Quantum machines of the same qubit modality (superconducting) but with different system characteristics is used. 2) All circuits are mappable to any given hardware topology and their transpiled versions are used for allocation problem. 3) Cost for retention of information in quantum/classical memory is ignored. 4) Task graphs are represented by directed acyclic graphs for ordered execution. See Figure. 3 for sample 5) Sub tasks execute asynchronously under hybrid quantum -classical communication. 6) All links between any pair of quantum devices are assumed to be similar in terms of underlying networking modules used. 7) There are enough machines to cater any individual task requirements. But, it should be noted that joint requirements of a workflow is dependent on connectivity of the distributed system. 8) Each QPU has their own queue and tasks allocated to them are executed in FCFS manner.
MQT dataset
Data extraction and processing
Simulation End
Begin Simulation
Yes
All Task processed
Wait Queue
No
Select workflow (T) for allocation
Qpu Data
Are Qpus available
Put workflow (T) to wait queue
No
Yes
Select optimal combination of Qpus for workflow (T)
Allocate and update qpu information
E. Proposed Algorithm As depicted in Figure 4, the simulation happens in discrete time intervals, where at a give simulation time (t) it collects all the workflows submitted by various users and pick them oneby-one on FCFS basis for passing it to the assignment algorithm for allocation. In case there are multiple user requests at the same time instance, it choose workflows in ascending order of qubit requirements or break tie based on user priority. This process continues until all tasks are assigned. The algorithms described in 1, 2 is used to assign one workflow at a time having multiple sub tasks. To meet the objectives defined in sub section III-B, we propose SoftIso, an extended version of graph isomorphism algorithms in [46], [47] with early stopping criteria for nonexhaustive search process, see Algorithm 1. This involve deviation thresholds from the maximum cost value and the previous cost value as THRES MAX and THRES PREV, respectively. The ”mapping” and the ”qubits” functions evaluates the conditions in Equations. 2 and 3, respectively. Since graph isomorphism is a NP hard problem, our solution with early stopping criteria provide reasonable guarantees for a faster solution on average. It is to be noted that it will still have exponential overhead for large and complex problem in worst case. Results in Table IV validates this with acceptable tradeoffs on system cost values. In addition to this we have also designed a randomized selection algorithm, RandomAware, as described in Algorithm 2. This algorithm assign tasks in ascending order of qubits to a random QPU having at most that many qubits. This is done for multiple trials and the final allocation is chosen from
Tasks
Fig. 4: Process pipeline for experimental simulation the one having lowest cost value among all the feasible trials. The number of random trials is set to the number of tasks in the input workflow. Although this algorithm doesn’t perform best in all the scenarios, it can still be beneficial over other algorithms for some use cases, see section IV-B for more detail. IV. P ERFORMANCE E VALUATION We conduct multiple experiments to analyze the performance of proposed algorithms for different scenarios and evaluation metrics. Details about the common experimental setup and the parameters used are provided in subsection IV-A. We report the comparisons with the procedure used in CloudQC [20], and a baseline greedy strategy named GreedyDfs. GreedyDfs assign tasks based on ascending order of qubit requirements to the nodes in ascending order of qubits availability and depth-first-search order of node connectivity. Our results in section IV-B indicate promising improvements over both of these techniques. A. Experiment Setup An open source discrete-event-based quantum simulator, QSimPy [48], is used for simulation experiments. It is extended as per our use case with elements including virtual
Algorithm 1: SoftIso
Algorithm 2: RandomAware Q
Input: Ti (chosen workflow), GQ (resource network) Output: Qi (assigned QPUs)
Input: Ti (chosen workflow), G (resource network) Output: Qi (assigned QPUs) iter ← GraphM atcher(GQ , Gi ) // mincost ← ∞; 3 maxcost ← −∞; 4 prevcost ← 0; 5 counter ← 0;
1
[46], [47]
2
// GQ∫ ⊂ GQ Q 6 for G ∫ ∈ iter do // with workflow i and QPU set ∫ 7 cost ← ζA∫ + (1 − ζ)(αE∫ + βR∫ + γN∫ ); 8 maxcost ← max(cost, maxcost); 9 if cost < mincost then // Conditions as in Eq. 2, 3 10 if mapping(GQ∫ , Gi ) & qubits(Q∫ , Ti ) then 11 mincost ← min(cost, mincost); 12 Qi ← Q∫ ; 13 end // Early stopping 14 if (|∆(cost, maxcost)| > T HRES M AX AND |∆(cost, prevcost)| > T HRES P REV ) OR counter ≥ 10|Ti | then 15 break; 16 end 17 end 18 counter ← counter + 1; 19 end
representations of quantum workflows, tasks and nodes. We use calibration data from actual hardware and quantum task definition from benchmarking datasets. 1) Dataset: There are two main data sources for our simulations, one for the quantum node properties and the other for quantum task definitions. a) Nodes: Calibration data for three IBM machines, namely brisbane, torino and marrakesh, are loaded from [49]. Details of these machines can be found in Table II. Every simulation experiment randomly chooses the required number of nodes, out of these three choices, and decide a random topology based on network success probability ϱ. b) Tasks: Quantum circuit definitions from MQT Bench dataset [50] is used, with properties as mentioned in Table III. Loaded circuits are compiled using qiskit transpiler for the three target machines. Quantum workflows of sizes ranging from 1-5 is created by randomly choosing them from a set of feasible combinations. For every simulation experiment an initial collection of user workflows is created, we call them workload, using Poisson’s distribution for arrival times and an uniformly sampled collection of program circuits with qubits between 1 and 100.
1
mincost ← ∞;
while trials ≤ |Ti | do // Initialize with empty set 3 Qs ← Φ; // sort tasks by qubits 4 Ti ← sort(Ti , qbij ); // Find task to QPU mapping 5 for QCij ∈ Ti do 6 Sj ← {Qk | qbk ≥ qbij }; 7 Qs ← Qs ∪ RandomSelect(Sj ); 8 end // with workflow i and QPU set s 9 cost ← ζAs + (1 − ζ)(αEs + βRs + γNs ); // Condition check as in Equation. 2 10 if cost < mincost and mapping(GQs , Gi ) then 11 mincost ← min(cost, mincost); 12 Qi ← Qs ; 13 end 14 trials ← trials + 1; 15 end 2
TABLE II: Node properties Properties Number of qubits CLOPS One qubit runtime (s) Two qubit runtime (s) Readout runtime (s) T1 coherence time (s) T2 coherence time (s) Median readout error Median single qubit error Median two qubit error
IBMbrisbane 127 180000 60e-9 660e-9 1600e-9 220.53e-6 128.92e-6 2.393e-2 2.517e-4 7.042e-3
IBMtorino 133 220000 32e-9 68e-9 1560e-9 181.41e-6 138.75e-6 2.991e-2 3.296e-4 2.68e-3
IBMmarrakesh 156 200000 36e-9 68e-9 2584e-9 188.11e-6 111.97e-6 1.074e-2 3.047e-4 2.451e-3
2) Experiment Parameters: We have assumed a singleswitch path between interlinked node (ns = 1) and the transmission efficiency (η) of 1 dB. To define the connectivity between nodes, the success probability of quantum link (ϱ) is set to 0.5, and the classical communication latency (ρ) to 0.02. The network of quantum nodes (resources) is created by randomly choosing the required devices from the set of available machines. We use equal weights for the availability and the three system metrics in Equation 4. i.e. ζ = 0.5 and α = β = γ = 1/3, for a balanced consideration of all the cost functions. THRES MAX and THRES PREV are set to 0.1 and 0.03, respectively for the SoftIso algorithm. It is to be noted that all the values of different cost function evaluations are normalized between 0-1 for an equivalent comparison. The parameters mentioned here are common for most of the results, unless stated otherwise.
TABLE III: Task properties Task property
Details
Source Number of qubits in tasks Program types Workflow size Compiler Arrival distribution Simulated hardwares
MQT Bench [50] [5-100] Random Circuit, Ground State, QFT, GHZ, QPE, AE, Graph State, Grover, DJ, QAOA, QNN, VQE, Shor’s [1-5] Qiskit Poissons ibm-brisbane, ibm-marrakesh, ibm-torino
3) Evaluation Metrics: Experiments are evaluated for six major metrics, including two performance metrics such as algorithm run time and percentage workload completion, and four system metrics like execution time, wait time, fidelity and communication cost. These help us in capturing an overall pictures of the designed system and perform a comprehensive comparison of proposed algorithms under different scenarios. All values are calculated as an average of 100 random experiments with same parameters but different workloads. A workload is defined as a collection of user workflows received by the allocator. Brief description of these metrics include: a) Execution Time: It is the total time taken by a given workload, with multiple workflows, to run on the assigned QPUs. This is characterized mainly by the gate runtime of the QPU. b) Wait Time: It is the sum of waiting time for all the tasks in their respective QPU queue. It is an important metric to evaluate the efficiently of allocation algorithms. c) Fidelity: Fidelity measures the accuracy of the results generated by a noisy QPU for executing the assigned task. There are different ways to calculate the fidelity of program execution [1], and in our case we use the simplest formulation as: F idelity = 1 − Error (10) Where, the error is characterized as defined in Equation 5. Higher the fidelity, better the results. Here, we measure it as the average fidelity of all the tasks submitted for an experiment. d) Communication overhead: Along with the fidelity and the execution time, this metric helps in evaluating the overall system performance of the resource allocation strategy. This is calculated as the sum of total communication cost, see Equation 7, for running all the workflows to the assigned network of interconnected QPUs. e) Algorithm runtime: It is the total cpu time required to simulate/run an experiment by a given allocation algorithm. The results for this metric are reported in Table IV. f) Task completion: This measures the percentage of the total tasks that are successfully allocated by an algorithm, over all the tasks in the workload. B. Results and Discussion We analyze the results observed from various experiments conducted for the allocation problem. This includes perfor-
mance comparison of different algorithm, trend analysis under varying parameters, optimized cost evaluations, etc. All the results reported in this section is an average of 100 experiments with similar parameters and different random seed for choices such as, workflow selection, node topology, and other algorithm specific requirements. 1) Trend Analysis: We did experiments and analyze the performance trends over, the size of workload (batch size), the number of quantum machines available (nodes), and the number of tasks per workflow (group), as shown in sub figures (a), (b), (c), respectively of Figures 5-9. The results here have (tasks per group, batch size) = (4, 50), (tasks per group, nodes) = (3, 5) & (nodes, batch size) = (5, 50), for the analysis on the number of nodes, batch size and tasks per group, respectively. These values are chosen for a reasonable sized system and workflows which can be practically realized within the current infrastructure. As shown in Figures 5a, 8a and 9a, the values of communication cost, execution time and wait times increases exponentially with the workload size. This is mainly because there are more tasks to execute and the cost of quantum simulation grows exponentially with problem size [51]. On the other hand, fidelity generally increases linearly because of the linear relation between workload size and quantum program. A peak at batch size = 100 is observed because of the intricate choice of quantum nodes having less error rates for that experiment, see Figure. 6a. With increase in the number of nodes, SoftIso and RandomAware algorithms have an increasing trend over different metrics. Whereas, CloudQC and GreedyDfs algorithms have either mixed or decreasing trends, see Figures 5b, 6b, 8b, 9b. This shows that both SoftIso and RandomAware methods can be used effectively for larger environments. Since the amount of links involved in communication increases with the number of tasks per workflow, there is an increasing trend seen in Figure. 5c. This linear increase supports well for the scalability of these solutions. But, the execution and wait times generally decrease with the number of tasks per group, see Figure. 8c, 9c. This is because of the simultaneous allocation of more tasks per decision cycle. Since a balanced cost function is used for Equation 4, fidelity and execution times had to compensate for this inherent increase in communication cost. It is important for the allocator to evenly distribute the workload among all the available QPUs with a reasonable
CloudQC
GreedyDfs
RandomAware
SoftIso
CloudQC
500
RandomAware
CloudQC
SoftIso
300 250 200 150 100
30 25 20 15 10 5
50 10
50
100
200
500
SoftIso
40 35 30 25 20 15 10 5
0
0
RandomAware
45
Total communicatinon cost
350
GreedyDfs
50
35
400
Total communicatinon cost
Total communicatinon cost
GreedyDfs
40
450
0
5
1000
10
15
20
1
2
3
Number of nodes
Batch size
a
4
5
Tasks per group
b
c
Fig. 5: Trends for communication cost by (a) workload size for allocation, (b) number of nodes in the network and (c) distinct tasks per workflow CloudQC
GreedyDfs
RandomAware
SoftIso
CloudQC
GreedyDfs
RandomAware
SoftIso
CloudQC 0.602
0.62
0.598
0.6
0.61
0.596
0.6 0.59 0.58
Average task fideliy
0.6
Average task fideliy
Average task fideliy
0.63
0.594 0.592 0.59 0.588
0.57
10
50
100
200
500
RandomAware
SoftIso
0.598 0.596 0.594 0.592 0.59 0.588
0.586
0.56
GreedyDfs
0.586
5
1000
10
15
1
20
2
a
3
4
5
Tasks per group
Number of nodes
Batch size
b
c
Fig. 6: Fidelity trends by (a) workload size for allocation, (b) number of nodes in the network and (c) distinct tasks per workflow Algorithms CloudQC GreedyDfs RandomAware SoftIso Workload ditribution by time
Workload ditribution by time
0.5 0.4 0.3 0.2
Algorithms CloudQC GreedyDfs RandomAware SoftIso
0.4
0.3
0.2
0.1
0.1 0.0 50
100
Batch size
200
500
1000
0.8
0.6
0.4
0.2
0.0 10
Algorithms CloudQC GreedyDfs RandomAware SoftIso
1.0
Workload ditribution by time
0.6
0.0 5
10
Number of nodes
a
b
15
20
1
2
3 Tasks per group
4
5
c
Fig. 7: Time distribution of workload per QPU, for different (a) workload size for allocation, (b) number of nodes in the network and (c) distinct tasks per workflow
consideration of other cost metrics. An uniform distribution can help towards a scalable strategy that also avoids critical bottlenecks. As shown in Figure 7, the box plots represents the percentage of time invested by each QPU in executing the entire workload. Wider boxes represents an unfair distribution where some QPUs are overloaded than others. Plots having a smaller variance and a fairly central average line is best for our problem specification. The impact of workload size on the variance of time shared by individual QPU is very insignificant. This is a good sign for all the algorithms in terms of scalability requirements. Though, the average share per QPU increases slightly with the workload size as there are more tasks to be executed. As shown in Figure 7a, RandomAware performs best, with SofIso slightly better than CloudQC.
As the number of available nodes increase the load is distributed only to fewer QPUs while others remain idle, see Figure 7b. This indicates that there is no need to overwhelm the system with for too many QPUs for a reasonable allocation. When the number of nodes are set to 5 and 10, SoftIso performs better with an average load of 20% per QPU and an evenly distributed workload. In Figure 7c we observe that most of the qpus remain idle for cases with fewer tasks per group. This is justified because workflows with less tasks require less networking as compared to workflows with more tasks. Since the average line tends towards 0, most of the qpus have less contribution when allocated using CloudQC. Whereas, for SoftIso and RandomAware algorithms the distributions are fair enough to most of the QPUs.
GreedyDfs
RandomAware
CloudQC
SoftIso
45000
Total execution time
Total execution time
40000 35000 30000 25000 20000 15000 10000
GreedyDfs
RandomAware
SoftIso
CloudQC
3500
3500
3000
3000
2500
2500
Total execution time
CloudQC 50000
2000 1500 1000 500
5000 10
50
100
200
500
SoftIso
2000 1500 1000
0 5
1000
RandomAware
500
0
0
GreedyDfs
10
15
20
1
2
Number of nodes
Batch size
a
3
4
5
Tasks per group
b
c
Fig. 8: Execution time(seconds) trends by (a) workload size for allocation, (b) number of nodes in the network and (c) distinct tasks per workflow GreedyDfs
RandomAware
SoftIso
CloudQC
GreedyDfs
RandomAware
CloudQC
SoftIso
16000
70000
7000000
14000
60000
6000000
12000
5000000 4000000 3000000
10000 8000 6000
2000000
4000
1000000
2000
10
50
100
200
500
1000
RandomAware
SoftIso
40000 30000 20000 10000
0
0
GreedyDfs
50000
Total wait time
Total wait time
Total wait time
CloudQC 8000000
0
5
10
Batch size
a
15
20
1
2
3
Number of nodes
Tasks per group
b
c
4
5
Fig. 9: Trends of wait time(seconds) by (a) workload size for allocation, (b) number of nodes in the network and (c) distinct tasks per workflow
2) Algorithm Comparisons: To understand and project a high level picture of the algorithmic performance, we created four different scenarios and did a stress test for all the algorithms. These cases include: SP-LR: Smaller system with smaller workflows, lesser workload and fewer nodes. • SP-MR: Overwhelmed system with smaller workflows and batch sizes, but more quantum resources and a densely connected network. • LP-LR: Overloaded system with much larger workload and complex workflows, but only a few quantum devices. • LP-MR: Large system with enough resources and fully connected network capable of running large scale workloads.
•
Where, SP → small-program with (tasks per group, batch size) = (2, 10), LP → large-program with (tasks per group, batch size) = (4, 500), LR → less-resources with (ϱ, nodes) = (0.3, 10), and MR → more-resources with (ϱ, nodes) = (0.9, 20). As reported in Table IV, all algorithms performs equally well in terms of completion percentage, except for the overloading case (LP-LR) where SoftIso performs exceptionally well. But, it should be noted that there is a trade-off in terms of cpu runtime for these techniques. Being a light weighted algorithm, RandomAware have the least decision time whereas, SoftIso takes the most amount of time due to the complexity of isomorphism problem. As compared to CloudQC, SoftIso has a reasonable trade-off with ∼3X improvement in completion
percentage and around 50% increase in cpu runtime. Even though the RandomAware algorithm has only 10% completion rate for the overloading case, it is still the least time taking approach. If ran for more number of trials, this can achieve comparable or even better results than other algorithms within a reasonable time bound. GreedyDfs algorithm also performs better than CloudQC on these metrics, but as mentioned in the following section IV-B3 the trade-off over other critical cost metrics are not negligible. If we see the distribution of task failures over all the 25K experiments, with every possible combinations of available hyperparameters (Figure 10), it can be noted that SoftIso have reasonably higher completion rate. Where, other algorithms like GreedyDfs and RandomAware performs poorly with around 50% - 30% experiments having more than 25% failure rate, SoftIso performs excellently with only around 2% experiments with high failures rates. Even the CloudQC algorithm has almost 5X more experiments with more unfulfilled tasks, than the SoftIso algorithm. 3) Costs Analysis: After analyzing the execution times of the four algorithms, Figure 8, it is clear that SoftIso performs better than all the other three techniques. It takes around 2-3% less time than CloudQC. Being randomized, there are mixed results for RandomAware algorithm, but it does have improved results than SoftIso for few of the cases. On the contrary, RandomAware performs best in terms of wait time among all the tree algorithms. It is around 2X better than Cloud QC and 0.5X better than SoftIso, see Figure 9.
TABLE IV: Model performance based on average decision time and delivery(%). SP means small-program and LP means large-program with (tasks per group, batch size) = (2, 10) and (4, 500), respectively. LR means less-resources and MR means more-resources with (ϱ, nodes) = (0.3, 10) and (0.9, 20), respectively. Average completion (%)
Model SP-LR
SP-MR
LP-LR
LP-MR
SP-LR
SP-MR
LP-LR
LP-MR
100 100 100 100
100 100 100 100
32 30 10 91
100 100 99 100
0.1281 0.0206 0.0337 0.1933
0.2116 0.0454 0.0626 0.3572
7.5288 1.4315 0.8018 10.2132
9.8415 0.9435 2.0141 74.1821
CloudQC GreedyDfs RandomAware SoftIso
CloudQC
GreedyDfs
1500 1000
4000
alternative method, RandomAware, showed improved results in multiple scenarios. Since development of quantum technology is an ongoing process, real life use cases for large scale problems can only be realized when proper infrastructure with quantum network is set up. Despite this fact, our work is still relevant to existing systems and can be easily extended to solutions with more metrics, workflow types, etc. This work can also be applied to environments with heterogeneous vendors and act as a supplementary module towards a complete solution for an endto-end quantum cloud management system.
3000 2000
ACKNOWLEDGMENTS 0.5
0.4
0.3
0
0.2
1000 0.1
Average fraction of unfulfilled tasks by count
5000
0.0
1.0
Number of experiemnts
SoftIso
0.8
0.6
0.4
0.2
0.0
Number of experiemnts
1.0
Average fraction of unfulfilled tasks by count
RandomAware 3500 3000 2500 2000 1500 1000 500 0
0.8
Average fraction of unfulfilled tasks by count
0.6
500 0
1.0
0.8
0.6
0.4
0
0.2
1000
2000
0.4
2000
2500
0.2
3000
3000
0.0
Number of experiemnts
4000
0.0
Number of experiemnts
5000
Decision time (s)
Average fraction of unfulfilled tasks by count
Fig. 10: Histogram of unfulfilled tasks over all the experiments ran with different combinations of parameters.
Though there is not much difference in terms of fidelity among the four methods, Figure. 6, SoftIso and RandomAware still have slightly higher values than CloudQC. But, when looked into the communication cost, see Figure 5, SoftIso is a clear winner with ∼40-50% improvement. RandomAware also has slightly better result than CloudQC with ∼5% improvement in most of the cases. It is mainly because of the nature of our proposed methods to give equal priority to various cost functions that they performed better than CloudQC, which in principle focuses more on optimizing for connectivity. It is important to note that GreedyDfs performs worst in all the scenarios because it only solves for the constraints and doesn’t consider the cost functions explicitly in the process. V. C ONCLUSIONS AND F UTURE W ORK In this paper, we proposed a practical solution to resource allocation problem for distributed quantum workflows using relevant system metrics into consideration. Our empirical results show that the proposed method, SoftIso, performs better than existing state-of-the-art methods, with average improvements of approximately 5% in execution time, 30% in communication overhead, 40% in wait time and 2% in fidelity, with a trade-off of around 50% on cpu runtime. Even the
This work is supported by the University of Melbourne and Maitri scholarships from the Department of Foreign Affairs and Trade, Government of Australia. R EFERENCES [1] M. A. Nielson, I. L. Chuang, M. A. Nielsen, and I. L. Chuang, “Introduction - Quantum computation and quantum information,” p. 700, 2010. [2] A. Khang, Applications and principles of quantum computing. IGI Global, 2024. [3] F. Bova, A. Goldfarb, and R. G. Melko, “Commercial applications of quantum computing,” EPJ Quantum Technology 2021 8:1, vol. 8, pp. 2–, 1 2021. [4] F. Schmidt-Bleek, “The Earth : Natural Resources and Human Intervention,” p. 247, 2011. [5] M. Dayarathna, Y. Wen, and R. Fan, “Data center energy consumption modeling: A survey,” IEEE Communications Surveys and Tutorials, vol. 18, pp. 732–794, 1 2016. [6] D. Jaschke and S. Montangero, “Is quantum computing green? An estimate for an energy-efficiency quantum advantage,” Quantum Science and Technology, vol. 8, p. 025001, 1 2023. [7] J. Preskill, “Quantum Computing in the NISQ era and beyond,” Quantum, vol. 2, p. 79, 8 2018. [8] M. Caleffi, M. Amoretti, D. Ferrari, J. Illiano, A. Manzalini, and A. S. Cacciapuoti, “Distributed quantum computing: A survey,” Computer Networks, vol. 254, p. 110672, 12 2024. [9] D. Barral, F. J. Cardama, G. Dı́az-Camacho, D. Faı́lde, I. F. Llovo, M. Mussa-Juane, J. Vázquez-Pérez, J. Villasuso, C. Piñeiro, N. Costas, J. C. Pichel, T. F. Pena, and A. Gómez, “Review of Distributed Quantum Computing: From single QPU to High Performance Quantum Computing,” Computer Science Review, vol. 57, p. 100747, 8 2025. [10] H. Buhrman and H. Röhrig, “Distributed Quantum Computing,” Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 2747, pp. 1–20, 2003. [11] A. Childs, R. Kothari, M. Kovacs-Deak, A. Sundaram, and D. Wang, “Quantum Divide and Conquer,” ACM Transactions on Quantum Computing, vol. 6, 4 2025.
[12] G. Bisicchia, J. Garcı́a-Alonso, J. M. Murillo, and A. Brogi, “Distributing Quantum Computations, by Shots,” Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 14419 LNCS, pp. 363–377, 2023. [13] C. Piveteau and D. Sutter, “Circuit Knitting With Classical Communication,” IEEE Transactions on Information Theory, vol. 70, pp. 2734–2745, 4 2024. [14] S. W. Loke, “From Distributed Quantum Computing to Quantum Internet Computing: an Overview,” 8 2022. [15] C. Qiao, Y. Zhao, G. Zhao, and H. Xu, “Quantum Data Networking for Distributed Quantum Computing: Opportunities and Challenges,” INFOCOM WKSHPS 2022 - IEEE Conference on Computer Communications Workshops, 2022. [16] G. S. Ravi, K. N. Smith, P. Murali, and F. T. Chong, “Adaptive job and resource management for the growing quantum cloud,” Proceedings - 2021 IEEE International Conference on Quantum Computing and Engineering, QCE 2021, pp. 301–312, 2021. [17] H. T. Nguyen, M. Usman, and R. Buyya, “DRLQ: A Deep Reinforcement Learning-based Task Placement for Quantum Cloud Computing,” IEEE International Conference on Cloud Computing, CLOUD, pp. 475– 481, 2024. [18] E. Giortamis, F. Romão, N. Tornow, D. Lugovoy, and P. Bhatotia, “Orchestrating Quantum Cloud Environments with Qonductor,” [19] W. Luo, J. Zhao, C. San Jose, T. Zhan, and Q. Guan, “Adaptive Job Scheduling in Quantum Clouds Using Reinforcement Learning,” Proceedings of ACM Conference (Conference’17), vol. 1, 6 2025. [20] R. Zhou, Y. Gan, Y. Liu, and C. Qian, “CloudQC: A Network-aware Framework for Multi-tenant Distributed Quantum Computing,” 4 2025. [21] B. O. Sane, M. Hajdušek, and R. Van Meter, “Optimizing Resource Allocation in a Distributed Quantum Computing Cloud: A GameTheoretic Approach,” 4 2025. [22] S. Bahrani, R. D. Oliveira, J. M. Parra-Ullauri, R. Wang, and D. Simeonidou, “Resource Management and Circuit Scheduling for Distributed Quantum Computing Interconnect Networks,” IEEE JOURNAL ON SELECTED AREAS IN COMMUNICATIONS, vol. XX, 9 2024. [23] J. C. Boschero, N. M. Neumann, W. van der Schoot, T. Sijpesteijn, and R. Wezeman, “Distributed Quantum Computing: Applications and Challenges,” Lecture Notes in Networks and Systems, vol. 1423 LNNS, pp. 100–116, 2025. [24] A. S. Cacciapuoti, M. Caleffi, F. Tafuri, F. S. Cataliotti, S. Gherardini, and G. Bianchi, “Quantum Internet: Networking Challenges in Distributed Quantum Computing,” IEEE Network, vol. 34, pp. 137–143, 1 2020. [25] F. Phillipson, N. Neumann, and R. Wezeman, “Classification of Hybrid Quantum-Classical Computing,” Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 14077 LNCS, pp. 18–33, 2023. [26] J. L. Peterson and A. Silberschatz, “Operating system concepts,” p. 625, 1985. [27] A. K. Singh, P. Dziurzanski, H. R. Mendis, and L. S. Indrusiak, “A Survey and Comparative Study of Hard and Soft Real-Time Dynamic Resource Allocation Strategies for Multi-/Many-Core Systems,” ACM Computing Surveys (CSUR), vol. 50, 4 2017. [28] A. Goscinski and M. Bearman, “Resource management in large distributed systems,” ACM SIGOPS Operating Systems Review, vol. 24, pp. 7–25, 9 1990. [29] K. Krauter, R. Buyya, and M. Maheswaran, “A taxonomy and survey of grid resource management systems for distributed computing,” Software - Practice and Experience, vol. 32, pp. 135–164, 2 2002. [30] P. T. Endo, A. V. De Almeida Palhares, N. N. Pereira, G. E. Goncalves, D. Sadok, J. Kelner, B. Melander, and J. E. Mångs, “Resource allocation for distributed cloud: Concepts and research challenges,” IEEE Network, vol. 25, pp. 42–46, 7 2011. [31] B. Jennings and R. Stadler, “Resource Management in Clouds: Survey and Research Challenges,” Journal of Network and Systems Management 2014 23:3, vol. 23, pp. 567–619, 3 2014. [32] D. Professor, “A Survey on Resource Allocation Strategies in Cloud Computing,” IJACSA) International Journal of Advanced Computer Science and Applications, vol. 3, no. 6, 2012. [33] H. Hussain, S. U. R. Malik, A. Hameed, S. U. Khan, G. Bickler, N. MinAllah, M. B. Qureshi, L. Zhang, W. Yongji, N. Ghani, J. Kolodziej, A. Y. Zomaya, C. Z. Xu, P. Balaji, A. Vishnu, F. Pinel, J. E. Pecero, D. Kliazovich, P. Bouvry, H. Li, L. Wang, D. Chen, and A. Rayes, “A
survey on resource allocation in high performance distributed computing systems,” Parallel Computing, vol. 39, pp. 709–736, 11 2013. [34] M. S. Qureshi, M. B. Qureshi, M. Fayaz, W. K. Mashwani, S. B. Belhaouari, S. Hassan, and A. Shah, “A comparative analysis of resource allocation schemes for real-time services in high-performance computing systems,” International Journal of Distributed Sensor Networks, vol. 16, 8 2020. [35] A. D. Corcoles, A. Kandala, A. Javadi-Abhari, D. T. McClure, A. W. Cross, K. Temme, P. D. Nation, M. Steffen, and J. M. Gambetta, “Challenges and Opportunities of Near-Term Quantum Computing Systems,” Proceedings of the IEEE, vol. 108, pp. 1338–1352, 8 2020. [36] C. H. Papadimitriou and K. Steiglitz, Combinatorial optimization: algorithms and complexity. Courier Corporation, 1998. [37] P. Mantha, F. J. Kiwit, N. Saurabh, S. Jha, and A. Luckow, “PilotQuantum: A Quantum-HPC Middleware for Resource, Workload and Task Management,” 12 2024. [38] D. C. McKay, I. Hincks, E. J. Pritchett, M. Carroll, L. C. G. Govia, and S. T. Merkel, “Benchmarking Quantum Processor Performance at Scale,” 11 2023. [39] E. Magesan, J. M. Gambetta, and J. Emerson, “Characterizing quantum gates via randomized benchmarking,” Physical Review A, vol. 85, p. 042311, 4 2012. [40] A. Wack, H. Paik, A. Javadi-Abhari, P. Jurcevic, I. Faro, J. M. Gambetta, and B. R. Johnson, “Quality, speed, and scale: three key attributes to measure the performance of near-term quantum computers,” arxiv.orgA Wack, H Paik, A Javadi-Abhari, P Jurcevic, I Faro, JM Gambetta, BR JohnsonarXiv preprint arXiv:2110.14108, 2021•arxiv.org. [41] M. Pompili, S. L. Hermans, S. Baier, H. K. Beukers, P. C. Humphreys, R. N. Schouten, R. F. Vermeulen, M. J. Tiggelman, L. dos Santos Martins, B. Dirkse, S. Wehner, and R. Hanson, “Realization of a multinode quantum network of remote solid-state qubits,” Science, vol. 372, pp. 259–264, 4 2021. [42] S. Shi and C. Qian, “Concurrent Entanglement Routing for Quantum Networks: Model and Designs,” SIGCOMM 2020 - Proceedings of the 2020 Annual Conference of the ACM Special Interest Group on Data Communication on the Applications, Technologies, Architectures, and Protocols for Computer Communication, pp. 62–75, 7 2020. [43] H. K. Beukers, M. Pasini, H. Choi, D. Englund, R. Hanson, and J. Borregaard, “Remote-Entanglement Protocols for Stationary Qubits with Photonic Interfaces,” PRX Quantum, vol. 5, p. 010202, 3 2024. [44] A. Carrera Vazquez, C. Tornow, D. Ristè, S. Woerner, M. Takita, and D. J. Egger, “Combining quantum processors with real-time classical communication,” Nature, vol. 636, pp. 75–79, 12 2024. [45] Y. AC-C, “Some complexity questions related to distributed computing,” in Proc. 11th Annual ACM Symposium on Theory of Computing, 1979, pp. 209–213, 1979. [46] L. P. Cordella, P. Foggia, C. Sansone, and M. Vento, “A (sub)graph isomorphism algorithm for matching large graphs,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 26, pp. 1367–1372, 10 2004. [47] M. Houbraken, S. Demeyer, T. Michoel, P. Audenaert, D. Colle, and M. Pickavet, “The Index-Based Subgraph Matching Algorithm with General Symmetries (ISMAGS): Exploiting Symmetry for Faster Subgraph Enumeration,” PLOS ONE, vol. 9, p. e97896, 5 2014. [48] H. T. Nguyen, M. Usman, and R. Buyya, “QSimPy: A learningcentric simulation framework for quantum cloud resource management,” Quantum Computing, pp. 165–183, 1 2025. [49] “IBM Callibration Data,” 2025. Available at https://quantum.cloud.ibm. com/docs/en/guides/qpu-information#calibration-data. [50] N. Quetschlich, L. Burgholzer, and R. Wille, “MQT Bench: Benchmarking software and design automation tools for quantum computing,” Quantum, 2023. MQT Bench is available at https://www.cda.cit.tum.de/ mqtbench/. [51] I. M. Georgescu, S. Ashhab, and F. Nori, “Quantum simulation,” Reviews of Modern Physics, vol. 86, p. 153, 3 2014.