Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

IEEE International Conference on Quantum Computing and Engineering (QCE)

Fully Integrated Quantum Method for Classical Register Allocation in LLVM

Brice Chichereau, Stéphane Vialle, Patrick Carribault

Published Sep 15, 2024• 0 citations
Publisher

Abstract

Quantum computing devices are being installed alongside supercomputing clusters to serve as hardware accel-erators. This new type of architecture will require an integrated hybrid software stack. With this goal in mind, we have developed a fully integrated hybrid quantum-classical method in the hope of improving Register Allocation in the classical LLVM compiler. We propose a hybrid variational optimization algorithm for the PBQP formulation of Register Allocation. We implemented this algorithm in C++ inside LLVM using the NVIDIA CUDA-$Q$framework. The performance of the method is evaluated using NVIDIA CUDA-Q noiseless emulators and shows promising results while still needing further optimizations. Our work constitutes a demonstration of an end-to-end tight integration of a quantum subroutine inside an existing classical codebase of interest with potentially interesting performance in fault-tolerant hardware.

DOI
10.1109/qce60285.2024.10295

Related papers

Experimenting with Hybrid Quantum Optimization in HPC Software Stack for CPU Register Allocation

Brice Chichereau, Stéphane Vialle, Patrick Carribault

Quantum computers exploit the particular behavior of quantum physical systems to solve some problems in a different way than classical computers. We are now approaching the point where quantum computing could provide real advantages over classical methods. The computational capabilities of quantum systems will soon be available in future supercomputer architectures as hardware accelerators called Quantum Processing Units (QPU). From optimizing compilers to task scheduling, the High-Performance Computing (HPC) software stack could benefit from the advantages of quantum computing. We look here at the problem of register allocation, a crucial part of modern optimizing compilers. We propose a simple proof-of-concept hybrid quantum algorithm based on QAOA to solve this problem. We implement the algorithm and integrate it directly into GCC, a well-known modern compiler. The performance of the algorithm is evaluated against the simple Chaitin-Briggs heuristic as well as GCC's register allocator. While our proposed algorithm lags behind GCC's modern heuristics, it is a good first step in the design of useful quantum algorithms for the classical HPC software stack.

IEEE International Conference on Quantum Computing and Engineering (QCE)•Sep 17, 2023•1 citation

QLLVM: A Scalable Quantum-Classical Co-Compilation Framework based on LLVM

Yu Zhu, Qiming Du, Yuqiong Jin +5 more

To address the urgent need in the NISQ era for high-performance, scalable quantum compilers and to advance the integration of classical and quantum computing, we present QLLVM, an advanced Quantum-Classical co-compilation framework built on LLVM. To our knowledge, QLLVM delivers an end-to-end, LLVM-based compilation workflow that unifies the build of classical high-performance programs, including CUDA, MPI, and C++, together with quantum programs into a single executable. For quantum program compilation, QLLVM adopts a three-stage design: high-level optimizations are implemented in the MLIR Quantum dialect and then lowered to QIR, an LLVM IR-based representation, for low-level optimization and hardware mapping. Its extensible architecture and seamless interoperability with classical high-performance computing provide an efficient, flexible, industrial-grade compilation infrastructure for future quantum software development. Experimental results show that, on the MQTBench benchmark suite, QLLVM reduces circuit depth and gate counts compared with state-of-the-art compilers and demonstrates clear advantages in compiling hybrid classical-quantum programs.

quant-pharXiv:2604.15094•Apr 17, 2026•0 citations

A Full Stack Framework for High Performance Quantum-Classical Computing

Xin Zhan, Katherine Grace Johnson, Aniello Esposito +5 more

To address the growing needs for scalable High Performance Computing (HPC) and Quantum Computing (QC) integration, we present our HPC-QC full stack framework and its hybrid workload development capability with modular hardware/device-agnostic software integration approach. The latest development in extensible interfaces for quantum programming, dispatching, and compilation within existing mature HPC programming environment are demonstrated. Our HPC-QC full stack enables high-level, portable invocation of quantum kernels from commercial quantum SDKs within HPC meta-program in compiled languages (C/C++ and Fortran) as well as Python through a quantum programming interface library extension. An adaptive circuit knitting hypervisor is being developed to partition large quantum circuits into sub-circuits that fit on smaller noisy quantum devices and classical simulators. At the lower-level, we leverage Cray LLVM-based compilation framework to transform and consume LLVM IR and Quantum IR (QIR) from commercial quantum software frontends in a retargetable fashion to different hardware architectures. Several hybrid HPC-QC multi-node multi-CPU and GPU workloads (including solving linear system of equations, quantum optimization, and simulating quantum phase transitions) have been demonstrated on HPE EX supercomputers to illustrate functionality and execution viability for all three components developed so far. This work provides the framework for a unified quantum-classical programming environment built upon classical HPC software stack (compilers, libraries, parallel runtime and process scheduling).

arXiv:2510.20128•Oct 23, 2025•0 citations

