[Paper Review] QParallel: Explicit Parallelism for Programming Quantum Computers

Thomas Häner, Vadym Kliuchnikov+3 more|arXiv (Cornell University)|Oct 7, 2022

Quantum Computing Algorithms and Architecture4 citations

TL;DR

QParallel is a Q#-based language extension that enables explicit parallelism in quantum programming to resolve ambiguities in implicit parallelism and support fine-grained space-time tradeoffs. By allowing programmers to explicitly mark parallel regions, it reduces circuit depth by up to a factor of q and improves performance by removing serial dependencies from critical paths, as demonstrated in benchmarks like multi-controlled NOT gates and quantum adders.

ABSTRACT

We present a language extension for parallel quantum programming to (1) remove ambiguities concerning parallelism in current quantum programming languages and (2) facilitate space-time tradeoff investigations in quantum computing. While the focus of similar libraries in the domain of classical computing (OpenMP, OpenACC, etc.) is to divide a computation into multiple threads, the main goal of QParallel is to keep the compiler and the runtime system from introducing parallelism-inhibiting dependencies, e.g., through reuse of qubits in automatic qubit management. We describe the syntax and semantics of the proposed language extension, implement a prototype based on Q#, and present several examples and use cases to illustrate its performance benefits. Moreover, we introduce a tool that guides programmers in the placement of parallel regions by identifying the subroutines that profit most from parallelization, which is especially useful if the programmer's knowledge of the source code is limited. Support for QParallel can be added to any multithreading library and language extension, including OpenMP and OpenACC.

Motivation & Objective

• Address the ambiguity and lack of control in implicit parallelism within current quantum programming languages.
• Enable programmers to explicitly manage parallel execution to influence space-time tradeoffs in quantum circuit compilation.
• Reduce circuit depth and improve performance by preventing qubit reuse from creating unintended serial dependencies.
• Support large-scale quantum programs with thousands of qubits and millions of gates through explicit, compiler-friendly parallelism.
• Facilitate optimization of quantum algorithms by guiding programmers to identify performance-critical subroutines using profiling and visualization tools.

Proposed method

• Design a Q#-based language extension inspired by OpenMP to allow explicit declaration of parallel regions using a new syntax.
• Integrate the extension with Q#’s existing resource estimation and tracing infrastructure to enable performance analysis.
• Use speedscope-compatible flame graph visualizations to identify critical paths and performance bottlenecks in quantum programs.
• Modify the Q# tracer to output performance data in a format consumable by speedscope for visualization of execution timelines.
• Apply the language extension to real-world quantum algorithms (e.g., multi-controlled NOT, quantum adders) to measure depth reduction and performance gains.
• Introduce a tool that analyzes resource usage and highlights subroutines on the critical path to guide where explicit parallelism should be applied.

Experimental results

Research questions

• RQ1 How can explicit parallelism in quantum programming reduce circuit depth and improve performance compared to implicit parallelism?
• RQ2 In what ways does explicit parallelism help avoid qubit reuse from creating unintended serial dependencies in quantum circuits?
• RQ3 How effective is a visualization-based tool in identifying performance-critical subroutines for parallelization when programmer knowledge of the codebase is limited?
• RQ4 To what extent can space-time tradeoffs be optimized through programmer-controlled parallel regions in large-scale quantum programs?
• RQ5 How does explicit parallelism affect the resource estimation and compilation of quantum circuits with high gate counts and qubit requirements?

Key findings

• Explicit parallelism in QParallel reduced the T-depth of a multi-controlled NOT gate from 43 to 7 cycles by removing serial dependencies from the critical path.
• By processing N adders in chunks of q fully parallel adders, QParallel reduced the T-depth of the circuit by a factor of q, demonstrating significant depth reduction.
• The integration of QParallel with speedscope enabled visualization of critical paths, revealing that implicit parallelism often leads to serial execution of low-depth operations due to qubit reuse.
• The tool for identifying critical subroutines helped programmers target high-impact regions for parallelization, even with limited knowledge of the codebase.
• QParallel enables more predictable and controllable space-time tradeoffs by giving programmers explicit control over which sections execute in parallel.
• The approach is generalizable and can be extended to other quantum programming languages with configurable qubit management, such as OpenQASM 3 and QCOR.