Refactor and rename QIR runtime headers and interfaces

src/QirRuntime/build-qir-runtime.ps1

@@ -72,7 +72,7 @@ if ($LastExitCode -ne 0) {
     Write-Host "##vso[task.logissue type=error;]Failed to build QIR Runtime."
 }
 
-$os = "win32"
+$os = "win"
 $pattern = "*.dll"
 if ($IsMacOS) {
     $os = "osx"

src/QirRuntime/lib/QIR/context.cpp

@@ -6,7 +6,7 @@
 #include "QirContext.hpp"
 
 #include "CoreTypes.hpp"
-#include "QuantumApi_I.hpp"
+#include "QirRuntimeApi_I.hpp"
 #include "allocationsTracker.hpp"
 
 // These two globals are used in QIR _directly_ so have to define them outside of the context.
@@ -20,15 +20,15 @@ namespace Quantum
     thread_local std::unique_ptr<QirExecutionContext> g_context = nullptr;
     std::unique_ptr<QirExecutionContext>& GlobalContext() { return g_context; }
 
-    void InitializeQirContext(ISimulator* sim, bool trackAllocatedObjects)
+    void InitializeQirContext(IRuntimeDriver* sim, bool trackAllocatedObjects)
     {
         assert(g_context == nullptr);
         g_context = std::make_unique<QirExecutionContext>(sim, trackAllocatedObjects);
 
-        if (g_context->simulator != nullptr)
+        if (g_context->driver != nullptr)
         {
-            ResultOne = g_context->simulator->UseOne();
-            ResultZero = g_context->simulator->UseZero();
+            ResultOne = g_context->driver->UseOne();
+            ResultZero = g_context->driver->UseZero();
         }
         else
         {
@@ -51,8 +51,8 @@ namespace Quantum
         g_context.reset(nullptr);
     }
 
-    QirExecutionContext::QirExecutionContext(ISimulator* sim, bool trackAllocatedObjects)
-        : simulator(sim)
+    QirExecutionContext::QirExecutionContext(IRuntimeDriver* sim, bool trackAllocatedObjects)
+        : driver(sim)
         , trackAllocatedObjects(trackAllocatedObjects)
     {
         if (this->trackAllocatedObjects)

src/QirRuntime/lib/QIR/delegated.cpp

@@ -6,7 +6,7 @@
 
 #include "QirRuntime.hpp"
 
-#include "QuantumApi_I.hpp"
+#include "QirRuntimeApi_I.hpp"
 #include "SimFactory.hpp"
 #include "QirContext.hpp"
 #include "QirTypes.hpp"
@@ -29,22 +29,22 @@ extern "C"
 {
     Result quantum__rt__result_zero()
     {
-        return Microsoft::Quantum::g_context->simulator->UseZero();
+        return Microsoft::Quantum::g_context->driver->UseZero();
     }
 
     Result quantum__rt__result_one()
     {
-        return Microsoft::Quantum::g_context->simulator->UseOne();
+        return Microsoft::Quantum::g_context->driver->UseOne();
     }
 
     QUBIT* quantum__rt__qubit_allocate() // NOLINT
     {
-        return Microsoft::Quantum::g_context->simulator->AllocateQubit();
+        return Microsoft::Quantum::g_context->driver->AllocateQubit();
     }
 
     void quantum__rt__qubit_release(QUBIT* qubit) // NOLINT
     {
-        Microsoft::Quantum::g_context->simulator->ReleaseQubit(qubit);
+        Microsoft::Quantum::g_context->driver->ReleaseQubit(qubit);
     }
 
     void quantum__rt__result_update_reference_count(RESULT* r, int32_t increment)
@@ -76,7 +76,7 @@ extern "C"
             if (rit == trackedResults.end())
             {
                 assert(increment == -1);
-                Microsoft::Quantum::g_context->simulator->ReleaseResult(r);
+                Microsoft::Quantum::g_context->driver->ReleaseResult(r);
             }
             else
             {
@@ -85,7 +85,7 @@ extern "C"
                 if (newRefcount == 0)
                 {
                     trackedResults.erase(rit);
-                    Microsoft::Quantum::g_context->simulator->ReleaseResult(r);
+                    Microsoft::Quantum::g_context->driver->ReleaseResult(r);
                 }
                 else
                 {
@@ -101,13 +101,13 @@ extern "C"
         {
             return true;
         }
-        return Microsoft::Quantum::g_context->simulator->AreEqualResults(r1, r2);
+        return Microsoft::Quantum::g_context->driver->AreEqualResults(r1, r2);
     }
 
     // Returns a string representation of the result.
     QirString* quantum__rt__result_to_string(RESULT* result) // NOLINT
     {
-        ResultValue rv = Microsoft::Quantum::g_context->simulator->GetResultValue(result);
+        ResultValue rv = Microsoft::Quantum::g_context->driver->GetResultValue(result);
         assert(rv != Result_Pending);
 
         return (rv == Result_Zero) ? quantum__rt__string_create("Zero") : quantum__rt__string_create("One");
@@ -116,6 +116,6 @@ extern "C"
     // Returns a string representation of the qubit.
     QirString* quantum__rt__qubit_to_string(QUBIT* qubit) // NOLINT
     {
-        return quantum__rt__string_create(Microsoft::Quantum::g_context->simulator->QubitToString(qubit).c_str());
+        return quantum__rt__string_create(Microsoft::Quantum::g_context->driver->QubitToString(qubit).c_str());
     }
 }

src/QirRuntime/lib/QSharpCore/intrinsics.cpp

@@ -4,14 +4,15 @@
 /*=============================================================================
     QIR assumes a single global execution context.
     To support the dispatch over the qir-bridge, the clients must register their
-    Microsoft::Quantum::ISimulator* first.
+    Microsoft::Quantum::IRuntimeDriver* first.
 =============================================================================*/
 #include <cassert>
 #include <vector>
 
 #include "qsharp__core__qis.hpp"
 
-#include "QuantumApi_I.hpp"
+#include "QirRuntimeApi_I.hpp"
+#include "QSharpSimApi_I.hpp"
 #include "QirContext.hpp"
 #include "QirTypes.hpp"
 
@@ -29,14 +30,19 @@ static std::vector<PauliId> ExtractPauliIds(QirArray* paulis)
     return pauliIds;
 }
 
+static Microsoft::Quantum::IQuantumGateSet* GateSet()
+{
+    return dynamic_cast<Microsoft::Quantum::IQuantumGateSet*>(Microsoft::Quantum::GlobalContext()->driver);
+}
+
 extern "C"
 {
     void quantum__qis__exp__body(QirArray* paulis, double angle, QirArray* qubits)
     {
         assert(paulis->count == qubits->count);
 
         std::vector<PauliId> pauliIds = ExtractPauliIds(paulis);
-        return Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->Exp(
+        return GateSet()->Exp(
             paulis->count, reinterpret_cast<PauliId*>(pauliIds.data()), reinterpret_cast<Qubit*>(qubits->buffer),
             angle);
     }
@@ -51,7 +57,7 @@ extern "C"
         assert(paulis->count == qubits->count);
 
         std::vector<PauliId> pauliIds = ExtractPauliIds(paulis);
-        return Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledExp(
+        return GateSet()->ControlledExp(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), paulis->count,
             reinterpret_cast<PauliId*>(pauliIds.data()), reinterpret_cast<Qubit*>(qubits->buffer), angle);
     }
@@ -63,12 +69,12 @@ extern "C"
 
     void quantum__qis__h__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->H(qubit);
+        GateSet()->H(qubit);
     }
 
     void quantum__qis__h__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledH(
+        GateSet()->ControlledH(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
@@ -78,13 +84,13 @@ extern "C"
         assert(count == paulis->count);
 
         std::vector<PauliId> pauliIds = ExtractPauliIds(paulis);
-        return Microsoft::Quantum::GlobalContext()->simulator->Measure(
+        return GateSet()->Measure(
             count, reinterpret_cast<PauliId*>(pauliIds.data()), count, reinterpret_cast<Qubit*>(qubits->buffer));
     }
 
     void quantum__qis__r__body(PauliId axis, double angle, QUBIT* qubit)
     {
-        return Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->R(axis, qubit, angle);
+        return GateSet()->R(axis, qubit, angle);
     }
 
     void quantum__qis__r__adj(PauliId axis, double angle, QUBIT* qubit)
@@ -94,7 +100,7 @@ extern "C"
 
     void quantum__qis__r__ctl(QirArray* ctls, PauliId axis, double angle, QUBIT* qubit)
     {
-        return Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledR(
+        return GateSet()->ControlledR(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), axis, qubit, angle);
     }
 
@@ -105,78 +111,78 @@ extern "C"
 
     void quantum__qis__s__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->S(qubit);
+        GateSet()->S(qubit);
     }
 
     void quantum__qis__s__adj(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->AdjointS(qubit);
+        GateSet()->AdjointS(qubit);
     }
 
     void quantum__qis__s__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledS(
+        GateSet()->ControlledS(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__s__ctladj(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledAdjointS(
+        GateSet()->ControlledAdjointS(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__t__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->T(qubit);
+        GateSet()->T(qubit);
     }
 
     void quantum__qis__t__adj(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->AdjointT(qubit);
+        GateSet()->AdjointT(qubit);
     }
 
     void quantum__qis__t__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledT(
+        GateSet()->ControlledT(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__t__ctladj(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledAdjointT(
+        GateSet()->ControlledAdjointT(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__x__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->X(qubit);
+        GateSet()->X(qubit);
     }
 
     void quantum__qis__x__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledX(
+        GateSet()->ControlledX(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__y__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->Y(qubit);
+        GateSet()->Y(qubit);
     }
 
     void quantum__qis__y__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledY(
+        GateSet()->ControlledY(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 
     void quantum__qis__z__body(Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->Z(qubit);
+        GateSet()->Z(qubit);
     }
 
     void quantum__qis__z__ctl(QirArray* ctls, Qubit qubit)
     {
-        Microsoft::Quantum::GlobalContext()->simulator->AsQuantumGateSet()->ControlledZ(
+        GateSet()->ControlledZ(
             ctls->count, reinterpret_cast<Qubit*>(ctls->buffer), qubit);
     }
 }

src/QirRuntime/lib/Simulators/FullstateSimulator.cpp

@@ -9,7 +9,8 @@
 #include <memory>
 #include <vector>
 
-#include "QuantumApi_I.hpp"
+#include "QirRuntimeApi_I.hpp"
+#include "QSharpSimApi_I.hpp"
 #include "SimFactory.hpp"
 
 using namespace std;
@@ -78,7 +79,7 @@ namespace Microsoft
 namespace Quantum
 {
     // TODO: is it OK to load/unload the dll for each simulator instance?
-    class CFullstateSimulator : public ISimulator, public IQuantumGateSet, public IDiagnostics
+    class CFullstateSimulator : public IRuntimeDriver, public IQuantumGateSet, public IDiagnostics
     {
         typedef void (*TSingleQubitGate)(unsigned /*simulator id*/, unsigned /*qubit id*/);
         typedef void (*TSingleQubitControlledGate)(
@@ -170,15 +171,6 @@ namespace Quantum
             }
         }
 
-        IQuantumGateSet* AsQuantumGateSet() override
-        {
-            return this;
-        }
-        IDiagnostics* AsDiagnostics() override
-        {
-            return this;
-        }
-
         void GetState(TGetStateCallback callback) override
         {
             typedef bool (*TDump)(unsigned, TGetStateCallback);
@@ -210,13 +202,6 @@ namespace Quantum
             releaseQubit(this->simulatorId, GetQubitId(q));
         }
 
-        Result M(Qubit q) override
-        {
-            typedef unsigned (*TM)(unsigned, unsigned);
-            static TM m = reinterpret_cast<TM>(this->GetProc("M"));
-            return reinterpret_cast<Result>(m(this->simulatorId, GetQubitId(q)));
-        }
-
         Result Measure(long numBases, PauliId bases[], long numTargets, Qubit targets[]) override
         {
             assert(numBases == numTargets);
@@ -425,7 +410,7 @@ namespace Quantum
         }
     };
 
-    std::unique_ptr<ISimulator> CreateFullstateSimulator()
+    std::unique_ptr<IRuntimeDriver> CreateFullstateSimulator()
     {
         return std::make_unique<CFullstateSimulator>();
     }