Maestro.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef MAESTRO_ENABLE_COMPOSER
#include <composer/Network/SimpleFullyConnectedNetwork.h>
#else
#include "../Network/SimpleDisconnectedNetwork.h"
#endif
 
#include "../Simulators/Core/Factory.h"
 
class Maestro
{
  public:
    Maestro() = default;
    ~Maestro() = default;
 
    // Add methods to expose functionality to Maestro here.
    // For example, methods to create circuits, simulators, run simulations, etc.
    unsigned long int CreateSimpleSimulator(int nrQubits, int nrCbits = -1)
    {
        if (nrQubits <= 0)
            return 0;
 
        const std::vector<Types::qubit_t> qubits{static_cast<Types::qubit_t>(nrQubits)};
        const std::vector<size_t> cbits{static_cast<size_t>(nrCbits < 0 ? nrQubits : nrCbits)};
 
#ifdef MAESTRO_ENABLE_COMPOSER
        auto network = std::make_shared<Network::SimpleNetwork<>>(qubits, cbits);
#else
        auto network = std::make_shared<Network::SimpleDisconnectedNetwork<>>(qubits, cbits);
#endif
 
        // lock the mutex to safely add the simulator
        std::lock_guard<std::mutex> lock(simpleSimulatorsMutex);
 
        if (curHandle == std::numeric_limits<unsigned long int>::max())
        {
            // Handle overflow, reset to 0
            curHandle = 0;
        }
        const unsigned long int handle = ++curHandle;
 
        simpleSimulators[handle] = network;
 
        return handle;
    }
 
    void DestroySimpleSimulator(unsigned long int simHandle)
    {
        std::lock_guard<std::mutex> lock(simpleSimulatorsMutex);
 
        simpleSimulators.erase(simHandle);
    }
 
    std::shared_ptr<Network::INetwork<>> GetSimpleSimulator(unsigned long int simHandle)
    {
        std::lock_guard<std::mutex> lock(simpleSimulatorsMutex);
        auto it = simpleSimulators.find(simHandle);
        if (it != simpleSimulators.end())
            return it->second;
 
        return nullptr;
    }
 
    int RemoveAllOptimizationSimulatorsAndAdd(unsigned long int simHandle, Simulators::SimulatorType simType, Simulators::SimulationType simExecType)
    {
        auto sim = GetSimpleSimulator(simHandle);
        if (!sim)
            return 0;
 
        sim->RemoveAllOptimizationSimulatorsAndAdd(simType, simExecType);
 
        return 1;
    }
 
    int AddOptimizationSimulator(unsigned long int simHandle, Simulators::SimulatorType simType, Simulators::SimulationType simExecType)
    {
        auto sim = GetSimpleSimulator(simHandle);
        if (!sim)
            return 0;
        sim->AddOptimizationSimulator(simType, simExecType);
        return 1;
    }
 
    unsigned long int CreateSimulator(Simulators::SimulatorType simType = Simulators::SimulatorType::kQCSim,
                                      Simulators::SimulationType simExecType = Simulators::SimulationType::kMatrixProductState)
    {
        auto simulator = Simulators::SimulatorsFactory::CreateSimulator(simType, simExecType);
 
        std::lock_guard<std::mutex> lock(simulatorsMutex);
        if (curSimulatorHandle == std::numeric_limits<unsigned long int>::max())
        {
            // Handle overflow, reset to 0
            curSimulatorHandle = 0;
        }
        const unsigned long int handle = ++curSimulatorHandle;
 
        simulators[handle] = simulator;
 
        return handle;
    }
 
    void *GetSimulator(unsigned long int simHandle)
    {
        std::lock_guard<std::mutex> lock(simulatorsMutex);
        auto it = simulators.find(simHandle);
        if (it != simulators.end())
            return it->second.get();
 
        return nullptr;
    }
 
    void DestroySimulator(unsigned long int simHandle)
    {
        std::lock_guard<std::mutex> lock(simulatorsMutex);
        simulators.erase(simHandle);
    }
 
  private:
    // allow multithreaded access
    std::mutex simpleSimulatorsMutex;
    std::mutex simulatorsMutex;
 
    std::unordered_map<unsigned long int, std::shared_ptr<Network::INetwork<>>> simpleSimulators; // map for network simulators
    std::unordered_map<unsigned long int, std::shared_ptr<Simulators::ISimulator>> simulators;    // map for simulators
 
    unsigned long int curHandle = 0;
    unsigned long int curSimulatorHandle = 0; // current handle for simulators
};