Factory.cpp

Go to the documentation of this file.

 
#define _CRT_SECURE_NO_WARNINGS 1
 
#ifndef NO_QISKIT_AER
#ifndef __APPLE__
#ifndef _QV_AVX2_IMPL
#define _QV_AVX2_IMPL
#pragma warning(push)
#pragma warning(disable : 4789)
#include "simulators/statevector/qv_avx2.cpp"
#pragma warning(pop)
#endif
#endif
#endif
 
#include "Factory.h"
#include "GpuLibraryRegistry.h"
 
#define INCLUDED_BY_FACTORY
#ifndef NO_QISKIT_AER
#include "AerSimulator.h"
#endif
#include "QCSimSimulator.h"
#include "Composite.h"
#include "GpuSimulator.h"
#include "DistributedGpuSimulator.h"
#include "QuestSimulator.h"
 
namespace Simulators {
 
#ifdef __linux__
std::atomic_int SimulatorsFactory::requestedGpuDeviceId{0};
thread_local int SimulatorsFactory::scopedGpuDeviceId = -1;
 
namespace {
GpuLibraryRegistry& GpuLibraries() {
  static GpuLibraryRegistry registry;
  return registry;
}
}
 
std::shared_ptr<DistributedGpuLibrary> SimulatorsFactory::GetDistributedGpuLibrary() {
  return DistributedGpuLibrary::GetInstance();
}
 
std::shared_ptr<DistributedGpuLibrary> DistributedGpuLibrary::GetInstance() {
  static auto lib = std::shared_ptr<DistributedGpuLibrary>(new DistributedGpuLibrary());
  return lib;
}
 
std::shared_ptr<DistributedMpiGpuLibrary> DistributedMpiGpuLibrary::GetInstance() {
  static auto lib = std::shared_ptr<DistributedMpiGpuLibrary>(new DistributedMpiGpuLibrary());
  return lib;
}
 
bool SimulatorsFactory::IsDistributedGpuAvailable() noexcept {
  try {
    auto lib = GetDistributedGpuLibrary();
    return lib->Load() && lib->GetGpuDeviceCount() > 0;
  } catch (...) {
    // Initialization still exposes the full diagnostic; discovery is a probe.
    return false;
  }
}
 
std::shared_ptr<DistributedMpiGpuLibrary> SimulatorsFactory::GetDistributedMpiGpuLibrary() {
  return DistributedMpiGpuLibrary::GetInstance();
}
 
void SimulatorsFactory::FinalizeDistributedMpiGpuBackend() {
  DistributedMpiGpuLibrary::GetInstance()->FinalizeBackend();
}
 
void SimulatorsFactory::SelectGpuDevice(int deviceId) {
  if (deviceId < 0) throw std::invalid_argument("gpu_device must be nonnegative");
  requestedGpuDeviceId = deviceId;
}
 
int SimulatorsFactory::ResolveGpuDevice(int deviceId) {
  if (deviceId >= 0) return deviceId;
  if (scopedGpuDeviceId >= 0) return scopedGpuDeviceId;
  return requestedGpuDeviceId.load();
}
 
SimulatorsFactory::ScopedGpuDevice::ScopedGpuDevice(int deviceId)
    : previous(scopedGpuDeviceId) {
  scopedGpuDeviceId = ResolveGpuDevice(deviceId);
}
SimulatorsFactory::ScopedGpuDevice::~ScopedGpuDevice() {
  scopedGpuDeviceId = previous;
}
 
std::shared_ptr<GpuLibrary> SimulatorsFactory::GetGpuLibrary(int deviceId) {
  return GpuLibraries().Acquire(ResolveGpuDevice(deviceId));
}
 
bool SimulatorsFactory::InitGpuLibrary() {
  return bool(GetGpuLibrary());
}
 
bool SimulatorsFactory::InitGpuLibraryWithMute() {
  return bool(GpuLibraries().Acquire(ResolveGpuDevice(), true));
}
 
int SimulatorsFactory::GetGpuDeviceCount() {
  return GpuLibraries().DeviceCount();
}
 
bool SimulatorsFactory::IsGpuLibraryAvailable(int deviceId) {
  return bool(GpuLibraries().Acquire(ResolveGpuDevice(deviceId), true));
}
 
#endif
 
std::shared_ptr<QuestLibSim> SimulatorsFactory::questLibrary = nullptr;
std::atomic_bool SimulatorsFactory::firstTimeQuest = true;
 
bool SimulatorsFactory::InitQuestLibrary() {
  if (!questLibrary) {
    questLibrary = std::make_shared<QuestLibSim>();
    if (!firstTimeQuest.exchange(false)) questLibrary->SetMute(true);
    if (questLibrary->Init(
#ifdef _WIN32
            "maestroquest.dll"
#elif defined(__APPLE__)
            "libmaestroquest.dylib"
#else
            "libmaestroquest.so"
#endif
            ))
      return true;
    else
      questLibrary = nullptr;
  }
  return false;
}
 
bool SimulatorsFactory::InitQuestLibraryWithMute() {
  if (!questLibrary) {
    questLibrary = std::make_shared<QuestLibSim>();
    firstTimeQuest = false;
    questLibrary->SetMute(true);
    if (questLibrary->Init(
#ifdef _WIN32
            "maestroquest.dll"
#elif defined(__APPLE__)
            "libmaestroquest.dylib"
#else
            "libmaestroquest.so"
#endif
            ))
      return true;
    else
      questLibrary = nullptr;
  }
  return false;
}
 
std::shared_ptr<ISimulator> SimulatorsFactory::CreateSimulator(
    SimulatorType t, SimulationType m) {
  switch (t) {
    case SimulatorType::kQCSim: {
      auto sim = std::make_shared<Private::QCSimSimulator>();
      if (m == SimulationType::kMatrixProductState)
        sim->Configure("method", "matrix_product_state");
      else if (m == SimulationType::kMatrixProductOperator)
        sim->Configure("method", "matrix_product_operator");
      else if (m == SimulationType::kStabilizer)
        sim->Configure("method", "stabilizer");
      else if (m == SimulationType::kTensorNetwork)
        sim->Configure("method", "tensor_network");
      else if (m == SimulationType::kPauliPropagator)
        sim->Configure("method", "pauli_propagator");
      else if (m == SimulationType::kPathIntegral)
        sim->Configure("method", "path_integral");
      else if (m == SimulationType::kDensityMatrix)
        sim->Configure("method", "density_matrix");
      else if (m == SimulationType::kExtendedStabilizer)
        sim->Configure("method", "extended_stabilizer");
      else if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Simulation Type not supported for QCSim");
 
      return sim;
    }
#ifndef NO_QISKIT_AER
    case SimulatorType::kQiskitAer: {
      auto sim = std::make_shared<Private::AerSimulator>();
      if (m == SimulationType::kMatrixProductState)
        sim->Configure("method", "matrix_product_state");
      else if (m == SimulationType::kStabilizer)
        sim->Configure("method", "stabilizer");
      else if (m == SimulationType::kTensorNetwork)
        sim->Configure("method", "tensor_network");
      else if (m == SimulationType::kExtendedStabilizer)
        sim->Configure("method", "extended_stabilizer");
      else if (m == SimulationType::kDensityMatrix)
        sim->Configure("method", "density_matrix");
      else if (m == SimulationType::kStatevector)
        sim->Configure("method", "statevector");
      else
        throw std::invalid_argument(
            "Simulation Type not supported for Qiskit Aer");
 
      return sim;
    }
    case SimulatorType::kCompositeQiskitAer:
      return std::make_shared<Private::CompositeSimulator>(
          SimulatorType::kQiskitAer);
#endif
    case SimulatorType::kCompositeQCSim:
      return std::make_shared<Private::CompositeSimulator>(
          SimulatorType::kQCSim);
#ifdef __linux__
    case SimulatorType::kDistGpuSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Distributed GPU supports only statevector");
      return std::make_shared<Private::DistributedGpuSimulator>();
    case SimulatorType::kDistMpiGpuSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Distributed MPI GPU supports only statevector");
      return std::make_shared<Private::DistributedMpiGpuSimulator>();
 
    case SimulatorType::kGpuSim:
      // Discovery does not initialize a device: configuration follows creation.
      if (GetGpuDeviceCount() == 0) return nullptr;
      if ((m == SimulationType::kStatevector ||
           m == SimulationType::kMatrixProductState ||
           m == SimulationType::kDensityMatrix ||
           m == SimulationType::kMatrixProductOperator ||
           m == SimulationType::kTensorNetwork ||
           m == SimulationType::kPauliPropagator)) {
        auto sim = std::make_shared<Private::GpuSimulator>();
        sim->Configure("gpu_device", std::to_string(ResolveGpuDevice()).c_str());
        if (m == SimulationType::kMatrixProductState)
          sim->Configure("method", "matrix_product_state");
        else if (m == SimulationType::kMatrixProductOperator)
          sim->Configure("method", "matrix_product_operator");
        else if (m == SimulationType::kTensorNetwork)
          sim->Configure("method", "tensor_network");
        else if (m == SimulationType::kPauliPropagator)
          sim->Configure("method", "pauli_propagator");
        else if (m == SimulationType::kStatevector)
          sim->Configure("method", "statevector");
        else if (m == SimulationType::kDensityMatrix)
          sim->Configure("method", "density_matrix");
 
        return sim;
      }
 
      return nullptr;
#endif
    case SimulatorType::kQuestSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument(
            "Simulation Type not supported for Quest Simulator");
      else if (questLibrary && questLibrary->IsValid()) {
        return std::make_shared<Private::QuestSimulator>();
      }
      return nullptr;
    default:
      break;
  }
 
  throw std::invalid_argument("Simulator Type not supported");
 
  return nullptr;  // keep compillers happy
}
 
std::unique_ptr<ISimulator> SimulatorsFactory::CreateSimulatorUnique(
    SimulatorType t, SimulationType m) {
  switch (t) {
    case SimulatorType::kQCSim: {
      auto sim = std::make_unique<Private::QCSimSimulator>();
      if (m == SimulationType::kMatrixProductState)
        sim->Configure("method", "matrix_product_state");
      else if (m == SimulationType::kMatrixProductOperator)
        sim->Configure("method", "matrix_product_operator");
      else if (m == SimulationType::kStabilizer)
        sim->Configure("method", "stabilizer");
      else if (m == SimulationType::kTensorNetwork)
        sim->Configure("method", "tensor_network");
      else if (m == SimulationType::kPauliPropagator)
        sim->Configure("method", "pauli_propagator");
      else if (m == SimulationType::kPathIntegral)
        sim->Configure("method", "path_integral");
      else if (m == SimulationType::kDensityMatrix)
        sim->Configure("method", "density_matrix");
      else if (m == SimulationType::kExtendedStabilizer)
        sim->Configure("method", "extended_stabilizer");
      else if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Simulation Type not supported for QCSim");
 
      return sim;
    }
#ifndef NO_QISKIT_AER
    case SimulatorType::kQiskitAer: {
      auto sim = std::make_unique<Private::AerSimulator>();
      if (m == SimulationType::kMatrixProductState)
        sim->Configure("method", "matrix_product_state");
      else if (m == SimulationType::kStabilizer)
        sim->Configure("method", "stabilizer");
      else if (m == SimulationType::kTensorNetwork)
        sim->Configure("method", "tensor_network");
      else if (m == SimulationType::kExtendedStabilizer)
        sim->Configure("method", "extended_stabilizer");
      else if (m == SimulationType::kDensityMatrix)
        sim->Configure("method", "density_matrix");
      else if (m == SimulationType::kStatevector)
        sim->Configure("method", "statevector");
      else
        throw std::invalid_argument(
            "Simulation Type not supported for Qiskit Aer");
 
      return sim;
    }
    case SimulatorType::kCompositeQiskitAer:
      return std::make_unique<Private::CompositeSimulator>(
          SimulatorType::kQiskitAer);
#endif
    case SimulatorType::kCompositeQCSim:
      return std::make_unique<Private::CompositeSimulator>(
          SimulatorType::kQCSim);
#ifdef __linux__
    case SimulatorType::kDistGpuSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Distributed GPU supports only statevector");
      return std::make_unique<Private::DistributedGpuSimulator>();
    case SimulatorType::kDistMpiGpuSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument("Distributed MPI GPU supports only statevector");
      return std::make_unique<Private::DistributedMpiGpuSimulator>();
 
    case SimulatorType::kGpuSim:
      // Discovery does not initialize a device: configuration follows creation.
      if (GetGpuDeviceCount() == 0) return nullptr;
      if ((m == SimulationType::kStatevector ||
           m == SimulationType::kMatrixProductState ||
           m == SimulationType::kDensityMatrix ||
           m == SimulationType::kMatrixProductOperator ||
           m == SimulationType::kTensorNetwork ||
           m == SimulationType::kPauliPropagator)) {
        auto sim = std::make_unique<Private::GpuSimulator>();
        sim->Configure("gpu_device", std::to_string(ResolveGpuDevice()).c_str());
        if (m == SimulationType::kMatrixProductState)
          sim->Configure("method", "matrix_product_state");
        else if (m == SimulationType::kMatrixProductOperator)
          sim->Configure("method", "matrix_product_operator");
        else if (m == SimulationType::kTensorNetwork)
          sim->Configure("method", "tensor_network");
        else if (m == SimulationType::kPauliPropagator)
          sim->Configure("method", "pauli_propagator");
        else if (m == SimulationType::kStatevector)
          sim->Configure("method", "statevector");
        else if (m == SimulationType::kDensityMatrix)
          sim->Configure("method", "density_matrix");
 
        return sim;
      }
 
      return nullptr;
#endif
    case SimulatorType::kQuestSim:
      if (m != SimulationType::kStatevector)
        throw std::invalid_argument(
            "Simulation Type not supported for Quest Simulator");
      else if (questLibrary && questLibrary->IsValid()) {
        return std::make_unique<Private::QuestSimulator>();
      }
      return nullptr;
    default:
      break;
  }
 
  throw std::invalid_argument("Simulator Type not supported");
 
  return nullptr;  // keep compillers happy
}
}  // namespace Simulators