Qrack GPU-accelerated simulator

.travis.yml

@@ -1,4 +1,4 @@
-sudo: false
+sudo: true
 language: python
 matrix:
   include:
@@ -40,6 +40,8 @@ install:
   - pip$PY install coveralls
   - CC=g++-7 pip$PY install revkit
   - if [ "${PYTHON:0:1}" = "3" ]; then pip$PY install dormouse; fi
+  - 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 vm6502q/ProjectQ
   - pip$PY install -e .
 
 before_script:

README.rst

@@ -32,6 +32,15 @@ This allows users to
 -  export quantum programs as circuits (using TikZ)
 -  get resource estimates
 
+Building with the Qrack Simulator
+---------------------------------
+
+The `Qrack <https://github.com/vm6502q/qrack>`__ simulator library provides optional GPU support for ProjectQ and may improve performance, portability, and/or memory efficiency. Depending partially on build options and hardware, Qrack generally trades off a small amount of floating point precision for speed, memory usage, and/or the ability to backport to 32-bit hardware and simpler instruction sets. To use it with ProjectQ, first install Qrack, according to the instructions in that project's README and `documentation <https://qrack.readthedocs.io/en/latest/start.html>`_. When you have built Qrack with the desired settings, "make install" in the build directory.
+
+With Qrack installed, you can use it as the default ProjectQ simulator by simply building and installing ProjectQ with the `--with-qracksimulator` global option. This exchanges the Qrack simulator for the default ProjectQ C++ simulator, throughout. Any application which would rely on the default C++ simulator should then automatically use the Qrack simulator instead.
+
+Note that Qrack does not support any nonunitary operations available in the default C++ simulator. To keep integer math unitary, the integer multiplication operation uses the more significant half of the multiplication operation register as a "carry" sub-register, which is measured and then zeroed at the beginning of a multiplication operation. 
+
 Examples
 --------
 

projectq/_version.py

@@ -13,4 +13,4 @@
 #   limitations under the License.
 
 """Define version number here and read it from setup.py automatically"""
-__version__ = "0.5.0"
+__version__ = "0.5.1"

projectq/backends/__init__.py

@@ -20,7 +20,7 @@
 * 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).
@@ -32,3 +32,10 @@
 from ._resource import ResourceCounter
 from ._ibm import IBMBackend
 from ._aqt import AQTBackend
+
+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/_ibm/_ibm_http_client.py

@@ -129,7 +129,7 @@ def _authenticate(self, token=None):
     def _run(self, info, device):
         """
         Run the quantum code to the IBMQ machine.
-        Update since March2020: only protocol available is what they call
+        Update since September 2020: only protocol available is what they call
         'object storage' where a job request via the POST method gets in
         return a url link to which send the json data. A final http validates
         the data communication.
@@ -162,19 +162,10 @@ def _run(self, info, device):
             **json_step1)
         request.raise_for_status()
         r_json = request.json()
-        download_endpoint_url = r_json['objectStorageInfo'][
-            'downloadQObjectUrlEndpoint']
-        upload_endpoint_url = r_json['objectStorageInfo'][
-            'uploadQobjectUrlEndpoint']
         upload_url = r_json['objectStorageInfo']['uploadUrl']
+        execution_id = r_json['id']
 
-        # STEP2: WE USE THE ENDPOINT TO GET THE UPLOT LINK
-        json_step2 = {'allow_redirects': True, 'timeout': (5.0, None)}
-        request = super(IBMQ, self).get(upload_endpoint_url, **json_step2)
-        request.raise_for_status()
-        r_json = request.json()
-
-        # STEP3: WE USE THE ENDPOINT TO GET THE UPLOT LINK
+        # STEP2: WE UPLOAD THE CIRCUIT DATA
         n_classical_reg = info['nq']
         # hack: easier to restrict labels to measured qubits
         n_qubits = n_classical_reg  # self.backends[device]['nq']
@@ -194,7 +185,7 @@ def _run(self, info, device):
         data += ('"parameter_binds": [], "memory_slots": '
                  + str(n_classical_reg))
         data += (', "n_qubits": ' + str(n_qubits)
-                 + '}, "schema_version": "1.1.0", ')
+                 + '}, "schema_version": "1.2.0", ')
         data += '"type": "QASM", "experiments": [{"config": '
         data += '{"n_qubits": ' + str(n_qubits) + ', '
         data += '"memory_slots": ' + str(n_classical_reg) + '}, '
@@ -205,31 +196,31 @@ def _run(self, info, device):
         data += '"clbit_labels": ' + str(c_label).replace('\'', '\"') + ', '
         data += '"memory_slots": ' + str(n_classical_reg) + ', '
         data += '"creg_sizes": [["c", ' + str(n_classical_reg) + ']], '
-        data += ('"name": "circuit0"}, "instructions": ' + instruction_str
+        data += ('"name": "circuit0", "global_phase": 0}, "instructions": ' + instruction_str
                  + '}]}')
 
-        json_step3 = {
+        json_step2 = {
             'data': data,
             'params': {
                 'access_token': None
             },
             'timeout': (5.0, None)
         }
-        request = super(IBMQ, self).put(r_json['url'], **json_step3)
+        request = super(IBMQ, self).put(upload_url, **json_step2)
         request.raise_for_status()
 
-        # STEP4: CONFIRM UPLOAD
-        json_step4 = {
+        # STEP3: CONFIRM UPLOAD
+        json_step3 = {
             'data': None,
             'json': None,
             'timeout': (self.timeout, None)
         }
-        upload_data_url = upload_endpoint_url.replace('jobUploadUrl',
-                                                      'jobDataUploaded')
-        request = super(IBMQ, self).post(upload_data_url, **json_step4)
+
+        upload_data_url = urljoin(_API_URL,
+                          'Network/ibm-q/Groups/open/Projects/main/Jobs/'+str(execution_id)
+                                  +'/jobDataUploaded')
+        request = super(IBMQ, self).post(upload_data_url, **json_step3)
         request.raise_for_status()
-        r_json = request.json()
-        execution_id = upload_endpoint_url.split('/')[-2]
 
         return execution_id
 

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
+