WIP: Qrack GPU-accelerated simulator framework as backend

.travis.yml

@@ -1,4 +1,4 @@
-sudo: false
+sudo: true
 language: python
 matrix:
   include:
@@ -40,7 +40,9 @@ install:
   - pip$PY install coveralls
   - CC=g++-7 pip$PY install revkit
   - if [ "${PYTHON:0:1}" = "3" ]; then pip$PY install dormouse; fi
-  - pip$PY install -e .
+  - cd ../.. && git clone https://github.com/vm6502q/qrack.git
+  - cd qrack && mkdir _build && cd _build && cmake .. && sudo make install && cd ../.. && sudo rm -r qrack && cd WrathfulSpatula/ProjectQ
+  - pip$PY install -e . --global-option="--with-qracksimulator"
 
 # command to run tests
 script: export OMP_NUM_THREADS=1 && pytest projectq --cov projectq

README.rst

@@ -32,6 +32,12 @@ This allows users to
 -  export quantum programs as circuits (using TikZ)
 -  get resource estimates
 
+This Fork
+---------
+This fork maintains support for the `Qrack <https://github.com/vm6502q/qrack>`__ simulator framework as an optional back end. To use Qrack with ProjectQ, checkout the Qrack repo. Build and install Qrack. Then, build ProjectQ with the optional global flag "--with-qracksimulator" passed to setup.py.
+
+This has been successfully tested in the context of a `SimulaQron <https://github.com/SoftwareQuTech/SimulaQron>`__-> ProjectQ -> Qrack stack with at least two physical nodes, with many logical nodes distributed between them. Qrack is the base quantum node simulator, ProjectQ is the compiler, and SimulaQron provides simulation or emulation of a quantum network. To reproduce this stack, as stated above, just install Qrack and use a copy of ProjectQ built and installed with the global flag "--with-qracksimulator", for SimulaQron.
+
 Examples
 --------
 

docs/projectq.backends.rst

@@ -9,6 +9,7 @@ backends
 	projectq.backends.ClassicalSimulator
 	projectq.backends.ResourceCounter
 	projectq.backends.IBMBackend
+        projectq.backends.QrackSimulator
 
 
 Module contents

projectq/backends/__init__.py

@@ -20,13 +20,20 @@
 * a debugging tool to print all received commands (CommandPrinter)
 * a circuit drawing engine (which can be used anywhere within the compilation
   chain)
-* a simulator with emulation capabilities
+* internal and external simulators with emulation capabilities
 * a resource counter (counts gates and keeps track of the maximal width of the
   circuit)
 * an interface to the IBM Quantum Experience chip (and simulator).
 """
 from ._printer import CommandPrinter
 from ._circuits import CircuitDrawer
-from ._sim import Simulator, ClassicalSimulator
+from ._sim import ClassicalSimulator
 from ._resource import ResourceCounter
 from ._ibm import IBMBackend
+
+try:
+    # Try to import the Qrack Simulator, if it exists.
+    from ._qracksim import Simulator
+except ImportError:
+    # If the Qrack Simulator isn't built, import the default ProjectQ simulator.
+    from ._sim import Simulator

projectq/backends/_qracksim/__init__.py

@@ -0,0 +1,15 @@
+#   Copyright 2017 ProjectQ-Framework (www.projectq.ch)
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+from ._simulator import Simulator

projectq/backends/_qracksim/_cpp/intrin/alignedallocator.hpp

@@ -0,0 +1,120 @@
+// Copyright (C) 2012 Andreas Hehn  <hehn@phys.ethz.ch>.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <cstdlib>
+#endif
+#include <cstddef>
+#include <memory>
+#include <new>
+
+#if __cplusplus < 201103L
+#define noexcept
+#endif
+
+
+template <typename T, unsigned int Alignment>
+class aligned_allocator
+{
+ public:
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    template <typename U>
+    struct rebind
+    {
+        typedef aligned_allocator<U, Alignment> other;
+    };
+
+    aligned_allocator() noexcept {}
+    aligned_allocator(aligned_allocator const&) noexcept {}
+    template <typename U>
+    aligned_allocator(aligned_allocator<U, Alignment> const&) noexcept
+    {
+    }
+
+    pointer allocate(size_type n)
+    {
+        pointer p;
+
+
+#ifdef _WIN32
+        p = reinterpret_cast<pointer>(_aligned_malloc(n * sizeof(T), Alignment));
+        if (p == 0) throw std::bad_alloc();
+#else
+        if (posix_memalign(reinterpret_cast<void**>(&p), Alignment, n * sizeof(T)))
+            throw std::bad_alloc();
+#endif
+        return p;
+    }
+
+    void deallocate(pointer p, size_type) noexcept
+    {
+#ifdef _WIN32
+        _aligned_free(p);
+#else
+        std::free(p);
+#endif
+    }
+
+    size_type max_size() const noexcept
+    {
+        std::allocator<T> a;
+        return a.max_size();
+    }
+
+#if __cplusplus >= 201103L
+    template <typename C, class... Args>
+    void construct(C* c, Args&&... args)
+    {
+        new ((void*)c) C(std::forward<Args>(args)...);
+    }
+#else
+    void construct(pointer p, const_reference t) { new ((void*)p) T(t); }
+#endif
+
+    template <typename C>
+    void destroy(C* c)
+    {
+        c->~C();
+    }
+
+    bool operator==(aligned_allocator const&) const noexcept { return true; }
+    bool operator!=(aligned_allocator const&) const noexcept { return false; }
+    template <typename U, unsigned int UAlignment>
+    bool operator==(aligned_allocator<U, UAlignment> const&) const noexcept
+    {
+        return false;
+    }
+
+    template <typename U, unsigned int UAlignment>
+    bool operator!=(aligned_allocator<U, UAlignment> const&) const noexcept
+    {
+        return true;
+    }
+};
+
+#if __cplusplus < 201103L
+#undef noexcept
+#endif
+