CUDA Quantum: The Platform for Integrated Quantum-Classical Computing

Jin-Sung Kim, Alex McCaskey, Bettina Heim +3 more

A critical challenge to making quantum computers work in practice is effectively combining them with classical computing resources. From the classical side of hybrid algorithms and integrated application workflows to decoding syndromes for quantum error correction, tightly coupled high performance classical computing will be important for many of the functions required to realize useful quantum computing. A key tool for enabling research and application development is a programming model and software toolchain which allow researchers to straightforwardly co-program classical and quantum computers and leverage the best tools available for each. NVIDIA CUDA Quantum is a single-source programming model in C++ and Python for heterogeneous quantum-classical computing. The CUDA Quantum platform provides several advantages and new capabilities that enable users to get more out of quantum processors. Here, we present CUDA Quantum and demonstrate several use cases including Variational Quantum Eigensolver (VQE) where it provides a significant (287x) performance and capability benefit over existing quantum programming.

ACM/IEEE Design Automation Conference (DAC)•Jul 9, 2023•33 citations

An LLVM-based C++ Compiler Toolchain for Variational Hybrid Quantum-Classical Algorithms and Quantum Accelerators

Pradnya Khalate, Xin-Chuan Wu, Shavindra Premaratne +6 more

Variational algorithms are a representative class of quantum computing workloads that combine quantum and classical computing. This paper presents an LLVM-based C++ compiler toolchain to efficiently execute variational hybrid quantum-classical algorithms on a computational system in which the quantum device acts as an accelerator. We introduce a set of extensions to the C++ language for programming these algorithms. We define a novel Executable and Linking Format (ELF) for Quantum and create a quantum device compiler component in the LLVM framework to compile the quantum part of the C++ source and reuse the host compiler in the LLVM framework to compile the classical computing part of the C++ source. A variational algorithm runs a quantum circuit repeatedly, each time with different gate parameters. We add to the quantum runtime the capability to execute dynamically a quantum circuit with different parameters. Thus, programmers can call quantum routines the same way as classical routines. With these capabilities, a variational hybrid quantum-classical algorithm can be specified in a single-source code and only needs to be compiled once for all iterations. The single compilation significantly reduces the execution latency of variational algorithms. We evaluate the framework's performance by running quantum circuits that prepare Thermofield Double (TFD) states, a quantum-classical variational algorithm.

arXiv:2202.11142•Feb 22, 2022•12 citations

International Conference on Quantum Technologies for High-Energy Physics (QT4HEP22)

Gian Giacomo Guerreschi

<!--HTML-->Variational algorithms are among the most promising near-term applications of quantum computers. Their execution is particularly challenging for current quantum computing systems since they require a tight interaction between the host CPU and the quantum accelerator. Here we present Intel Quantum SDK, an LLVM-based C++ compiler toolchain to efficiently compile and execute variational algorithms. Using our extension to the C++ language, the user can write programs describing both the quantum and classical parts of the algorithm. The classical and quantum parts of the C++ source are then compiled by the LLVM framework and by a novel quantum device compiler component, respectively. The runtime is augmented with the capability of executing quantum circuits dynamically, meaning that the values of the circuit's parameters can be changed without triggering the recompilation of the quantum part. We briefly describe how to gain access to the Intel Quantum SDK and get started with hybrid quantum-classical workloads.

•Jan 1, 2022•0 citations
Quantum computing devices are being installed alongside supercomputing clusters to serve as hardware accel-erators. This new type of architecture will require an integrated hybrid software stack. With this goal in mind, we have developed a fully integrated hybrid quantum-classical method in the hope of improving Register Allocation in the classical LLVM compiler. We propose a hybrid variational optimization algorithm for the PBQP formulation of Register Allocation. We implemented this algorithm in C++ inside LLVM using the NVIDIA CUDA-QQQframework. The performance of the method is evaluated using NVIDIA CUDA-Q noiseless emulators and shows promising results while still needing further optimizations. Our work constitutes a demonstration of an end-to-end tight integration of a quantum subroutine inside an existing classical codebase of interest with potentially interesting performance in fault-tolerant hardware.
Quantum computers exploit the particular behavior of quantum physical systems to solve some problems in a different way than classical computers. We are now approaching the point where quantum computing could provide real advantages over classical methods. The computational capabilities of quantum systems will soon be available in future supercomputer architectures as hardware accelerators called Quantum Processing Units (QPU). From optimizing compilers to task scheduling, the High-Performance Computing (HPC) software stack could benefit from the advantages of quantum computing. We look here at the problem of register allocation, a crucial part of modern optimizing compilers. We propose a simple proof-of-concept hybrid quantum algorithm based on QAOA to solve this problem. We implement the algorithm and integrate it directly into GCC, a well-known modern compiler. The performance of the algorithm is evaluated against the simple Chaitin-Briggs heuristic as well as GCC's register allocator. While our proposed algorithm lags behind GCC's modern heuristics, it is a good first step in the design of useful quantum algorithms for the classical HPC software stack.
To address the urgent need in the NISQ era for high-performance, scalable quantum compilers and to advance the integration of classical and quantum computing, we present QLLVM, an advanced Quantum-Classical co-compilation framework built on LLVM. To our knowledge, QLLVM delivers an end-to-end, LLVM-based compilation workflow that unifies the build of classical high-performance programs, including CUDA, MPI, and C++, together with quantum programs into a single executable. For quantum program compilation, QLLVM adopts a three-stage design: high-level optimizations are implemented in the MLIR Quantum dialect and then lowered to QIR, an LLVM IR-based representation, for low-level optimization and hardware mapping. Its extensible architecture and seamless interoperability with classical high-performance computing provide an efficient, flexible, industrial-grade compilation infrastructure for future quantum software development. Experimental results show that, on the MQTBench benchmark suite, QLLVM reduces circuit depth and gate counts compared with state-of-the-art compilers and demonstrates clear advantages in compiling hybrid classical-quantum programs.
To address the growing needs for scalable High Performance Computing (HPC) and Quantum Computing (QC) integration, we present our HPC-QC full stack framework and its hybrid workload development capability with modular hardware/device-agnostic software integration approach. The latest development in extensible interfaces for quantum programming, dispatching, and compilation within existing mature HPC programming environment are demonstrated. Our HPC-QC full stack enables high-level, portable invocation of quantum kernels from commercial quantum SDKs within HPC meta-program in compiled languages (C/C++ and Fortran) as well as Python through a quantum programming interface library extension. An adaptive circuit knitting hypervisor is being developed to partition large quantum circuits into sub-circuits that fit on smaller noisy quantum devices and classical simulators. At the lower-level, we leverage Cray LLVM-based compilation framework to transform and consume LLVM IR and Quantum IR (QIR) from commercial quantum software frontends in a retargetable fashion to different hardware architectures. Several hybrid HPC-QC multi-node multi-CPU and GPU workloads (including solving linear system of equations, quantum optimization, and simulating quantum phase transitions) have been demonstrated on HPE EX supercomputers to illustrate functionality and execution viability for all three components developed so far. This work provides the framework for a unified quantum-classical programming environment built upon classical HPC software stack (compilers, libraries, parallel runtime and process scheduling).
A critical challenge to making quantum computers work in practice is effectively combining them with classical computing resources. From the classical side of hybrid algorithms and integrated application workflows to decoding syndromes for quantum error correction, tightly coupled high performance classical computing will be important for many of the functions required to realize useful quantum computing. A key tool for enabling research and application development is a programming model and software toolchain which allow researchers to straightforwardly co-program classical and quantum computers and leverage the best tools available for each. NVIDIA CUDA Quantum is a single-source programming model in C++ and Python for heterogeneous quantum-classical computing. The CUDA Quantum platform provides several advantages and new capabilities that enable users to get more out of quantum processors. Here, we present CUDA Quantum and demonstrate several use cases including Variational Quantum Eigensolver (VQE) where it provides a significant (287x) performance and capability benefit over existing quantum programming.
Variational algorithms are a representative class of quantum computing workloads that combine quantum and classical computing. This paper presents an LLVM-based C++ compiler toolchain to efficiently execute variational hybrid quantum-classical algorithms on a computational system in which the quantum device acts as an accelerator. We introduce a set of extensions to the C++ language for programming these algorithms. We define a novel Executable and Linking Format (ELF) for Quantum and create a quantum device compiler component in the LLVM framework to compile the quantum part of the C++ source and reuse the host compiler in the LLVM framework to compile the classical computing part of the C++ source. A variational algorithm runs a quantum circuit repeatedly, each time with different gate parameters. We add to the quantum runtime the capability to execute dynamically a quantum circuit with different parameters. Thus, programmers can call quantum routines the same way as classical routines. With these capabilities, a variational hybrid quantum-classical algorithm can be specified in a single-source code and only needs to be compiled once for all iterations. The single compilation significantly reduces the execution latency of variational algorithms. We evaluate the framework's performance by running quantum circuits that prepare Thermofield Double (TFD) states, a quantum-classical variational algorithm.
<!--HTML-->Variational algorithms are among the most promising near-term applications of quantum computers. Their execution is particularly challenging for current quantum computing systems since they require a tight interaction between the host CPU and the quantum accelerator. Here we present Intel Quantum SDK, an LLVM-based C++ compiler toolchain to efficiently compile and execute variational algorithms. Using our extension to the C++ language, the user can write programs describing both the quantum and classical parts of the algorithm. The classical and quantum parts of the C++ source are then compiled by the LLVM framework and by a novel quantum device compiler component, respectively. The runtime is augmented with the capability of executing quantum circuits dynamically, meaning that the values of the circuit's parameters can be changed without triggering the recompilation of the quantum part. We briefly describe how to gain access to the Intel Quantum SDK and get started with hybrid quantum-classical workloads.