Raw File
Tip revision: 1b57c8e01a682145f576e101c868ba84ea38ec1b authored by ah744 on 06 August 2016, 01:41:28 UTC
Fixed Rotation Decomposition Naming and BF Type Mismatch
Tip revision: 1b57c8e
What Is ScaffCC?
ScaffCC is a compiler and scheduler for the Scaffold programing language. It is written using the LLVM open-source infrastructure. It is for the purpose of writing and analyzing code for quantum computing applications.

ScaffCC enables researchers to compile quantum applications written in Scaffold to a low-level quantum assembly format (QASM), apply error correction, and generate time and area metrics. It is written to be scalable up to problem sizes in which quantum algorithms outperform classical ones, and as such provide valuable insight into the overheads involved and possible optimizations for a realistic implementation on a future device technology.

If you use ScaffCC in your publications, please cite this work as follows:

Ali JavadiAbhari, Shruti Patil, Daniel Kudrow, Jeff Heckey, Alexey Lvov, Frederic Chong and Margaret Martonosi, ScaffCC: A Framework for Compilation and Analysis of Quantum Computing Programs, ACM International Conference on Computing Frontiers (CF 2014), Cagliari, Italy, May 2014

Release Information

Current Release

ScaffCC is currently in a beta release. Specifically, the release details are:

-   Version 2.0

-   Release Date: July 10, 2016

Supported Operating Systems

ScaffCC currently offers support for the following operating systems:

-   “Ubuntu"

-   “Red Hat"

This list will continue to grow in the future!


Getting ScaffCC

1.  Go to

2.  Download the repository:

           git clone [dir]

Building ScaffCC

First you need to install the following dependencies. For each one, you
can either install by building from source, or use the package manager
of your system (“yum" on Red Hat or “apt-get" on Ubuntu).

1.  Static libraries for libstdc++ and glibc

    -   “Ubuntu"

        Install GNU gold linker

        You can check if you have this now by doing ‘ld -v’ and if it
        says ‘GNU gold’ you have it

                sudo apt-get install binutils-gold

    -   “Red Hat"

                sudo yum install libstdc++-static 
                sudo yum install glibc-static

2.  GCC 4.5 or higher NOTE: if you need to preserve an older build,
    consider using ‘update-alternatives’ as system-wide method for
    preserving and maintaining these.

3.  Boost 1.48

    -   “Source Build"

        Boost installation instructions are here:

                tar zxf boost_1_48_0.tar.gz && cd boost_1_48_0/
                sudo ./
                sudo ./b2 install --prefix=/usr/local

        Alternatively, Ubuntu users can install the current Boost
        version via:

                sudo apt-get install libboost-all-dev

4.  The GNU Multiple Precision Arithmetic Library (gmp and gmpxx)

    -   “Ubuntu" Use tab-completion to verify the correct packages

                sudo apt-get install libgmp-dev libgmpxx4ldbl

    -   “Source Build"

                sudo ./configure --disable-shared --enable-static --enable-cxx
                sudo make && sudo make check && sudo make install

5.  The GNU MPFR Library (mpfr)

    -   “Ubuntu"

                sudo apt-get install libmpfr-dev

    -   “Source Build"

                sudo ./configure --disable-shared --enable-static
                sudo make && sudo make check && sudo make install

6.  Python 2.7 (or later)

7.  CMake (For Integrating RKQC Functionality)

    -   “Ubuntu"

                sudo apt-get install cmake

    -   “Source Build"

        There are instructions for downloading and building CMake from
        source at:

Once you have all of the required libraries, simply run



    make USE_GCC=1

at the root of the repository. The USE\_GCC flag will force the
Makefile to use GCC to compile instead, and this has been seen to be
faster on some systems.

Verifying Installation

Included with ScaffCC is a suite of tests designed to verify the
integrity of new installations. To access these tests and verify that
the installation process completed successfully:

1.  Enter the scripts/ directory:

                cd scripts/

2.  Run the Regression Test Suite:


This invokation will compile three small benchmarks, and verify that the
generated files match those precompiled on an existing system, which are
included in the test cases directory. If the three tests complete with a
“Succeeded", the installation was successful.
Using ScaffCC 

Running the Compiler

To run the compiler, simply use the ‘’ script in the main
directory, with the name of the program and optional compiler flags.

### Basic Example:

The command below runs the compiler with default options on the Binary
Welded Tree algorithm, with n=100 and s=100 as problem sizes. The
default compiler option is to generate resource estimations (number of
qubits and gates).

    ./ Algorithms/Binary Welded Tree/Binary_Welded_Tree_n100s100.scaffold

Compiler Options

