Quantum computing simulation on a classical computer is difficult due to the exponential runtime and memory overhead. Previous work addresses the difficulty by utilizing multiple Graphical Processing Units (GPUs) and multi-node computers. GPUs are efficient for handling runtime issues but have limited total accessible memory space. Meanwhile, the memory of a multi-node computer can be scaled to the petabytes order, but its bandwidth for access from host computers (CPUs) is narrow. To simultaneously accelerate simulation and enlarge the total memory space, we propose a heterogeneous parallelization approach by combining GPUs and CPUs. Our simulator allocates memory to the GPUs first, and then to the CPUs. It thus accelerates simulation by using the full capabilities of the GPUs if memory for the simulation fits in the GPUs on a cluster. Allocating memory to the CPUs reduces benefits of the GPUs but enlarges the capacity of qubits in the simulation. In such case, it can exploit the memory of the GPUs to add one more qubit in the simulation if the size of memory in a node is the power of two (such as 512GB). We show empirical performance evaluations of our simulator in a distributed environment of POWER9.
Quantum computing simulation on a classical computer is difficult due to the exponential runtime and memory overhead. Previous work addresses the difficulty by utilizing multiple Graphical Processing Units (GPUs) and multi-node computers. GPUs are efficient for handling runtime issues but have limited total accessible memory space. Meanwhile, the memory of a multi-node computer can be scaled to the petabytes order, but its bandwidth for access from host computers (CPUs) is narrow. To simultaneously accelerate simulation and enlarge the total memory space, we propose a heterogeneous parallelization approach by combining GPUs and CPUs. Our simulator allocates memory to the GPUs first, and then to the CPUs. It thus accelerates simulation by using the full capabilities of the GPUs if memory for the simulation fits in the GPUs on a cluster. Allocating memory to the CPUs reduces benefits of the GPUs but enlarges the capacity of qubits in the simulation. In such case, it can exploit the memory of the GPUs to add one more qubit in the simulation if the size of memory in a node is the power of two (such as 512GB). We show empirical performance evaluations of our simulator in a distributed environment of POWER9.
Quantum computers are becoming practical for computing numerous applications. However, simulating quantum computing on classical computers is still demanding yet useful because current quantum computers are limited because of computer resources, hardware limits, instability, and noises. Improving quantum computing simulation performance in classical computers will contribute to the development of quantum computers and their algorithms. Quantum computing simulations on classical computers require long performance times, especially for quantum circuits with a large number of qubits or when simulating a large number of shots for noise simulations or circuits with intermediate measures. Graphical processing units (GPU) are suitable to accelerate quantum computer simulations by exploiting their computational power and high bandwidth memory and they have a large advantage in simulating relatively larger qubits circuits. However, GPUs are inefficient at simulating multi-shots runs with noises because the randomness prevents highly parallelization. In addition, GPUs have a disadvantage in simulating circuits with a small number of qubits because of the large overheads in GPU kernel execution. In this paper, we introduce optimization techniques for multi-shot simulations on GPUs. We gather multiple shots of simulations into a single GPU kernel execution to reduce overheads by scheduling randomness caused by noises. In addition, we introduce shot-branching that reduces calculations and memory usage for multi-shot simulations. By using these techniques, we speed up x10 from previous implementations.
The drastic growth of data generation by companies such as Google and Facebook, the widespread integration of IoT devices into everyday life, advancements in artificial intelligence, and the rise of social media platforms are driving a shift from model-driven to data-driven science. This surge in data created a need for massively parallel accelerators such as graphics processing units (GPU). High Performance Computing (HPC) are required to accommodate the growing complexity of data-driven technologies. HPC demands are anticipated to reach exascale levels within this decade. Since 2004, three waves of high-performance accelerators have driven advancements in HPC: the first wave introduced Central Processing Units (CPUs) and Field Programmable Gate Arrays (FPGAs), the second wave brought General Purpose Graphics Processing Units (GPGPUs), and the third wave focused on machine learning specific GPUs. Recent research reveals that quantum processing units (QPUs) have the potential to be the fourth wave of high-performance acceleration in the near future. However, as Quantum Computing is still in its early stages, its practical and useful quantum computation is yet to be developed. In this paper, a heterogeneous CPU-GPU-QPU (HCGQ) accelerator is proposed. The accelerator is based on an input size threshold, where the CPU assigns smaller input sizes workloads to the GPU, and larger input sizes to the QPU. This dynamic workload allocation is realized entirely through software-level integration. Using the searching algorithm and deep neural networks as benchmarks, it was observed that the HCGQ accelerator outperformed standalone GPUs and QPUs in terms of speed and energy efficiency.
Quantum circuit simulations are applied in more and more circumstances as the quantum computing community becomes broader. It helps researchers to evaluate the quantum algorithms and relieve the burden of limited quantum computing resources. However, most of the state-of-the-art quantum simulators utilizes either CPU or GPU to store and calculate the state vector, which results in resources stravation. Morever, the mamximum number of qubits supported by simulator is bounded by the memory, since the memory utilization increases exponentially with the number of qubits. In this study, we leverage Heterogeneous computing to utilize both CPU and GPU to store and update state vectors. We also integrate lossy data compression to reduce memory requirements. Specifically, we develop a heterogeous framework that has a dynamic scheduler to fully utilize the computing resources. We apply lossy compression to chunked state vector to make the maximum number of qubits higher than the regular simulators, the compression also benifits the data movement between CPU and GPU.
Abstract State vector describing the state of an n-qubit quantum system requires 2ncomplex numbers, which means the memory usage of simulating a quantum computer grows exponentially with respect to the number of qubits. For the memory of a single hardware is limited, distributed computation is necessary for simulating quantum systems with large number of qubits. In our proposal, we developed a multi-GPU solution. State vector is divided into several chunks and allocated to different GPU device. Making it possible to simulate quantum circuits of any size on appropriate GPU cluster. We analyse the theoretical computation resource and come to the conclusion that memory copy bandwidth between GPUs is the bottleneck of time consumption. Total execution time is O(logDN/DN) if peer-to-peer memory copy is supported, otherwise time elapsed is O(logDN) where DN is number of GPU devices. Memory consumption on one GPU is O(1/DN).
Quantum circuit simulation at scale demands high-performance computing (HPC) frameworks capable of distributing exponentially growing state vectors and tensor networks across heterogeneous compute clusters. As quantum algorithm development accelerates and circuits approach 50-100 qubits in practical workloads, simulation bottlenecks shift from single-node memory constraints to inter-node communication overhead, GPU memory bandwidth, and framework-level scheduling inefficiencies. This paper proposes the HPC Quantum Simulation Framework Benchmark (HQSFB), a systematic evaluation of five leading quantum simulation frameworks -- Qiskit Aer, Cirq on GCP, cuQuantum (NVIDIA), QuEST, and Intel Quantum Simulator (IQS) -- across six HPC deployment configurations spanning single-GPU workstations to 512-GPU supercomputer partitions. HQSFB introduces the Framework Efficiency Score (FES) combining simulation throughput, GPU utilisation, inter-node communication overhead, and memory scaling efficiency. Key results: cuQuantum achieves the highest FES (0.924) with 94.2% GPU utilisation and 42x speedup over CPU baseline at 512 GPUs; QuEST achieves the best memory scaling efficiency (0.962) for distributed statevector simulation; Qiskit Aer provides the broadest circuit compatibility with FES = 0.842. The framework provides HPC configuration guidance and an open benchmark suite for quantum simulation infrastructure planning.
The D-GM execution environment improves distributed simulation of quantum algorithms in heterogeneous computing environments comprising both multi-core CPUs and GPUs. The main contribution of this work consists in the optimization of the environment VirD-GM, conceived in three steps: ( i ) the theoretical studies and implementation of the abstractions of the Mixed Partial Process defined in the qGM model, focusing on the reduction of the memory consumption regarding multidimensional QTs; ( ii ) the distributed/parallel implementation of such abstractions allowing its execution on clusters of GPUs; ( iii ) and optimizations that predict multiplications by zero-value of the quantum states/transformations, implying reduction in the number of computations. The results obtained in this work embrace the distribute/parallel simulation of Hadamard gates up to 21 qubits, showing scalability with the increase in the number of computing nodes.