This paper presents EdgeQuantum, a tiered-memory quantum circuit simulator designed to overcome the memory wall of resource-constrained edge devices. As quantum algorithms scale toward dozens of qubits for on-device NISQ workloads, simulating their state vectors demands coordinated multi-tier memory management beyond the device’s physical DRAM capacity. EdgeQuantum introduces a unified storage hierarchy that integrates unified DRAM and commodity NVMe storage into a 2-tier memory architecture. With this design, EdgeQuantum achieves zero-copy data movement through UVM visibility control, hides write latency through a 4-buffer asynchronous pipeline with serialized NVMe access, and expands capacity via ping-pong mantissa-truncated LZ4 compression. Our evaluation across six quantum circuits on an 8 GB NVIDIA Jetson Orin Nano shows that EdgeQuantum enables up to 40-qubit (8 TB) simulation for high-compression circuits and 36 qubits for dense circuits, while expanding effective memory capacity by up to 1024×. Without compression, EdgeQuantum outperforms the blocking I/O baseline by up to 1.64×. With compression, overlapping CPU compression and storage I/O with GPU computation improves end-to-end pipeline efficiency by 1.40× to 1.60×.
This paper presents EdgeQuantum, a tiered-memory quantum circuit simulator designed to overcome the memory wall of resource-constrained edge devices. As quantum algorithms scale toward dozens of qubits for on-device NISQ workloads, simulating their state vectors demands coordinated multi-tier memory management beyond the device’s physical DRAM capacity. EdgeQuantum introduces a unified storage hierarchy that integrates unified DRAM and commodity NVMe storage into a 2-tier memory architecture. With this design, EdgeQuantum achieves zero-copy data movement through UVM visibility control, hides write latency through a 4-buffer asynchronous pipeline with serialized NVMe access, and expands capacity via ping-pong mantissa-truncated LZ4 compression. Our evaluation across six quantum circuits on an 8 GB NVIDIA Jetson Orin Nano shows that EdgeQuantum enables up to 40-qubit (8 TB) simulation for high-compression circuits and 36 qubits for dense circuits, while expanding effective memory capacity by up to 1024×. Without compression, EdgeQuantum outperforms the blocking I/O baseline by up to 1.64×. With compression, overlapping CPU compression and storage I/O with GPU computation improves end-to-end pipeline efficiency by 1.40× to 1.60×.
This paper presents AURORA-Q, a tiered-memory quantum circuit simulation framework designed to overcome the memory bottleneck and scalability limits of large-scale quantum circuit simulation on Perlmutter. Its primary strategy is to extend beyond GPU-centric designs bounded by VRAM and introduce a unified tiered-memory architecture that integrates GPU VRAM, DRAM, and storage into a simulation framework. With this design, AURORA-Q partitions the full state vector into subsets, manages their residency across memory tiers, overlaps computation with data movement through an async execution pipeline, and employs a dynamic two-level cache with adaptive resource control to exploit access locality under constrained resources. Our evaluation demonstrates that AURORA-Q executes up to 43 qubit simulations on 512 GPUs, a scale unattainable by existing state-of-the-art simulators due to limited memory resources. AURORA-Q achieves up to2.91×speedup compared to baselines, while maintaining up to a 79.3% cache hit rate and reducing pipeline stalls by 73% to hide I/O latency.
Since the state-of-the-art quantum computers are still noisy and error-prone, classical simulation of quantum circuits is essential in verifying/calibrating quantum computers and prototyping/debugging complex quantum algorithms. Classical simulation of large quantum systems is challenging due to its exponential increase in space and computation requirements. In this paper, we propose a full-state simulation framework, SnuQS. It exploits storage devices, such as HDDs and NVMe SSDs, to enlarge the available main memory capacity at a small cost. To achieve maximum I/O bandwidth, we propose an overlay-based memory management technique and optimization techniques. We also propose an I/O subsystem architecture that guarantees the maximum bandwidth of each storage device. We evaluate SnuQS on a 64-core CPU and 4-GPU system with 80 2TB HDDs and 10 4TB NVMe SSDs using quantum supremacy and quantum Fourier transform circuits. The experimental result indicates that SnuQS and the proposed I/O subsystem together is an effective and practical solution to scale the full-state simulation of large quantum circuits at about 300X lower cost than the DDR4 DRAM main-memory-only system.
State-vector simulation of n qubits requires 2^n complex amplitudes, capping a 6 GB consumer GPU at 29 qubits. We present qubit, a quantum circuit simulator whose state vector is partitioned into blocks, each stored in one of three tiers (ZERO with no storage, COMPRESSED as block-scaled int16 at 4 B/amplitude, or FULL as complex64) and resident entirely in GPU memory: promotion and demotion are kernels, and the only host traffic is scheduling metadata and measurement scalars, in contrast to prior compression frameworks that stage compressed state in host memory. Quantization error is accumulated exactly on-device; because unitaries preserve norms, per-event errors compose linearly in L2 norm, giving a conservative a-priori fidelity bound F ≥ (1−D)²/(1+D)² for total injected error D. The bound is tight at low circuit depth and becomes loose as errors accumulate, so we pair it with a random-walk estimate and direct measurement, and use its inverse to turn a user-specified fidelity target into a compression budget the runtime never exceeds. Unlike structure-aware simulators (matrix product states, stabilizer methods, or Qrack), which shrink only low-entanglement states, this compresses the genuinely dense states that have no structure to exploit: on an RTX 3060 Laptop GPU (6 GB, dense complex64 ceiling 29 qubits) qubit holds a 29-qubit fully-dense state in half its footprint at measured fidelity 0.9998, and is 3.5–6× faster than Qrack on dense circuits on the same card, while the ZERO tier still captures sparse states exactly (a 31-qubit GHZ circuit in 1 MB). An automatic planner chooses among dense, entanglement-factorized, and tiered representations from a static analysis of the circuit, so the user declares qubits, gates, and a fidelity target, and nothing else. Code and data: https://github.com/ArubikU/qubit
Full-state quantum circuit simulation requires exponentially increased memory size to store the state vector as the number of qubits scales, presenting significant limitations in classical computing systems. Our paper introduces BMQSim, a novel state vector quantum simulation framework that employs lossy compression to address the memory constraints on graphics processing unit (GPU) machines. BMQSim effectively tackles four major challenges for state-vector simulation with compression: frequent compression/decompression, high memory movement overhead, lack of dedicated error control, and unpredictable memory space requirements. Our work proposes an innovative strategy of circuit partitioning to significantly reduce the frequency of compression occurrences. We introduce a pipeline that seamlessly integrates compression with data movement while concealing its overhead. Additionally, BMQSim incorporates the first GPU-based lossy compression technique with point-wise error control. Furthermore, BMQSim features a two-level memory management system, ensuring efficient and stable execution. Our evaluations demonstrate that BMQSim can simulate the same circuit with over 10 times less memory usage on average, achieving fidelity over 0.99 and maintaining comparable simulation time to other state-of-the-art simulators.
Classical simulation of quantum circuits remains indispensable for algorithm development, hardware validation, and error analysis in the noisy intermediate-scale quantum (NISQ) era. However, state-vector simulation faces exponential memory scaling, with an n-qubit system requiring O(2^n) complex amplitudes, and existing simulators often lack the flexibility to exploit heterogeneous computing resources at runtime. This paper presents a GPU-accelerated quantum circuit simulation framework that introduces three contributions: (1) an empirical backend selection algorithm that benchmarks CuPy, PyTorch-CUDA, and NumPy-CPU backends at runtime and selects the optimal execution path based on measured throughput; (2) a directed acyclic graph (DAG) based gate fusion engine that reduces circuit depth through automated identification of fusible gate sequences, coupled with adaptive precision switching between complex64 and complex128 representations; and (3) a memory-aware fallback mechanism that monitors GPU memory consumption and gracefully degrades to CPU execution when resources are exhausted. The framework integrates with Qiskit, Cirq, PennyLane, and Amazon Braket through a unified adapter layer. Benchmarks on an NVIDIA A100-SXM4 (40 GiB) GPU demonstrate speedups of 64x to 146x over NumPy CPU execution for state-vector simulation of circuits with 20 to 28 qubits, with speedups exceeding 5x from 16 qubits onward. Hardware validation on an IBM quantum processing unit (QPU) confirms Bell state fidelity of 0.939, a five-qubit Greenberger-Horne-Zeilinger (GHZ) state fidelity of 0.853, and circuit depth reduction from 42 to 14 gates through the fusion pipeline. The system is designed for portability across NVIDIA consumer and data-center GPUs, requiring no vendor-specific compilation steps.
Quantum circuit simulation (QCS) is essential in the noisy intermediate scale quantum (NISQ) era when real quantum computers are scarce. However, fully tracking the states of a quantum system in QCS is highly challenging due to the exponential memory growth that significantly limits the computational reach of classical systems for QCS. Though it is straightforward to leverage secondary storage to extend the scale of QCS, excessive data movement between memory and storage dominates the simulation time, making this solution unrealistic. To tackle this challenge, we identify an intrinsic property of QCS and implement an open-source framework to effectively reduce data movement by >116x. We evaluate the framework on various benchmarks and demonstrate 4x memory reduction with only <20% overhead. On a memory constrained system, we show that it extends the scale of QCS to 32 qubits (64 GB memory requirement) while existing simulators are bounded to 28 qubits (4 GB memory requirement). Our implementation can be accessed via https://github.com/Zhaoyilunnn/qdao.