Hardware-Software Co-design for Distributed Quantum Computing

Quantum information is encoded in continuous complex probability amplitudes. Noiseless (pure) quantum states are linear combinations of eigenstates of the physical systems, i.e. quantum superpositions. Quantum states can be written as $|\psi\rangle=\alpha|0\rangle+\beta|1\rangle$ with $\alpha,\beta\in\mathbb{C}$, where $|0\rangle$ and $|1\rangle$ are orthonormal bases of a two-dimensional Hilbert space, and normalization requires $|\alpha|^{2}+|\beta|^{2}=1$. In quantum computing, an entire quantum circuit is a unitary operator $U$, s.t. $U^{\dagger}U=UU^{\dagger}=I$, where the dagger in the superscript denotes composition of complex conjugation and transpose, and $I$ is the identity operator.

Entanglement is another key feature of quantum mechanics, and also one of the most important resources in DQC. A canonical example of entangled states are the 4 orthonormal Bell states (EPR pairs) of two qubits: $|\Phi^{\pm}\rangle=\frac{1}{\sqrt{2}}(|00\rangle\pm|11\rangle)$, $|\Psi^{\pm}\rangle=\frac{1}{\sqrt{2}}(|01\rangle\pm|10\rangle)$. The Bell states can be transformed into each other via applications of single-qubit operations known as Pauli operators which are defined as follows: $X|0\rangle=|1\rangle$, $X|1\rangle=|0\rangle$ (also denoted as $\oplus$), $Z|0\rangle=|0\rangle$, $Z|1\rangle=-|1\rangle$, and $Y=iXZ$.

Environment perturbations will cause decoherence by imposing errors on quantum states. Decoherence generally transforms quantum states to mixed states, i.e. a statistical mixture of pure quantum states. A common error model is the Pauli channel that applies each of the three Pauli operators and the identity operator with certain probabilities. The fidelity of the mixed output quantum state $\rho$ with respect to the ideal pure output state $|\psi\rangle$: $F=\langle\psi|\rho|\psi\rangle$, is a key performance metric.

Heralded remote entanglement generation [10, 11, 12, 13] can establish entanglement between two local systems that have no direct physical interaction. The effective interaction is realized in the following way:

1. 1.

   The local systems emit photons which are entangled with themselves. Such matter-photon entanglement can be generally expressed as a standard Bell state.

2. 2.

   The two emitted photons are transmitted through a physical channel to an intermediate photonic Bell state measurement (BSM) station.

3. 3.

   The photonic BSM realizes an effective entanglement swapping [14], which conditioned on success projects the quantum state of two remote systems into a Bell state.

4. 4.

   The classical BSM result is communicated with the two end nodes, which heralds whether the remote entanglement generation is successful.

The above processes are visualized in Fig. 1(a).

In DQC, nonlocal multi-qubit gates between QPUs can be implemented through teleportation. We may either teleport qubits [15] from one QPU to another QPU, perform local multi-qubit gates and teleport the qubit back, or directly teleport the multi-qubit gates [16]. These approaches require Bell pairs as resources that are consumed for each attempt, local operations on each QPU, and potential feedforward Pauli frame correction. The circuit for quantum state teleportation is depicted in Fig. 1(b). Fig. 1(c) shows the specific circuit that teleports a CNOT gate.

Related to this work, AutoComm [17] and QuComm [18] are state-of-the-art approaches which take into account quantum circuit structure to harness the benefits of DQC. However, these works ignore one important feature - the probabilistic nature of EPR pair generation. AutoComm identifies burst communication patterns in the input program and utilizes state or CNOT teleportation to allow remote operations. It compiles the circuit and schedules remote operations offline, making it unaware of the real-time EPR pair generation pattern. QuComm identifies multi-node collective communication, and uses “buffer” qubits which store generated EPR pairs while communication qubits are freed up to be able to keep generating EPR pairs.

Several research papers have sought to reduce the communication overhead of distributed quantum programs by exploring various qubit partitioning and mapping techniques [19, 20, 21, 22, 23, 24, 25, 26]. Different from the mapping algorithms for monolithic devices [27, 28, 29, 30, 31, 32, 33], some work [34, 35, 36] focuses on tackling the mapping problem in multi-core quantum computers. Additional work incorporates a recent trend and use reinforcement learning for DQC compiling [37, 38]. These approaches are orthogonal to our work. Finally, a hardware-focused body of work recently emerged as well [39, 40, 41, 42].

The runtime of DQC in realistic heralded remote entanglement generation is affected by the success probability and the cycle time per attempt. The final fidelity of the DQC circuit output is affected by the quality of the generated entanglement (fidelity of the generated Bell pair). However, entanglement infidelity only injects errors into the circuit locally when implementing remote gates, similar to other noisy local gates.

Thus, the success probability of one entanglement generation attempt is $p_{\mathrm{succ}}=p_{pq,1}p_{pq,2}\eta_{t,1}\eta_{t,2}p_{s}\leq 1/2$. Note that both sides must succeed with the transmission.

