×

Status message

This proposal has been approved and the Eclipse XACC project has been created.

Eclipse xacc

Basics
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please login and add your feedback in the comments section.
Parent Project: 
Background: 

A quantum annealing processor from D-Wave is commercially available, a 5-qubit gate-model chip from IBM is publicly available in the cloud, and a growing number of small-scale quantum processing units (QPUs) are expected to come online within the next 5 years. Hybrid classical-quantum computing paradigms are poised to broadly benefit the scientific applications that are ubiquitous within research fields such as modeling and simulation of quantum many-body systems, applied numerical mathematics, and data analytics. However, developing hybrids that integrate quantum algorithmic statements alongside conventional programming models is an outstanding technical challenge. While several efforts in quantum programming have focused on formal language development, embedded domain specific languages and APIs, and low-level compiler tools, there have been few concerted efforts to provide a standard and general purpose mechanism for integrating quantum programs into the sophisticated and complex high performance computing (HPC) environments that are the staple of modern scientific computing. This lack of software infrastructure and absence of properly vetted standards represents a major roadblock to programming future quantum-enhanced, large-scale heterogeneous computing systems. An open, high-level standard for general classical-quantum hybrid programming and execution is needed to enable widespread adoption of quantum computing by domain computational scientists.

Fortunately, the problem of accommodating new hybrid-hardware HPC programming paradigms is not without precedent. The integration of GPUs into HPC systems was also a significant burden for many large-scale scientific applications because of the fundamentally different way programmers interact with the hardware. Hardware-specific solutions include language extensions like the CUDA library from NVidia that enable programming natively in the local dialect. Hardware-agnostic solutions, like the Open Compute Language (OpenCL), define a hybrid programming specification for offloading work to attached classical accelerators (GPUs, MIC, FPGA, etc.), in a manner that masks or abstracts the underlying hardware type. These hardware-agnostic approaches have proven useful because they retain a wide degree of flexibility for the programmer by automating those aspects of compilation that are overly complex. Despite prior efforts, we anticipate that programming models for quantum processing units (QPUs) will be even more challenging due to the radically different physical features and behaviors brought by quantum computing, as well as the wide variety of hardware types (superconducting, ion traps, adiabatic superconducting, etc.). There are a number of quantum hardware approaches, and the general research community has not come to the conclusion that one is necessarily better than the other. Therefore, for the near-term, we will need the ability to program quantum computers in a hardware agnostic manner. Borrowing from the GPU analogy, hardware-specific solutions like CUDA likely do not necessarily make sense in the near-term for enabling quantum acceleration due to the fact that a better technology very easily could be introduced, forcing a rewrite of quantum accelerated code.

On the quantum languages side, existing approaches for interfacing domain computational scientists with quantum acceleration have progressed extensively over the last few years. A number of quantum programming languages have been developed, and novel development efforts are currently underway to provide an even better high-level mechanisms for writing, compiling, and executing quantum code. The state-of-the-art in this regard are recent approaches that provide embedded domain specific languages for quantum program expression. Efforts from Rigetti and Microsoft have followed this strategy and currently have open-source Python libraries for quantum programming alongside classical code, with extensibility built in for quantum hardware (or simulation) backends. These efforts are great steps in the development of modern quantum computer science. Just as we have many programming languages for classical computing, we are starting to see the onset of many languages for programming quantum computing. However, an unintended downside to these efforts is that for each programming framework or approach, there must be an implementations of the hardware backends that interpret and execute the programming and compilation result. This lack of programming integration is an impediment to large-scale adoption of quantum computing by domain computational scientists, as it forces the use of one method or programming framework when others may prove better for the problem at hand.

We propose a new Eclipse Project - the eXtreme-scale ACCelerator programming framework (XACC) , a general purpose and open programming standard and reference implementation for accelerating classical computing with quantum acceleration in a manner that promotes language (embedded or stand-alone) and hardware (gate or adiabatic model) interoperability. The XACC specification defines the standard interfaces and abstractions that enable hybrid classical-quantum programming at a level that is accessible to domain computational scientists. This specification should be familiar to existing scientific application developers, as it borrows concepts from classical heterogeneous programming, and enables language interoperability in a manner similar to the LLVM compiler framework. The XACC Specification interfaces provide a means to describe quantum kernels, compilers, programs, and accelerators in a language and hardware agnostic manner.

 
Scope: 

The scope of Eclipse XACC is to provide:

  • A standard specification and API for expressing quantum algorithms alongside classical code.

  • A standard quantum intermediate representation specification and reference implementation that enables quantum language and hardware interoperability.

  • A high-level programming API for executing quantum code on attached quantum accelerators.

  • An extensible compiler mechanism that enables the expression of quantum algorithms in a variety of quantum languages (embedded or static).

  • Integration with currently available QPUs from IBM, D-Wave, and Rigetti.

  • Command line tools to map quantum kernels to the XACC quantum intermediate representation.

  • Just-in-time compilation of quantum kernels

  • Ahead-of-time compilation of quantum kernels
Description: 

