QAT: Improving architecture and configuration management (#1134)

* Optimization example: revert PR #1100 (#1125)

* Use stdin/stdout instead of TCP/IP. (#1118)

* Use stdin/stdout instead of TCP/IP.

* Update package-lock.

Co-authored-by: Ricardo Espinoza <[email protected]>

* Add QIR JIT compilation from Python example (#1124)

* Add QIR JIT compilation example in Python

* Add README to JIT example and update for Windows

* Small fix to JIT example README

* Fix NuGet instructions on Linux

* More fixes for Linux

Co-authored-by: bettinaheim <[email protected]>
Co-authored-by: Stefan J. Wernli <[email protected]>

* Update Using and Borrowing Syntax (#1099)

* Adding new custom simulator example (#1120)

* Initial implementation of a simple simulator for QIR.

Goal: Implement an example simulator that is easy to understand and maps more or less directly to the theory.

Based on the Eigen C++ linear algebra library.

Untested, guide to come.

* Small tweaks to QIR simulator example

* Restructured version of the Simulator example to separate out components.

* First portion of QIR Runtime simulator guide

* Add second simulator type: trace simulator

Move each simulator to its own subdirectory.

* Update Simulation example readme with simulator structure and trace simulator implementation

* Remove version 1 of the simulation example

* Split out TraceSimulator from top-level README and add run instructions

* Move headers and libraries into subfolders

* Remove version number from example folder name

* Add explanation of the full state simulator sample

* Remove duplicate information from top-level simulation sample README

* Update structure of top-level simulation sample README

* Small fixes to top-level simulator readme

* Use and update relative links within repo

* Small formatting changes to the sample state simulator README

* Add more details on including the Eigen library

* Apply suggestions from code review

Co-authored-by: Chris Granade <[email protected]>

* Add copyright header to source files

* Use unicode angle brackets for quantum states

* Small fixes to top-level README of simulation example

* Get QIR Runtime dependencies from NuGet package instead

* Add Linux instructions to sample simulators

* Better formatting of the Windows/Linux separation

* Apply suggestions from code review.

* Add notice about Clang requirement to compile sample

* Update examples/QIR/Simulation/TraceSimulator/README.md

* Update examples/QIR/Simulation/StateSimulator/README.md

Co-authored-by: Chris Granade <[email protected]>
Co-authored-by: Stefan J. Wernli <[email protected]>

* Fixing memory leak in generated QIR (#1129)

* Creating module based configuration

* Adding configuration modules

* More refactoring

* Deprecating RuleSet profile

* Refactoring

* Finishing dump config

* Preparing for draft PR

* Cleaning

* More refactoring

* Preparing error logging

* Fixing CI

* Adding commandline tests

* Refactor

* Fixing issues

* Minor changes

* Style fixing

* Update Unit Syntax (#1103)

* Renaming pass

* More refactor

* Finalising component registration

* Formatting style

* Minor refactor

* Fixed CI

* More tests

* Removing example QIR

* Update Array Syntax (#1135)

* Update readme links to runtime repo (#1137)

* Updating test

* Updating Phi tests

* CI update

* Removing garbage

* Updating according to requests

* Removing garbage

* Updating config binder

Co-authored-by: dime10 <[email protected]>
Co-authored-by: Chris Granade <[email protected]>
Co-authored-by: Ricardo Espinoza <[email protected]>
Co-authored-by: bettinaheim <[email protected]>
Co-authored-by: Stefan J. Wernli <[email protected]>
Co-authored-by: Scott Carda <[email protected]>

Author: 7 people

src/Passes/Makefile

@@ -21,5 +21,6 @@ test-examples:
 clean:
 	rm -rf Release/
 	rm -rf Debug/
+	find . | grep ".profraw" | xargs rm	
 	cd examples && make clean
 

src/Passes/Source/AllocationManager/AllocationManager.cpp

@@ -12,15 +12,15 @@ namespace microsoft
 namespace quantum
 {
 
-    AllocationManager::AllocationManagerPtr AllocationManager::createNew()
+    BasicAllocationManager::BasicAllocationManagerPtr BasicAllocationManager::createNew()
     {
-        AllocationManagerPtr ret;
-        ret.reset(new AllocationManager());
+        BasicAllocationManagerPtr ret;
+        ret.reset(new BasicAllocationManager());
 
         return ret;
     }
 
-    AllocationManager::Index AllocationManager::allocate(String const& name, Index const& size)
+    BasicAllocationManager::Index BasicAllocationManager::allocate(String const& name, Index const& size)
     {
         auto ret = next_qubit_index_;
 
@@ -44,12 +44,7 @@ namespace quantum
         return ret;
     }
 
-    AllocationManager::Address AllocationManager::getAddress(Address const& address, Index const& n) const
-    {
-        return address + n;
-    }
-
-    void AllocationManager::release(Address const& address)
+    void BasicAllocationManager::release(Address const& address)
     {
         --allocation_index_;
         auto it = mappings_.begin();
@@ -67,16 +62,24 @@ namespace quantum
         }
 
         mappings_.erase(it);
-        if (mappings_.empty())
-        {
-            next_qubit_index_ = 0;
-        }
-        else
+        if (reuse_qubits_)
         {
-            auto& b           = mappings_.back();
-            next_qubit_index_ = b.start + b.size;
+            if (mappings_.empty())
+            {
+                next_qubit_index_ = 0;
+            }
+            else
+            {
+                auto& b           = mappings_.back();
+                next_qubit_index_ = b.start + b.size;
+            }
         }
     }
 
+    void BasicAllocationManager::setReuseQubits(bool val)
+    {
+        reuse_qubits_ = val;
+    }
+
 } // namespace quantum
 } // namespace microsoft

src/Passes/Source/AllocationManager/AllocationManager.hpp

@@ -2,6 +2,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#include "AllocationManager/IAllocationManager.hpp"
+
 #include "Llvm/Llvm.hpp"
 
 #include <memory>
@@ -13,14 +15,10 @@ namespace microsoft
 {
 namespace quantum
 {
-    // TODO(QAT-private-issue-35): work out similarities and differences between resource allocation at
-    // runtime and compile time to make common interface and/or implementation depending on what is most
-    // suited.
-
     /// AllocationManager is a simple qubit and results allocator that can be used at compile-time.
     /// It is based on an assumption that all qubit allocating function calls are inlined and that
     /// qubits/results can be allocated with strictly growing IDs.
-    class AllocationManager
+    class BasicAllocationManager : public IAllocationManager
     {
       public:
         /// Defines a named register/memory segment with start
@@ -38,15 +36,13 @@ namespace quantum
             Address end{0};   ///< Index not included in memory segment
         };
 
-        using Address              = uint64_t;
-        using Index                = uint64_t;
-        using String               = std::string;
-        using AllocationManagerPtr = std::shared_ptr<AllocationManager>;
-        using Resource             = std::vector<llvm::Value*>;
-        using Resources            = std::unordered_map<std::string, Resource>;
-        using NameToIndex          = std::unordered_map<String, Index>;
-        using AddressToIndex       = std::unordered_map<Address, Index>;
-        using Mappings             = std::vector<MemoryMapping>;
+        using Address                   = uint64_t;
+        using Index                     = uint64_t;
+        using String                    = std::string;
+        using NameToIndex               = std::unordered_map<String, Index>;
+        using AddressToIndex            = std::unordered_map<Address, Index>;
+        using Mappings                  = std::vector<MemoryMapping>;
+        using BasicAllocationManagerPtr = std::shared_ptr<BasicAllocationManager>;
 
         /// Construction only allowed using smart pointer allocation through static functions.
         /// Constructors are private to prevent
@@ -55,7 +51,7 @@ namespace quantum
         /// Creates a new allocation manager. The manager is kept
         /// as a shared pointer to enable allocation accross diffent
         /// passes and/or replacement rules.
-        static AllocationManagerPtr createNew();
+        static BasicAllocationManagerPtr createNew();
         /// @}
 
         /// Allocation and release functions
@@ -66,23 +62,24 @@ namespace quantum
         /// of a larger segment, the function returns the address pointing to the first element.
         /// Allocation is garantueed to be sequential. Note that this assumption may change in the
         /// future and to be future proof, please use AllocationManager::getAddress().
-        Address allocate(String const& name = "", Index const& size = 1);
-
-        /// Gets the Address of n'th element in a segment given the segments address.
-        Address getAddress(Address const& address, Index const& n) const;
+        Address allocate(String const& name = "", Index const& size = 1) override;
 
         /// Releases the segment by address.
-        void release(Address const& address);
+        void release(Address const& address) override;
 
         /// @}
 
+        /// Configuration function to set mode of qubit allocation. If function argument is true,
+        /// the allocation manager will reuse qubits.
+        void setReuseQubits(bool val);
+
       private:
         /// Private constructors
         /// @{
         /// Public construction of this object is only allowed
         /// as a shared pointer. To create a new AllocationManager,
         /// use AllocationManager::createNew().
-        AllocationManager() = default;
+        BasicAllocationManager() = default;
         /// @}
 
         /// Variables used for mode_ == NeverReuse
@@ -103,6 +100,9 @@ namespace quantum
         /// @}
 
         Index allocation_index_{0};
+
+        /// Whether or not to reuse qubits
+        bool reuse_qubits_{true};
     };
 
 } // namespace quantum

src/Passes/Source/Profiles/IProfile.cpp renamed to src/Passes/Source/AllocationManager/IAllocationManager.cpp

@@ -1,14 +1,14 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-#include "Profiles/IProfile.hpp"
+#include "AllocationManager/IAllocationManager.hpp"
 
 namespace microsoft
 {
 namespace quantum
 {
 
-    IProfile::~IProfile() = default;
+    IAllocationManager::~IAllocationManager() = default;
 
 } // namespace quantum
 } // namespace microsoft

src/Passes/Source/AllocationManager/IAllocationManager.hpp

@@ -0,0 +1,31 @@
+#pragma once
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "Llvm/Llvm.hpp"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace microsoft
+{
+namespace quantum
+{
+
+    class IAllocationManager
+    {
+      public:
+        using Address              = uint64_t;
+        using Index                = uint64_t;
+        using String               = std::string;
+        using AllocationManagerPtr = std::shared_ptr<IAllocationManager>;
+
+        virtual ~IAllocationManager();
+        virtual Address allocate(String const& name = "", Index const& size = 1) = 0;
+        virtual void    release(Address const& address)                          = 0;
+    };
+
+} // namespace quantum
+} // namespace microsoft

src/Passes/Source/AllocationManager/Tests/Unit/main.cpp

@@ -4,20 +4,99 @@
 #include "AllocationManager/AllocationManager.hpp"
 #include "gtest/gtest.h"
 
-TEST(AllocationManagerTestSuite, LinearAllocationTest)
+TEST(AllocationManagerTestSuite, LinearAllocationTestReuse)
 {
-    auto manager = microsoft::quantum::AllocationManager::createNew();
+    auto manager = microsoft::quantum::BasicAllocationManager::createNew();
+    manager->setReuseQubits(true);
 
     // Expecting ids to be allocated linearly for single
     // allocations
-    EXPECT_TRUE(manager->allocate() == 0);
-    EXPECT_TRUE(manager->allocate() == 1);
-    EXPECT_TRUE(manager->allocate() == 2);
-    EXPECT_TRUE(manager->allocate() == 3);
-    EXPECT_TRUE(manager->allocate() == 4);
+    auto q1 = manager->allocate();
+    EXPECT_EQ(q1, 0);
+    auto q2 = manager->allocate();
+    EXPECT_EQ(q2, 1);
+    auto q3 = manager->allocate();
+    EXPECT_EQ(q3, 2);
+    auto q4 = manager->allocate();
+    EXPECT_EQ(q4, 3);
+    auto q5 = manager->allocate();
+    EXPECT_EQ(q5, 4);
 
     // We expect that allocating
-    manager->allocate("test", 10);
-    EXPECT_TRUE(manager->allocate() == 15);
-    manager->allocate("test2", 10);
+    auto arr1 = manager->allocate("test", 10);
+    EXPECT_EQ(arr1, 5);
+    auto arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 15);
+
+    // Testing reusing
+    manager->release(arr2);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 15);
+
+    manager->release(arr2);
+    manager->release(q1);
+    manager->release(q2);
+    manager->release(q3);
+    manager->release(q4);
+    manager->release(q5);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 15);
+
+    manager->release(arr1);
+    manager->release(arr2);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 0);
+}
+
+TEST(AllocationManagerTestSuite, LinearAllocationTestNoReuse)
+{
+    auto manager = microsoft::quantum::BasicAllocationManager::createNew();
+    manager->setReuseQubits(false);
+
+    auto q1 = manager->allocate();
+    EXPECT_EQ(q1, 0);
+    auto q2 = manager->allocate();
+    EXPECT_EQ(q2, 1);
+    auto q3 = manager->allocate();
+    EXPECT_EQ(q3, 2);
+    auto q4 = manager->allocate();
+    EXPECT_EQ(q4, 3);
+    auto q5 = manager->allocate();
+    EXPECT_EQ(q5, 4);
+
+    // We expect that allocating
+    auto arr1 = manager->allocate("test", 10);
+    EXPECT_EQ(arr1, 5);
+    auto arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 15);
+
+    // Testing reusing
+    manager->release(arr2);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 25);
+
+    manager->release(arr2);
+    manager->release(q1);
+    manager->release(q2);
+    manager->release(q3);
+    manager->release(q4);
+    manager->release(q5);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 35);
+
+    manager->release(arr1);
+    manager->release(arr2);
+    arr2 = manager->allocate("test2", 10);
+    EXPECT_EQ(arr2, 45);
+}
+
+TEST(AllocationManagerTestSuite, InvalidRelease)
+{
+    auto manager = microsoft::quantum::BasicAllocationManager::createNew();
+    auto q1      = manager->allocate();
+    EXPECT_EQ(q1, 0);
+    auto q2 = manager->allocate();
+    EXPECT_EQ(q2, 1);
+
+    EXPECT_THROW(manager->release(28837), std::runtime_error);
 }

src/Passes/Source/Apps/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_executable(qat Qat/Qat.cpp Qat/LlvmAnalysis.cpp)
+add_executable(qat Qat/Qat.cpp Qat/LlvmAnalysis.cpp Qat/Config.cpp)
 
 target_link_libraries(qat ${llvm_libs})
-target_link_libraries(qat ProfilePass Rules AllocationManager Commandline Profiles)
+target_link_libraries(qat RuleTransformationPass Rules AllocationManager Commandline Generators)