Large quantum computers are increasingly being designed as several small chips ("cores") joined by slow, error-prone links. A quantum program must be split across them, and whenever two qubits on different cores need to interact, one qubit's state has to be shipped across a link. Today's compilers for these machines choose the split that minimizes the total number of such transfers. Classical parallel computing learned long ago that a small total is not enough. What sets the running time is the busiest processor or the busiest link, because everyone else waits for it at the next synchronization point. Measurements of modular quantum machines already show this: when QFT is spread over more cores, per-qubit traffic concentration ("hotspotness") rises by nearly 3,000%, and classical control messages alone reach up to 40% of runtime on a 10×10 core array.
We propose a mapper that directly targets the running time of the slowest core or link. It borrows negotiated congestion from classical routing. The compiler maps the circuit, simulates its timed execution on the actual inter-core network, and finds which links and cores stalled in which time windows. It then raises the price of those resources and maps again, repeating until the bottleneck stops moving. The central question is empirical and falsifiable: on realistic core-to-core networks such as rings and grids, does minimizing total communication leave a large, recoverable gap in execution time?
Core Claim
In modular quantum processors, a circuit's communication pattern behaves like an unevenly filled sparse matrix. In each time slice only a few qubit pairs interact across cores, and that interaction is concentrated on a few hot qubits. A mapper that minimizes total transfers therefore behaves like row-partitioned sparse kernels on GPUs: the aggregate cost is low, but stragglers dominate. We claim three things. First, total inter-core transfers correlate only weakly with simulated execution time once the inter-core network is a ring or grid rather than all-to-all. Second, a mapper that iteratively reprices congested links and cores cuts execution time well below the total-communication optimum, while adding only modestly to transfer count. Third, a simple static balance penalty in the cost function captures only part of this gain, because where the bottlenecks fall depends on timing, which only a scheduled simulation reveals.
Where This Sits in Prior Work
The motivating evidence comes from three characterization papers. Characterizing the Inter-Core Qubit Traffic in Large-Scale Quantum Modular Architectures defines hotspotness and a computation-to-communication ratio, and shows traffic imbalance exploding under strong scaling (the longest gate sequence for GHZ grows 1738% from 4 to 60 cores). It stops at measurement and proposes no compiler. Assessing the Role of Communication in Modular Multi-Core Quantum Systems models the interconnect, including medium-access limits, clock rates, and memory ports. It shows that a teleportation-minimizing mapper (TeleSABRE) halves teleportations and cuts execution time by over 50%, yet the share of time spent on classical communication grows. Minimizing volume shifts the bottleneck without removing it. Mapping quantum algorithms to multi-core quantum computing architectures shows that inter-core overhead surges under strong scaling with time-sliced partitioning, again assuming all-to-all cores.
The method we build on and compete against is Hungarian Qubit Assignment (HQA). It solves a linear assignment problem per time slice, with a lookahead "attraction force" toward upcoming partners. It reports a 1.28× average reduction in inter-core communications over graph partitioning (FGP-rOEE). HQA treats cores as bins connected all-to-all and scores only communication count. We keep its per-slice assignment engine and change two things: the cost it sees and the network it assumes.
The idea of balancing work rather than structure comes from classical sparse computing. Design Principles for Sparse Matrix Multiplication on the GPU splits work by non-zero elements instead of rows to remove straggler threads. SpDISTAL partitions distributed tensors by non-zero count. Balanced Sparsity forces equal non-zeros per block and reports a 3.1× speedup over unstructured sparsity on an LSTM trained on PTB. Our analogue of a "non-zero" is a scheduled transfer on a specific link in a specific time window. The analogue of balanced sparsity is a per-core, per-window transfer quota, which we test as a hard-constraint variant.
The theory papers constrain the design. Parallel token swapping for qubit routing proves that distance-only lower bounds can be off by Ω(n) on general graphs. Algorithmic Theory of Qubit Routing proves that SWAP minimization is NP-hard even on paths. Both tell us not to expect exact optima and not to trust hop-distance as a proxy for time, so we evaluate against a timed simulation. Route-Forcing is a cautionary case in the other direction: aggressive parallelism cut depth 4.7× but added 1.3× more SWAPs. We report both axes for that reason.
Research Program
We would build three components.
The first is a timed execution model for modular machines. It covers intra-core gates, inter-core state transfer along a configurable core graph (all-to-all, ring, 2D grid), per-link capacity, and classical-message latency, with parameters following the modeling choices in the communication-assessment paper above. From a mapped circuit it produces a makespan, the total execution time, and a record of which links and cores were busy or waited in each window.
The second is the mapper. We start from HQA's per-slice cost matrix, the cost of placing each logical qubit on each core. Each core $c$ and each inter-core link $\ell$ in each window $w$ carry a price $p_{c,w}$ or $p_{\ell,w}$, all initially zero. A transfer's cost becomes its hop count on the core graph plus the sum of prices along its route and at its endpoints in its window. After each map-and-simulate round, the prices of resources that were saturated or on the critical path are increased. The increase uses a history term that accumulates over rounds, so persistently hot resources become expensive, as in negotiated-congestion routers. The loop stops when the makespan stops improving.
The third is an analysis layer. It measures, over many mappings of the same circuit, how well total transfer count predicts makespan on each network topology. That relationship decides whether the whole problem is real.
Intra-core connectivity is held all-to-all in the main study to isolate the inter-core effect, as HQA does. A secondary study adds heavy-hex-like intra-core graphs using a standard single-chip router.
Baselines
The naive reference point is a round-robin or contiguous-block assignment of logical qubits to cores, recomputed at no time slice. It anchors how bad an unbalanced, unoptimized split is.
The graph-partitioning baseline is FGP-rOEE as used in Mapping quantum algorithms to multi-core quantum computing architectures. It represents standard partitioning with the usual equal-qubit-count balance constraint.
The strongest existing method is HQA from Hungarian Qubit Assignment. It is the best published total-communication minimizer for this setting, reporting a 1.28× average reduction in inter-core communications over FGP-rOEE and up to 3.4× on structured circuits. We found no reported makespan or execution-time result for HQA on non-all-to-all core networks, so the comparison on our main metric is new. We will run HQA and all variants on the same circuits, core counts, and timing model, with an identical lookahead window and decay tuned once on a held-out circuit family. Every method will get the same wall-clock compilation budget; our iterative loop's extra rounds count against it. Where the implementation is available, we also include TeleSABRE as described in Assessing the Role of Communication in Modular Multi-Core Quantum Systems, whose reported gain is halving teleportations and cutting execution time by over 50% relative to unoptimized mapping.
Two ablations isolate the key ingredient. The first is "HQA plus static balance penalty": a fixed term added to the cost for per-core and per-link load in each slice, computed from the circuit alone without simulation, with its weight tuned on the same held-out family. The second is the hard-quota variant, which caps transfers per core per window in the spirit of balanced sparsity.
Beating the field means a lower median makespan than both HQA and the static-penalty ablation on ring and grid core networks at 16 or more cores, at comparable compilation time. It also means an increase in total transfers of no more than a small, reported factor, and the gain must survive across circuit families rather than coming from one.
Why not just…?
Why not just add a load-balance term to HQA's cost matrix? This is the most serious threat, and it is why the static-penalty ablation exists. A penalty computed from the circuit sees how many interactions each core has, but not when transfers collide on a link. Collisions depend on scheduling and on multi-hop routes through the core graph, and the communication study shows that removing one bottleneck exposes another. If the static penalty matches the iterative version within noise, we will report that. The contribution then shrinks to the objective change and the correlation analysis, which still shows that total-count minimization is the wrong target.
Why not keep HQA's assignment and fix congestion by scheduling transfers more cleverly afterwards? Post-hoc scheduling can spread transfers across time, but it cannot move a hot qubit off an overloaded core. The QFT hotspot data in Characterizing the Inter-Core Qubit Traffic indicate that the concentration lives in the assignment itself. We test this by giving HQA's output our best congestion-aware scheduler and comparing it with the joint method. A small remaining gap would mean scheduling suffices.
Why not use a balanced graph partitioner like METIS? Such partitioners balance qubit counts per core, which is structural balance. That is the classical row-partitioning mistake that non-zero-based splitting fixed. They also lack temporal lookahead, and HQA already beats this family by 1.28× on communication. FGP-rOEE stays in as a baseline to confirm this on makespan.
Why not just add more link ports or faster interconnect? Hardware helps, but the same study reports that memory ports saturate after about three per core, and that classical communication dominates below roughly 50 MHz network clocks. We sweep clock frequency to show where software balancing matters and where it becomes irrelevant.
Proposed Experiments
The circuits are Cuccaro adders, QFT, GHZ, Grover, random circuits, and Quantum Volume, as used by HQA and the traffic study. We add large QASMBench circuits up to 127 qubits from QASMBench and circuits from MQTBench, which are cited as inputs in the communication-assessment paper. Systems range from 4 to 100 cores, up to about 1,000 qubits, on all-to-all, ring, and grid core networks.
The metrics are simulated makespan, total inter-core transfers, maximum link utilization, hotspotness, share of time in classical communication, and compilation time.
The first decisive check comes before any method comparison. Across a few hundred randomized and optimized mappings per circuit, we measure the rank correlation between total transfers and makespan. If it stays high on rings and grids, the premise fails and we stop.
The second check expects the proposed method's advantage over HQA to be near zero on all-to-all core networks and to grow with network diameter and core count. This follows because congestion arises only when routes share links. A gain appearing on all-to-all networks would suggest a modeling artifact.
The third check is GHZ, which the HQA paper reports as its one losing case. A star-shaped interaction pattern is inherently hot at one qubit, so we expect little room there. It serves as a sanity case where balancing should not help much.
Finally, we sweep network clock frequency to locate the regime in which balancing pays off. We report transfer-count inflation next to every makespan gain, so that a Route-Forcing-style trade of total operations for time is visible rather than hidden.
References
- Characterizing the Inter-Core Qubit Traffic in Large-Scale Quantum Modular Architectures
- Assessing the Role of Communication in Modular Multi-Core Quantum Systems
- Mapping quantum algorithms to multi-core quantum computing architectures
- Hungarian Qubit Assignment for Optimized Mapping of Quantum Circuits on Multi-Core Architectures
- Design Principles for Sparse Matrix Multiplication on the GPU
- SpDISTAL: Compiling Distributed Sparse Tensor Computations
- Balanced Sparsity for Efficient DNN Inference on GPU
- Parallel token swapping for qubit routing
- Algorithmic Theory of Qubit Routing
- Route-Forcing: Scalable Quantum Circuit Mapping for Scalable Quantum Computing Architectures
- QASMBench: A Low-level QASM Benchmark Suite for NISQ Evaluation and Simulation