updates to tests (70791ab0) · Commits · ORNL Quantum Computing Institute / qcor

compiler/tests/QCORASTVisitorTester.in.cpp

+843 −305

File changed.

Preview size limit exceeded, changes collapsed.

runtime/qcor.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,8 @@

		#include "FermionOperator.hpp"
		#include "PauliOperator.hpp"
		#include "CountGatesOfTypeVisitor.hpp"
		#include "CommonGates.hpp"

		#include <regex>

		@@ -17,6 +19,11 @@ namespace qcor {
		namespace __internal {
		bool executeKernel = true;
		void switchDefaultKernelExecution(bool execute) { executeKernel = execute; }
		bool hasMeasurements(std::shared_ptr<CompositeInstruction> inst) {
		quantum::CountGatesOfTypeVisitor<quantum::Measure> count(inst);
		return count.countGates() > 0;
		}

		void updateMap(xacc::HeterogeneousMap &m, std::vector<double> &values) {
		if (values.empty()) {
		m.get_mutable<std::vector<double>>("initial-parameters") =

runtime/qcor.hpp

+128 −13

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@
		#include "Observable.hpp"
		#include "heterogeneous.hpp"
		#include "xacc.hpp"

		#include <future>
		#include <vector>

		@@ -106,7 +107,8 @@ protected:
		public:
		virtual double operator()(const std::vector<double> &params) = 0;
		void initialize(std::shared_ptr<Observable> obs,
		std::shared_ptr<CompositeInstruction> k, std::shared_ptr<AcceleratorBuffer> b) {
		std::shared_ptr<CompositeInstruction> k,
		std::shared_ptr<AcceleratorBuffer> b) {
		observable = obs;
		kernel = k;
		kernels = obs->observe(k);
		@@ -164,6 +166,9 @@ parametersFromVariadic(const std::shared_ptr<CompositeInstruction> function,
		__internal::constructInitialParameters(tmp, args...);
		return tmp.get<std::vector<double>>("initial-parameters");
		}

		bool hasMeasurements(std::shared_ptr<CompositeInstruction> inst);

		} // namespace __internal

		void Initialize();
		@@ -279,8 +284,18 @@ public:

		template <typename QuantumKernel, typename... Args>
		void execute(QuantumKernel &&kernel, Args... args) {
		execute(kernel, args...);
		}

		template <typename QuantumKernel, typename... Args>
		void execute(QuantumKernel &kernel, Args... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);

		if (!__internal::hasMeasurements(function)) {
		xacc::error("[qpu_handler::execute(kernel,args...)] Invalid kernel for "
		"execution.\nNo measurements specified:\n" +
		function->toString());
		}
		auto nLogicalBits = function->nLogicalBits();
		auto accelerator = xacc::getAccelerator(function->accelerator_signature());

		@@ -336,7 +351,8 @@ public:
		}

		template <typename QuantumKernel, typename... InitialArgs>
		void execute(QuantumKernel &kernel, std::shared_ptr<ObjectiveFunction> objFunction,
		void execute(QuantumKernel &kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		std::shared_ptr<Optimizer> optimizer,
		std::shared_ptr<Observable> observable, InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		@@ -348,13 +364,35 @@ public:
		objFunction->initialize(observable, function, buffer);

		OptFunction optF(
		[&, objFunction](const std::vector<double> &x) { return objFunction->operator()(x); },
		[&, objFunction](const std::vector<double> &x) {
		return objFunction->operator()(x);
		},
		function->nVariables());
		auto result = optimizer->optimize(optF);

		buffer->addExtraInfo("opt-val", ExtraInfo(result.first));
		buffer->addExtraInfo("opt-params", ExtraInfo(result.second));
		}

		// Execute the Objective Function at the given initial args
		template <typename QuantumKernel, typename... InitialArgs>
		void execute(QuantumKernel &kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		std::shared_ptr<Observable> observable, InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		auto parameters = __internal::parametersFromVariadic(function, args...);
		auto nLogicalBits = function->nLogicalBits();
		if (!buffer) {
		buffer = xacc::qalloc(nLogicalBits);
		}

		objFunction->initialize(observable, function, buffer);

		auto result = objFunction->operator()(parameters);

		buffer->addExtraInfo("opt-val", ExtraInfo(result));
		buffer->addExtraInfo("opt-params", ExtraInfo(parameters));
		}
		};

		// Full TaskInitiate, built in objective function (given by its name)
		@@ -380,7 +418,37 @@ taskInitiate(QuantumKernel &&kernel, const std::string objectiveFunctionName,
		});
		}

		// No observable, assume Z on all qubits
		// TaskInitiate just execute kernel with measurements (parameterized, rvalue
		// kernel)
		template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel, FirstArg arg, InitialArgs... args) {
		return taskInitiate(kernel, arg, args...);
		}

		// TaskInitiate just execute kernel with measurements (parameterized, lvalue
		// kernel)
		template <typename QuantumKernel, typename FirstArg, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &kernel, FirstArg arg, InitialArgs... args) {
		auto function =
		qcor::__internal::getCompositeInstruction(kernel, arg, args...);
		auto parameters = __internal::parametersFromVariadic(function, arg, args...);
		return qcor::submit([&, parameters](qcor::qpu_handler &qh) {
		qh.execute(kernel, parameters);
		});
		}

		// TaskInitiate just execute kernel with measurements (no params, rvalue kernel)
		template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &&kernel) {
		return taskInitiate(kernel);
		}

		// TaskInitiate just execute kernel with measurements (no params, rvalue kernel)
		template <typename QuantumKernel> Handle taskInitiate(QuantumKernel &kernel) {
		auto function = qcor::__internal::getCompositeInstruction(kernel);
		return qcor::submit([&](qcor::qpu_handler &qh) { qh.execute(kernel); });
		}

		// No observable, assume Z on all qubits, objective function given by name
		template <typename QuantumKernel, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel,
		const std::string objectiveFunctionName,
		@@ -403,7 +471,8 @@ Handle taskInitiate(QuantumKernel &&kernel,
		});
		}

		// No optimizer, evaluate at given initial args
		// No optimizer, evaluate at given initial args, objective function given by
		// name
		template <typename QuantumKernel, typename... InitialArgs>
		Handle
		taskInitiate(QuantumKernel &&kernel, const std::string objectiveFunctionName,
		@@ -419,21 +488,16 @@ taskInitiate(QuantumKernel &&kernel, const std::string objectiveFunctionName,
		});
		}

		// Custom Objective Function, no Observable
		// template <typename QuantumKernel, typename... InitialArgs>
		// Handle taskInitiate(QuantumKernel &&kernel, ObjectiveFunction &&objFunction,
		// std::shared_ptr<Optimizer> optimizer, InitialArgs... args) {
		// return taskInitiate(kernel, objFunction, optimizer, args...);
		// }
		// Custom Objective Function, no Observable (will use all Zs)
		template <typename QuantumKernel, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel, std::shared_ptr<ObjectiveFunction> objFunction,
		Handle taskInitiate(QuantumKernel &&kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		std::shared_ptr<Optimizer> optimizer, InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		auto parameters = __internal::parametersFromVariadic(function, args...);

		return qcor::submit(
		[&, parameters, function, optimizer](qcor::qpu_handler &qh) {

		optimizer->appendOption("initial-parameters", parameters);

		std::string allZsObsStr = "";
		@@ -444,6 +508,57 @@ Handle taskInitiate(QuantumKernel &&kernel, std::shared_ptr<ObjectiveFunction> o
		qh.execute(kernel, objFunction, optimizer, observable, args...);
		});
		}

		// Custom Objective Function, with observable and optimizer
		template <typename QuantumKernel, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		std::shared_ptr<Optimizer> optimizer,
		std::shared_ptr<Observable> observable,
		InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		auto parameters = __internal::parametersFromVariadic(function, args...);

		return qcor::submit(
		[&, parameters, function, optimizer](qcor::qpu_handler &qh) {
		optimizer->appendOption("initial-parameters", parameters);
		qh.execute(kernel, objFunction, optimizer, observable, args...);
		});
		}

		// Custom Objective Function, with observable and no optimizer, just eval at
		// given args
		template <typename QuantumKernel, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		std::shared_ptr<Observable> observable,
		InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		auto parameters = __internal::parametersFromVariadic(function, args...);

		return qcor::submit([&, parameters, function](qcor::qpu_handler &qh) {
		HeterogeneousMap m{
		std::make_pair("observable", observable),
		};
		qh.execute(kernel, objFunction, observable, parameters);
		});
		}

		// Custom Objective Function, with no observable and no optimizer, just eval at
		// given args with default all Zs observable
		template <typename QuantumKernel, typename... InitialArgs>
		Handle taskInitiate(QuantumKernel &&kernel,
		std::shared_ptr<ObjectiveFunction> objFunction,
		InitialArgs... args) {
		auto function = qcor::__internal::getCompositeInstruction(kernel, args...);
		auto parameters = __internal::parametersFromVariadic(function, args...);
		std::string allZsObsStr = "";
		for (int i = 0; i < function->nLogicalBits(); i++) {
		allZsObsStr += "Z" + std::to_string(i) + " ";
		}
		auto observable = getObservable("pauli", allZsObsStr);
		return taskInitiate(kernel, objFunction, observable, args...);
		}
		} // namespace qcor

		#endif

