Exploring complex quantum systems with a hybrid CPU-GPU computing platform

A. Yu. Polyakov, S. Denisov, Peter Hänggi A

Published Jan 1, 2013• 0 citations

Abstract

One of the most striking features of quantum mechanics is the exponential growth of resources, required to find the states of a composite system, with the size of the system. This also is the origin of the two main bottlenecks in numerical studies of complex quantum systems, that are (i) diagonalizations of big matrices and (ii) propagations of large systems of linear differential equations with global symplectic structure. Operations of the first type are purely scalable, while most of the propagation algorithms allow for the high degree of parallelism. Here we show how the workload of finding Floquet eigenstates of an ac-driven non- integrable quantum system can be shared between a general-purpose central processing unit (CPU) and a graphic processing unit (GPU), when both are working within one computing platform. Namely, diagonalization steps are delegated to the CPU, while the time propagation is performed on the GPU. This strategy led to a computational time speed-up of several order of magnitude as compared to the performance of the CPU alone.

Related papers

Heterogeneous CPU-GPU-Quantum Accelerator

Seham Al Abdul Wahid, Arghavan Asad, Rupinder Kaur +3 more

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.

Sep 17, 20251 citation

Scaling Sample-Based Quantum Diagonalization on GPU-Accelerated Systems using OpenMP Offload

Robert E. Walkup, Juha Jäykkä, Igor Pasichnyk +14 more

Hybrid quantum-HPC algorithms advance research by delegating complex tasks to quantum processors and using HPC systems to orchestrate workflows and complementary computations. Sample-based quantum diagonalization (SQD) is a hybrid quantum-HPC method in which information from a molecular Hamiltonian is encoded into a quantum circuit for evaluation on a quantum computer. A set of measurements on the quantum computer yields electronic configurations that are filtered on the classical computer, which also performs diagonalization on the selected subspace and identifies configurations to be carried over to the next step in an iterative process. Diagonalization is the most demanding task for the classical computer. Previous studies used the Fugaku supercomputer and a highly scalable diagonalization code designed for CPUs. In this work, we describe our efforts to enable efficient scalable and portable diagonalization on heterogeneous systems using GPUs as the main compute engines based on the previous work. GPUs provide massive on-device thread-level parallelism that is well aligned with the algorithms used for diagonalization. We focus on the computation of ground-state energies and wavefunctions using the Davidson algorithm with a selected set of electron configurations. We describe the offload strategy, code transformations, and data-movement, with examples of measurements on the Frontier supercomputer and five other GPU accelerated systems. Our measurements show that GPUs provide an outstanding performance boost of order 100x on a per-node basis. This dramatically expedites the diagonalization step-essential for extracting ground and excited state energies-bringing the classical processing time down from hours to minutes.

arXiv:2601.16169Jan 22, 20260 citations

Cutting Quantum Circuits to Run on Quantum and Classical Platforms

Wei Tang, Margaret Martonosi

Quantum computing (QC) offers a new computing paradigm that has the potential to provide significant speedups over classical computing. Each additional qubit doubles the size of the computational state space available to a quantum algorithm. Such exponentially expanding reach underlies QC's power, but at the same time puts demanding requirements on the quantum processing units (QPU) hardware. On the other hand, purely classical simulations of quantum circuits on either central processing unit (CPU) or graphics processing unit (GPU) scale poorly as they quickly become bottlenecked by runtime and memory. This paper introduces CutQC, a scalable hybrid computing approach that distributes a large quantum circuit onto quantum (QPU) and classical platforms (CPU or GPU) for co-processing. CutQC demonstrates evaluation of quantum circuits that are larger than the limit of QPU or classical simulation, and achieves much higher quantum circuit evaluation fidelity than the large NISQ devices achieve in real-system runs.

arXiv:2205.05836May 12, 20227 citations

Parallel time integration using Batched BLAS (Basic Linear Algebra Subprograms) routines

Konstantin Herb, Pol Welter

We present an approach for integrating the time evolution of quantum systems. We leverage the computation power of graphics processing units (GPUs) to perform the integration of all time steps in parallel. The performance boost is especially prominent for small to medium-sized quantum systems. The devised algorithm can largely be implemented using the recently-specified batched versions of the BLAS routines, and can therefore be easily ported to a variety of platforms. Our PARAllelized Matrix Exponentiation for Numerical Time evolution (PARAMENT) implementation runs on CUDA-enabled graphics processing units. Program Title: PARAMENT CPC Library link to program files: https://doi.org/10.17632/zy5v4xs89d.1 Developer's repository link: https://github.com/parament-integrator/parament Licensing provisions: Apache 2.0 Programming language: C / CUDA / Python Nature of problem: Time-integration of the Schrödinger equation with a time-dependent Hamiltonian for quantum systems with a small Hilbert space but many time-steps. Solution method: A 4th order Magnus integrator, highly parallelized on a GPU, implemented using a small subset of BLAS functions for improved portability.

arXiv:2108.07126Computer Physics CommunicationsSep 27, 20217 citations

Quantum computing simulator on a heterogenous HPC system

Jun Doi, Hitomi Takahashi, Rudy Raymond +2 more

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.

ACM International Conference on Computing Frontiers (CF)Apr 30, 201944 citations

Distributed quantum computing integrated into high-performance computing environments

F. Javier Cardama

High-Performance Computing (HPC) has historically served as the primary engine for scientific advancement, enabling complex simulations ranging from meteorological prediction to protein folding or drug discovery. For decades, the exponential growth in computational power was sustained by the empirical axioms of Moore’s Law and Dennard scaling. However, in the last decade, these principles have begun to exhibit unambiguous signs of saturation. The fundamental physical, thermodynamic, and quantum limitations of silicon transistors have compelled the industry to abandon frequency scaling in favor of massive parallelism and architectural heterogeneity. Consequently, contemporary top-tier supercomputers are no longer homogeneous machines, but complex clusters that integrate multicore Central Processing Units (CPU) with specialized accelerators such as Graphics Processing Units (GPU) or FPGAs.

Jan 1, 20260 citations