QAT refactor

src/Passes/.clang-tidy

@@ -36,6 +36,7 @@ modernize-use-override,\
 modernize-use-transparent-functors,\
 misc-*,\
 -misc-misplaced-widening-cast,\
+-misc-no-recursion,\
 performance-*"
 
 WarningsAsErrors: '*'

src/Passes/CMakeLists.txt

@@ -109,5 +109,4 @@ message(STATUS "${llvm_libs}")
 
 # Adding the libraries
 add_subdirectory(Source)
-add_subdirectory(tests)
 

src/Passes/Makefile

@@ -13,7 +13,13 @@ serve-docs:  documentation
 doxygen:
 	doxygen doxygen.cfg
 
+
+test-examples:
+	# Run all examples and verify that the output is a valid IR
+	cd examples && make all
+
 clean:
 	rm -rf Release/
 	rm -rf Debug/
+	cd examples && make clean
 

src/Passes/README.md

@@ -0,0 +1,50 @@
+# QIR Passes
+
+This document contains a brief introduction on how to use the QIR passes. A more comprehensive [walk-through is found here](./docs/src/index.md).
+
+## Building
+
+To build the tool, create a new build directory and switch to that directory:
+
+```sh
+mkdir Debug
+cd Debug/
+```
+
+To build the library, first configure CMake from the build directory
+
+```sh
+cmake ..
+```
+
+and then make your target
+
+```sh
+make qat
+```
+
+For full instructions on dependencies and how to build, follow [these instructions](./docs/src/DeveloperGuide/Building.md).
+
+## Getting started
+
+Once the project is built (see next sections), you can transform a QIR according to a profile as follows:
+
+```sh
+./Source/Apps/qat --generate --profile baseProfile -S ../examples/QirAllocationAnalysis/analysis-example.ll
+```
+
+Likewise, you can validate that a QIR follows a specification by running (Note, not implemented yet):
+
+```sh
+./Source/Apps/qat --validate --profile baseProfile -S ../examples/QirAllocationAnalysis/analysis-example.ll
+```
+
+## Documentation
+
+Most of the documentation is available [directly on Github](./docs/src/index.md). If you need API documentation, you can build and run it by typing
+
+```sh
+make serve-docs
+```
+
+in the root folder of the passes directory.

src/Passes/Source/AllocationManager/AllocationManager.cpp

@@ -30,75 +30,52 @@ namespace quantum
         map.index = allocation_index_;
         map.size  = size;
 
-        if (!name.empty())
-        {
-            if (name_to_index_.find(map.name) != name_to_index_.end())
-            {
-                throw std::runtime_error("Memory segment with name " + map.name + " already exists.");
-            }
-
-            name_to_index_[map.name] = map.index;
-        }
-
         map.start = next_qubit_index_;
 
         // Advancing start
         next_qubit_index_ += size;
         map.end = map.start + size;
 
-        mappings_.emplace(allocation_index_, std::move(map));
+        mappings_.emplace_back(std::move(map));
 
         // Advancing the allocation index
         ++allocation_index_;
 
         return ret;
     }
 
-    AllocationManager::Index AllocationManager::getOffset(String const& name) const
-    {
-        auto it = name_to_index_.find(name);
-        if (it == name_to_index_.end())
-        {
-            throw std::runtime_error("Memory segment with name " + name + " not found.");
-        }
-        auto index = it->second;
-
-        auto it2 = mappings_.find(index);
-        if (it2 == mappings_.end())
-        {
-            throw std::runtime_error(
-                "Memory segment with name " + name + " not found - index exist, but not present in mapping.");
-        }
-
-        return it2->second.start;
-    }
-
-    AllocationManager::Address AllocationManager::getAddress(String const& name, Index const& n) const
-    {
-        return getAddress(getOffset(name), n);
-    }
-
     AllocationManager::Address AllocationManager::getAddress(Address const& address, Index const& n) const
     {
         return address + n;
     }
 
