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/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;
 
  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;
 
  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) const = 0;
 
 
  virtual void SetInitialQubitsMapOptimization(bool optimize = true) = 0;
 
  virtual bool GetInitialQubitsMapOptimization() 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;
};
 
}  // namespace Network
 
#endif  // !_NETWORK_INTERFACE_H_