runtime/tests/CMakeLists.txt

+9 −8

Original line number	Diff line number	Diff line
		set(CMAKE_CXX_COMPILER qcor)
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -a local-ibm")
		message(STATUS "LINKING ${XACC_ROOT}/lib")

		set(CMAKE_CXX_COMPILER ${CMAKE_BINARY_DIR}/qcor)
		set(ORIGINAL_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
		link_directories(${XACC_ROOT}/lib)
		add_executable(test_bell_state test_bell_state.cpp)
		target_include_directories(test_bell_state PRIVATE ${XACC_INCLUDE_ROOT}/gtest)
		add_test(test_bell_state test_bell_state)
		target_link_libraries(test_bell_state PRIVATE gtest gtest_main)

		set(CMAKE_CXX_FLAGS "${ORIGINAL_CXX_FLAGS} -a local-ibm")

		add_executable(test_simple_kernel test_simple_kernel.cpp)
		target_include_directories(test_simple_kernel PRIVATE ${XACC_INCLUDE_ROOT}/gtest)
		add_test(test_simple_kernel test_simple_kernel)
		target_link_libraries(test_simple_kernel PRIVATE gtest gtest_main)

runtime/tests/test_bell_state.cpp→runtime/tests/test_simple_kernel.cpp

+11 −4

Original line number	Diff line number	Diff line
		#include <gtest/gtest.h>
		#include "qcor.hpp"

		TEST(bell_state_tester, check_bell_state) {
		TEST(test_task_initiate, checkVariations) {

		auto bell = [&](qbit q) {
		H(q[0]);
		@@ -10,22 +10,29 @@ TEST(bell_state_tester, check_bell_state) {
		Measure(q[1]);
		};

		// Test just executing the kernel
		auto q = qcor::qalloc(2);
		bell(q);

		q->print();
		EXPECT_TRUE(q->getMeasurementCounts().count("00"));
		EXPECT_TRUE(q->getMeasurementCounts().count("11"));

		// Now test with submit()
		auto handle = qcor::submit([&](qcor::qpu_handler& qh) {
		qh.execute(bell);
		});

		auto results = qcor::sync(handle);
		results->print();
		EXPECT_TRUE(results->getMeasurementCounts().count("00"));
		EXPECT_TRUE(results->getMeasurementCounts().count("11"));

		// Now test with task initiate
		auto handle1 = qcor::taskInitiate(bell);
		auto results2 = qcor::sync(handle1);
		results2->print();
		EXPECT_TRUE(results->getMeasurementCounts().count("00"));
		EXPECT_TRUE(results->getMeasurementCounts().count("11"));

		}

		int main(int argc, char **argv) {