WorksPhysics and Astronomy
Universal Quantum Computer Simulation of 50 Qubits on Europe`s First Exascale Supercomputer Harnessing Its Heterogeneous CPU-GPU Architecture
Abstract
We have developed a new version of the high-performance Jülich universal quantum computer simulator (JUQCS-50) that leverages key features of the GH200 superchips as used in the JUPITER supercomputer, enabling simulations of a 50-qubit universal quantum computer for the first time. JUQCS-50 achieves this through three key innovations: (1) extending usable memory beyond GPU limits via high-bandwidth CPU-GPU interconnects and LPDDR5 memory; (2) adaptive data encoding to reduce memory footprint with acceptable trade-offs in precision and compute effort; and (3) an on-the-fly network traffic optimizer. These advances result in a 16.6-fold speedup over the previous 48-qubit record on the K computer
Introduction
Quantum computing promises transformative advances in cryptography, materials science, quantum chemistry, and artificial intelligence [1]. However, current quantum hardware remains limited by noise, gate infidelity, and restricted circuit depth, making large-scale, reliable execution infeasible. As a result, simulation of quantum circuits on digital computers remains essential for algorithm development and benchmarking.
Simulation of quantum circuits on digital computers is computationally demanding, as both memory usage and runtime scale exponentially with the number of qubits [2]. Recent progress in high-performance quantum simulators has begun to mitigate these challenges by exploiting massively parallel architectures. JUQCS-50 is a high-fidelity universal quantum computer simulator that demonstrates near-linear scalability in elapsed time with increasing qubit count, enabling simulations at unprecedented scale.
Leveraging the JUNIQ (Jülich Unified Infrastructure for Quantum Computing) platform and the JUPITER supercomputer, JUQCS-50 supports the simulation of quantum circuits with up to 50 qubits for the first time.
This capability enables accurate benchmarking of algorithms such as the Variational Quantum Eigensolver (VQE) and the Quantum Approximate Optimization Algorithm (QAOA), well beyond the reliable operating regime of current quantum processors.
Although some quantum processors now exceed 50 qubits, current devices still suffer from substantial noise and limited gate fidelities, which severely restrict the reliable circuit size and depth. For example, a simple 4-bit adder (depth 10) on an IQM chip achieves only a 70 % to 80 % success rate, and performance degrades rapidly for larger circuits (a 50-qubit adder requires 1001 gates and depth 101). Even recent breakthroughs, such as the demonstrations of surface-code quantum error correction below threshold [3], where increasing the code distance yields exponentially improved logical lifetimes, highlight that today’s hardware is only beginning to enter the regime where scalable fault-tolerant computation becomes feasible. In contrast, classical simulations of the same circuits produce numerically exact results, unaffected by hardware noise or decoherence.
This work makes the following contributions:
Demonstration of the first universal 50-qubit quantum computer simulation, using exascale capabilities.
High-performance system design achieving effi
cient execution on 16 384 GH200 superchips using hybrid memory and optimized communication.
Adaptive byte encoding combining low-precision arithmetic with FP64 to reduce memory footprint and improve performance.
Comprehensive performance evaluation, including weak and strong scaling studies using Hadamard circuits.
The remainder of this paper is organized as follows. The next Section briefly discusses the computational problem. § 3 provides an overview of the current state of the art in quantum computer simulation techniques. § 4 describes the methods and optimizations implemented in JUQCS-50 that enable simulations at the 50-qubit scale. § 5 introduces the performance metrics used to evaluate JUQCS-50, and § 6 presents the corresponding performance results. In § 7, we discuss an application of JUQCS-50 to adder circuits, including both the approach and results. Finally, § 8 concludes the paper with a summary of the key findings and perspectives for future work.
Problem statement
A universal quantum computer [2] simulator requires storage for the full state vector (wave function) describing the state of the quantum computer [2]. Using the FP64 representation, storing the (complex-valued) state vector for an -qubit quantum computer requires bytes of memory, accounting for the number of bytes required to store an element of the state vector. For example, representing the state of a qubit quantum computer requires 64 GiB of memory in FP64 precision.
A quantum program is a sequence of quantum gates [2], each of which modifies the state vector. In general, each gate affects all the elements of the state vector. Simulating a single-qubit quantum gate amounts to multiplying all disjoint pairs of state vector elements by a matrix (corresponding to the quantum gate), the choice of pairs being determined by the particular qubit on which the quantum gate is applied. Similarly, simulating a two-qubit quantum gate amounts to multiplying all disjoint quadruples of state vector elements by a matrix (corresponding to the quantum gate), the choice of quadruples being determined by the particular qubits on which the gate is applied. As all these matrix-vector multiplications involve disjoint elements only, these operations can be carried out in parallel. Depending on the qubit(s) addressed, the pairs (quadruples) of vector elements may be located very far apart in memory. For instance, for a single-qubit gate acting on one of the qubits , the two indices of a pair differ by . This is a characteristic feature of a gate-based quantum computer simulator and is of prime importance when the state vector becomes so large that the memory storing all its elements has to be distributed over several processing entities—NVIDIA Grace Hopper GH200 superchips, in our case (see § 4).
In the distributed-memory setting, it is convenient to use as the superchip index, the integer representation of as many of the high-order bits of the element address as needed [4]. Let denote the number of qubits for which the state vector fits into the memory of one GH200 superchip. Then the number of superchips required to simulate an qubit quantum computer and the number of state vector elements per superchip are given by and , respectively. Performing a single-qubit gate on qubit with index requires no exchange of data between superchips because each pair of amplitudes that need to be updated resides in the memory of the same superchip, and all pairs can be updated in parallel. The same holds for two-qubit gates involving qubits . These are the embarrassingly parallel cases: all superchips can perform the necessary calculations independently without any communication between the superchips. In contrast, for a single-qubit gate on qubit (or a two-qubit gate with its target qubit [2] index exceeding ), superchips have to exchange data.
Focusing on the single-qubit case for simplicity, it follows that half of the state vector elements stored in each superchip need to be exchanged [4]. This redistribution of elements always involves pairs of superchips, the indices of these superchips depending on the qubit that is being considered. For two-qubit gates, three-quarters of the number of elements need to be transferred between pairs of superchips.
As an example, consider simulating a qubit quantum computer on the JUPITER supercomputer, requiring a total of GiB to store all state vector elements in FP64 precision. Because of the inherent restriction to powers of two, characteristic of qubit systems, each GH200 GPU with 96 GiB memory (see Figure 1 for a diagram of a node) can hold the equivalent of of these state vector elements (64 GiB). This implies that with each single-qubit gate applied to a qubit with index , 16 384 GiB of data traverses through the network fabric before the gate operation can actually be carried out. Even for the fastest communication networks that are available today, it is clear that as the number of qubits increases, the data exchange between superchips, when not performed efficiently, may become a very time-consuming and limiting part of the simulation. In summary,
Figure 1. Overview of JUPITER’s quad GH200 node design with included technology and bandwidths. Each node contains four GH200 superchips, each comprising a tightly integrated pair of CPU (blue) and GPU (green); see § 4. Each processor includes its main memory (LPDDR5 and HBM3, respectively); CPUs have individual cores shown. Purple blocks indicate network interfaces. Lines between node blocks indicate available connections, with respective bandwidths superimposed.
Required memory and compute time increase exponentially with the number of qubits .
The number of floating point operations per gate is given by , where is a factor that depends weakly on the kind of gate.
For all gates involving qubits with indices smaller than , there is no communication between superchips.
For a single-qubit gate on the qubit with index , all superchips have to perform a send-receive operation, exchanging elements of the state vector.
For a two-qubit gate involving a target qubit with index in the interval , all pairs of superchips have to perform a send-receive operation, exchanging elements of the state vector
Current State of the Art
As explained above, dealing with the exponential growth of computational resources as the number of qubits increases is the main challenge of simulating quantum systems. Various techniques have been developed to address this challenge, each with its own strengths and weaknesses.
State Vector Simulation
Conceptually, state vector simulation is the most straightforward method, representing the full quantum
state as a complex-valued vector of dimension , where is the number of qubits.
This method allows for exact simulations but is resource-intensive. Examples are IBM Qiskit’s Aer-Simulator [5], Google Cirq [6], Eviden’s Qaptiva [7], and JUQCS [8, 9]. Memory and processing constraints currently limit the applicability of the three former examples to problems of 30–41 qubits. JUQCS goes significantly beyond this: the largest universal quantum computer JUQCS has simulated thus far contained 48 qubits [8].
Just like its predecessors [4, 8, 10], which have set multiple world records for simulating the largest universal quantum computers [11, 12], JUQCS-50 is designed with a strong emphasis on portability. It runs seamlessly across a wide spectrum of hardware platforms—from desktop PCs to high-end supercomputers with distributed and shared memory. This flexibility makes JUQCS-50 accessible to a broad user base, enabling both development and large-scale production runs in diverse computing environments. On CPU-based systems, only a Fortran 2003-compatible compiler (e.g., Intel IFX, gfortran, nvfortran) and standard MPI support are required. To utilize NVIDIA GPUs, JUQCS-50 additionally depends on CUDA-Fortran and CUDA-aware MPI, ensuring efficient execution while maintaining ease of deployment across systems. Notably, the majority of JUQCS-50 software development was conducted on the JUWELS Booster system [13], utilizing NVIDIA A100 GPUs and AMD CPUs. This preceded the operational launch of JUPITER and underscores the feasibility of enablement work on previous-generation hardware.
JUQCS-50 is functionally portable across CPU-only and GPU-accelerated systems (Fortran 2003 + MPI, with optional CUDA-Fortran and CUDA-aware MPI). However, the performance results are hardware-specific, relying on GH200 features such as the high-bandwidth NVLink-C2C CPU–GPU interconnect and unified use of GPU HBM and CPU LPDDR5 memory. The reported performance therefore reflects portability within GH200-like heterogeneous architectures with comparable bandwidth and memory hierarchies.
In general, to keep the elapsed time of universal quantum computer simulations within reasonable bounds, it is essential to have effective algorithms and hardware to handle the massive amount of data transfers that result from distributing memory over many computational units.
JUQCS-50 addresses all these issues, facilitating the simulation of 50 qubits on the imminent exascale computer JUPITER, deploying GH200 superchips. JUQCS-50 can exploit new powerful features of the superchips to enable the simulation of these qubits using 4096 JUPITER nodes, with a significant reduction of the elapsed time to execute quantum circuits.
Tensor Network Simulation
Tensor networks are mathematical structures that can efficiently represent quantum states if entanglement is limited. This approach can significantly reduce memory usage for circuits with low-depth or limited connectivity. Instead of storing the entire state vector, tensor network methods break down computations into small, manageable parts. In practice, they are very useful for simulating shallow circuits with limited entanglement and tree-like circuit structures. One prime, typical example of this approach is the random quantum circuit simulator for the new generation of Sunway Supercomputers [14]. This simulator exploits the particular structure of the random quantum circuits used in Google’s quantum supremacy work [15] to construct a very efficient scheme to compute a small fraction of the exponentially large number of amplitudes for systems containing up to 100 qubits [14]. In contrast, JUQCS was used to compare the frequencies of the states produced by the supremacy experiments with the exact simulation of several random quantum circuits employed in the experiments, up to qubits [15].
Circuit cutting/entanglement-removal approach
If the number of entangling gates is small, a circuit-cutting strategy based on a Controlled-Z (CZ) gate decomposition enables the simulation of circuits with up to 64 qubits using modest computational resources [16]. In this approach, each CZ gate is replaced by a measurement-based decomposition, which removes entanglement and splits the original circuit into many independent subcircuits. These smaller subcircuits can then be simulated separately, and their contributions are recombined to recover the full result. This method is most effective for low-depth circuits with sparse CZ gates, since the number of subcircuits grows exponentially with the number of decomposed CZ gates. In contrast, JUQCS-50 performs a full state-vector simulation on realies on aggressive memory and communication optimizations rather than circuit decomposition.
Dedicated simulation software for Shor's algorithm
Shor’s algorithm for factoring integers is one of the most anticipated applications of quantum computing [1, 2]. It also provides another instance of dedicated simulation software executing a particular quantum algorithm for problem sizes that are out of reach for universal quantum computer simulators. The largest semiprime that has been factored by a universal quantum computer simulator (JUQCS) executing Shor’s original algorithm is 65 531. This simulation required simulating a 48-qubit universal quantum computer [8]. In contrast, with a completely different, dedicated implementation of the same algorithm, employing GPUs and dedicated post-processing of the outcomes of the simulation [17], the largest semiprime that could be factored without exploiting prior knowledge of the solution is 549 755 813 701 = 712 321 × 771 781 [17]. As in the case of tensor network simulation, this illustrates once more that comparing simulators, highly tuned to specific problems, with universal quantum computer simulators, is a delicate issue.
Summary
Although specialized simulators can handle larger qubit counts for certain structured circuits, their efficiency depends on exploitable properties such as limited entanglement or algorithm-specific constraints. While alternative methods can outperform JUQCS for particular problems or restricted queries, they do not generalize to unrestricted universal quantum computation. JUQCS-50 instead supports full state vector evolution for arbitrary circuits, enabling general-purpose hardware benchmarking, software verification, and algorithm development without assumptions on circuit structure.
As a simulator of a universal quantum computer, capable of executing arbitrary quantum circuits composed of universal gates [2] (and beyond), JUQCS distinguishes itself through unmatched performance and the ability to handle a record number of qubits.
Innovations Realized
Consider simulating an qubit quantum computer in FP64 precision on a GH200-based system such as JUPITER. Storing all the elements of the state vector requires TiB of memory. In AI terminology, this quantum computer simulator can be viewed as a trillion (not billion) parameter model ( because of the normalization of the state vector).
JUPITER2 has about 6000 nodes (24 000 superchips). Each of the superchips is equipped with 96 GiB of HBM3 (device) and 120 GiB of LPDDR5 (host) memory; 216 GiB in total per GH200 superchip. Because the state vector size must be a power of two, the effective memory available for storing the state vector on a single GH200 superchip is therefore limited to 128 GiB. This memory is equally divided across the GPU and CPU. Memory for buffers (much less than 96 GiB-64 GiB=32 GiB) is allocated on the GPU. Again, due to the powers-of-two restriction, the largest number of nodes that can actually be used for JUQCS is 4096 (16 384 superchips), yielding in total GiB = 2048 TiB, a factor of eight too small for simulating 50 qubits.
As previously demonstrated [8], the memory requirement can be reduced by a factor of eight by using a special form of adaptive byte encoding (see subsection 4.3), representing each state vector element by 2 bytes ( bit) instead of 16 bytes ( bit, for a complex number in FP64 precision). This compression reduces precision in general cases (though not in specific ones, such as the gate sequences used for benchmarking in this work) and increases computation time (see subsection 4.3).
Employing this technique makes it possible to reach the 50-qubit barrier with a universal quantum computer simulator running on JUPITER. A key question, then, is how to let JUQCS-50 compute entirely on the GPU using also the LPDDR5 host memory in its GH200 superchip efficiently within the GPU-based execution with minimal performance impacts. To this end, we adopt a design in which the CPUs act solely as memory hosts, while all computation, including encoding and decoding as well as communication, is performed on the GPUs.
In conclusion, to push the boundaries of what can be simulated with state-of-the-art hardware such as JUPITER, it is necessary to
maximize the utilization of available memory across GH200 superchips (in powers of two)
minimize the elapsed time spent on communication
In the following, we outline our unique solutions for these requirements. As the software developed is proprietary, the internal algorithmic implementation is not publicly available. The software version, parameters, and workflow applied in this study are documented to ensure reproducibility.
Intra-GH200 communication
The Grace Hopper superchip is a hardware-coherent GPU-accelerated system where all processors can access all memory with high performance through the 900 GB/s NVLink-C2C connection. The most productive approach to use the full memory is through the Unified Memory concept, in which applications interact with one large memory pool. The Operating System (OS; Linux) natively supports the GH200 superchip and views both the CPU and the GPU memory as separate NUMA (Non-Uniform Memory Access) nodes. It is thus possible to use native, OS-provided allocators and rely on the OS capabilities to utilize multiple NUMA nodes to create a single, large allocation exceeding the size of the memory of a single NUMA node, usable from both the CPU and GPU parts of GH200. Of course, the CUDA allocation mechanism can also be used. Approximately sorted with increasing programming effort, the options to use GH200’s memories are:
Use
malloc(), which does not require any code changes, and rely on OS and Unified Memory Driver heuristics for data placement.Use
malloc(), which does not require any code changes, and guide data placement externally withnumactl -interleave.3Use
numa_alloc_onnode()to explicitly place the real and the imaginary parts in different NUMA nodes.
Use Unified Memory Data Usage Hints of CUDA’s Unified Memory API [18] to explicitly stripe allocations between LPDDR5 and HBM3 memory. Listing 1 shows the code snippet used for this particular implementation.
Use explicit data movement functions from the CUDA API like
cudaMemcpyAsync()to move portions of the data between host and device memories, combined with automatic, on-the-fly optimization of network traffic. The corresponding code is proprietary and is not publically available.
The Unified Memory Data Usage Hints support the Unified Memory Driver with indications of data locality and promise to be a good middle-ground between automated data placement and programming effort. The implementation uses code as outlined in Listing 1
size_t bytes_remaining = size_in_bytes;
char * psi_r_pos = (char *) psi_r;
char * psi_i_pos = (char *) psi_i;
while ( bytes_remaining >=
current_chunk_size ) {
cudaMemAdvise_v2(psi_r_pos,
current_chunk_size,
cudaMemAdviseSetPreferredLocation,
current_loc);
cudaMemPrefetchAsync_v2(psi_r_pos,
current_chunk_size, current_loc, 0, 0);
cudaMemAdvise_v2(psi_i_pos,
current_chunk_size,
cudaMemAdviseSetPreferredLocation,
current_loc);
cudaMemPrefetchAsync_v2(psi_i_pos,
current_chunk_size, current_loc, 0, 0);
psi_r_pos += current_chunk_size;
psi_i_pos += current_chunk_size;
bytes_remaining -= current_chunk_size;
std::swap(current_loc, next_loc);
std::swap(current_chunk_size,
next_chunk_size);
}

Figure 1 (PDF p. 6). Core of the Unified Memory Data Usage Hints implementation. The swap functions update the variables next_loc and next_chunksize within the loop
to distribute page-size-aligned chunks alternately between the LPDDR5 and the HBM3 NUMA node iteratively. This mechanism balances concurrent HBM3 and LPDDR5 usage. In the code, current_loc is initialized with the HBM3 NUMA node of the GPU used by the process, while next_loc is initialized with the LPDDR5 NUMA node closest to that GPU. Through the two chunk_size variables, the ratio between HBM3 data and LPDDR5 data can be steered to maximize HBM usage, something that is not possible with plain malloc() and the numactl --interleave approach.
To evaluate the different possible approaches, we run a qubit benchmark with Hadamard gates and 11 passes requiring 128 GB of memory on one GH200. Experiments with malloc() provided very poor performance4. Monitoring GPU memory usage indicated that this was because Unified Memory Driver migration heuristics caused frequent page migrations between LPDDR5 and HBM3 in the given memory oversubscription scenario. The same happened when combining malloc() with numactl --interleave, and also when using the Unified Memory Data Usage Hints to explicitly stripe. This unexpected effect is currently being investigated by the Unified Memory team at NVIDIA. We could work around the behavior by disabling access-counter-based memory migration, as described in the CUDA 12.4 release notes [19]. While using Data Usage Hints, we experimentally identified a 4/11 ratio of LPDDR5 to HBM3 data as the best-performing configuration. This closely approximates the theoretical optimum of , while reserving sufficient space for auxiliary data structures.
Already with additional NUMA-related knowledge as provided with numactl, significant performance improvements can be gained. The use of Data Usage Hints offers further gains with minimal programming effort and is particularly effective for applications with complex data patterns or in prototyping and exploratory scenarios.
The last, fifth option is to use explicit data movement functions to transfer data between HBM3 and LPDDR5 memory. A library of such explicit memory transfer functions is provided by the Host State Vector Migration feature of NVIDIA cuQuantum but details of the implementation or performance have not been published.
JUQCS-50 surpasses the basic use of explicit data movement functions by integrating asynchronous CUDA copy functions with a look-ahead analyzer of the input gate sequence, enabling the automated, dynamic optimization of data movements on-the-fly.
The performance of the five approaches is compared in Table 1 (access-counter-based memory migrations disabled). To enhance performance and ensure adaptability to applications requiring storage for multiple state vectors, we have opted to utilize explicit memory transfers and on-the-fly optimization of data movements.
| Strategy | Runtime (s) | Speedup (rel) |
| 1 malloc() | 446.67 | 1 |
| 2 numactl | 160.00 | 2.8 |
| 3 numa_alloc_onnode() | 101.57 | 4.4 |
| 4 Data Usage Hints | 71.70 | 6.2 |
| 5 Explicit Data Copies | 53.87 | 8.3 |
Table 1. Comparison of memory over-subscription strategies on one GH200 superchip.
Inter-GH200 communication
We use standard CUDA-aware MPI library calls to exchange data between different GH200s and nodes and adopt the technique of Ref. [4], which minimizes the amount of data transfers automatically. A detailed description of this technique (which is different from the ShareMem approach of HyQuas [20]), as well as state vector distribution across GPUs and CPUs and the distinction between local and non-local qubits, can be found in our earlier works [4, 8, 10] (Fig. 1 of [10] applies to both JUWELS-Booster and JUPITER).
Exploiting the asynchronous stream feature provided by CUDA, packing and unpacking data during the send and receive operations of MPI reduces the time to perform the inter-GH200 communication by approximately 10 %.
In principle, the number of inter-GH200 data exchanges could be further reduced through independent preprocessing of the gate sequence, an approach external to JUQCS (see also § 7). As this represents a nontrivial challenge, it lies beyond the scope of the present work and is planned for future investigation. Other approaches for communication optimization, such as discussed in Refs. [21, 22], might be beneficial.
Byte-encoding of the state vector elements
In earlier work [8], we explored various ways to encode the complex values of the state vector with less than two double-precision numbers (bit). An adaptive encoding scheme that has been found to perform well is based on the polar representation of a complex number () and uses an update strategy to adaptively and automatically tune the encoding/decoding scheme to the particular quantum circuit being executed. A key feature of the scheme is its capacity to retain algorithmic precision to FP64-levels for some simulations, like the Hadamard benchmarks presented in this work. Obviously, using two (bit) instead of sixteen bytes (bit) to store each of the complex-valued elements of the state vector reduces the amount of memory by a factor of eight.
Of course, this memory reduction comes at the expense of additional compute time incurred by on-the-fly encoding and decoding during the execution of the gate. For instance, running the gate sequence for the qubit case (which fits in the HBM3 memory of a single GH200) takes 57.4 s and 45.8 s of computation time in byte-encoded and FP64 modes, respectively. For qubits, however, using the memory of one GH200 superchip (HBM and LPDDR memory), in which only inter-superchip data is transferred, the byte-encoded code finishes the Hadamard benchmark in 13.5 s, whereas the FP64 finishes in 23.0 s, reflecting the fact that the amount of data transferred in the former is eight times smaller than in the latter.
In general, the amount of additional compute complexity depends on the gate and varies from very little in the case of the X or CNOT gate to a factor of two to three (depending on the hardware) for gates such as the Hadamard gate [8]. For the purpose of this work, the gate operations have been implemented as GPU device kernels. We emphasize that the adaptive encoding/decoding is performed on-the-fly at runtime.
Encoding Choices and Their Tradeoffs
Predicting exactly which gate sequences will suffer significant accuracy loss under byte-encoding remains challenging. Generally, applications sensitive to high phase resolution or those spanning large amplitude ranges are most vulnerable. Ultimately, empirical validation is necessary for specific circuits; for example, Ref. [8] observed no significant deterioration in a 48-qubit implementation of Shor’s algorithm, and we report similar stability for a 50-qubit application in § 7.
While 50-qubit simulations on JUPITER currently necessitate byte-encoding to fit within memory constraints, JUQCS-50 is designed for versatility. It can utilize both HBM3 and LPDDR5 memory in FP32 or FP64 precision (see Table 3 for a comparison of these modes). Specifically, using FP32 precision with LPDDR5 memory allows for the simulation of large circuits up to 48 qubits without noticeable loss of fidelity [23].
Table 3: The maximum number of qubits and a comparison of elapsed times (ET) in seconds and the number of GPUs (in parentheses) for running benchmarks on JUPITER Booster in the three different modes (Byte Encoding, 32 bit, 64 bit). The second row shows how the elapsed times depend on the number of GPUs used, the third how the times change if number of GPUs is kept constant; in both cases, the number of qubits is kept constant.
| BE | FP32 | FP64 | |||
| Maximum | 50 | 48 | 47 | ||
| ET / s (#GPUs) | 45 | 223 (512) | 115 (2048) | 124 (4096) | |
| ET / s (#GPUs) | 45 | 43 (4096) | 67 (4096) | 124 (4096) |
Table 3.
As summarized in Table 3, the available execution modes reveal a clear trade-off: FP32 typically offers the best balance of speed and accuracy, whereas byte-encoding becomes essential for larger problems when reduced precision allows.
Performance criteria
The quantum computer simulator used in this work, JUQCS-50, was already introduced above. The base program, JUQCS, looks back on a long history of performance-conscious evaluations [4, 8] and is used for a variety of scientific applications [8, 24]. To evaluate the computational efficiency of JUQCS-50, we consider several performance metrics that capture both user-level experience and system-level behavior.
The most relevant measure from the user’s perspective is the total elapsed time to simulate a quantum circuit. This walltime includes not only the gate operations themselves but also the initialization of data structures, MPI setup, I/O, and other runtime overheads.
Complementary metrics provide deeper insights into system performance, see Appendix § 10. These include the pure computation time, MPI communication time, and the time spent transferring data between HBM3 and LPDDR5 memory within each GH200 superchip—along with the associated data volumes.
The NVIDIA Grace Hopper GH200 superchip is core to our work, combining a 72-core, ARM-based CPU (Grace) with a Hopper GPU in one package, connected through a unique 900 GB/s bus (NVLink-C2C, Chip-to-Chip). The platform offers cache coherency for all involved memories, even between different superchips. Together with the fast NVLink-C2C, this cache coherency enables our memory-oversubscribing method, allowing access to the 120 GB LPDDR5 host memory and 96 GB HBM3 device memory from both processors with good performance. The involved bandwidths can be seen in the node diagram Figure 1 with four GH200s.
JUPITER is built from NVIDIA GH200 superchips and provides four of these superchips per node. Since the available power is allocated per superchip, it must be shared between the Grace CPU and the Hopper GPU. Investigating how different power distribution strategies impact the overall performance is an important direction for future work. JUPITER employs an InfiniBand NDR fabric with a Dragonfly+ topology [25] with 25 groups and up to 240 nodes in a group, offering Gbit/s injection bandwidth per node. An overview of some defining system parameters is given in Table 2.
| Quantity | JUPITER Booster |
| Number of nodes | 5884 |
| Number of GH200 | 23 536 |
| TDP per GH200 | 680 W |
| Total CPU LPDDR5 memory | 2880 TB |
| Total GPU HBM3 memory | 2304 TB |
| Interconnect Type | InfiniBand NDR200 |
| Node Injection Bandwidth | Gbit/s |
| Network Topology | Dragonfly+ |
| Top500 Listing | Jun. 2025 |
| Rmax | 1001 PFLOP/s |
| Rpeak | 1300 PFLOP/s |
Table 2. Specifications JUPITER Booster
JUQCS-50 is implemented in modern Fortran and utilizes CUDA Fortran for GPU acceleration through the NVIDIA HPC SDK toolkit, version 25.5, and GPU-aware OpenMPI or ParaStationMPI on JUPITER. All results reported in this work have been obtained with the OpenMPI version.
As previously discussed, the memory required to simulate an -qubit universal quantum computer grows exponentially with . This exponential growth imposes a hard limit on the number of qubits that can be simulated, namely on JUPITER. While the theoretical exponential scaling of computation time with can be almost entirely mitigated through massive parallelization [4, 8], as discussed in the next section, memory—rather than elapsed time—becomes the primary limiting factor for most applications. As a result, weak-scaling performance, as a function of , serves as the key indicator of performance. For completeness, we also present strong-scaling data for qubits, where the number of GPUs increases from 4 to 128, with four GPUs per node.
Performance Results
In this section, we delve into the performance results obtained for JUQCS-50, focusing on the key metrics identified earlier. For clarity and completeness, detailed performance tables are provided in Appendix § 10.
Quantum Circuit used for Benchmarking
To validate the results of byte-encoded simulations, it is expedient to use a gate sequence that does not suffer from precision loss due to this encoding. One such sequence consists of Hadamard gates [2] followed by the simultaneous measurement of the three components (equivalent to measuring in the , , bases) of each qubit (which is only possible in simulation, see [26]). Specifically, we use
where denotes the Hadamard operation on qubit and represents the measurement of all qubits, see Figure 2 for a graphical representation. This sequence keeps a reasonable balance between computational workload and MPI-based communication overhead as is varied. Note that the sequence Equation (1) is to be read from right to left.

Figure 2. Graphical representation of the benchmark circuit Equation (1) for the case of qubits. Operations proceed from left to right. Each application of a Hadamard gate () changes all the elements of the state vector. The rightmost symbol represents the simultaneous measurement of all three components of the Pauli-spin matrices representing a qubit, as performed by JUQCS-50. The initial state vector has all qubits in state zero.
Elapsed and Computation Times
Table A.6 lists the elapsed and compute times for JUQCS-50 executing a sequence of Hadamard gates on JUPITER in adaptive byte-encoded mode, using HBM3 and LPDDR5 memory, and on-the-fly optimization of data exchange, performing computation on the GPU only. In this mode, due to the intrinsic factor of two that is characteristic of quantum computers, the largest quantum computer that can be simulated on JUPITER (16 384 GH200 superchips) contains 50 qubits. In the case of a sequence of Hadamard gates followed by a measurement of all qubits, the use of the adaptive byte-encoding does not cause a loss of precision; that is, the final data are FP64-accurate by design, providing a nontrivial validation of the code.
Figure 3 presents the total elapsed time per gate operation, as well as the computation time per gate, across a range of qubit counts for two distinct sets of runs. One of the most striking conclusions is the apparent high reproducibility of the data. The timings reported here are statistically significant. For the largest runs, the deviation from the expected trend is primarily due to external network activity caused by concurrent jobs on the system shared by many users. In addition, in byte-encoded mode, the reported compute time includes a small fraction of MPI-related overhead.
Figure 3. Total and compute elapsed time per gate operation for executing the circuit shown in Figure 2 on JUPITER as a function of the number of qubits (weak scaling). The first dataset (labeled “1”; see Table A.6) was obtained with JUQCS running with exclusive access to the JUPITER supercomputer. The second dataset (labeled “2”) was collected on a different day, when other applications were running concurrently on JUPITER. Lines are shown as guides to the eye only.
Notably, the computation times remain nearly constant as the number of nodes (qubits) increases from 1 to 256 (36 to 46), while the total elapsed times reveal that the impact of network communication grows approximately linearly rather than exponentially with the number of qubits.
The computation time increases a little faster than theoretically expected. Based on the data in Table A.6, and taking the case as a reference, we can estimate the expected computation time for the case under ideal parallelism as s. This estimate is close to but still lower than the actual measured time of 142 s. The discrepancy arises from a combination of factors: interruptions in the byte decoding-encoding process due to global MPI communication (which is not accounted for in the reported MPI time), variability in GPU computation speeds, and network congestion. These factors become more important for , resulting in a notable change in the slopes of the lines through both the computation and elapsed times. At 47 qubits, executed on 512 nodes, the borders of one single Dragonfly group with 240 nodes are safely surpassed, and a majority of communication happens through the tapered network between the groups, rather than inside them. (cudaMemcpyAsync)).
To examine the combined impact of global MPI communication, integral to the byte decoding–encoding process, variability in GPU computation speeds, and network congestion, as well as to showcase the versatility of JUQCS-50, we conducted benchmarks in FP32 mode. In this configuration, state vector coefficients are stored in FP32 format, while all arithmetic operations are performed in FP64. Additionally, LPDDR5 was not used as a CPU memory extension. Figure 4 illustrates the computation time and total elapsed time per gate, with further details provided in Table A.7. The most striking observation is that, up to the maximum number of qubits supported by JUPITER in this mode, namely and aside from a minor anomaly at , the computation time remains nearly constant. This indicates near-perfect weak scaling behavior across the qubit range from 36 to 47.
Figure 4. Total elapsed and compute times per gate operation for the range of qubits simulated on JUPITER in FP32 mode without using the LPDDR5 memory as an extension (weak scaling). When comparing to Figure 3, note the difference in scale of the y-axis and keep in mind that the number of GPUs used is eight times larger, see Table A.7. Lines are guides to the eye only.
As expected, the total elapsed time increases with , driven by the growing volume of data exchanged and compounded by network congestion, particularly since these benchmarks were executed concurrently with other users’ workloads (all major MPI communication is of the blocking type, and the columns GPU-CPU time and data in the tables provide the necessary information about the use of asynchronous APIs (cudaMemcpyAsync)).
According to theory, the computational effort is expected to grow as . Fitting the data (not shown) for elapsed times to yields and . The value of is significantly smaller than the theoretically expected value of one, a manifestation of a high degree of parallelism of JUQCS. A slightly better fit (not shown) is obtained by using with and , suggesting that the data does not allow making conclusive assertions about the trend.
We conclude that the change in slope observed for in Figure 3 may be attributed to the increased computational burden of the byte decoding-encoding process, which demands substantially more arithmetic operations, intermittently disrupted by global MPI communication, the topology, and the fact that the FP32 benchmark did not use the LPDDR5 memory of the CPU as a memory extension.
Overall, the computation time demonstrates excellent weak scaling behavior. The impact of transmitting massive volumes of data across the network manifests as a relatively mild dependence on in the weak scaling, the total elapsed time, a point that will be examined in more detail later.
For the 36-qubit case, the elapsed times in Table A.6 and Table A.8 show that the FP64 version takes about 54 s to complete the task by using eight GH200 superchips, whereas the byte-encoded version accomplished the same task in about 116 s using only one GH200 superchip. Put differently, the byte-encoded version is about a factor of times more efficient (see Table A.6).
Due to the communication making up a larger part of the elapsed time as the number of qubits increases, for the largest problem that can be run on JUPITER in FP64 mode, the gain in efficiency, due to using byte-encoding, is a factor (see Table A.6 and Table A.8).
To put the performance of the GH200-based system in perspective: setting the earlier world record [8] for qubits using byte-encoding for Hadamard benchmarks took the K computer 3102 s and the Taihu-Light system (without using accelerators) 8548 s. For comparison, we compute the elapsed time/gate for the K computer and the JUPITER executing the Hadamard circuit under the exact same conditions, and find 47.03 s/gate for the former and 2.83 s/gate for the latter (see Table A.6). This amounts to a performance increase by a factor of 16.6 on the JUPITER system over the K computer.
On the JUPITER supercomputer, the maximum number of qubits that can be simulated using JUQCS-50 varies by numerical precision and memory configuration. Specifically, in byte-encoded, FP32, and FP64 modes, the limits are 50 (49), 48 (47), and 47 (46) qubits, respectively, with (without) LPDDR5 memory of the GH200. Using the largest FP64-simulatable problem (47 (46) qubits) as a reference, the corresponding benchmark execution times are 264 (101), 145 (103), and 185 (106) seconds for byte-encoded, FP32, and FP64 modes, respectively, utilizing 512 (512), 2048 (2048), and 4096 (4096) JUPITER nodes. These results demonstrate that for problems of large but not maximal size, JUQCS-50 enables optimization across numerical precision, runtime, and node count.
Network Performance
Regarding the data transfer rate between HBM3 and LPDDR5 memory in the same GH200 superchip, Tables A.6–A.9 show that this rate, which includes pre- and postprocessing of the buffers in GPU memory, is of the order of 100 GiB/s. The amount of data that is being exchanged within one GH200 superchip is (except for ) more than a factor of two larger than the data that is being sent and received by the same superchip over the interconnects (column GPU-GPU MPI data). Because of the sequence-dependent pattern by which data is being sent over the network, a straightforward comparison of the transfer times is rather difficult.
For qubits, 2048 TiB of data is required to represent the state vector. With each single-qubit gate that requires MPI communication, half of this data travels through the network. In total, for the sequences used, there are 36 such network-active gate operations. The highly-optimized measurements of all the qubits require 13/14 of all the data being exchanged. Thus, in total, for , TiB traverses the network in about 100 seconds, a respectable amount of TiB per second.
For , GPUs compete for network bandwidth to send and receive data. The sharp drop in bandwidth for , signals the transition from intra-node-dominated, fast NVLink communication (see Figure 1) to the slower, inter-node-dominated network-mode of communication. Disregarding small fluctuations, the MPI times listed in Table A.6 fit well to the function for . In this regime, the dependence shows up as a slowly decaying () measured bandwidth (MPI data/MPI time; data taken from Table A.6–Table A.9) depicted in Figure 5.
Figure 5. Measured communication bandwidth (in GiB/s) as a function of qubits (bottom) and MPI processes/nodes (top) with the expected performance shown for JUPITER. Horizontal lines indicate the limits of the interconnect bandwidths for comparison. The line through the data points is a guide to the eye only.
Strong Scaling
Strong scaling has no real-world relevance from the viewpoint of quantum processing hardware because a quantum information processor having qubits has no way to distribute the execution over several units. However, from the viewpoint of benchmarking and simulation, it is interesting to study the strong scaling behavior of the algorithm and hardware. Table A.9 collects the data for fixed and an increasing number of GPUs, always for the same quantum circuit, also see Figure 6.
Figure 6. Relative efficiency measured (strong scaling) for 40 qubits over a range of MPI processes/nodes. Shown is the relative time with respect to the elapsed time on four nodes (16 MPI processes, qubits). The lines through the data points are guides to the eye only.
The strong scaling data shows that the computation times and GPU-CPU communication times scale close to perfect, but, as expected, the total elapsed times do not, due to the necessary communication among nodes.
As the number of MPI processes doubles, the GPUs have to exchange less data (by a factor of two) but they also have to compete with more GPUs (by a factor of two) for network bandwidth. From Table A.9, it follows that the measured time per GiB is 0.017, 0.020, 0.022, 0.027, 0.033 and 0.047 for 16,...,512 MPI processes, respectively. As the number of MPI processes increases, there is an initial, approximately linear increase of the time per GiB. Then, starting from 128 MPI processes, the time per GiB is dominated by the slower inter-node network and the measured time per GiB saturates at approximately 0.047 s/GiB or, equivalently, a bandwidth of 21 GiB/s, in rough agreement with the bandwidth (24 GiB/s, see Table A.9) for a large number of qubits. As there is the intrinsic limitation to powers of two, there is no way to determine accurately the number of MPI processes at which the saturation sets in.
Hopper GPU versus ARM CPU
Although not directly related to the use of the heterogeneous CPU-GPU architecture of the GH200 superchip, benchmarking the CPU and GPU components separately is valuable from the standpoint of JUQCS-50 code portability. Table 4 presents data enabling such a comparison across the three precision modes currently supported by JUQCS-50. From this data we conclude that (i) storing the state vector in FP32 precision yields the fastest computation times for both CPU and GPU and (ii) MPI communication via the GPUs is faster than via the CPUs (which is to be expected from the design of the GH200 chip), and (iii) depending on the precision, the Hopper GPU accomplished the task a factor of ≈ 3 to 4 faster than the CPU. This is partially due to the fact that with JUQCS-50, the GPU computes faster than it can retrieve data from its HBM3 memory and, of course, this factor is also affected by the time used for MPI communication.
| elapsed time (s) | computation time (s) | MPI time (s) | MPI time (s) | Compute engine | precision of state vector |
| 16.14 | 7.24 | 6.08 | 111 | GPU | BE |
| 18.85 | 4.89 | 10.88 | 447 | GPU | FP32 |
| 27.20 | 6.17 | 17.72 | 895 | GPU | FP64 |
| 47.61 | 25.76 | 9.67 | 111 | CPU | BE |
| 40.49 | 14.29 | 23.72 | 447 | CPU | FP32 |
| 119.42 | 63.96 | 52.43 | 895 | CPU | FP64 |
Table 4. Data obtained by running the benchmark circuit Equation (1) on either the Hopper GPU or the ARM CPU (using 64 of the 72 cores) of the GH200 superchip for qubits and 256 MPI processes (64 nodes) with byte-encoding (BE), FP32, and FP64.
Summary
Overall, Table A.6 and Figure 3 show that the elapsed time increases approximately linearly (not exponentially) with the number of qubits . Recall that exponential scaling with the number of qubits is a prime characteristic of simulating universal quantum computing. Therefore, the fact that a simulator such as JUQCS-50 can simulate these computers in an elapsed time that grows approximately linearly with is significant.
The simulation consumes 58 W h energy for the 39 qubit case on one node, incorporating both CPU and GPU data. Beyond this single-node case, we observe a linear dependency between energy and number of nodes, with a robust slope of 78 W h.
Our focus in this work was on optimizing the data movement, both on-superchip and beyond, to enable simulation of 50 qubits for a first time. Certainly, further fine-tuning potential exists for the novel GH200 platforms. In particular, the size of the buffers and the number of streams used for communication are unlikely to be optimal yet, and GPU device kernels that perform recursion can also be improved.
Application: Adder Circuits
Sequences of Hadamard gates are well-suited for benchmarking purposes because: (i) they are simple to implement and yield known outcomes, (ii) their execution time is typically under 10 minutes, (iii) they exert significant stress on the communication network, and (iv) they maintain full precision without loss due to byte-encoding, which simplifies validation.
Quantum algorithms that perform integer addition using quantum registers represent another valuable class of quantum circuits. (i) They are nontrivial in that they incorporate quantum Fourier transforms and controlled phase shifts, both core components of foundational quantum algorithms such as phase estimation [2] and Shor’s algorithm [17, 27]. (ii) The final output of the quantum computation, being the sum of the input integers, is easily validated. (iii) These circuits can place a substantial load on the communication network, offering a rigorous test of system performance. (iv) When executed in byte-encoding mode, due to the presence of controlled phase shifts, they may suffer a loss of numerical precision, providing information about the effect of using byte-encoding on the accuracy of the quantum computation.
A bird’s-eye view of a quantum circuit to add (superpositions of) three integers stored in the registers R1, R2, and R3, is shown in Figure 7. Each of these registers is assumed to consist of qubits, enabling representing integers in the range . Following Draper [28], the idea is to perform a (quantum) Fourier transform (FT) on , then apply the controlled phase shifts (CR) to accumulate the information stored in and into the phases of the coefficients of the (partial) state vector in , and finally perform an inverse (quantum) Fourier transform (FT) to transfer the information contained in the phases back to integer representation. The diagram in Figure 7 illustrates the structure of a circuit that adds (superpositions of) integers stored in three registers. However, the design generalizes straightforwardly to any number of registers.

Figure 7. Structure of quantum circuit to add three bit integers encoded in quantum registers , , consisting of qubits. The sum of the integers is returned in register , the qubits of other registers being untouched. By construction, integer addition is modulo . FT: quantum circuit to perform a discrete Fourier transform [2]; CR: collection of controlled phase shifts. The right most symbol represents the simultaneous measurement of all three components of the Pauli-spin matrices representing a qubit, as performed by JUQCS-50. The structure trivially generalizes to fewer and more registers encoding integers.
As an illustration, Figure 8 presents the quantum circuit for adding two integers each one represented by a two-qubit register (). The gates flip the states of qubits 1 and 2 from and to and , respectively. Due of the structure of the FT used [2], the most significant bit of the integer is stored in the least significant bit of the register. Therefore, after performing the gates, the state in encodes the integer 1 and the state in encodes the integer 2. Upon measurement, the state yields , the last two bits encoding .
Figure 8. Realization of the quantum adder circuit shown in Figure 7 for the case of two two-bit integers (). The first two gates (denoted by X) are not part of the adder circuit but serve to encode the integers 1 and 2 in registers and , respectively (see text). X: interchanges qubit state 0 and 1; H: Hadamard gate; : controlled phase shift by . See [2] for a detailed description of these gates.
As an illustration and also to scrutinize the effect of using byte-encoding on the final result of a quantum computation, we use JUQCS-50 to execute a quantum circuit for adding two 25-bit integers () with encoding 21346502 and encoding 12207929. The quantum circuit contains 1001 gates, which is too large to be displayed graphically on one page. The integers have been chosen so that their binary sum (being ) results in a sequence of all ones. Translated into qubit language, this implies that all the expectation values of the -components of the qubits () are equal to one, allowing the correctness of the output to be visually confirmed at a glance.
Table 5 shows the results of the simulation. It is immediately clear that the quantum circuit yields the correct values of . Also clear is that due to the use of byte encoding, some expectation values of the - and -components deviate from the exact result .
| Qubit | |||
| 24 | 0.50 | 0.50 | 1.00 |
| 25 | 0.50 | 0.52 | 1.00 |
| 26 | 0.51 | 0.50 | 1.00 |
| 27 | 0.50 | 0.50 | 1.00 |
| 28 | 0.50 | 0.50 | 1.00 |
| 29 | 0.50 | 0.50 | 1.00 |
| 30 | 0.50 | 0.50 | 1.00 |
| 31 | 0.50 | 0.50 | 1.00 |
| 32 | 0.50 | 0.50 | 1.00 |
| 33 | 0.50 | 0.50 | 1.00 |
| 34 | 0.50 | 0.50 | 1.00 |
| 35 | 0.50 | 0.50 | 1.00 |
| 36 | 0.50 | 0.50 | 1.00 |
| 37 | 0.50 | 0.50 | 1.00 |
| 38 | 0.50 | 0.50 | 1.00 |
| 39 | 0.50 | 0.50 | 1.00 |
| 40 | 0.50 | 0.50 | 1.00 |
| 41 | 0.50 | 0.50 | 1.00 |
| 42 | 0.50 | 0.50 | 1.00 |
| 43 | 0.50 | 0.50 | 1.00 |
| 44 | 0.50 | 0.50 | 1.00 |
| 45 | 0.50 | 0.50 | 1.00 |
| 46 | 0.50 | 0.50 | 1.00 |
| 47 | 0.48 | 0.49 | 1.00 |
| 48 | 0.50 | 0.50 | 1.00 |
| 49 | 0.50 | 0.50 | 1.00 |
Table 5. JUQCS-50 results for a 50-qubit quantum circuit designed to add two 25-bit integers (see text). Only the 25 expectation values of the qubits in register are shown (qubits are numbered starting from zero).
It is worth noting that, unless proven otherwise, current quantum devices are unlikely to perform integer addition with the level of precision achieved by JUQCS-50 in its byte-encoded mode [29].
The quantum adder circuit also provides a nice example to explore how much can be gained by optimizing the circuit with respect to the amount of MPI communication. In its generic form shown in Figure 7, it took JUPITER 1996 s (180 s MPI GPU-GPU time, 720 s GPU-CPU time) to execute the quantum circuit. Simply interchanging the roles of and by relabeling the qubits (an operation that is part of JUQCS-50’s instruction repertoire), reduces this time to 1193 s (69 s MPI GPU-GPU time, 335 s GPU-CPU time). This substantial performance improvement is solely attributed to the reduction in communication.
More broadly, it is evident that strategically relabeling qubits to minimize inter-GPU communication can significantly decrease the total execution time of simulating a quantum circuit. Optimizing the quantum circuit in this regard can be performed independently of JUQCS-50 and is therefore beyond the scope of the present study, but important future research.
Conclusion
JUQCS-50 efficiently utilizes the available hardware, CPUs, GPUs, and a combination of both, by exploiting the architectural strengths of modern systems like the GH200 superchips. Relative to the works reported in [4, 8, 10], the main technical innovations introduced in JUQCS-50 are:
Explicit management of CPU–GPU memory transfers, including on-the-fly optimization of data movement between GPU and CPU memory within each node, enabling efficient use of the heterogeneous memory hierarchy.
Use of CUDA-accelerated packing and unpacking of amplitude data during MPI send/receive operations, significantly reducing communication overhead between nodes.
Support for storing state-vector amplitudes in FP32 format, lowering memory requirements and communication volume while maintaining sufficient numerical accuracy for universal-circuit simulation.
GPU kernels for byte-encoded operations.
These innovations not only enable the aforementioned large-scale realistic simulations of user-defined circuits but, at the same time, combined with its ease of deployment and operation, JUQCS-50 can continuously and controllably stress both computational units and the network over defined periods, making it an ideal and realistic benchmark user application.
From the data presented in Tables A.6–A.8, it follows that, to a good approximation, the elapsed time increases approximately linearly with the number of qubits , rather than exponentially. In other words, when combined with massively parallel computers, the universal quantum computer simulator JUQCS-50 overcomes the exponential scaling characteristic of gate-based quantum computers.
The advanced JUQCS-50, the newly developed version of JUQCS, will empower researchers to 1) perform exact simulations of arbitrary quantum circuits with varying degrees of accuracy, still far better than offered by current, state-of-the-art quantum computing hardware; 2) study the effects of noise and errors on quantum algorithms; 3) perform simulations of quantum annealing and quantum spin-dynamics for a wide variety of model Hamiltonians over a time span and with an accuracy that is not within reach of state-of-the-art quantum computing hardware; 4) expand simulations to larger quantum systems while keeping simulation times low; 5) benchmark (super)computers [4, 8, 24, 30].
JUQCS-50 is currently being integrated into JUNIQ [31], the Jülich UNIfied Infrastructure for Quantum Computing, providing science and industry access to state-of-the-art quantum computing emulators and devices. With JUPITER operational, JUQCS-50 will enable the study of problems up to 500 to 1000 times larger than those currently handled by other simulators (as discussed in § 3), thereby unlocking a new range of universal quantum computing applications yet to be explored. More specifically, JUQCS-50 will allow researchers to run applications such as variational quantum eigensolvers (VQE) [32, 33, 34], quantum approximate optimization algorithms (QAOA) [8, 9, 23, 35, 36, 37], and quantum annealing [38] with an accuracy that is beyond the reach of state-of-the-art quantum computer hardware for systems with up to 50 qubits.
Acknowledgments
We acknowledge support from the following entities: The Ministry of Culture and Science of the State of North Rhine-Westphalia (MKW-NRW) for the project EPIQ; MKW-NRW together with EuroHPC JU, the German Federal Ministry of Education and Research (BMBF) for the project JUNIQ. This project received access to the JUPITER supercomputer, which is funded by the EuroHPC Joint Undertaking, the German Federal Ministry of Research, Technology and Space, and the Ministry of Culture and Science of the German state of North Rhine-Westphalia, through the JUPITER Research and Early Access Program (JUREAP). We thank the Swiss National Supercomputing Center CSCS for providing access to the Alps supercomputer, which was essential to prepare our workload for JUPITER.
CRediT authorship contribution statement
Hans De Raedt: Conceptualization, software, investigation, writing – original draft, writing– review & editing; Jiri Kraus: Conceptualization, software, writing – original draft, writing– review & editing; Andreas Herten: investigation, resources, visualization, writing – original draft, writing – review & editing; Vrinda Mehta: investigation, validation, writing – original draft, writing – review & editing; Mathis Bode: resources, writing – review & editing; Markus Hrywniak: Software, writing – review & editing; Kristel Michielsen: Writing – review & editing, funding acquisition; Thomas Lippert: Writing – review & editing, funding acquisition.
Data availability Data will be made available on reasonable request.
Declaration of competing interest The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Declaration of generative AI and AI-assisted technologies in the manuscript preparation process
During the preparation of this work, the authors used ChatGPT, Gemini, and Copilot to enhance the language of the text. After using this tool, the authors reviewed and edited the content as needed and take full responsibility for the content of the published article.
Raw performance data
Table A.6: Elapsed and compute times for executing Hadamard gates [2] in a sequence designed to challenge both computation and communication on JUPITER, with JUQCS-50 employing adaptive byte-encoding, using both HBM3 and LPDDR5 memory and on-the-fly optimization of data exchange (weak scaling). The column GPU-GPU MPI lists the data sent and received by each of the GPUs (using CUDA-aware MPI). MPI time includes the time encoding and decoding buffers for transmitting these data. The columns ’GPU-CPU data’ and ’count’ specify the volume of data and the number of data exchanges between HBM3 and LPDDR5 memory. GPU-CPU time includes the time for writing and reading buffers in HBM3 memory. The column #gate operations is the number of Hadamard operations plus the measurement of each of the qubits. The simulation of a 50-qubit, universal quantum computer on JUPITER sets a new world record.
| Qubits | memory (GiB) | MPI processes | elapsed time (s) | computation time (s) | #gate operations | MPI time (s) | GPU-GPU MPI Data (GiB) | GPU-CPU time (s) | GPU-CPU Data (GiB) | GPU-CPU count |
| 36 | 1026 | 1 | 116.13 | 101.54 | 41 | 0.00 | 0 | 11.60 | 1216 | 19 |
| 37 | 2052 | 2 | 129.43 | 105.51 | 42 | 2.37 | 512 | 17.99 | 2048 | 32 |
| 38 | 4104 | 4 | 138.31 | 108.99 | 43 | 4.20 | 832 | 20.23 | 2368 | 37 |
| 39 | 8208 | 8 | 153.83 | 113.96 | 44 | 12.68 | 1120 | 22.46 | 2688 | 42 |
| 40 | 16416 | 16 | 168.77 | 117.59 | 45 | 21.63 | 1264 | 24.54 | 2944 | 46 |
| 41 | 32832 | 32 | 175.00 | 118.55 | 46 | 24.64 | 1272 | 26.43 | 3136 | 49 |
| 42 | 65664 | 64 | 187.04 | 125.00 | 47 | 28.19 | 1404 | 28.51 | 3392 | 53 |
| 43 | 131328 | 128 | 200.97 | 130.16 | 48 | 34.25 | 1534 | 30.59 | 3648 | 57 |
| 44 | 262656 | 256 | 212.78 | 133.61 | 49 | 40.50 | 1663 | 32.64 | 3904 | 61 |
| 45 | 525312 | 512 | 222.71 | 137.59 | 50 | 43.94 | 1791 | 34.77 | 4160 | 65 |
| 46 | 1050624 | 1024 | 234.13 | 142.25 | 51 | 49.82 | 1919 | 36.81 | 4416 | 69 |
| 47 | 2101248 | 2048 | 263.86 | 163.43 | 52 | 55.15 | 2047 | 38.88 | 4672 | 73 |
| 48 | 4202496 | 4096 | 286.27 | 175.67 | 53 | 62.81 | 2175 | 40.94 | 4928 | 77 |
| 49 | 8404992 | 8192 | 307.83 | 192.56 | 54 | 64.65 | 2303 | 43.00 | 5184 | 81 |
| 50 | 16809984 | 16384 | 339.96 | 183.69 | 55 | 99.81 | 2431 | 45.08 | 5440 | 85 |
Table A.6.
Table A.7: Same as Table A.6 except that all calculations were performed with JUQCS-50 running in FP32 mode and without using the LPDDR5 memory as an extension (weak scaling).
| Qubits | memory (GiB) | MPI processes | elapsed time (s) | computation time (s) | #gate operations | MPI time (s) | GPU-GPU MPI Data (GiB) | GPU-CPU time (s) | GPU-CPU Data (GiB) | GPU-CPU count |
| 36 | 1040 | 8 | 16.92 | 8.66 | 41 | 6.26 | 560 | 0.00 | 0 | 0 |
| 37 | 2080 | 16 | 22.13 | 8.91 | 42 | 10.88 | 632 | 0.00 | 0 | 0 |
| 38 | 4160 | 32 | 25.60 | 9.13 | 43 | 13.74 | 700 | 0.00 | 0 | 0 |
| 39 | 8320 | 64 | 26.51 | 9.43 | 44 | 14.29 | 766 | 0.00 | 0 | 0 |
| 40 | 16640 | 128 | 29.12 | 9.54 | 45 | 16.33 | 831 | 0.00 | 0 | 0 |
| 41 | 33280 | 256 | 32.35 | 9.93 | 46 | 19.14 | 895 | 0.00 | 0 | 0 |
| 42 | 66560 | 512 | 36.62 | 10.58 | 47 | 22.38 | 959 | 0.00 | 0 | 0 |
| 43 | 133120 | 1024 | 41.33 | 11.85 | 48 | 26.90 | 1023 | 0.00 | 0 | 0 |
| 44 | 266240 | 2048 | 55.92 | 14.31 | 49 | 37.87 | 1087 | 0.00 | 0 | 0 |
| 45 | 532480 | 4096 | 55.33 | 12.72 | 50 | 38.03 | 1151 | 0.00 | 0 | 0 |
| 46 | 1064960 | 8192 | 69.02 | 11.64 | 51 | 50.69 | 1215 | 0.00 | 0 | 0 |
| 47 | 2129920 | 16384 | 103.19 | 12.28 | 52 | 78.34 | 1279 | 0.00 | 0 | 0 |
Table A.7.
| Qubits | memory (GiB) | MPI processes | elapsed time (s) | computation time (s) | #gate operations | MPI time (s) | GPU-GPU MPI Data (GiB) | GPU-CPU time (s) | GPU-CPU Data (GiB) | GPU-CPU count |
| 36 | 1040 | 8 | 53.75 | 11.06 | 41 | 12.11 | 1120 | 25.24 | 2560 | 40 |
| 37 | 2080 | 16 | 65.17 | 12.60 | 42 | 22.12 | 1264 | 24.45 | 2816 | 44 |
| 38 | 4160 | 32 | 63.98 | 11.47 | 43 | 24.00 | 1272 | 23.04 | 3008 | 47 |
| 39 | 8320 | 64 | 70.22 | 12.10 | 44 | 27.65 | 1404 | 24.97 | 3264 | 51 |
| 40 | 16640 | 128 | 82.74 | 15.69 | 45 | 32.89 | 1534 | 27.47 | 3520 | 55 |
| 41 | 33280 | 256 | 82.71 | 12.81 | 46 | 35.04 | 1663 | 28.78 | 3776 | 59 |
| 42 | 66560 | 512 | 87.52 | 13.16 | 47 | 37.42 | 1791 | 30.65 | 4032 | 63 |
| 43 | 133120 | 1024 | 98.06 | 13.86 | 48 | 46.24 | 1919 | 32.54 | 4288 | 67 |
| 44 | 266240 | 2048 | 109.98 | 13.56 | 49 | 55.18 | 2047 | 34.46 | 4544 | 71 |
| 45 | 532480 | 4096 | 124.06 | 16.24 | 50 | 59.02 | 2175 | 36.36 | 4800 | 75 |
| 46 | 1064960 | 8192 | 150.05 | 18.61 | 51 | 65.45 | 2303 | 38.25 | 5056 | 79 |
| 47 | 2129920 | 16384 | 185.19 | 32.99 | 52 | 91.09 | 2431 | 40.18 | 5312 | 83 |
Table A.8. Same as Table A.6 except that all calculations were performed with JUQCS-50 running in FP64 mode (weak scaling).
| Qubits | memory (GiB) | MPI processes | elapsed time (s) | computation time (s) | #gate operations | MPI time (s) | GPU-GPU MPI Data (GiB) | GPU-CPU time (s) | GPU-CPU Data (GiB) | GPU-CPU count |
| 40 | 16416 | 16 | 166.90 | 115.75 | 45 | 21.62 | 1264 | 24.55 | 2944 | 46 |
| 40 | 16448 | 32 | 88.80 | 58.99 | 45 | 12.79 | 636 | 13.23 | 1568 | 49 |
| 40 | 16512 | 64 | 47.71 | 29.64 | 45 | 7.73 | 351 | 7.14 | 848 | 53 |
| 40 | 16640 | 128 | 27.30 | 14.99 | 45 | 5.27 | 191 | 3.83 | 456 | 57 |
| 40 | 16896 | 256 | 16.59 | 8.06 | 45 | 3.46 | 103 | 2.05 | 244 | 61 |
| 40 | 17408 | 512 | 11.90 | 4.57 | 45 | 2.61 | 55 | 1.09 | 130 | 65 |
Table A.9. Same as Table A.6 except that all calculations were performed for the same number of qubits (strong scaling).
References
- [1]S. S. Gill, S. Tuli, M. Xu, I. C. Singh, S. Dustdar, R. Buyya, Quantum computing: A taxonomy, systematic review and future directions, Software: Practice and Experience 52 (2022) 92–136. doi:10.1002/spe.2958.
- [2]M. Nielsen, I. Chuang, Quantum Computation and Quantum Information, 10th anniversary edition ed., Cambridge University Press, Cambridge, 2010. doi:10.1017/cbo9780511976667.
- [3]Google Quantum AI and Collaborators, Quantum error correction below threshold, Nature 638 (2024) 920–926. doi:10.1038/s41586-024-08449-y.
- [4]K. De Raedt, K. Michielsen, H. De Raedt, B. Trieu, G. Arnold, M. Richter, Th. Lippert, H. Watanabe, N. Ito, Massively parallel quantum computer simulator, Comp. Phys. Comm. 176 (2007) 121–136. doi:10.1016/j.cpc.2006.08.007.DOI
- [5]The Qiskit Community, Qiskit: An open-source framework for quantum computing, 2023. URL: https://qiskit.org/.
- [6]The Cirq Developers, Cirq: A python framework for nisq-era quantum circuits, 2023. URL: https://quantumai.google/cirq/.
- [7]Eviden, Qaptiva: Quantum application development platform, 2023. URL: https://eviden.com/solutions/advanced-computing/quantum-computing/qaptiva-hpc/.
- [8]H. De Raedt, F. Jin, D. Willsch, M. Willsch, N. Yoshioka, N. Ito, S. Yuan, K. Michielsen, Massively parallel quantum computer simulator, eleven years later, Comp. Phys. Comm. 237 (2019) 47–61. doi:10.1016/j.cpc.2018.11.005.DOI
- [9]M. Willsch, D. Willsch, F. Jin, H. De Raedt, K. Michielsen, Benchmarking the quantum approximate optimization algorithm, Quantum Information Processing 19 (2020). doi:10.1007/s11128-020-02692-8.DOI
- [10]D. Willsch, M. Willsch, F. Jin, K. Michielsen, H. De Raedt, GPU-accelerated simulations of quantum annealing and the quantum approximate optimization algorithm, Comp. Phys. Comm. 278 (2022) 108411. doi:10.1016/j.cpc.2022.108411.DOI
- [11]HPCwire, Quantum computer simulation: New world record on jugene, 2010. URL: https://www.hpcwire.com/2010/06/28/quantum_computer_simulation_new_world_record_on_jugene/.
- [12]HPCwire, World record: Quantum computer with 46 qubits simulated, 2017. URL: https://www.hpcwire.com/2017/12/18/world-record-quantum-computer-46-qubits-simulated/.
- [13]D. Alvarez, JUWELS cluster and booster: Exascale pathfinder with modular supercomputing architecture at Jülich Supercomputing Centre, Journal of large-scale research facilities JLSRF 7 (2021). doi:10.17815/jlsrf-7-183.
- [14]Y. Liu, X. Liu, F. Li, H. Fu, Y. Yang, J. Song, P. Zhao, Z. Wang, D. Peng, H. Chen, C. Guo, H. Huang, W. Wu, D. Chen, Closing the “quantum supremacy” gap: achieving real-time simulation of a random quantum circuit using a new Sunway supercomputer, in: Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC ’21, ACM, 2021. doi:10.1145/3458817.3487399.DOI
- [15]Google AI Quantum and Collaborators, Quantum supremacy using a programmable superconducting processor, Nature 574 (2019) 505–510. doi:10.1038/s41586-019-1666-5.
- [16]Z.-Y. Chen, Q. Zhou, C. Xue, X. Yang, G.-C. Guo, G.-P. Guo, 64-qubit quantum circuit simulation, Science Bulletin 63 (2018) 964–971. doi:10.1016/j.scib.2018.06.007.DOI
- [17]D. Willsch, M. Willsch, F. Jin, H. De Raedt, K. Michielsen, Large-scale simulation of Shor’s quantum factoring algorithm, Mathematics 11 (2023) 4222. doi:10.3390/math11194222.DOI
- [18]Cuda c++ programming guide - data usage hints section, Last retrieved on April 1, 2025. URL: https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#data-usage-hints.
- [19]Cuda 12.4 release notes - general cuda section, Last retrieved on April 1, 2025. URL: https://docs.nvidia.com/cuda/archive/12.4.0/cuda-toolkit-release-notes/index.html#general-cuda.
- [20]C. Zhang, Z. Song, H. Wang, K. Rong, J. Zhai, Hyquas: hy-brid partitioner based quantum circuit simulation system on gpu, in: Proceedings of the ACM International Conference on Supercomputing, ICS ’21, ACM, 2021, pp. 443–454. doi:10.1145/3447818.3460357.DOI
- [21]C. Jiao, W. Zhang, L. Shen, Communication optimizations for state-vector quantum simulator on cpu+gpu clusters, in: Proceedings of the 52nd International Conference on Parallel Processing, ICPP 2023, ACM, 2023, pp. 203–212. doi:10.1145/3605573.3605631.DOI
- [22]M. Xu, S. Cao, X. Miao, U. A. Acar, Z. Jia, Atlas: Hierarchical partitioning for quantum circuit simulation on gpus, in: SC24: International Conference for High Performance Computing, Networking, Storage and Analysis, IEEE, 2024, pp. 1–17. doi:10.1109/sc41406.2024.00087.DOI
- [23]J. A. Montanez-Barrera, K. Michielsen, Large-scale quantum circuit simulation on an exascale system for qpu benchmarking, 2026. doi:10.48550/ARXIV.2604.26423.
- [24]D. Willsch, H. Lagemann, M. Willsch, F. Jin, H. De Raedt, K. Michielsen, Benchmarking supercomputers with the Jülich Universal Quantum Computer Simulator (2019). doi:10.48550/ARXIV.1912.03243.DOI
- [25]A. Shpiner, Z. Haramaty, S. Eliad, V. Zdornov, B. Gafni, E. Zahavi, Dragonfly+: Low cost topology for scaling datacenters, in: 2017 IEEE 3rd International Workshop on High-Performance Interconnection Networks in the Exascale and Big-Data Era (HiPINBЕ), 2017, pp. 1–8. doi:10.1109/HiPINBЕ.2017.11.DOI
- [26]P. Gokhale, O. Angiuli, Y. Ding, K. Gui, T. Tomesh, M. Suchara, M. Martonosi, F. T. Chong, O(n³) measurement cost for variational quantum eigensolver on molecular hamiltonians, IEEE Transactions on Quantum Engineering 1 (2020) 1–24. doi:10.1109/TQE.2020.3035814.
- [27]P. Shor, Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer, SIAM Review 41 (1999) 303. doi:10.1137/S0030539795293172.
- [28]T. G. Draper, Addition on a quantum computer, 2000. doi:10.48550/ARXIV.QUANT-PH/0008033.DOI
- [29]K. Michielsen, M. Nocon, D. Willsch, F. Jin, Th. Lippert, H. De Raedt, Benchmarking gate-based quantum computers, Comp. Phys. Comm. 220 (2017) 44 – 55. doi:10.1016/j.cpc.2017.06.011.DOI
- [30]A. Herten, S. Achilles, D. Alvarez, J. Badwaik, E. Behle, M. Bode, T. Breuer, D. Caviedes-Voullième, M. Cherti, A. Dabah, S. E. Sayed, W. Frings, A. Gonzalez-Nicolas, E. B. Gregory, K. H. Mood, T. Hater, J. Jitsev, C. M. John, J. H. Meinke, C. I. Meyer, P. Mezentsev, J.-O. Mirus, S. Nassyr, C. Penke, M. Römmer, U. Sinha, B. V. S. Vieth, O. Stein, E. Suarez, D. Willsch, I. Zhukov, Application-Driven Exascale: The JUPITER Benchmark Suite, in: SC24: International Conference for High Performance Computing, Networking, Storage and Analysis, IEEE, 2024, pp. 1–45. doi:10.1109/sc41406.2024.00038.DOI
- [31]JUNIQ: The Jülich UNified Infrastructure for Quantum Computing, Last retrieved on April 1, 2025. URL: https://www.fz-juelich.de/en/ias/jsc/systems/quantum-computing/juniq-facility/juniq.
- [32]A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, J. L. O’Brien, A variational eigenvalue solver on a quantum processor, Nature Communications 5 (2014) 4213. doi:10.1038/ncomms5213.DOI
- [33]J. R. McClean, J. Romero, R. Babbush, A. Aspuru-Guzik, The theory of variational hybrid quantum-classical algorithms, New Journal of Physics 18 (2016) 023023. doi:10.1088/1367-2630/18/2/023023.DOI
- [34]M. Cerezo, A. Arrasmith, R. Babbush, S. Benjamin, S. Endo, K. Fujii, J. McClean, K. Mitarai, X. Yuan, L. Cincio, P. Coles, Variational quantum algorithms, Nature Reviews Physics 3 (2021) 625–644. doi:10.1038/s42254-021-00348-9.DOI
- [35]E. Farhi, J. Goldstone, S. Gutmann, A quantum approximate optimization algorithm, arXiv preprint arXiv:1411.4028 (2014). URL: https://arxiv.org/abs/1411.4028.
- [36]L. Zhou, S.-T. Wang, S. Choi, H. Pichler, M. D. Lukin, Quantum approximate optimization algorithm: Performance, mechanism, and implementation on near-term devices, Phys. Rev. X 10 (2020) 021067. URL: https://link.aps.org/doi/10.1103/PhysRevX.10.021067. doi:10.1103/PhysRevX.10.021067.DOI
- [37]P. C. Lotshaw, T. Nguyen, A. Santana, et al., Scaling quantum approximate optimization on near-term hardware, Sci. Rep. 12 (2022). URL: https://doi.org/10.1038/s41598-022-14767-w. doi:10.1038/s41598-022-14767-w.
- [38]K. Vyas, F. Jin, H. De Raedt, K. Michielsen, Quantum speed-up for solving the one-dimensional Hubbard model using quantum annealing, Physical Review Research 8 (2026) 023109. doi:10.1103/bj6c-t252.DOI





