4 benchmark suite setup

include/AlternatingVerificationExecutor.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "EquivalenceCheckingManager.hpp"
+#include "VerificationExecutor.hpp"
+
+class AlternatingVerificationExecutor : public VerificationExecutor {
+public:
+  AlternatingVerificationExecutor() = delete;
+
+  explicit AlternatingVerificationExecutor(
+      std::unique_ptr<VerificationTask> verificationTask);
+
+  json        executeTask() override;
+  std::string getIdentifier() override;
+
+private:
+  std::unique_ptr<ec::EquivalenceCheckingManager> mEquivalenceCheckingManager;
+};

include/CircuitSimulatorExecutor.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "CircuitSimulator.hpp"
+#include "SimulationExecutor.hpp"
+
+class CircuitSimulatorExecutor : public SimulationExecutor {
+public:
+  CircuitSimulatorExecutor() = delete;
+
+  explicit CircuitSimulatorExecutor(
+      std::unique_ptr<SimulationTask> simulationTask);
+
+  json        executeTask() override;
+  std::string getIdentifier() override;
+
+private:
+  std::unique_ptr<CircuitSimulator<>> mCircuitSimulator;
+};

include/Executor.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Task.hpp"
+
+#include <memory>
+
+class Executor {
+public:
+  virtual ~Executor() = default;
+  explicit Executor() = default;
+
+  virtual json        executeTask()   = 0;
+  virtual std::string getIdentifier() = 0;
+
+private:
+  std::unique_ptr<Task> task;
+};

include/SimulationExecutor.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "SimulationTask.hpp"
+
+class SimulationExecutor : public Executor {
+public:
+  SimulationExecutor() = default;
+
+  const std::unique_ptr<SimulationTask>& getTask();
+
+  void setTask(std::unique_ptr<SimulationTask>& task);
+
+protected:
+  std::unique_ptr<SimulationTask> mTask;
+};

include/SimulationTask.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "QuantumComputation.hpp"
+#include "Task.hpp"
+
+class SimulationTask : public Task {
+public:
+  SimulationTask() = default;
+
+  explicit SimulationTask(std::unique_ptr<qc::QuantumComputation> qc)
+      : qc(std::move(qc)) {}
+
+  [[nodiscard]] const std::unique_ptr<qc::QuantumComputation>& getQc() const;
+  std::string getIdentifier() override;
+
+protected:
+  std::unique_ptr<qc::QuantumComputation> qc;
+};

include/Task.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+class Task {
+public:
+  virtual ~Task()                     = default;
+  virtual std::string getIdentifier() = 0;
+};

include/TestHelpers.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+void printAll(const nlohmann::json& json);

include/VerificationExecutor.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "VerificationTask.hpp"
+
+class VerificationExecutor : public Executor {
+public:
+  VerificationExecutor() = default;
+
+  [[nodiscard]] const std::unique_ptr<VerificationTask>& getTask() const;
+
+  void setTask(std::unique_ptr<VerificationTask>& task);
+
+protected:
+  std::unique_ptr<VerificationTask> mTask;
+};

include/VerificationTask.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "QuantumComputation.hpp"
+#include "Task.hpp"
+
+class VerificationTask : public Task {
+public:
+  VerificationTask() = default;
+  VerificationTask(std::unique_ptr<qc::QuantumComputation> qc1,
+                   std::unique_ptr<qc::QuantumComputation> qc2)
+      : qc1(std::move(qc1)), qc2(std::move(qc2)) {}
+  std::string getIdentifier() override;
+
+protected:
+  std::unique_ptr<qc::QuantumComputation> qc1;
+  std::unique_ptr<qc::QuantumComputation> qc2;
+
+public:
+  [[nodiscard]] const std::unique_ptr<qc::QuantumComputation>& getQc1() const;
+
+  [[nodiscard]] const std::unique_ptr<qc::QuantumComputation>& getQc2() const;
+};

src/AlternatingVerificationExecutor.cpp