Hybrid classical-quantum computing paradigms are posed to benefit the scientific applications that are ubiquitous within the scientific computing research community, including modeling and simulation of quantum many-body systems, applied math, and data analytics. However, developing quantum-classical hybrids that integrate quantum algorithmic statements alongside conventional programming models is an outstanding technical challenge. Anticipating these unique challenges, a 2015 Advanced Scientific Computing Research (ASCR) workshop on quantum computing concluded that development of software infrastructure and interfaces will be critical for leveraging this technology into existing scientific computing research. While several efforts in quantum programming have focused on formal language development and low-level compiler tools, there has yet to be a concerted effort to integrate quantum programs into the sophisticated and complex HPC environments that are the staple of modern scientific computing. This lack of infrastructure and absence of proper tooling represents a major roadblock to programming small-scale QPUs as well as large-scale hierarchical (heterogeneous) computing systems.

The problem of accommodating new programming paradigms is not without precedent. The integration of GPUs into HPC systems was also a significant burden for many large-scale scientific applications because of the fundamentally different way programmers interact with the hardware. Hardware-specific solutions include language extensions like the CUDA library from NVidia that enable programming natively in the local dialect. This approach is useful because it retains a wide degree of flexibility to the programmer while also automating those aspects of compilation that are overly complex. Despite prior efforts, we anticipate that QPU programming models will be even more challenging due to the radically different features and behaviors brought by quantum computing. As highlighted by the ASCR report, there are serious questions concerning how to realize efficient quantum algorithm expression, compilation, and execution within the classical HPC context. The development of new programming models, runtime systems, and interfacing paradigms is needed to facilitate the future generation of HPC software. This system software is absolutely necessary for assessing concrete QPU performance, algorithm efficiency, and application scaling as well as better understanding the payoffs from quantum computing.

XACC is a programming specification and software framework that tackles the aforementioned challenges and provides a hybrid classical-quantum programming model that enables quantum acceleration within existing classical HPC applications. XACC provides the software interfaces and infrastructure required by domain computational scientists to offload computationally intractable work to an attached quantum accelerator. It handles algorithm programming in a manner similar to OpenCL, with code expressed as language-agnostic quantum kernels, thus enabling XACC to interact with existing quantum programming languages (QPLs) such as Scaffold, Quipper, and QCL. To accomplish this language interoperability, XACC keeps track of associated compilers for each programming language and orchestrates their compilation, or translation, to accelerator-level assembly code. XACC provides developers with two mechanisms for compilation: (1) a runtime API (just-in-time compilation) that enables the control of all aspects of high-level programming, translation, and execution, and (2) a static compiler that transforms invoked quantum kernels into an execution of the compiled result on the accelerator. Both mechanisms delegate to a classical compiler for generation of the hybrid classical-quantum executable. Furthermore, since XACC is extensible in languages and compilers, users can program and execute algorithms suited for either gate model quantum computing or adiabatic quantum computing.

The inevitable near-term variability in quantum hardware designs and implementations forces any software programming framework for quantum acceleration to be extensible in the hardware types it interacts with. XACC is no exception to this, and therefore provides a set of interfaces for injecting custom accelerator instances. These accelerator instances take as input the results of the XACC compilation step and leverage vendor-supplied APIs to perform the actual execution on the attached device. The first target QPUs for XACC are the 5-qubit gate model chip from IBM and the 1000 qubit quantum annealing model chip from D-Wave. These are both injected into the XACC framework as accelerator instances whose associated implementation delegates execution details to APIs supplied by IBM and D-Wave. This mechanism also enables the integration of external quantum computing simulation applications. Simulators act as virtual accelerators in the XACC framework - they provide an implementation of the accelerator infrastructure that delegates execution to simulations on small laptops, workstations, or even clusters and supercomputers.

The high-level programming, compilation, and execution tooling provided by XACC are envisioned as just an appropriate beginning. They form the software foundation for the more ambitious goal of easily leveraged, high-level software libraries for common quantum computing algorithms, math libraries, and utilities. The foundational layer provided by XACC will be used to build up libraries and repositories of common quantum kernels - quantum phase estimation, fourier transforms, and linear systems solvers. These utilities are vital for the DOE-relevant computational science problems facing potential testbed facility users.

Maximizing the utility of any quantum computing testbed necessarily requires a high-level, accessible, and feature-rich set of software tooling for interacting with complex quantum hardware. The ideal users of such a facility will not use the testbed if they have to program low-level hardware details. XACC provides the required infrastructure in an easily deployed, open-source manner and enables high-level programming and execution of both gate and adiabatic model quantum computing. Its design and implementation have been carefully crafted to leverage existing quantum programming languages and techniques, and interact with QPUs in a hardware-agnostic manner.

Why Here?: 

The Eclipse Science Working Group is an ideal home for this project because of the unique collaboration venue it provides for advanced, open source, research software engineering projects. Furthermore, the Eclipse Foundation is a good fit because many Eclipse member companies, including Microsoft, IBM, and Google are interested in quantum computing and its applications in their businesses.

People
Project Leads: 
Mentors: 
Source Code
Source Repository Type: