PaperlayerView exact revision on arXiv

Source-linked AI summary

QuEST and High Performance Simulation of Quantum Computers

Tyson Jones, Anna Brown, Ian Bush, Simon Benjamin

arXiv:1802.08032v6quant-ph

TL;DR

Classical quantum simulation must support increasingly large, repeated studies across architectures despite exponential resource growth and the need to compare packages. The paper introduces QuEST, a portable simulator combining OpenMP, MPI, CUDA, and pure- and mixed-state capabilities. QuEST reports strong and weak scaling across multicore and distributed systems, including a 38-qubit circuit on up to 2048 nodes.

  • Problem

    Quantum simulation requires efficient, comparable tools spanning laptops to supercomputers as memory and operation costs grow exponentially with qubit count.

  • Method

    QuEST combines ISO C with OpenMP, MPI, hybrid parallelisation, CUDA acceleration, and state-vector and density-matrix simulation through a common interface.

  • Results

    QuEST shows excellent strong and weak scaling, simulates a 38-qubit circuit on up to 2048 nodes, and achieves ∼5× GPU speedup over 24-threaded simulation.

  • Takeaways & Limitations

    A single QuEST program can be deployed across laptops, multicore systems, GPUs, and distributed supercomputers while retaining competitive or faster performance.

Abstract

from arXiv · show

We introduce QuEST, the Quantum Exact Simulation Toolkit, and compare it to ProjectQ, qHipster and a recent distributed implementation of Quantum++. QuEST is the first open source, OpenMP and MPI hybridised, GPU accelerated simulator of universal quantum circuits. Embodied as a C library, it is designed so that a user's code can be deployed seamlessly to any platform from a laptop to a supercomputer. QuEST is capable of simulating generic quantum circuits of general single-qubit gates and multi-qubit controlled gates, on pure and mixed states, represented as state-vectors and density matrices, and under the presence of decoherence. Using the ARCUS Phase-B and ARCHER supercomputers, we benchmark QuEST's simulation of random circuits of up to 38 qubits, distributed over up to 2048 compute nodes, each with up to 24 cores. We directly compare QuEST's performance to ProjectQ's on single machines, and discuss the differences in distribution strategies of QuEST, qHipster and Quantum++. QuEST shows excellent scaling, both strong and weak, on multicore and distributed architectures.

I. INTRODUCTION

Classical quantum simulation is needed to study algorithms, scaling, noise robustness, and hardware limitations across platforms. QuEST addresses the need for flexible simulators that support comparison and deployment from workstations to larger systems.

  • Simulation supports evaluating quantum algorithms’ scaling, error robustness, and dependence on hardware limitations.
  • Exact simulation becomes expensive because memory and elementary-operation time grow exponentially with qubit count.
  • Repeated simulations are needed to study parameter variation and circuit behaviour under noise, increasing the importance of efficiency.
  • An ecosystem of simulators helps researchers verify complex simulations by comparing results across packages.
  • QuEST is presented as the first open-source simulator combining distributed and GPU facilities with broad hardware support.
  • Simulators typically target one or a few architectures, motivating a universal simulator deployable across available platforms.

B. Simulator Optimisations

Quantum simulators accelerate state-vector operations through SIMD, multithreading, cache techniques, distributed memory, and GPUs. QuEST combines portable C with OpenMP, MPI, CUDA, and unified interfaces while supporting pure and mixed-state simulation.

  • Simulator Optimisations: SIMD accelerates state-vector updates by concurrently modifying multiple amplitude elements.
  • Simulator Optimisations: OpenMP provides shared-memory task parallelism across multiple CPU cores and NUMA memory spaces.
  • Simulator Optimisations: Cache blocking and gate fusion reduce costly main-memory exchanges by combining operations on adjacent qubits.
  • Simulator Optimisations: MPI partitions state vectors across networked machines, providing parallelisation and aggregate memory for larger circuits.
  • Simulator Optimisations: GPU simulators use CUDA to exploit thousands of linked cores for substantial acceleration on limited-size circuits.
  • Simulator Optimisations: QuEST combines ISO C, OpenMP, MPI, hybrid parallelisation, CUDA acceleration, and one interface across platforms.
  • Simulator Optimisations: For n qubits, the default state-vector storage consumes 16×2^n B, with ProjectQ adding a ×1.5 allocation overhead.
  • Simulator Optimisations: QuEST represents density matrices as 2N-qubit state-vectors, reusing hardware-optimised gate operations and supporting decoherence channels.

