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 <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 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(const 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;
};
 
} // namespace Network
 
#endif // !_NETWORK_INTERFACE_H_