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).
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 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.
Executing large quantum circuits is not feasible using the currently available NISQ (noisy intermediate-scale quantum) devices. The high costs of using real quantum devices make it further challenging to research and develop quantum algorithms. As a result, performing classical simulations is usually the preferred method for researching and validating large-scale quantum algorithms. However, these simulations require a huge amount of resources, as each additional qubit exponentially increases the computational space required. Distributed Quantum Computing (DQC) is a promising alternative to reduce the resources required for simulating large quantum algorithms at the cost of increased runtime. This study presents a comparative analysis of two simulation methods: circuit-splitting and full-circuit execution using distributed memory, each having a different type of overhead. The first method, using CutQC, cuts the circuit into smaller subcircuits and allows us to simulate a large quantum circuit on smaller machines. The second method, using Qiskit-Aer-GPU, distributes the computational space across a distributed memory system to simulate the entire quantum circuit. Results indicate that full-circuit executions are faster than circuit-splitting for simulations performed on a single node. However, circuit-splitting simulations show promising results in specific scenarios as the number of qubits is scaled.
As is intrinsic to the fundamental goal of quantum computing, classical simulation of quantum algorithms is notoriously demanding in resource requirements. Nonetheless, simulation is critical to the success of the field and a requirement for algorithm development and validation, as well as hardware design. GPU-acceleration has become standard practice for simulation, and due to the exponential scaling inherent in classical methods, multi-GPU simulation can be required to achieve representative system sizes. In this case, inter-GPU communications can bottleneck performance. In this work, we present the introduction of MPI into the QED-C Application-Oriented Benchmarks to facilitate benchmarking on HPC systems. We review the advances in interconnect technology and the APIs for multi-GPU communication. We benchmark using a variety of interconnect paths, including the recent NVIDIA Grace Blackwell NVL72 architecture that represents the first product to expand high-bandwidth GPU-specialized interconnects across multiple nodes. We show that while improvements to GPU architecture have led to speedups of over 4.5X across the last few generations of GPUs, advances in interconnect performance have had a larger impact with over 16X performance improvements in time to solution for multi-GPU simulations.
Executing large quantum circuits is not feasible using the currently available NISQ (noisy intermediate-scale quantum) devices. The high costs of using real quantum devices make it further challenging to research and develop quantum algorithms. As a result, performing classical simulations is usually the preferred method for researching and validating large-scale quantum algorithms. However, these simulations require a huge amount of resources, as each additional qubit exponentially increases the computational space required. Distributed Quantum Computing (DQC) is a promising alternative to reduce the resources required for simulating large quantum algorithms at the cost of increased runtime. This study presents a comparative analysis of two simulation methods: circuit-splitting and full-circuit execution using distributed memory, each having a different type of overhead. The first method, using CutQC, cuts the circuit into smaller subcircuits and allows us to simulate a large quantum circuit on smaller machines. The second method, using Qiskit-Aer-GPU, distributes the computational space across a distributed memory system to simulate the entire quantum circuit. Results indicate that full-circuit executions are faster than circuit-splitting for simulations performed on a single node. However, circuit-splitting simulations show promising results in specific scenarios as the number of qubits is scaled.
Large quantum circuits cannot be executed efectively on available NISQ (noisy intermediatescale quantum) devices.Moreover, due to the associated cost, researching and developing quantum algorithms on real quantum devices is not feasible.Classical simulations are, therefore, the best method to research and validate large-scale quantum algorithms.This, however, requires a large amount of resources as each additional qubit doubles the computational space for a quantum algorithm.Distributed Quantum Computing (DQC) is a promising alternative to reduce the resources required to simulate large quantum algorithms at the cost of increased runtime.This study performs a comparative analysis between two simulation methods, i.e. circuitsplitting versus full-circuit execution using distributed memory, with each method having a diferent type of overhead.The frst approach cuts the circuits into smaller subcircuits and allows us to simulate large quantum circuits using smaller machines.The second approach distributes the computational space across a distributed memory space and simulates the entire circuit.Results show that full-circuit executions are faster than circuit-splitting for simulations executed on a single node.However, circuit-splitting simulations show promising results in specifc scenarios as the number of qubits is scaled.v