2. Distributed

Distributed simulation balances communication count, message size, memory overhead, and scalability. QuEST minimizes communications per gate while accepting higher memory overhead, whereas alternatives trade memory savings for additional communication.

  • 2. Distributed: Distributed simulators partition state vectors equally across processes, commonly exchanging complete partitions between paired nodes for single-qubit gates.
  • 2. Distributed: Communication count, message size, and node memory overhead form a performance tradeoff in distributed simulation.
  • 2. Distributed: Half-partition cloning reduces memory cost to 1.5× and can fit another qubit, but requires twice as many MPI messages.
  • 2. Distributed: QuEST minimizes communications per gate, yielding good parallel performance but typically imposing a factor-of-2 memory overhead.
  • 2. Distributed: Further recursive division lowers memory overhead toward negligible levels while increasing communication and risking latency-dominated scaling.
  • 2. Distributed: QuEST supports distributed operation of any-qubit controlled gates, whereas qHipster is limited to single- and two-qubit controlled gates.

3. GPU

QuEST uses GPU acceleration for quantum simulation, combining high parallelism with lower hardware cost for circuits that fit within GPU memory.

  • QuEST supports both state-vector and density-matrix simulation on CUDA-enabled GPUs, with speedups of ∼5× over 24-threaded single-node simulation.This extends GPU support beyond state-vector-only simulation to mixed-state representations.

4. Multi-platform

QuEST is presented as a simulator that supports the range of classical architectures used for quantum-computation simulation, from laptops to national-grade supercomputers.

  • QuEST is the only simulator identified as supporting all of the classical architectures discussed in the paper.The paper states that QuEST code can be deployed immediately across all supported environments and simulation scales.
  • Figure 3 shows a depth 10 random circuit on 5 qubits with linear topology, drawn using ProjectQ’s circuit drawer.

C. Algorithm

The benchmark compares QuEST and ProjectQ on pseudo-random universal circuits while examining performance across circuit sizes, platforms, and distributed communication.

  • C. Algorithm: The study compares QuEST and ProjectQ on pseudo-random universal circuits varying in depth and qubit count.The circuits use H, T, C(Z), X1/2, and Y1/2 gates, with topology fixed by depth and qubit count while gate parameters are randomized.
  • C. Algorithm: Random circuits are used as a computationally hard benchmark, although specialised simulators may perform better on particular circuit classes.ProjectQ may exploit topological optimisation or classical emulation for subcircuits such as the quantum Fourier transform.
  • C. Algorithm: The experiments additionally measure QuEST’s communication efficiency through the time required for single-qubit rotations on distributed hardware.
  • C. Algorithm: The evaluation uses Oxford’s ARCUS Phase-B and ARCHER computing facilities, including single-node and distributed comparisons.QuEST and ProjectQ are compared on single nodes, while QuEST is also benchmarked on GPU nodes and ARCHER.
  • C. Algorithm: Table I compares the facilities offered by publicly available state-of-the-art simulators, including support for density matrices representing mixed states.The distributed adaptation of Quantum++ is noted as not publicly available.

B. Software

