Network.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _NETWORK_INTERFACE_H_
#define _NETWORK_INTERFACE_H_
 
#include <boost/container_hash/hash.hpp>
#include <complex>
#include <memory>
#include <unordered_set>
#include <vector>
 
#include "../Circuit/Circuit.h"
#include "../Simulators/Core/Factory.h"
#include "Controller.h"
 
namespace Network
{

enum class NetworkType
{
    kSimpleDisconnectedNetwork, 
    kSimpleNetwork,             
    kSimpleDESNetwork,          
    kNetqasmNetwork,            
    kNetqasmDESNetwork          
};

template <typename Time = Types::time_type> class INetwork : public std::enable_shared_from_this<INetwork<Time>>
{
  public:
    using ExecuteResults = typename Circuits::Circuit<Time>::ExecuteResults;
    using SimulatorPair = std::pair<Simulators::SimulatorType, Simulators::SimulationType>;
    using SimulatorsSet = std::unordered_set<SimulatorPair, boost::hash<SimulatorPair>>;

    virtual ~INetwork() = default;

    virtual size_t GetNumberOfGatesDistributedOrCut(const std::shared_ptr<Circuits::Circuit<Time>> &circuit) const = 0;

    virtual void Execute(const std::shared_ptr<Circuits::Circuit<Time>> &circuit) = 0;

    virtual void ExecuteOnHost(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t hostId) = 0;

    virtual std::vector<double> ExecuteExpectations(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, const std::vector<std::string> &paulis) = 0;

    virtual std::vector<double> ExecuteOnHostExpectations(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t hostId,
                                                          const std::vector<std::string> &paulis) = 0;

    virtual std::vector<std::complex<double>> ExecuteOnHostAmplitudes(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t hostId) = 0;

    virtual std::complex<double> ExecuteOnHostProjectOnZero(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t hostId) = 0;

    virtual ExecuteResults RepeatedExecute(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t shots = 1000) = 0;

    ExecuteResults RepeatedExecuteCircuit(const Schedulers::ExecuteCircuit<Time> &executeCircuit)
    {
        return RepeatedExecute(executeCircuit.circuit, executeCircuit.shots);
    }

    virtual ExecuteResults RepeatedExecuteOnHost(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t hostId, size_t shots = 1000) = 0;

    ExecuteResults RepeatedExecuteCircuitOnHost(const Schedulers::ExecuteCircuit<Time> &executeCircuit, size_t hostId)
    {
        return RepeatedExecuteOnHost(executeCircuit.circuit, hostId, executeCircuit.shots);
    }

    virtual std::vector<ExecuteResults> ExecuteScheduled(const std::vector<Schedulers::ExecuteCircuit<Time>> &circuits) = 0;

    virtual void CreateSimulator(Simulators::SimulatorType simType = Simulators::SimulatorType::kQCSim,
                                 Simulators::SimulationType simExecType = Simulators::SimulationType::kMatrixProductState, size_t nrQubits = 0) = 0;

    virtual std::shared_ptr<Simulators::ISimulator> GetSimulator() const = 0;
 
    // Actual device of the current simulator, or -1 if no GPU state exists.
    virtual int GetGpuDevice() const
    {
        const auto sim = GetSimulator();
        return sim ? sim->GetGpuDevice() : -1;
    }

    virtual void Configure(const char *key, const char *value) = 0;

    virtual void CreateScheduler(SchedulerType schType = SchedulerType::kNoEntanglementQubitsParallel) = 0;

    virtual std::shared_ptr<Schedulers::IScheduler<Time>> GetScheduler() const = 0;

    virtual const std::shared_ptr<IHost<Time>> GetHost(size_t hostId) const = 0;

    virtual const std::shared_ptr<IController<Time>> GetController() const = 0;

    virtual Circuits::OperationState &GetState() = 0;

    virtual size_t GetNumHosts() const = 0;

    virtual size_t GetNumQubits() const = 0;

    virtual size_t GetNumQubitsForHost(size_t hostId) const = 0;

    virtual size_t GetNumNetworkEntangledQubits() const = 0;

    virtual size_t GetNumNetworkEntangledQubitsForHost(size_t hostId) const = 0;

    virtual size_t GetNumClassicalBits() const = 0;

    virtual size_t GetNumClassicalBitsForHost(size_t hostId) const = 0;

    virtual bool AreQubitsOnSameHost(size_t qubitId1, size_t qubitId2) const = 0;

    virtual bool AreClassicalBitsOnSameHost(size_t bitId1, size_t bitId2) const = 0;

    virtual bool AreQubitAndClassicalBitOnSameHost(size_t qubitId, size_t bitId) const = 0;

    virtual size_t GetHostIdForQubit(size_t qubitId) const = 0;

    virtual size_t GetHostIdForEntangledQubit(size_t qubitId) const = 0;

    virtual size_t GetHostIdForAnyQubit(size_t qubitId) const = 0;

    virtual size_t GetHostIdForClassicalBit(size_t classicalBitId) const = 0;

    virtual std::vector<size_t> GetQubitsIds(size_t hostId) const = 0;

    virtual std::vector<size_t> GetNetworkEntangledQubitsIds(size_t hostId) const = 0;

    virtual std::vector<size_t> GetClassicalBitsIds(size_t hostId) const = 0;

    virtual std::vector<size_t> GetEntangledQubitMeasurementBitIds(size_t hostId) const = 0;

    virtual bool IsNetworkEntangledQubit(size_t qubitId) const = 0;

    virtual bool IsLocalOperation(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual bool IsDistributedOperation(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual bool OperatesWithNetworkEntangledQubit(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual bool SendPacket(size_t fromHostId, size_t toHostId, const std::vector<uint8_t> &packet) = 0;

    virtual bool IsEntanglingGate(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual bool ExpectsClassicalBitFromOtherHost(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual size_t GetHostIdForClassicalControl(const std::shared_ptr<Circuits::IOperation<Time>> &op) const = 0;

    virtual bool IsEntanglementQubitBusy(size_t qubitId) const = 0;

    virtual bool AreEntanglementQubitsBusy(size_t qubitId1, size_t qubitId2) const = 0;

    virtual void MarkEntangledQubitsBusy(size_t qubitId1, size_t qubitId2) = 0;

    virtual void MarkEntangledQubitFree(size_t qubitId) = 0;

    virtual void ClearEntanglements() = 0;

    std::shared_ptr<INetwork<Time>> getptr()
    {
        return std::enable_shared_from_this<INetwork<Time>>::shared_from_this();
    }

    virtual NetworkType GetType() const = 0;

    virtual std::shared_ptr<INetwork<Time>> Clone() const = 0;

    virtual std::shared_ptr<Circuits::Circuit<Time>> GetDistributedCircuit() const = 0;

    virtual void SetOptimizeSimulator(bool optimize = true) = 0;

    virtual bool GetOptimizeSimulator() const = 0;

    virtual Simulators::SimulatorType GetLastSimulatorType() const = 0;
 
    // Device used by the last execution, which may differ from a recreated simulator.
    virtual int GetLastGpuDevice() const
    {
        return -1;
    }
 
    virtual unsigned GetLastGateFusionMaxQubits() const
    {
        return 0;
    }
 
    virtual bool WasGateFusionEnabled() const
    {
        return false;
    }
 
    // Requested setting, independent of the selected backend capability.
    virtual bool GetGateFusion() const
    {
        return true;
    }

    virtual Simulators::SimulationType GetLastSimulationType() const = 0;

    virtual const SimulatorsSet &GetSimulatorsSet() const = 0;

    virtual void AddOptimizationSimulator(Simulators::SimulatorType type, Simulators::SimulationType kind) = 0;

    virtual void RemoveOptimizationSimulator(Simulators::SimulatorType type, Simulators::SimulationType kind) = 0;

    virtual void RemoveAllOptimizationSimulatorsAndAdd(Simulators::SimulatorType type, Simulators::SimulationType kind) = 0;

    virtual bool OptimizationSimulatorExists(Simulators::SimulatorType type, Simulators::SimulationType kind) const = 0;

    virtual size_t GetMaxSimulators() const = 0;

    virtual void SetMaxSimulators(size_t maxSimulators) = 0;

    virtual std::vector<std::vector<std::string>> GetSubroutinesTextCode() const
    {
        return {};
    }

    virtual std::shared_ptr<Simulators::ISimulator> ChooseBestSimulator(std::shared_ptr<Circuits::Circuit<Time>> &dcirc, size_t &counts, size_t nrQubits,
                                                                        size_t nrCbits, size_t nrResultCbits, Simulators::SimulatorType &simType,
                                                                        Simulators::SimulationType &method, std::vector<bool> &executed,
                                                                        bool multithreading = false, bool dontRunCircuitStart = false) = 0;
 
    virtual void SetInitialQubitsMapOptimization(bool optimize = true) = 0;
 
    virtual bool GetInitialQubitsMapOptimization() const = 0;
 
    virtual void SetMPSOptimizeSwaps(bool optimize = true) = 0;
 
    virtual bool GetMPSOptimizeSwaps() const = 0;
 
    virtual void SetMPSOptimizationBondDimensionThreshold(size_t threshold) = 0;
 
    virtual size_t GetMPSOptimizationBondDimensionThreshold() const = 0;
 
    virtual void SetMPSOptimizationQubitsNumberThreshold(size_t threshold) = 0;
 
    virtual size_t GetMPSOptimizationQubitsNumberThreshold() const = 0;
 
    virtual void SetLookaheadDepth(int depth) = 0;
 
    virtual int GetLookaheadDepth() const = 0;
 
    virtual void SetLookaheadDepthWithHeuristic(int depth) = 0;
 
    virtual int GetLookaheadDepthWithHeuristic() const = 0;
 
    virtual double getGrowthFactorSwap() const
    {
        return 0.;
    }
 
    virtual double getGrowthFactorGate() const
    {
        return 0.;
    }
 
    virtual void setGrowthFactorSwap(double factor)
    {
    }
 
    virtual void setGrowthFactorGate(double factor)
    {
    }

    virtual size_t GetCurrentMaxBondDimension() const
    {
        return 0;
    }
};
 
} // namespace Network
 
#endif // !_NETWORK_INTERFACE_H_