@@ -0,0 +1,36 @@
+#include "AlternatingVerificationExecutor.hpp"
+
+AlternatingVerificationExecutor::AlternatingVerificationExecutor(
+    std::unique_ptr<VerificationTask> verificationTask) {
+  mTask    = std::move(verificationTask);
+  auto qc1 = mTask->getQc1()->clone();
+  auto qc2 = mTask->getQc2()->clone();
+  mEquivalenceCheckingManager =
+      std::make_unique<ec::EquivalenceCheckingManager>(qc1, qc2);
+  mEquivalenceCheckingManager->setAlternatingChecker(true);
+  mEquivalenceCheckingManager->setSimulationChecker(false);
+  mEquivalenceCheckingManager->setConstructionChecker(false);
+  mEquivalenceCheckingManager->setZXChecker(false);
+}
+
+std::string AlternatingVerificationExecutor::getIdentifier() {
+  return "alt_ver_exe" + mTask->getIdentifier();
+}
+
+json AlternatingVerificationExecutor::executeTask() {
+  json result;
+  auto start = std::chrono::high_resolution_clock::now();
+
+  mEquivalenceCheckingManager->run();
+  result = mEquivalenceCheckingManager->getResults().json();
+  // Add memory usage
+  auto stop = std::chrono::high_resolution_clock::now();
+  auto runtime =
+      std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
+  result["runtime"] = runtime.count();
+  std::string const identifier =
+      this->getTask()->getIdentifier() + "_" + this->getIdentifier();
+  result["identifier"] = identifier;
+
+  return result;
+}

src/CMakeLists.txt