The software comparison configures QuEST and ProjectQ for platform-specific execution and measures gate-simulation runtime while testing compiler and gate-fusion choices.

  • B. Software: On ARCUS Phase-B, QuEST uses GCC and OpenMP, QuEST-GPU uses CUDA, and ProjectQ runs its C++ backend through Python.
  • B. Software: On ARCHER, QuEST uses ICC with OpenMP and MPI through MPICH3, optimized for the Aries interconnect, while ProjectQ uses GCC and Python.
  • B. Software: ProjectQ enables gate fusion only for multithreaded simulations when simulating many qubits.
  • B. Software: Disabling ProjectQ’s compiler engines improves multithreaded simulation of few-qubit random circuits by avoiding futile Python optimisation time.This configuration is not used in benchmarking because it disables classical emulation and gate decomposition.
  • B. Software: The benchmark measures only runtime for simulating the gate sequence, excluding state allocation, object management, and other one-time overheads.
  • B. Software: The implementations initialize simulators, allocate qubits, set the zero state, execute the circuit, and synchronize distributed QuEST work before timing completion.

A. Single Node Performance

QuEST is competitive with ProjectQ on multicore systems, despite ProjectQ’s single-thread advantage, and benefits substantially from GPU acceleration. Performance depends on system size, architecture, and threading behavior.

  • For fewer than ∼22 qubits, ProjectQ’s Python overhead is several orders of magnitude slower than QuEST’s C overhead, independent of circuit depth.
  • For larger systems, ProjectQ’s C++ state-vector backend dominates runtime, while the time per gate of both simulators grows exponentially with qubit count.
  • On a single ARCUS-B thread, ProjectQ is twice as fast as QuEST, but QuEST outperforms ProjectQ on 16 threads and both are equally fast on 24-thread ARCHER.ProjectQ’s scaling is non-monotonic, with performance suffering above 8 threads before recovering at 16.
  • Figure 4 compares mean runtimes and ProjectQ-to-QuEST speedups across 1, 16, and 24 threads for random circuits of varying depth.Vertical dashed lines mark the largest state vector fitting in the LLC, and shaded regions show standard deviations over ∼77 k simulations.
  • ∼5× speedup is achieved by QuEST with a GPU over ProjectQ on 24 threads.The comparison uses a 2880-CUDA-core GPU on ARCUS Phase-B against 24-thread execution.

B. Distributed Performance

QuEST scales across distributed ARCHER nodes using MPI, supporting large state vectors and maintaining strong weak-scaling behavior as simulated systems grow. Communication overhead is comparatively modest but network-dependent.

  • QuEST strong-scaling tests distribute 30- and 38-qubit random circuits across 1 to 2048 ARCHER nodes using one MPI process and 24 threads per node.
  • Figure 8 measures weak scaling by rotating a single qubit across 16–256 ARCHER nodes, separating communication-induced slowdown from rotation slowdown.Communication occurs for qubits at positions ≥30 as the simulated system grows from 34 qubits.
  • ≈9% slowdown occurs when QuEST’s weak-scaling test increases from 34 to 37 simulated qubits.The test uses enough nodes to keep the state-vector partition size constant as system size increases.
  • ∼101 slowdown is observed for communicated-qubit operations relative to non-communicated operations, comparable to qHipster and below Quantum++’s reported ∼106 slowdown.The authors note that these communication results depend on the network used.

V. SUMMARY

The paper presents QuEST as a high-performance open-source framework for universal quantum-computer simulation. It combines multicore, GPU, and distributed execution, demonstrating strong and weak scaling through simulations of up to 38 qubits on 2048 nodes.

  • QuEST is a high-performance open-source framework for simulating universal quantum computers.
  • QuEST shows good OpenMP strong scaling and is competitive with ProjectQ for multithreaded random-circuit simulations.
  • 5× and 40× speedups are achieved over 24-thread and single-thread simulations respectively using QuEST’s GPU parallelisation.
  • QuEST supports MPI distributed-memory execution and demonstrates strong and weak scaling across up to 2048 nodes while simulating a 38-qubit random circuit.
Loading 1802.08032v6…