-    void AllocationManager::release(String const& name)
+    void AllocationManager::release(Address const& address)
     {
-        auto it = name_to_index_.find(name);
-        if (it == name_to_index_.end())
+        --allocation_index_;
+        auto it = mappings_.begin();
+
+        // Finding the element. Note that we could implement binary
+        // search but assume that we are dealing with few allocations
+        while (it != mappings_.end() && it->start != address)
         {
-            throw std::runtime_error("Memory segment with name " + name + " not found.");
+            ++it;
         }
-        name_to_index_.erase(it);
 
-        // TODO(tfr): Address to index
-    }
+        if (it == mappings_.end())
+        {
+            throw std::runtime_error("Qubit segment not found.");
+        }
 
-    void AllocationManager::release(Address const&)
-    {
-        // TODO(tfr): Address to index
-        // TODO(tfr): Name to index
+        mappings_.erase(it);
+        if (mappings_.empty())
+        {
+            next_qubit_index_ = 0;
+        }
+        else
+        {
+            auto& b           = mappings_.back();
+            next_qubit_index_ = b.start + b.size;
+        }
     }
 
 } // namespace quantum

src/Passes/Source/AllocationManager/AllocationManager.hpp

@@ -46,7 +46,7 @@ namespace quantum
         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::unordered_map<Index, MemoryMapping>;
+        using Mappings             = std::vector<MemoryMapping>;
 
         /// Construction only allowed using smart pointer allocation through static functions.
         /// Constructors are private to prevent
@@ -68,19 +68,9 @@ namespace quantum
         /// future and to be future proof, please use AllocationManager::getAddress().
         Address allocate(String const& name = "", Index const& size = 1);
 
-        /// Gets the Address of a named segment or address. Given a named resource segment, this
-        /// function returns the address of the first element in the
-        Address getOffset(String const& name) const;
-
-        /// Gets the Address of a named segments n'th element.
-        Address getAddress(String const& name, Index const& n) const;
-
         /// Gets the Address of n'th element in a segment given the segments address.
         Address getAddress(Address const& address, Index const& n) const;
 
-        /// Releases the named segment.
-        void release(String const& name);
-
         /// Releases the segment by address.
         void release(Address const& address);
 

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

@@ -18,9 +18,6 @@ TEST(AllocationManagerTestSuite, LinearAllocationTest)
 
     // We expect that allocating
     manager->allocate("test", 10);
-    EXPECT_TRUE(manager->getOffset("test") == 5);
     EXPECT_TRUE(manager->allocate() == 15);
     manager->allocate("test2", 10);
-    EXPECT_TRUE(manager->getOffset("test") == 5);
-    EXPECT_TRUE(manager->getOffset("test2") == 16);
 }

src/Passes/Source/Apps/CMakeLists.txt

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

src/Passes/Source/Apps/Qat/Qat.cpp

@@ -16,6 +16,7 @@
 #include "Commandline/Settings.hpp"
 #include "Profiles/BaseProfile.hpp"
 #include "Profiles/IProfile.hpp"
+#include "Profiles/RuleSetProfile.hpp"
 
 #include "Llvm/Llvm.hpp"
 
@@ -35,14 +36,24 @@ int main(int argc, char** argv)
             {{"debug", "false"},
              {"generate", "false"},
              {"validate", "false"},
-             {"profile", "base-profile"},
-             {"S", "false"}}};
+             {"profile", "baseProfile"},
+             {"S", "false"},
+             {"O0", "false"},
+             {"O1", "false"},
+             {"O2", "false"},
+             {"O3", "false"},
+             {"verify-module", "false"}}};
 
         ParameterParser parser(settings);
         parser.addFlag("debug");
         parser.addFlag("generate");
         parser.addFlag("validate");
+        parser.addFlag("verify-module");
         parser.addFlag("S");
