The rapid expansion of quantum computing research has created a growing need for effective and scalable tools to simulate quantum algorithms. In this study, we present a performance analysis of several quantum circuit simulators by using the Deutsch-Jozsa (DJ) and Quantum Fourier Transform (QFT). A gate-based QASM implementation serves as the baseline and is converted to code compatible with each simulator. Our evaluation covers multi-CPU simulators like Qiskit, Qsim-Cirq, and QuEST, as well as their GPU-accelerated variants along with CUDA-Q, for qubit sizes ranging from 21 to 35. By profiling these algorithms, we compare key performance indicators and reveal notable efficiency differences between platforms. In particular, the multi-node version of QuEST shows strong CPU utilization, high speedup, and efficient memory scalability. whereas GPUbased implementations provide clear performance advantages at higher qubit counts. These findings offer practical guidance for choosing simulation platforms according to problem size and available computing resources, thereby supporting more efficient quantum-algorithm workflows.
The rapid expansion of quantum computing research has created a growing need for effective and scalable tools to simulate quantum algorithms. In this study, we present a performance analysis of several quantum circuit simulators by using the Deutsch-Jozsa (DJ) and Quantum Fourier Transform (QFT). A gate-based QASM implementation serves as the baseline and is converted to code compatible with each simulator. Our evaluation covers multi-CPU simulators like Qiskit, Qsim-Cirq, and QuEST, as well as their GPU-accelerated variants along with CUDA-Q, for qubit sizes ranging from 21 to 35. By profiling these algorithms, we compare key performance indicators and reveal notable efficiency differences between platforms. In particular, the multi-node version of QuEST shows strong CPU utilization, high speedup, and efficient memory scalability. whereas GPUbased implementations provide clear performance advantages at higher qubit counts. These findings offer practical guidance for choosing simulation platforms according to problem size and available computing resources, thereby supporting more efficient quantum-algorithm workflows.
This article presents a comprehensive study of the performance of quantum circuit simulation using the Matrix Product State (MPS) method within Qiskit Aer. The primary focus is on comparing the computational efficiency of implementations on central processing unit (CPU) and graphics processing unit (GPU) across various simulation platforms. Four key quantum algorithms are experimentally examined: the Variational Quantum Eigensolver (VQE), the Quantum Fourier Transform (QFT), the Quantum Approximate Optimization Algorithm (QAOA), and the Greenberger– Horne–Zeilinger (GHZ) state. For each algorithm, graphs are constructed showing the dependence of execution time on the number of qubits and the type of simulator. A single diagram is also provided to compare all four algorithms using the MPS method in Qiskit Aer. The results indicate that although the MPS simulator in Qiskit Aer is currently implemented only for CPU, it outperforms the traditional statevector simulator for low-entanglement circuits. At the same time, the lack of GPU acceleration limits the scalability of the MPS simulator. Analysis shows that implementing hardware acceleration of SVD operations using NVIDIA's cuQuantum and cuTensorNet libraries can provide a speedup of up to seven times. A comparative analysis of GPU implementations in Qiskit Aer and CUDA-Q is also conducted, including libraries such as cuStateVec, LAPACK, and cuSOLVER. Graphs are created to demonstrate the strengths and weaknesses of the simulators and simulation methods in Qiskit Aer. Notably, the MPS method remains one of the fastest by computation speed on CPU, but is sometimes surpassed by other methods on GPU. Further optimization directions for MPS are proposed, including the development of a hybrid CPU/GPU architecture and the utilization of modern GPU libraries to accelerate critical operations. Keywords: quantum computing, quantum simulation, Qiskit Aer, MPS, statevector, cudaq.
The increasing complexity of quantum algorithms and the limitations of current Noisy Intermediate-Scale Quantum (NISQ) hardware underscore the importance of efficient classical simulators. To support informed decision-making by users of quantum circuit simulators, we benchmark seven statevector-based quantum circuit simulators (Qiskit, Qulacs, Qibo, Qsimov, Cirq, Pennylane and the Intel Quantum Simulator (IQS)) on a multicore node of the Lusitania high-performance computing (HPC) system. We evaluate their performance in terms of execution time, memory usage and core scalability using Grover’s algorithm, the quantum Fourier transform (QFT), and quantum volume (QV) circuits, across qubit counts ranging from 3 to 30. Our results reveal that Qulacs offers the best performance for circuits below 22 qubits, while Qiskit becomes the fastest for larger and more complex circuits. Qiskit and Qulacs achieve the most efficient parallel performance across multiple cores, while others display limited scaling benefits. IQS shows the lowest memory consumption in QFT and QV benchmarks for systems under 24 qubits; however, it suffers from higher execution times, particularly for Grover’s algorithm. The experimental implementation of Qsimov consistently underperforms in both runtime and scalability; for this reason, it is employed as a baseline in our measurements, serving to highlight the importance of performance optimizations in statevector-based quantum circuit simulators. Previous findings provide a comprehensive performance landscape to guide researchers in selecting appropriate simulators for both standard and large-scale quantum workloads on HPC infrastructures.
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.
In recent years, quantum computing has undergone significant developments and has established its supremacy in many application domains. While quantum hardware is accessible to the public through the cloud environment, a robust and efficient quantum circuit simulator is necessary to investigate the constraints and foster quantum computing development, such as quantum algorithm development and quantum device architecture exploration. In this paper, we observe that most of the publicly available quantum circuit simulators (e.g., QISKit from IBM, QDK from Microsoft, and Qsim-Cirq from Google) suffer from slow simulation and poor scalability when the number of qubits increases. To this end, we systematically investigate the deficiencies in quantum circuit simulation (QCS) and propose Q-GPU, a framework that leverages GPUs with comprehensive optimizations to allow efficient and scalable QCS. Specifically, Q-GPU features i) proactive state amplitude transfer, ii) zero state amplitude pruning, iii) delayed qubit involvement, and iv) lossless nonzero state amplitude compression. Experimental results across nine representative quantum circuits indicate that Q-GPU significantly reduces the execution time of the state-of-the-art GPU-based QCS by 71.89% (3.55× speedup). Q-GPU also outperforms the state-of-the-art OpenMP CPU implementation, the Google Qsim-Cirq simulator, and the Microsoft QDK simulator by 1.49×, 2.02×, and 10.82×, respectively.
In the nearest future quantum computers will be suitable for practical use. The development of quantum algorithms can be carried out using classical computers and specialized software that allows simulating of a quantum circuit functioning. Simulation results can be used to analyze the algorithm and also contribute to co-design when developing quantum architectures. However, when planning and performing numerical experiments, it is necessary to understand the capabilities of simulators and the limitations on the parameters of the quantum circuit imposed by the characteristics of the available classical computational resources (computers). This paper presents the results of computational experiments on simulating the operation of quantum circuits on an ideal quantum computer using the QuEST and Intel-QS packages, as well as our own "naïve" implementation. Restrictions on the size of a simulated quantum system N are shown when using computing systems of various classes — a virtual machine, a computing server, a computing server with a graphics accelerator (GPU), a supercomputer (the maximum achieved size is N = 33). The performance and scalability characteristics of the considered implementations on shared and distributed memory are given (the observed scaling efficiency is 30 % and 70 %, respectively). For the QuEST package and our own implementation the performance is presented for systems with graphics accelerator (GPU).
Quantum computing in the NISQ era requires advanced emulation tools to facilitate the development and validation of complex quantum algorithms, as current quantum devices remain too noisy and resource-limited. This work presents a comprehensive review of quantum emulation software available for HPC centers using various comparison metrics to evaluate parallelization, precision, acceleration via Graphics Processing Unit (GPU), emulation with noise, among others. The comparative analysis evaluates four quantum emulation frameworks (QuEST, Qaptiva HPC, CUDA-Q, and PennyLane) across three hardware platforms with distinct characteristics: two HPC clusters (Spartan-Eviden and Joliot-Curie TGCC) and one quantum emulation appliance (Eviden Qaptiva 804). The scope of this analysis is fundamentally tied to the state-vector emulation paradigm. The experimental results of our evaluation reveal that performance depends on classical hardware configuration and circuit characteristics, that is, CUDA-Q excels in single-GPU environments, while Qaptiva HPC shows advantages in distributed multi-node configurations (both CPU and GPU).