To see a list of compiler options which can be passed as flags, run:

    ./ -h

    Usage: ./ [-h] [-rqfRFcpd] [-L #] <filename>.scaffold
        -r   Generate resource estimate (default)
        -q   Generate QASM
        -f   Generate flattened QASM
        -R   Disable rotation decomposition
        -T   Disable Toffoli decomposition
        -l   Levels of recursion to run (default=1)
        -F   Force running all steps
        -c   Clean all files (no other actions)
        -p   Purge all intermediate files (preserves specified output,
             but requires recompilation for any new output)
        -d   Dry-run; show all commands to be run, but do not execute
        -v   Show current ScaffCC version

Sample Scripts

This section describes some of the example scripts contained in the
‘scripts/’ directory. They are written to test the various
functionalities of ScaffCC, as detailed below.

Each of them automates the process of running multiple compiler passes
on an input file to perform the required analysis or optimization.

### Generating LLVM Intermediate Format: ./

Lowers .scaffold source file to .ll file (intermediary LLVM format).
Creates &lt;algorithm&gt;.ll The .ll file is the main file in LLVM on
which all transformations, optimizations and analysis are performed.

### Critical Path Estimation: ./

Finds critical path information for several different flattening
thresholds by doing the following:

1.  Finding module sizes using the ResourceCount2 pass.

2.  Flattening modules based on the found module sizes and the
    requested threshold.

3.  Finds length of critical path, in terms of number of operations
    on it. Look for the number in front of “main” in the output.

#### flattening\

Divides modules into different buckets based on their size, to be used
for flattening decision purposes.

### Module Call Frequency Estimation: ./

Generates an estimate of how many times each module is called, which can
guide flattening decisions.

### Generate Longest-Path-First-Schedule (LPFS): ./

Generates LPFS schedules with different options as specified below.

Options in the script: K=number of SIMD regions / D=capacity of each
region / th=flattening thresholds

Calls the following scripts:

#### ./

Runs the 3 different communication-aware schedulers, LPFS, RCP, SS, with
different scheduler configurations. Look in ./ for configuration
options. For example using -m gives metrics only, while -s outputs
entire schedule.

#### ./

The main scheduler code for LPFS and RCP.

#### ./comm\

Applies the communication penalty to timesteps.

All output files are placed in a new directory to avoid cluttering.
Built-in Quantum Applications 

This section describes the apps provided with this software, in the
‘Algorithms/’ directory.

1.  Cat-State Preparation: Prepares an n-bit quantum register in the
    maximally entangled Cat-State. The app is parameterized by n.

2.  Quantum Fourier Transform (QFT): Performs quantum Fourier transform
    on an n-bit number. The app is parameterized by n.

3.  Square Root: Uses a quantum concept called *amplitude amplification*
    to find the square root of an n-bit number with the Grover’s
    search technique. The app is parameterized by n.

4.  Binary Welded Tree: Uses quantum random walk algorithm to find a
    path between an entry and exit node of a binary welded tree
    . The app is parameterized by the height of the tree (n)
    and a time parameter (s) within which to find the solution.

5.  Ground State Estimation: Uses quantum phase estimation algorithm to
    estimate the ground state energy of a molecule. The app
    is parameterized by the size of the molecule in terms of its
    molecular weight (M).

6.  Triangle Finding Problem: Finds a triangle within a dense,
    undirected graph. The app is parameterized by the number
    of nodes n in the graph.

7.  Boolean Formula: Uses the quantum algorithm described
    in the citation in the full documentation, to compute a winning strategy for the
    game of Hex. The app is parameterized by size of the Hex board

8.  Class Number: A problem from computational algebraic number theory,
    to compute the class group of a real quadratic number field
    . The app is parameterized by p, the
    number of digits after the radix point for floating point numbers
    used in computation.

9.  Secure Hash Algorithm 1: An implementation of the reverse
    cryptographic hash function. The message is decrypted by
    using the SHA-1 function as the oracle in a Grovers
    search algorithm. The app is parameterized by the size of the
    message in bits (n).

10. Shor’s Factoring Algorithm: Performs factorization using the Quantum
    Fourier Transform. The app is parameterized by n, the size
    in bits of the number to factor.

RKQC: RevKit For Quantum Computation 

RKQC is a compiler for reversible logic circuitry. The framework has
been developed to compile high level circuit descriptions down to
assembly language instructions, primarily for quantum computing
machines. Specifically, input files to the RKQC compiler contain
descriptions of reversible circuits, and the output files are the
assembly instructions for the circuit, in the “.qasm” format.

In many important quantum computing algorithms, a large portion of the
modules use only classical reversible logic operations that can be
decomposed into the universal set of NOT, CNOT, and Toffoli gates. Often
these are referred to as “classical oracles.” These oracles can also be
simulated on a conventional computer.

RKQC is used by the Scaffold quantum circuits compiler as a subroutine
for the compilation of purely classical reversible logic modules, or
oracles. It has also been designed to operate as a stand alone tool, and
can be used in this fashion. It was also developed as a full conversion
of the RevKit platform. 

The documentation describing installation and usage of RKQC is included
in the docs/ directory, with the full documentation.

Expanding ScaffCC 

ScaffCC is completely open-source and may be expanded to accomodate
future needs of quantum circuit analysis and optimization.

At the core of ScaffCC are the LLVM compiler passes, which operate on
LLVM IR (.ll) code. All LLVM passes are stored in:


Passes specific to ScaffCC are stored in:


In general, to run a pass in LLVM, you invoke the opt program as

    build/Release+Asserts/bin/opt -S -load build/Release+Asserts/lib/ {pass_name} {input_ll_file} > {output_ll_file} 2> {log_file}

Note that "pass\_name" refers to the unique name of the pass by which
it is registered in the LLVM system, by invoking the following in the
implementation of the pass:

    static RegisterPass<{pass_name}> X({pass_name}, {description_of_functionality});

To write a new pass, start by looking at the previously implemented
examples in this directory, and consulting the LLVM Documentation:
back to top