+        parser.addFlag("O0");
+        parser.addFlag("O1");
+        parser.addFlag("O2");
+        parser.addFlag("O3");
 
         parser.parseArgs(argc, argv);
 
@@ -64,11 +75,27 @@ int main(int argc, char** argv)
         }
 
         // Extracting commandline parameters
-        bool                         debug              = settings.get("debug") == "true";
-        bool                         generate           = settings.get("generate") == "true";
-        bool                         validate           = settings.get("validate") == "true";
-        auto                         optimisation_level = llvm::PassBuilder::OptimizationLevel::O1;
-        std::shared_ptr<BaseProfile> profile            = std::make_shared<BaseProfile>();
+        bool                      debug              = settings.get("debug") == "true";
+        bool                      generate           = settings.get("generate") == "true";
+        bool                      validate           = settings.get("validate") == "true";
+        auto                      optimisation_level = llvm::PassBuilder::OptimizationLevel::O0;
+        std::shared_ptr<IProfile> profile            = std::make_shared<BaseProfile>();
+
+        // Setting the optimisation level
+        if (settings.get("O1") == "true")
+        {
+            optimisation_level = llvm::PassBuilder::OptimizationLevel::O1;
+        }
+
+        if (settings.get("O2") == "true")
+        {
+            optimisation_level = llvm::PassBuilder::OptimizationLevel::O2;
+        }
+
+        if (settings.get("O3") == "true")
+        {
+            optimisation_level = llvm::PassBuilder::OptimizationLevel::O3;
+        }
 
         // In case we debug, we also print the settings to allow provide a full
         // picture of what is going.
@@ -103,6 +130,19 @@ int main(int argc, char** argv)
                 llvm::errs() << "Byte code ouput is not supported yet. Please add -S to get human readible "
                                 "LL code.\n";
             }
+
+            // Verifying the module.
+            if (settings.get("verify-module") == "true")
+            {
+                llvm::VerifierAnalysis verifier;
+                auto                   result = verifier.run(*module, analyser.moduleAnalysisManager());
+                if (result.IRBroken)
+                {
+                    llvm::errs() << "IR is broken."
+                                 << "\n";
+                    exit(-1);
+                }
+            }
         }
 
         if (validate)

src/Passes/Source/CMakeLists.txt

@@ -8,15 +8,18 @@ microsoft_add_library(Commandline)
 microsoft_add_library(AllocationManager)
 microsoft_add_library_tests(AllocationManager)
 
+microsoft_add_library(ProfilePass)
+target_link_libraries(ProfilePass PRIVATE Rules)
+# microsoft_add_library_tests(ProfilePass)
+
+
 microsoft_add_library(Rules)
-microsoft_add_library_tests(Rules ExpandStaticAllocation QirAllocationAnalysis TransformationRule Rules AllocationManager Commandline Profiles)
+microsoft_add_library_tests(Rules Rules ProfilePass AllocationManager Commandline Profiles)
 
 target_link_libraries(Rules PRIVATE AllocationManager)
 
-add_subdirectory(Passes)
-
 microsoft_add_library(Profiles)
-target_link_libraries(Profiles PRIVATE Rules ExpandStaticAllocation TransformationRule QirAllocationAnalysis)
-microsoft_add_library_tests(Profiles ExpandStaticAllocation QirAllocationAnalysis TransformationRule Rules AllocationManager Commandline Profiles)
+target_link_libraries(Profiles PRIVATE Rules)
+microsoft_add_library_tests(Profiles Rules AllocationManager Commandline Profiles)
 
 add_subdirectory(Apps)

src/Passes/Source/Llvm/Llvm.hpp

@@ -56,6 +56,9 @@
 #include "llvm/Transforms/Scalar/ADCE.h"
 #include "llvm/Transforms/Scalar/DCE.h"
 
+// Const folding
+#include "llvm/Analysis/ConstantFolding.h"
+
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif