Did you know that you can navigate the posts by swiping left and right?

Quantum data centers : when a hop costs an exponent

03 Aug 2026 . category: networking . Comments
#networking #quantum #datacenter

the classical data center topology argument was settled a long time ago. fat-tree and dragonfly in 2008, BCube the year after, and by about 2015 the interesting question had moved from which topology to what does a port cost. the topologies became a catalogue. pick your oversubscription ratio, pick a radix, wire it up, and if you got it wrong you buy more spine switches.

a quantum data center is the same shape of problem with one term changed. still machines in racks, still switches between them. but what moves between the machines is entanglement, and entanglement is not a packet you can buffer and forward. it is a thing you attempt to create, over and over, until one attempt survives the fiber.

which means an extra hop does not add latency. it multiplies it.

this paper takes four topologies straight out of the classical catalogue, drops them into a quantum data center model, and reports what survives the translation. Pouryousef, Towsley, Kaur, Kompella, Shapourian and Nejabati, “Benchmarking Quantum Data Center Architectures: A Performance and Scalability Perspective,” arXiv:2601.01353, January 2026, Cisco Research and UMass Amherst. QFly, BCube, Clos and Fat-Tree, from 8 to 150 QPUs, under three workload shapes.

the headline finding is that the ranking flips. hold one resource fixed and Fat-Tree and Clos win. hold a different one fixed and QFly wins by a distance. the paper reports the flip as a result. i think it is a result about the experiment rather than about the architectures, and that reading it that way is more useful. more on that at the end.

below: what a quantum data center is made of, the one equation the whole paper runs on, why the fiber turns out to be irrelevant, what the four topologies actually do differently, and then what i’d want before i believed any of the rankings.

what is in the box

a QPU here is a small quantum processor: 16 data qubits that hold the algorithm’s state, and 5 communication qubits that talk to the outside world. the data qubits never leave. the communication qubits are the network interface.

between the QPUs sits an optical fabric with four kinds of part:

  • EPPS, entangled photon pair sources. they fire probabilistically. you do not ask for a pair, you take what arrives.
  • optical switches, which set up the light path. these are the topology.
  • BSM modules, Bell state measurement. two photons arrive, interfere, and if the detectors click in the right pattern the two distant qubits behind them are now entangled. this is the thing that actually creates a link.
  • single photon detectors.

the reason you want any of this is gate teleportation. if a circuit needs a two-qubit gate between a qubit on QPU 3 and a qubit on QPU 47, and those are different machines, you cannot just run the gate. what you do instead is consume a pre-shared entangled pair between the two QPUs, plus two classical bits, and the gate happens as if the qubits were adjacent.

so every non-local gate in the circuit is a request to the network for one EPR pair, and the question the paper is asking is how long that request takes and what it contends with. it is the same primitive that an entanglement distribution network hands to its users, with the distances collapsed from kilometres to a hundred metres. collapsing them changes which term dominates, and that turns out to matter enormously.

the one equation

here is the whole paper in three lines. an attempt to make an EPR pair takes

    T_att  =  T_src  +  2D/v_fiber  +  T_reset

the source period, the round trip for the heralding signal to come back, and the time to reset the communication qubit for another go. that attempt succeeds with a probability equal to the end-to-end transmittance of the optical path:

    T_chan  =  10^(−L_tot/10)

and attempts are independent, so the number of them you need is geometric and the expected time to get one pair is

    E[T_pair]  ≈  T_att / T_chan  =  T_att × 10^(L_tot/10)

that is the mechanism behind every result in the paper. loss goes into an exponent. every 3 dB you add to the path doubles the time to get a pair, forever, with no diminishing returns and no way to buffer your way out of it.

and the loss you are adding is:

    L_tot  =  L_fiber  +  L_sw  +  L_BSM  (+ L_mem)

with the switch term being the sum over every switch the photon passes through. a single switch of radix k is internally a tree of 2×2 elements, so its insertion loss goes as

    L_sw(k)  ≈  (2⌈log₂ k⌉ − 1) × ℓ_2×2

now look at the shape of those two expressions together, because it is the whole design argument. hop count multiplies the switch loss. radix only adds a logarithm to it. a path through five switches costs five times whatever one switch costs. making a switch eight times bigger costs you three more stages.

so in a quantum data center, flattening the topology is not a cost optimization the way it is classically. it is a physics optimization, and it is the only one available.

and the fiber does not matter at all

this is the part that surprised me, and it falls out of the paper’s own parameter table.

ParameterValueWhat it decides
QPU to switch, switch to switch0.1 kmnothing, as it turns out
Fiber attenuation0.1 dB/kmnothing, as it turns out
Switch insertion loss, per 2×2 stage0.3 dBthe entire loss budget
Communication qubit memory loss3 dBwhether repeaters are worth it
Communication qubit reset time10 µsthe attempt clock
EPR source rate106 pairs/sless than you would think
Coherence cutoff τ_cut, BCube only200 µswhether BCube works at all
Data qubits per QPU16how many QPUs a circuit needs
Communication qubits per QPU5never swept
Optical channels per fiber5never swept
Total BSM budget100swept two ways, and that is the problem

a six-link path is 0.6 km of fiber, which at 0.1 dB/km is 0.06 dB. one radix-8 switch is (2×3−1) × 0.3 = 1.5 dB. a single switch traversal costs twenty-five times what the entire fiber plant costs.

which means the loss budget of a quantum data center is, to within a rounding error, a count of how many switches you went through. the glass is free. the same thing is true of the ORNL campus network at 1.2 km, where a rerouted hop costs about 10 dB and the 250 m of fiber under it costs 0.05, and it holds even harder at 100 m.

play with it:

what a hop costs inside the buildingloss is an exponent, so hop count multiplies the time to get a pair. the fiber is the thin sliver on the left of the bar, and it never grows.fiberoptical switchesBSM and detection
paths these topologies actually produce
where the decibels go
expected time to one EPR pair, against switches traversed
total loss—
success per attempt—
attempts needed—
E[Tpair]—
fiber’s share—
against the same path classically—

two things worth noticing while the sliders are moving.

the attempt clock is the memory, not the light. the source runs at 10⁶ pairs per second, so it could offer an attempt every microsecond. the communication qubit takes 10 µs to reset. so the real attempt rate is 100 kHz, and somewhere between 60 and 77% of every attempt is a qubit waiting to become reusable. everything optical in this system is idling most of the time.

the classical comparison is not close. five hops in a classical data center costs you a few extra microseconds of store-and-forward, additively, and nobody designs around it. five switch traversals here costs a factor of five in EPR latency at the paper’s optimistic 0.3 dB, and a factor of a hundred and thirty if your switches are 1 dB per stage. diameter went from a nice-to-have to the dominant design variable, and that single fact is what the rest of the paper is exploring.

the four topologies

three of the four are switch-centric: the QPUs sit at the edge and do nothing but consume entanglement. the fabric carries it, and a single BSM somewhere along the path heralds the pair end to end.

ArchitectureKindShapeSwitches on the worst path
Fat-Treeswitch-centricedge, aggregation, core. k pods, 5k²/4 switches, k³/4 QPUs5
Closswitch-centricsame three tiers, but radix, rack fanout and fabric size dimensioned separately. two variants, tight and compact3 to 5
QFlyswitch-centricflattened, dragonfly-style. groups of QPUs under high-radix switches, switches linked directly to each other2
BCubeserver-centrick+1 switch layers of n-radix switches, every QPU on one switch per layer. QPUs act as repeaters2, plus a QPU in the middle

BCube is the interesting one, because it changes what a hop is.

in the three switch-centric designs, a long path means one long optical path with lots of switches in it, and one BSM at the end of it. the loss all multiplies together and you pay the exponent once, on a big number.

in BCube, a QPU in the middle of the path stores half of a pair, then does an entanglement swap. so the path is broken into segments, and each segment gets its own exponent on a small number. that is repeaters, applied at data center scale, which is a slightly startling thing to do over 200 metres of fiber and is exactly why it is worth testing. the wavelength-selective switch in a metro network is transparent for the same reason a switch-centric fabric is: nothing in the path stores or measures the photon. BCube gives that up on purpose.

the cost of doing that is two-fold. storing a photon in a memory has its own loss, 3 dB in the paper’s model. and you now need every segment to be alive at the same time, which is where the coherence cutoff τ_cut comes in: an early-finishing segment sits there decohering while it waits for its neighbours, and if it waits longer than τ_cut the whole thing is thrown away and restarted.

the paper reduces the trade to one number:

    ρ_ℓ  =  L_sw per hop  /  L_mem

if a switch traversal is cheap relative to a memory access, stay switch-centric and let the light go all the way. if it is expensive, break the path and swap. at the paper’s parameters, a radix-12 switch is 2.1 dB and a memory is 3 dB, so ρ_ℓ = 0.7, and switch-centric is comfortably ahead. push the insertion loss up and it stops being ahead.

let the light through, or break the path and swapswitch-centric pays one exponent on the whole path. server-centric pays a small exponent per segment, plus a memory, plus the risk that a segment ages out before its neighbours arrive.switch-centric, one BSMserver-centric, swap at each QPU
how segments are generated
jump to
expected time to one end-to-end pair, against path length
switch-centric—
server-centric—
ρℓ—
rounds surviving τcut—
verdict—

the shape to take away: switch-centric latency curves upward with path length and server-centric does not. breaking a path into segments converts an exponential in total loss into something much closer to linear, at the price of a memory per segment and a coherence budget that has to cover all of them. that is the same argument for repeaters that holds over 400 km of metro fiber, arriving at 200 metres because the switches are lossy enough to make it true.

whether it arrives depends entirely on ρ_ℓ, which is a number about your components and not about your topology.

what the simulation says

the workloads are three shapes of circuit, each with 16 data qubits per QPU:

  • nearest neighbour, gates between adjacent qubits in a chain. mostly local.
  • random Clifford+T, scattered CNOTs.
  • long range, uniformly random qubit pairs. every gate is a network request.

the metric is

    ρ_lat  =  T_distributed / T_monolithic

against a hypothetical single QPU that holds every qubit with all-to-all connectivity and no communication at all. ratios near 1 mean the network is nearly free; the paper reports roughly 1 at 16 QPUs and 2 to 4 at 128, depending on workload.

nearest-neighbour circuits stay almost flat, which is unsurprising and is worth stating anyway: if your compiler can keep the gates local, the topology barely matters. long-range circuits degrade steepest across every architecture. the entire architectural argument lives in the gap between those two.

the flip

now the result the paper leads with, and the one i want to look at hardest.

there are two ways to hand out BSM modules, and they give opposite answers.

fix the BSMs per switch. every switch gets, say, two. then an architecture’s total BSM capacity is proportional to its switch count, and Fat-Tree and Clos_tight, which have a lot of switches, end up with a large aggregate budget and the lowest latency ratios.

fix the total budget at 100 and spread it evenly. now more switches means fewer BSMs at each one, and the ones with few switches concentrate the resource. QFly wins across every scale, fully-connected QFly by the most.

at 128 QPUs a Fat-Tree needs about 80 switches and a QFly about 8. so the first accounting model hands Fat-Tree ten times the BSM hardware; the second hands QFly ten times the per-switch capacity. the two normalizations differ by a factor of a hundred in what they give one architecture relative to the other, and the ranking flipping between them is not really news about the topologies.

the ranking is a function of the accountingsame three switch-centric fabrics (Clos in both variants), same workload, three ways of paying for BSM modules. the third one is not in the paper.bestmiddleworst
how you pay for BSMs
time to finish the same long-range workload, lower is better
winner—
spread, best to worst—
BSMs in the fabric—

the configurations behind that widget are mine, worked out from the standard topology formulas at 128 QPUs rather than lifted from the paper’s own table, and the contention model is a crude demand / available queue. it is there to show the shape of the argument, not to reproduce the paper’s figures.

but the shape is the point. hold hardware fixed and you get one ranking, hold money fixed and you get another, and only one of those is a question an operator can act on.

two sensitivity results that are worth more than the rankings

coherence. BCube’s performance rises steadily with τ_cut from 50 µs upward. that is the “segments alive together” term in the widget above, and it means BCube’s viability is a memory specification, not an architecture choice. a group with 50 µs communication qubits and a group with 500 µs ones should build different data centers.

insertion loss. everything degrades as ℓ_2×2 rises, but Clos and Fat-Tree degrade much faster than QFly and BCube. this is the multiplication from the top of the post showing up in the results, and it is the cleanest finding in the paper: deep fabrics are a bet on cheap switches. if optical switch insertion loss improves, the tree topologies get more attractive. if it does not, the flat ones win and it is not close.

that second one is the sentence i’d hang the paper on. the ranking between the four architectures is essentially a forecast of one component parameter.

what’s missing

this is a simulation study, and simulation studies get graded on what they chose to model. these are the choices i’d push on.

there is no fidelity anywhere. the whole paper measures latency. it never tracks what state actually arrives. that matters enormously for the switch-centric versus server-centric comparison, because BCube’s advantage comes from entanglement swapping, and every swap compounds the infidelity of both segments while the switch-centric path has one BSM and no intermediate memories. a server-centric fabric that delivers pairs twice as fast at fidelity 0.8 is not better than a switch-centric one delivering at 0.95. for a distributed circuit it may be useless, because gate teleportation with a low-fidelity pair is just a noisy gate. the paper’s own framing is fault-tolerant distributed computing, where the relevant threshold is a fidelity, and the metric it reports cannot see it. this is the gap i’d close first.

the monolithic baseline is a fiction, and it hides the interesting number. T_mono assumes one QPU holding all the qubits, all-to-all connected, no communication cost. at 128 QPUs that is a 2,048-qubit all-to-all machine, which is precisely the thing distributed quantum computing exists because nobody can build. normalizing to it is fine as a denominator, but it means every reported number is a ratio to an impossibility, and the comparison an operator actually needs, this fabric against that fabric in seconds, is not printed. it also flatters everyone equally: four architectures at ρ_lat of 2 to 4 could all be unusable.

switch reconfiguration is excluded. the paper says so plainly, to isolate loss and memory effects, which is a reasonable thing to do in a sensitivity study. but MEMS optical switches settle in a millisecond or so and LCoS parts are slower, while the entire EPR generation being modelled takes tens to hundreds of microseconds. if the fabric reconfigures per gate, reconfiguration is not a correction term, it is the entire runtime, and the topology ranking is irrelevant next to how many gate requests you can serve per switch configuration. that is a scheduling question the classical optical data center literature already fought over, and it is the biggest omission here.

the scarce resource that is fixed is the one worth sweeping. BSM budget gets swept two ways. meanwhile optical channels per fiber sits at 5 and never moves, and communication qubits per QPU sits at 5. multiplexing is the standard answer to probabilistic entanglement generation: run m attempts in parallel on m wavelengths and the geometric mean time drops by roughly m. that is a direct multiplier on the exponent that the whole paper is organized around. my guess is that a serious multiplexing sweep would compress the differences between all four architectures, which is a more actionable finding than the ranking.

the workloads are the wrong worst case. “long range” here means uniformly random qubit pairs. no compiler would ever hand a fabric that. real distributed compilation partitions the circuit to keep gates local, and the interesting benchmark is not how does topology X do on random gates but how much does a bad partition cost me on topology X. one of these architectures probably degrades gracefully under a mediocre partitioner and another falls off a cliff, and that is the number a systems team would want.

the swap success probability never appears. BCube’s whole case rests on entanglement swapping at intermediate QPUs, and the probability that a swap succeeds is folded into a loss term rather than stated. with linear-optical Bell measurement it caps at 50%; with matter qubits it can be near-deterministic. those two worlds give completely different answers for BCube and the paper does not say which one it is in.

the coherence cutoff is applied to BCube only. switch-centric endpoints also hold entangled state while they wait: for a contended BSM, for the classical correction, for the other pairs a multi-qubit gate needs. giving decoherence to the server-centric design and not to the switch-centric ones puts a thumb on a scale that the paper is otherwise carefully balancing.

0.1 dB/km and 10 µs are optimistic in opposite directions. standard single-mode fiber at 1550 nm is about 0.2 dB/km, though at 100 m it makes no difference. the 10 µs reset does make a difference, since it is 60 to 77% of T_att depending on path length and therefore sets the clock for everything. trapped ions take hundreds of microseconds to milliseconds to recool and reinitialize, neutral atoms are slower still, and only a couple of platforms are anywhere near 10 µs. the results are a statement about one corner of the hardware space and are presented as if they were general.

no code. there is a simulator behind this, and a fairly elaborate one. event-driven, layer by layer, with contention and random service order. nothing in the paper points at a repository. a benchmarking paper whose conclusion is it depends on your parameters is exactly the kind that needs its tool published, because the useful artifact is not the rankings, it is the ability to re-run them with your own numbers.

what i’d build next