1. 1.

   For realistic DQC, the allowed waiting time for photon emission should be a fixed value (cutoff time) otherwise the probabilistic nature of emission might lead to an excessively long wait for the emission. On the other hand, the chosen cutoff time will affect the photon emission probability for every attempt of the protocol.

2. 2.

   If successfully emitted, photons are transmitted via optical channels in which photons travel at the speed of light. The speed of light in optical fiber is $2\times 10^{8}\mathrm{m/s}$. Assuming that the length of the optical fiber from one QPU to the central BSM station is roughly 10m in a DQC center, the on-way transmission time is then $\sim 50$ns.

3. 3.

   Latency is introduced when extracting, processing, and transmitting classical measurement results from detectors. Even after obtaining and processing the measurement outcomes, latency may be introduced when transmitting the classical feedback using classical communication protocols. The lower bound for this last step is the physical transmission of information at the speed of light.

As a result, the total duration (cycle time) $T_{\mathrm{EG}}$ of a single heralded remote entanglement generation attempt is much longer than the cycle times for local operations $T_{\mathrm{local}}$. For the typical case we assume $T_{\mathrm{EG}}\geq 10T_{\mathrm{local}}$ [18].

We advocate the use of three types of qubits: buffer qubits, data qubits used to evaluate quantum circuits, and communication qubits which generate entanglement. A schematics of the architecture involving the three different types of qubits is shown in Fig. 2(a). After a pair of communication qubits successfully generates entanglement, each host node applies a local SWAP gate between its communication qubit and a buffer qubit. This results in storing the entangled state in the buffer qubit, whereas the communication qubit is freed up and can continue to be used in entanglement generation attempts. The buffer qubits can store multiple entanglement links to fulfill the demand for remote gates when needed. Decoupling EPR pair generation from storage also enables the pre-initialization of EPR pairs prior to program execution. As demonstrated in Section V, pre-initialized EPR pairs in the buffer (the init_buf design) reduce overall circuit latency. We note that QuComm [18] also formalized the concept of buffering in DQC to ensure sufficient communication resources for collective communication. In contrast, our work emphasizes the critical role of buffering in addressing the challenges of probabilistic EPR pair generation and evaluates the effectiveness of buffer qubits in this context. Next we provide additional motivation for introducing buffer qubits with focus on the system design perspective.

The cycle time for remote entanglement generation is generally much longer than the time scale of local quantum operations. For this reason we propose the use of asynchronous entanglement generation among all available communication qubits, a process that is able to “smoothen” the entanglement generation temporal pattern. This yields better resource allocation in the time domain.

In Fig. 3, we visualize the number of successfully generated entanglement links over time, in units of local operation cycle time $T_{\mathrm{local}}$, and without loss of generality we have assumed $T_{\mathrm{EG}}=4T_{\mathrm{local}}$. In the left panel, when all entanglement generation attempts are synchronous, the entanglement links will arrive in bursts. Remote gates thus need to wait for the burst arrival of entanglement links. After some links in the burst are consumed, the remaining links have to be stored in buffer qubits, which leads to idling decoherence, thus lowering the fidelity of remote gates. In contrast, the right panel demonstrates the pattern of asynchronous attempt when communication qubits are divided into 4 sub-groups, whose starting times of entanglement generation attempts are separated by $T_{\mathrm{local}}$. Different colors denote different sub-groups. In this way, the number of entanglement generated within one time unit is lower, but they distribute more uniformly over time so that some remote gates are able to utilize the entanglement links as soon as they are generated. Additionally, the burst arrival of entangled states can lead to excessive waste when we apply a cut-off policy to buffer qubits, i.e. reset buffer qubits if they store entanglement for too long to avoid too much decoherence in entangled states.

Adaptive scheduling of remote gates represents an additional optimization opportunity that can be implemented in software. Note that for simplicity this work assumes all remote operations are implemented through gate teleportation, and we leave the simultaneous inclusion of both state and gate teleportations as a future work.

Information about existing generated entanglement links can be exploited by the DQC controller. Before a remote gate is executed, we examine whether there are already enough entanglement links stored in the buffer qubits. If yes, we can execute the remote gate earlier so that it can consume existing entanglement as-soon-as-possible (ASAP). This will create a longer time interval between the executed remote gate and subsequent remote gates, and the communication qubits will have a higher chance to create additional entanglement links demanded by the subsequent gates. If there are not enough entanglement links available yet, we can push the remote gate back (as-late-as-possible, ALAP) so that there is more time to generate the required entanglement.

This adaptive circuit modification process must be performed in real time. Because dynamically resynthesizing the quantum circuit based on the number of available EPR pairs $e$ in the buffer is difficult, we can instead statically pre-compile multiple versions of the circuit. To ensure the scalability of the classical compilation, instead of recompiling the whole circuit, we partition the circuit into segments and use a look-up table strategy to manage them. Each segment is compiled with different scheduling policies, and the appropriate circuit version is selected in real time based on the number of available EPR pairs $e$. To achieve this, we first identify the remote gates and partition the original circuit into segments, where each segment contains $m$ remote gates. The parameter $m$ is tunable and is set to the product of the number of communication qubits and the EPR pair generation rate $p_{\mathrm{succ}}$ in our experiments. After partitioning the circuit, we can obtain the variants of the circuit segment corresponding to ASAP and ALAP, respectively, as illustrated by the examples in Fig. 4. During execution, if $e>m$, the controller looks up the next segment with ASAP policy. If $e=0$, the controller opts for the ALAP policy. Otherwise, the controller uses the original scheduling. We leave more complicated scheduling strategies for future work.