@@ -6,26 +6,34 @@ add_subdirectory("${PROJECT_SOURCE_DIR}/extern/ddsim" "extern/ddsim"
 add_subdirectory("${PROJECT_SOURCE_DIR}/extern/qcec" "extern/qcec"
                  EXCLUDE_FROM_ALL)
 
-# add_library( ${PROJECT_NAME} ${PROJECT_SOURCE_DIR}/include/checker
-# ${PROJECT_SOURCE_DIR}/include/Configuration.hpp
-# ${PROJECT_SOURCE_DIR}/include/EquivalenceCriterion.hpp
-# ${PROJECT_SOURCE_DIR}/include/EquivalenceCheckingManager.hpp
-# ${PROJECT_SOURCE_DIR}/include/ThreadSafeQueue.hpp
-# EquivalenceCheckingManager.cpp checker/EquivalenceChecker.cpp
-# checker/dd/DDEquivalenceChecker.cpp checker/dd/DDConstructionChecker.cpp
-# checker/dd/DDSimulationChecker.cpp checker/dd/DDAlternatingChecker.cpp
-# checker/dd/applicationscheme/GateCostApplicationScheme.cpp
-# checker/dd/simulation/StateGenerator.cpp checker/zx/ZXChecker.cpp)
+if(NOT TARGET ${PROJECT_NAME})
+  add_library(
+    ${PROJECT_NAME}
+    ${PROJECT_SOURCE_DIR}/include/Executor.hpp
+    ${PROJECT_SOURCE_DIR}/include/SimulationExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/VerificationExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/CircuitSimulatorExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/AlternatingVerificationExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/Task.hpp
+    ${PROJECT_SOURCE_DIR}/include/SimulationTask.hpp
+    ${PROJECT_SOURCE_DIR}/include/VerificationTask.hpp
+    ${PROJECT_SOURCE_DIR}/include/TestHelpers.hpp
+    TestHelpers.cpp
+    SimulationExecutor.cpp
+    CircuitSimulatorExecutor.cpp
+    VerificationExecutor.cpp
+    AlternatingVerificationExecutor.cpp
+    SimulationTask.cpp
+    VerificationTask.cpp)
 
-add_library(${PROJECT_NAME} INTERFACE)
+  # set include directories
+  target_include_directories(
+    ${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/include
+                           ${PROJECT_BINARY_DIR}/include)
 
-# set include directories
-target_include_directories(
-  ${PROJECT_NAME} INTERFACE ${PROJECT_SOURCE_DIR}/include
-                            ${PROJECT_BINARY_DIR}/include)
+  # link to the MQT libraries
+  target_link_libraries(${PROJECT_NAME} PUBLIC MQT::ddsim MQT::qcec)
 
-# link to the MQT libraries
-target_link_libraries(${PROJECT_NAME} INTERFACE MQT::ddsim MQT::qcec)
-
-# add MQT alias
-add_library(MQT::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+  # add MQT alias
+  add_library(MQT::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+endif()

src/CircuitSimulatorExecutor.cpp

@@ -0,0 +1,38 @@
+#include "CircuitSimulatorExecutor.hpp"
+
+CircuitSimulatorExecutor::CircuitSimulatorExecutor(
+    std::unique_ptr<SimulationTask> simulationTask) {
+  mTask   = std::move(simulationTask);
+  auto qc = std::make_unique<qc::QuantumComputation>(mTask->getQc()->clone());
+  mCircuitSimulator = std::make_unique<CircuitSimulator<>>(std::move(qc));
+}
+
+std::string CircuitSimulatorExecutor::getIdentifier() {
+  return "circ_sim_exe" + mTask->getIdentifier();
+}
+
+template <typename KTy, typename VTy>
+inline void toJson(json& j, const std::map<KTy, VTy>& m) {
+  for (const auto& entry : m) {
+    j[entry.first] = entry.second;
+  }
+}
+
+json CircuitSimulatorExecutor::executeTask() {
+  json result;
+  auto start = std::chrono::high_resolution_clock::now();
+
+  const auto results = mCircuitSimulator->simulate(1024U);
+  toJson(result, results);
+  // Add memory usage
+
+  auto stop = std::chrono::high_resolution_clock::now();
+  auto runtime =
+      std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
+  result["runtime"] = runtime.count();
+  std::string const identifier =
+      this->getTask()->getIdentifier() + "_" + this->getIdentifier();
+  result["identifier"] = identifier;
+
+  return result;
+}

src/SimulationExecutor.cpp

@@ -0,0 +1,5 @@
+#include "SimulationExecutor.hpp"
+
+const std::unique_ptr<SimulationTask>& SimulationExecutor::getTask() {
+  return mTask;
+}

src/SimulationTask.cpp

@@ -0,0 +1,7 @@
+#include "SimulationTask.hpp"
+
+std::string SimulationTask::getIdentifier() { return "sim_" + qc->getName(); }
+
+const std::unique_ptr<qc::QuantumComputation>& SimulationTask::getQc() const {
+  return qc;
+}

src/TestHelpers.cpp

@@ -0,0 +1,11 @@
+#include "TestHelpers.hpp"
+
+#include <iostream>
+
+void printAll(const nlohmann::json& jsonObject) {
+  for (auto it = jsonObject.begin(); it != jsonObject.end(); ++it) {
+    const auto& key   = it.key();
+    const auto& value = it.value();
+    std::cout << key << ": " << value << std::endl;
+  }
+}

src/VerificationExecutor.cpp

@@ -0,0 +1,5 @@
+#include "VerificationExecutor.hpp"
+
+const std::unique_ptr<VerificationTask>& VerificationExecutor::getTask() const {
+  return mTask;
+}

src/VerificationTask.cpp

@@ -0,0 +1,15 @@
+#include "VerificationTask.hpp"
+
+std::string VerificationTask::getIdentifier() {
+  return "ver_" + qc1->getName() + "_" + qc2->getName();
+}
+
+const std::unique_ptr<qc::QuantumComputation>&
+VerificationTask::getQc1() const {
+  return qc1;
+}
+
+const std::unique_ptr<qc::QuantumComputation>&
+VerificationTask::getQc2() const {
+  return qc2;
+}

test/CMakeLists.txt

@@ -9,6 +9,16 @@ if(NOT TARGET gtest OR NOT TARGET gmock)
   add_subdirectory("${PROJECT_SOURCE_DIR}/${GTEST_PATH}" "${GTEST_PATH}"
                    EXCLUDE_FROM_ALL)
 endif()
-
-package_add_test(${PROJECT_NAME}_test ${PROJECT_NAME} test_ddsim_simple.cpp
-                 test_qcec_simple.cpp)
+configure_file(${CMAKE_SOURCE_DIR}/test/circuits.json
+               ${CMAKE_CURRENT_BINARY_DIR}/circuits.json COPYONLY)
+configure_file(${CMAKE_SOURCE_DIR}/test/equi_circuits.json
+               ${CMAKE_CURRENT_BINARY_DIR}/equi_circuits.json COPYONLY)
+package_add_test(
+  ${PROJECT_NAME}_test
+  ${PROJECT_NAME}
+  test_ddsim_simple.cpp
+  test_qcec_simple.cpp
+  test_simexec_simple.cpp
+  test_simexec.cpp
+  test_qcecexec_simple.cpp
+  test_qcecexec.cpp)

test/circuits.json

@@ -0,0 +1,7 @@
+[
+  {
+    "description": "two_qubit_circuit_with_two_x_gates",
+    "initial_circuit": "OPENQASM 2.0;include \"qelib1.inc\";qreg q[2];x q[0];x q[1];\n",
+    "expected_11": 1024
+  }
+]

test/equi_circuits.json

@@ -0,0 +1,8 @@
+[
+  {
+    "description": "simple_circuits",
+    "initial_circuit1": "OPENQASM 2.0;include \"qelib1.inc\";qreg q[2];x q[0];x q[1];\n",
+    "initial_circuit2": "OPENQASM 2.0;include \"qelib1.inc\";qreg q[2];x q[0];x q[1];x q[0];x q[0];\n",
+    "expected_equivalence": "equivalent"
+  }
+]