Papers for

high performance computing developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

OpenMPI speeds up quantum circuit execution using openmp offloading

OpenMQPI: An MLIR-based Pipeline to Offload Quantum Circuits via OpenMP

Abstract: Quantum computing introduces specialized software stacks and programming interfaces that are often tightly coupled to specific ecosystems and hardware backends, limiting interoperability and software reuse. For HPCQC application developers, this complicates the integration of quantum accelerators into existing applications. Existing quantum frameworks also use ecosystem-specific circuit representations and compilation pipelines, hindering integration with established heterogeneous compiler infrastructures. We propose OpenMQPI, an MLIR-based OpenMP extension for quantum programming that leverages OpenMP's standardized target offloading infrastructure to integrate quantum resources into HPC applications. OpenMQPI introduces QPIR, a lightweight MLIR dialect for representing quantum circuits within OpenMP target regions, and a compiler pipeline that performs quantum-specific optimizations and lowers circuits to executables compatible with OpenMP offloading. At runtime, an MQSS plugin enables the generated executable to offload quantum circuits to quantum hardware through the OpenMP target offloading model. We evaluate OpenMQPI using the VQE, QFT, and Deutsch-Jozsa algorithms with 5, 10, 15, and 20 qubits, comparing execution times against Qiskit and CUDA Quantum. OpenMQPI achieves the lowest average VQE execution time across all tested qubit configurations. At 20 qubits, it requires 5.18 s, compared with 5.83 s for Qiskit and 7.39 s for CUDA Quantum. For QFT and Deutsch-Jozsa, OpenMQPI achieves execution times comparable to Qiskit and lower than those of CUDA Quantum.

Tue 13 OctProgramming Languages
The gist
Quantum computers need special software that often only works with certain machines, making it hard to mix quantum and traditional high-performance computing. The authors created OpenMQPI, which uses a common programming framework called OpenMP to more easily run quantum circuits alongside normal programs. They built a new way to describe quantum circuits and a compiler to turn these into runnable code that can offload tasks to quantum hardware. Their system runs some standard quantum algorithms faster than other popular tools, especially as the number of qubits grows.
Open → 2610.18056v1

Interactive debugger adds live controls for python gpu computing

Interactive Debugger for Performance Portable Python HPC Kernels

Abstract: We propose PKDB, the first interactive debugger for GPU and multithreaded low-level kernels written in Python. Python is widely used in high performance computing (HPC), with frameworks such as PyKokkos translating Python-embedded domain-specific languages to native code that runs across OpenMP-threaded CPUs and various GPUs. Yet interactive debugging support for such code is absent: developers resort to print statements, framework-specific assertions, or CPU-only execution, the last of which requires altering the program or its data and can mask device-specific bugs. PKDB enables standard interactive debugging like breakpoints, stepping, and variable inspection while preserving actual on-device execution without source modification. Beyond these fundamentals, PKDB introduces two advanced capabilities that exploit the dynamic nature of Python and PyKokkos: (i) Live code evaluation, which lets developers execute arbitrary Python expressions or entire kernels in the middle of a paused kernel without restarting the process; (ii) Kernel call site substitution, which allows an actively running kernel to be updated and reloaded on the fly, so only the kernel is recompiled and re-executed without restarting the application. Our performance evaluation on Intel, AMD, and NVIDIA CPUs, and NVIDIA and AMD GPUs shows that PKDB introduces limited overhead and is practical for everyday use while introducing critical debugging features to the Python HPC ecosystem.

Mon 7 SeptDistributed, Parallel, and Cluster Computing
The gist
Debugging high-performance, GPU-accelerated Python code is difficult because existing tools are limited or require changing the program, which can hide bugs. The authors present PKDB, an interactive debugger that works directly on GPUs and multithreaded CPUs without altering the source code. It supports usual debugging actions like breakpoints and variable checks, plus unique features like running any code while paused and updating running kernels on the fly. This lets developers find and fix problems more easily in complex Python HPC programs.
Open → 2609.07912v1