We evaluate different designs by comparing the circuit depth and the circuit fidelity. The circuit depth represents the total latency of the circuit. A depth of one corresponds to the latency of a single local CNOT gate. The circuit fidelity represents the quality of the final output. The fidelity is estimated as the product of fidelities of all local single-qubit gates, local two-qubit gates, remote gates implemented through gate teleportation, and an additional idling decoherence factor which accounts for latency. The local gate fidelities we use are listed in Table II. It is important to note that the fidelity of remote gates depends on the fidelity of the consumed entanglement link, which is affected by the buffer qubit decoherence. We use the phenomenological exponential decay factor $\exp(-\kappa t)$, where $t$ is the idling time, to model idling decoherence.

Inspired by a recent open-source ad hoc quantum network simulation [53], we simulate asynchronous entanglement generation by communication qubits and storage of entanglement by buffer qubits. The system parameters are documented in Sec. IV-A. We assume that the initially generated Bell state is in the Werner form, i.e., a mixture of a pure Bell state and a 2-qubit maximally mixed state. We also assume that all buffer qubits have an identical decoherence rate, and the decoherence channel is the unbiased depolarizing channel, i.e. the three Pauli errors have an identical probability. As a result, the idling dynamics of the Bell state fidelity is given by $F(t)=F_{0}\exp(-2\kappa t)+[1-\exp(-2\kappa t)]/4$, where $F_{0}$ is the initial fidelity. The fidelity of a remote gate is obtained through the evaluation of the gate teleportation circuit which includes a noisy Bell state, noisy local 2-qubit gates, and a noisy single-qubit measurement.

We evaluated different designs on a simulated 2-node 32-data-qubit DQC architecture with 16 fully-connected data qubits assigned to each node. Each node contains 10 additional communication qubits and 10 buffer qubits. The results are presented in Figure 5 and 6. In Figure 5, we compare the circuit depth across different designs. The y-axis represents the circuit depth relative to the ideal circuit depth. The original design, which lacks buffer qubits, results in significant EPR pair waste and a substantial increase of the circuit depth. As shown in the figure, the largest reduction of the depth is achieved by leveraging buffer qubits. The sync_buf design reduces the circuit depth by $61.7\%$. However, the synchronous EPR pair generation pattern in sync_buf does not align well with the remote gate request pattern. The asynchronous EPR pair generation design async_buf yields an additional average $7\%$ reduction of the circuit depth. Building on this, the adaptive scheduling adapt_buf further reduces the depth. By combining the pre-initialized EPR pairs and the adaptive scheduling, init_buf achieves an additional $7.5\%$ depth reduction compared to the non-adaptive async_buf design.

We also compared the estimated circuit fidelity across different designs. As shown in Figure 6, the async_buf and adapt_buf designs achieve the same fidelity, yielding an average improvement of 2$\times$ and 1.32$\times$ compared to the original and sync_buf designs, respectively. Although the init_buf design leverages the pre-initiated EPR pairs to shorten the circuit depth, the extended idle time of these EPR pairs can lead to reduced fidelity.

We evaluate performance with a different number of communication and buffer qubits. The results are shown in Figure 7. We pick the QAOA-r8-32 benchmark since the TLIM benchmark already achieves a near-ideal depth with 10 communication qubits, whereas the QFT-32 benchmark involves an excessive number of remote gates. The original design is excluded as it shows minimal change, allowing us to focus on the optimized designs. This also emphasizes that merely increasing the number of communication qubits is ineffective, as EPR pairs are wasted without proper storage in the buffer. As we increase the number of communication and buffer qubits, we notice a significant reduction of the circuit depth. Among the designs, init_buf consistently delivers the best performance. When the number of communication qubits reaches 20, it achieves a near-ideal depth, indicating that all remote gates are served immediately. Despite the significant reduction of the circuit depth, the circuit fidelity remains almost unchanged. Hence, we opted to not include the figure. The primary reason is that with asynchronous and adaptive scheduling EPR pairs are consumed immediately after generation, maintaining high fidelity across different cases. The relatively short circuit depth also minimizes the impact of decoherence errors, resulting in negligible differences of the fidelity.

We evaluate two QAOA benchmarks on a 2-node 64-data-qubit system with 32 data qubits allocated to each node. Each node contains 20 additional communication qubits and buffer qubits. The circuit depth comparison is presented in Figure 8. The init_buf design achieves a $12\%$ circuit depth reduction compared to the sync_buf design. As illustrated, our proposed designs continue to significantly reduce the circuit depth for larger system sizes.