Simulators/Core/Factory.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMULATORS_FACTORY_H_
#define _SIMULATORS_FACTORY_H_
 
#include "../DistributedGpu/DistributedGpuLibrary.h"
#include "../DistributedGpu/DistributedMpiGpuLibrary.h"
#include "../Gpu/GpuDensityMatrix.h"
#include "../Gpu/GpuLibMPSSim.h"
#include "../Gpu/GpuLibStateVectorSim.h"
#include "../Gpu/GpuLibTNSim.h"
#include "../Gpu/GpuMPO.h"
#include "../Gpu/GpuPauliPropagator.h"
#include "../Gpu/GpuStabilizer.h"
#include "../PathIntegral/PathIntegralSimulator.h"
#include "../Quest/QuestLibSim.h"
 
#include "../Interfaces/Simulator.h"
 
#ifdef _WIN32
#define MAESTRO_FACTORY_EXPORT __declspec(dllexport)
#else
#define MAESTRO_FACTORY_EXPORT
#endif
 
namespace Simulators
{

class SimulatorsFactory
{
  public:
    MAESTRO_FACTORY_EXPORT static std::shared_ptr<ISimulator> CreateSimulator(SimulatorType t = SimulatorType::kQCSim,
                                                                              SimulationType method = SimulationType::kMatrixProductState);

    MAESTRO_FACTORY_EXPORT static std::unique_ptr<ISimulator> CreateSimulatorUnique(SimulatorType t = SimulatorType::kQCSim,
                                                                                    SimulationType method = SimulationType::kMatrixProductState);
 
    // Concrete backends without a fusion adapter. Composite children use statevector.
    // The method is fixed for the lifetime of the returned object.
    MAESTRO_FACTORY_EXPORT static std::unique_ptr<ISimulator> CreateImmediateSimulatorUnique(SimulatorType type,
                                                                                             SimulationType method = SimulationType::kStatevector);
 
#ifdef __linux__
    // Defined in the core library so Python's hidden-visibility extension
    // shares the same plugin instances and native-state lifetime counters.
    static std::shared_ptr<DistributedGpuLibrary> GetDistributedGpuLibrary();
    static std::shared_ptr<DistributedMpiGpuLibrary> GetDistributedMpiGpuLibrary();
    static bool IsDistributedGpuAvailable() noexcept;
    static void FinalizeDistributedMpiGpuBackend();
    static bool InitGpuLibrary();
    static bool InitGpuLibraryWithMute();
 
    // Default for subsequently created simulators; explicit gpu_device wins.
    static void SelectGpuDevice(int deviceId);
    static int ResolveGpuDevice(int deviceId = -1);
    static int GetGpuDeviceCount();
    static bool IsGpuLibraryAvailable(int deviceId = -1);
    static std::shared_ptr<GpuLibrary> GetGpuLibrary(int deviceId = -1);
 
    // Legacy estimators construct simulators synchronously without accepting a
    // configuration map. Scope their default to the requesting network without
    // changing the process-wide default or another network's worker thread.
    class ScopedGpuDevice
    {
      public:
        explicit ScopedGpuDevice(int deviceId);
        ~ScopedGpuDevice();
        ScopedGpuDevice(const ScopedGpuDevice &) = delete;
        ScopedGpuDevice &operator=(const ScopedGpuDevice &) = delete;
 
      private:
        int previous;
    };
 
    static std::unique_ptr<GpuLibStateVectorSim> CreateGpuLibStateVectorSim(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
 
        return std::make_unique<GpuLibStateVectorSim>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::unique_ptr<GpuDensityMatrix> CreateGpuDensityMatrix(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->HasDensityMatrixAPI())
            return nullptr;
        return std::make_unique<GpuDensityMatrix>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::unique_ptr<GpuMPO> CreateGpuMPO(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->HasMPOAPI())
            return nullptr;
        return std::make_unique<GpuMPO>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::unique_ptr<GpuLibMPSSim> CreateGpuLibMPSSim(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
 
        return std::make_unique<GpuLibMPSSim>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::unique_ptr<GpuLibTNSim> CreateGpuLibTensorNetSim(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
 
        return std::make_unique<GpuLibTNSim>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::shared_ptr<GpuStabilizer> CreateGpuStabilizerSimulator(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
        return std::make_shared<GpuStabilizer>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::shared_ptr<GpuPauliPropagator> CreateGpuPauliPropagatorSimulator(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
        return std::make_shared<GpuPauliPropagator>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
    static std::unique_ptr<GpuPauliPropagator> CreateGpuPauliPropagatorSimulatorUnique(int deviceId = -1)
    {
        auto initializationLock = GpuLibrary::GetInstance()->LockInitialization();
        auto gpuLibrary = GetGpuLibrary(deviceId);
        if (!gpuLibrary || !gpuLibrary->IsValid())
            return nullptr;
        return std::make_unique<GpuPauliPropagator>(gpuLibrary, gpuLibrary->GetCreationDevice());
    }
 
  private:
    static std::atomic_int requestedGpuDeviceId;
    static thread_local int scopedGpuDeviceId;
 
  public:
#else
    static bool IsGpuLibraryAvailable(int = -1)
    {
        return false;
    }
 
    static bool InitGpuLibrary()
    {
        return false;
    }
 
    static void SelectGpuDevice(int)
    {
    }
 
    static int GetGpuDeviceCount()
    {
        return 0;
    }
#endif
    MAESTRO_FACTORY_EXPORT static bool InitQuestLibrary();
    MAESTRO_FACTORY_EXPORT static bool InitQuestLibraryWithMute();
    MAESTRO_FACTORY_EXPORT static bool IsQuestLibraryAvailable();
    MAESTRO_FACTORY_EXPORT static std::shared_ptr<QuestLibSim> GetQuestLibrary();
 
    static std::shared_ptr<PathIntegralSimulator> CreatePathIntegralSimulator()
    {
        return std::make_shared<PathIntegralSimulator>();
    }
 
  private:
    static std::shared_ptr<QuestLibSim> questLibrary;
    static std::atomic_bool firstTimeQuest;
};
 
} // namespace Simulators
 
#endif // !_SIMULATORS_FACTORY_H_