Gather DDSIM benchmarks

CMakeLists.txt

@@ -34,3 +34,10 @@ if(BUILD_DD_EVAL_TESTS)
   include(GoogleTest)
   add_subdirectory(test)
 endif()
+
+option(BUILD_DD_EVAL_BENCHMARKS "Also build benchmarks for DDEval project")
+if(BUILD_DD_EVAL_BENCHMARKS)
+  enable_testing()
+  include(GoogleTest)
+  add_subdirectory(benchmarks)
+endif()

benchmarks/CMakeLists.txt

@@ -0,0 +1,16 @@
+if(NOT TARGET gtest OR NOT TARGET gmock)
+  # Prevent overriding the parent project's compiler/linker settings on Windows
+  set(gtest_force_shared_crt # cmake-lint: disable=C0103
+      ON
+      CACHE BOOL "" FORCE)
+
+  # store path to googletest in variable
+  set(GTEST_PATH "extern/ddsim/extern/qfr/extern/dd_package/extern/googletest")
+  add_subdirectory("${PROJECT_SOURCE_DIR}/${GTEST_PATH}" "${GTEST_PATH}"
+                   EXCLUDE_FROM_ALL)
+endif()
+
+package_add_test(
+  ${PROJECT_NAME}_sim_benchmark ${PROJECT_NAME} benchmark_simexec_qpe.cpp
+  benchmark_simexec_ghz.cpp benchmark_simexec_berstein.cpp
+  benchmark_simexec_grover.cpp)

benchmarks/benchmark_simexec_berstein.cpp