1. add fidelity and report a two-axis result. track the state through swaps and BSMs, and report the ratio that matters: time to deliver a pair above a target fidelity. i suspect this reorders the switch-centric versus server-centric comparison, and possibly reverses it, because BCube pays fidelity for the latency it saves and the paper’s metric only sees the saving.

2. put reconfiguration back in and make it a scheduling problem. measure gate requests served per switch configuration, then design a scheduler that batches non-local gates by the configuration they need. this is the actual co-design opportunity in the paper’s own conclusion, and it maps almost directly onto the classical hybrid optical-electrical data center scheduling literature, where the same “the switch is slow, so amortize it” argument was worked out at length a decade ago.

3. price it. define a cost unit for a switch port, a BSM module and a communication qubit, and sweep the total budget. report a Pareto front instead of two contradictory rankings. an operator never holds BSMs-per-switch fixed; they hold a purchase order fixed. the flip in this paper is a symptom of the missing cost model, and a cost model would be maybe a week of work on top of what already exists.

4. make multiplexing a first-class axis. channels per fiber and communication qubits per QPU, swept alongside topology. the hypothesis worth testing is that enough multiplexing makes the topology choice nearly irrelevant, which if true is the most useful thing the simulator could tell anyone, because buying wavelengths is cheaper than rewiring a building.

5. benchmark against a partitioner, not against random gates. take real circuits, run a real qubit-to-QPU placement, and measure sensitivity to placement quality per architecture. that turns the output from a topology ranking into a design rule.

6. do it at the logical layer. the intro cites lattice surgery and distributed surface codes, then benchmarks bare physical circuits. under error correction a non-local logical operation is a merge that consumes a stream of EPR pairs at a sustained rate, so the question stops being latency per gate and becomes entanglement bandwidth per logical operation. that is a throughput problem with completely different architectural implications, and it is where this field is actually heading.

7. publish the design rule, not just the plots. everything in the loss half of this paper reduces to E[hops] × (2⌈log₂ k⌉ − 1) × ℓ_2×2. that is a closed form. print it per architecture as a single coefficient, and a reader can evaluate their own fabric against their own switch datasheet without running the simulator at all. papers that hand you a number you can multiply get used; papers that hand you a bar chart get cited.

8. release the simulator. see above.

the short version

  • a quantum data center moves entanglement, not packets, and entanglement is attempted rather than forwarded. so an extra hop does not add latency, it multiplies it: E[T_pair] ≈ T_att × 10^(L_tot/10).
  • hop count multiplies switch loss; radix only adds ⌈log₂ k⌉ to it. flattening the topology is a physics optimization, not a cost one.
  • at 100 m links and 0.1 dB/km, the entire fiber plant is 0.06 dB against 1.5 dB for one radix-8 switch. the glass is free and the switches are everything.
  • the attempt clock is the 10 µs communication-qubit reset, not the 1 µs source. the source can offer ten attempts for every one the memory can accept.
  • four topologies: Fat-Tree, Clos and QFly are switch-centric with one BSM per path; BCube is server-centric and swaps at intermediate QPUs, trading one big exponent for several small ones plus a memory and a coherence budget.
  • the switch-versus-server trade collapses to ρ_ℓ = L_sw per hop / L_mem, which is a statement about your components rather than your architecture.
  • the ranking flips with the accounting. fixed BSMs per switch favors the deep fabrics; a fixed total budget favors QFly. at 128 QPUs those two normalizations differ by roughly 100× in relative resourcing, so the flip is a property of the experiment.
  • the two sensitivity results outlast the rankings: BCube’s viability is a coherence-time specification, and deep fabrics are a bet on optical switch insertion loss getting cheaper.
  • what is missing: fidelity anywhere at all, reconfiguration delay, multiplexing as a swept parameter, a cost model, a real partitioner, the swap success probability, and the code.

what i keep coming back to is the sentence the paper ends on, that performance cannot be inferred from topology alone. that is true, and it is also the conclusion of every classical data center benchmarking paper ever written, which is why classical work stopped ranking topologies and started publishing cost-normalized design rules instead. the quantum version has a cleaner story available than the classical one ever did, because the dominant term is a single closed-form expression in hops and radix. the loss model in the front half of this paper is more useful than the simulation results in the back half, and i would like to see somebody build the next paper on it rather than around it.