@@ -0,0 +1,60 @@
+#include "QuantumComputation.hpp"
+#include "algorithms/BernsteinVazirani.hpp"
+#include "executors/CircuitSimulatorExecutor.hpp"
+#include "executors/HybridSimulatorAmplitudeExecutor.hpp"
+#include "executors/HybridSimulatorDDExecutor.hpp"
+#include "executors/StochasticNoiseSimulatorExecutor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+#include "gtest/gtest.h"
+
+TEST(SimExecBenchmarkBerstein, HybridSimulatorAmplitudeExec) {
+  auto hybridSimulatorAmplitudeExecutor =
+      std::make_unique<HybridSimulatorAmplitudeExecutor>();
+  std::size_t const    n  = 25;
+  auto                 qc = std::make_unique<qc::BernsteinVazirani>(n, false);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = hybridSimulatorAmplitudeExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+TEST(SimExecBenchmarkBerstein, HybridSimulatorDDExec) {
+  auto hybridSimulatorDDExecutor =
+      std::make_unique<HybridSimulatorDDExecutor>();
+  std::size_t const    n  = 40;
+  auto                 qc = std::make_unique<qc::BernsteinVazirani>(n, false);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = hybridSimulatorDDExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+TEST(SimExecBenchmarkBerstein, StochasticNoiseSimulatorExec) {
+  auto stochasticNoiseSimulatorExecutor =
+      std::make_unique<StochasticNoiseSimulatorExecutor>();
+  std::size_t const    n  = 30;
+  auto                 qc = std::make_unique<qc::BernsteinVazirani>(n, false);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = stochasticNoiseSimulatorExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+// Gives "C++ exception with description "Unsupported non-unitary functionality
+// 'Rst '." thrown in the test body." when run in dynamic

benchmarks/benchmark_simexec_ghz.cpp

@@ -0,0 +1,39 @@
+#include "QuantumComputation.hpp"
+#include "algorithms/Entanglement.hpp"
+#include "executors/CircuitSimulatorExecutor.hpp"
+#include "executors/DeterministicNoiseSimExecutor.hpp"
+#include "executors/HybridSimulatorAmplitudeExecutor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+#include "gtest/gtest.h"
+
+TEST(SimExecBenchmarkGHZ, HybridSimulatorAmplitudeExec) {
+  auto hybridSimulatorAmplitudeExecutor =
+      std::make_unique<HybridSimulatorAmplitudeExecutor>();
+  auto                 qc = std::make_unique<qc::Entanglement>(25);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = hybridSimulatorAmplitudeExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+TEST(SimExecBenchmarkGHZ, DeterministicNoiseSimExec) {
+  auto deterministicNoiseSimulatorExecutor =
+      std::make_unique<DeterministicNoiseSimExecutor>();
+  auto                 qc = std::make_unique<qc::Entanglement>(20);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto           result =
+      deterministicNoiseSimulatorExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}

benchmarks/benchmark_simexec_grover.cpp

@@ -0,0 +1,55 @@
+#include "QuantumComputation.hpp"
+#include "algorithms/Grover.hpp"
+#include "executors/CircuitSimulatorExecutor.hpp"
+#include "executors/UnitarySimRecursiveExecutor.hpp"
+#include "executors/UnitarySimSequentialExecutor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+#include "gtest/gtest.h"
+
+TEST(SimExecBenchmarkGrover, CircuitSimulatorExec) {
+  auto circuitSimulatorExecutor = std::make_unique<CircuitSimulatorExecutor>();
+  std::size_t const    n        = 25;
+  auto                 qc       = std::make_unique<qc::Grover>(n);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = circuitSimulatorExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+TEST(SimExecBenchmarkGrover, UnitarySimSequentialExec) {
+  auto unitarySimSequentialExecutor =
+      std::make_unique<UnitarySimSequentialExecutor>();
+  std::size_t const    n  = 22;
+  auto                 qc = std::make_unique<qc::Grover>(n);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = unitarySimSequentialExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}
+
+TEST(SimExecBenchmarkGrover, UnitarySimRecursiveExec) {
+  auto unitarySimRecursiveExecutor =
+      std::make_unique<UnitarySimRecursiveExecutor>();
+  std::size_t const    n  = 22;
+  auto                 qc = std::make_unique<qc::Grover>(n);
+  SimulationTask const simulationTask(std::move(qc));
+  const auto result = unitarySimRecursiveExecutor->execute(simulationTask);
+  std::cout << result << "\n";
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() >
+              1000000);
+  EXPECT_TRUE(result["construction_time"].get<int>() +
+                  result["execution_time"].get<int>() <
+              300000000);
+}

benchmarks/benchmark_simexec_qpe.cpp

@@ -0,0 +1,38 @@
+#include "algorithms/QPE.hpp"
+#include "executors/CircuitSimulatorExecutor.hpp"
+#include "executors/UnitarySimRecursiveExecutor.hpp"
+#include "executors/UnitarySimSequentialExecutor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+#include "gtest/gtest.h"
+
+// QPE fails from n=65 on in ComplexTable line 151. See if later versions of the
+// dd package can fix this.
+
+TEST(SimExecBenchmarkQPE, CircuitSimulatorExec) {
+  auto circuitSimulatorExecutor = std::make_unique<CircuitSimulatorExecutor>();
+  std::size_t const    n        = 65;
+  auto                 qc       = std::make_unique<qc::QPE>(n, true, false);
+  SimulationTask const simulationTask(std::move(qc));
+  EXPECT_DEATH(circuitSimulatorExecutor->execute(simulationTask), "Assertion");
+}
+
+TEST(SimExecBenchmarkQPE, UnitarySimRecursiveExec) {
+  auto unitarySimRecursiveExecutor =
+      std::make_unique<UnitarySimRecursiveExecutor>();
+  std::size_t const    n  = 65;
+  auto                 qc = std::make_unique<qc::QPE>(n, true, false);
+  SimulationTask const simulationTask(std::move(qc));
+  EXPECT_DEATH(unitarySimRecursiveExecutor->execute(simulationTask),
+               "Assertion");
+}
+
+TEST(SimExecBenchmarkQPE, UnitarySimSequentialExec) {
+  auto unitarySimSequentialExecutor =
+      std::make_unique<UnitarySimSequentialExecutor>();
+  std::size_t const    n  = 65;
+  auto                 qc = std::make_unique<qc::QPE>(n, true, false);
+  SimulationTask const simulationTask(std::move(qc));
+  EXPECT_DEATH(unitarySimSequentialExecutor->execute(simulationTask),
+               "Assertion");
+}

include/executors/DeterministicNoiseSimExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class DeterministicNoiseSimExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "deterministic_noise_simulator";
+  };
+};

include/executors/HybridSimulatorAmplitudeExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class HybridSimulatorAmplitudeExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "hybrid_schrodinger_feynman_simulator_amplitude";
+  };
+};

include/executors/HybridSimulatorDDExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class HybridSimulatorDDExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "hybrid_schrodinger_feynman_simulator_dd";
+  };
+};

include/executors/StochasticNoiseSimulatorExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class StochasticNoiseSimulatorExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "stochastic_noise_simulator";
+  };
+};

include/executors/UnitarySimRecursiveExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class UnitarySimRecursiveExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "unitary_simulator_recursive";
+  };
+};

include/executors/UnitarySimSequentialExecutor.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Executor.hpp"
+#include "tasks/SimulationTask.hpp"
+
+class UnitarySimSequentialExecutor : public Executor<SimulationTask> {
+public:
+  json execute(const SimulationTask& task) override;
+
+  [[nodiscard]] std::string getIdentifier() const override {
+    return "unitary_simulator_sequential";
+  };
+};

src/CMakeLists.txt

@@ -12,14 +12,25 @@ if(NOT TARGET ${PROJECT_NAME})
     ${PROJECT_SOURCE_DIR}/include/Executor.hpp
     ${PROJECT_SOURCE_DIR}/include/executors/CircuitSimulatorExecutor.hpp
     ${PROJECT_SOURCE_DIR}/include/executors/AlternatingVerificationExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/HybridSimulatorDDExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/HybridSimulatorAmplitudeExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/DeterministicNoiseSimExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/StochasticNoiseSimulatorExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/UnitarySimRecursiveExecutor.hpp
+    ${PROJECT_SOURCE_DIR}/include/executors/UnitarySimSequentialExecutor.hpp
     ${PROJECT_SOURCE_DIR}/include/Task.hpp
     ${PROJECT_SOURCE_DIR}/include/tasks/SimulationTask.hpp
     ${PROJECT_SOURCE_DIR}/include/tasks/VerificationTask.hpp
     executors/CircuitSimulatorExecutor.cpp
     executors/AlternatingVerificationExecutor.cpp
+    executors/HybridSimulatorDDExecutor.cpp
+    executors/HybridSimulatorAmplitudeExecutor.cpp
+    executors/DeterministicNoiseSimExecutor.cpp
+    executors/StochasticNoiseSimulatorExecutor.cpp
+    executors/UnitarySimRecursiveExecutor.cpp
+    executors/UnitarySimSequentialExecutor.cpp
     tasks/SimulationTask.cpp
     tasks/VerificationTask.cpp)
-
   # set include directories
   target_include_directories(
     ${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/include

src/executors/CircuitSimulatorExecutor.cpp

@@ -7,7 +7,8 @@ json CircuitSimulatorExecutor::execute(const SimulationTask& task) {
   auto const constructionStart = std::chrono::steady_clock::now();
 
   auto qc = std::make_unique<qc::QuantumComputation>(task.getQc()->clone());
-  auto circuitSimulator = std::make_unique<CircuitSimulator<>>(std::move(qc));
+  auto circuitSimulator =
+      std::make_unique<CircuitSimulator<>>(std::move(qc), 23);
 
   auto const executionStart = std::chrono::steady_clock::now();
 

src/executors/DeterministicNoiseSimExecutor.cpp

@@ -0,0 +1,31 @@
+#include "executors/DeterministicNoiseSimExecutor.hpp"
+
+#include "DeterministicNoiseSimulator.hpp"
+
+json DeterministicNoiseSimExecutor::execute(const SimulationTask& task) {
+  json       result;
+  auto const constructionStart = std::chrono::steady_clock::now();
+
+  auto qc = std::make_unique<qc::QuantumComputation>(task.getQc()->clone());
+  auto circuitSimulator =
+      std::make_unique<DeterministicNoiseSimulator<>>(std::move(qc), 23);
+
+  auto const executionStart = std::chrono::steady_clock::now();
+
+  result["measurement_results"] = circuitSimulator->deterministicSimulate();
+  // Add memory usage
+
+  auto const executionStop = std::chrono::steady_clock::now();
+  auto const constructionTime =
+      std::chrono::duration_cast<std::chrono::microseconds>(executionStart -
+                                                            constructionStart);
+  auto const execTime = std::chrono::duration_cast<std::chrono::microseconds>(
+      executionStop - executionStart);
+  result["construction_time"] = constructionTime.count();
+  result["execution_time"]    = execTime.count();
+
+  result["executor"] = getIdentifier();
+  result["task"]     = task.getIdentifier();
+
+  return result;
+}