GpuLibTNSim.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _GPU_LIB_TN_SIM_H_
#define _GPU_LIB_TN_SIM_H_
 
#ifdef __linux__
 
#include <memory>
 
#include "GpuDeviceContext.h"
 
namespace Simulators {
 
class GpuLibTNSim {
 public:
  explicit GpuLibTNSim(const std::shared_ptr<GpuLibrary>& lib, int device = -1)
      : lib(lib), obj(nullptr) {
    if (lib) {
      auto lock = lib->LockInitialization();
      if (lib->SetGpuDevice(device == -1 ? lib->GetCreationDevice() : device))
        obj = lib->CreateTensorNet();
    }
  }
 
  int GetGpuDevice() const { return lib ? lib->TNGetGpuId(obj) : -1; }
 
  GpuLibTNSim(const std::shared_ptr<GpuLibrary> &lib, void *obj)
      : lib(lib), obj(obj) {}
 
  GpuLibTNSim() = delete;
  GpuLibTNSim(const GpuLibTNSim &) = delete;
  GpuLibTNSim &operator=(const GpuLibTNSim &) = delete;
  GpuLibTNSim(GpuLibTNSim &&) = default;
  GpuLibTNSim &operator=(GpuLibTNSim &&) = default;
 
  ~GpuLibTNSim() {
    if (lib && obj) lib->DestroyTensorNet(obj);
  }
 
  bool Create(unsigned int nrQubits) {
    if (obj) return lib->TNCreate(obj, nrQubits);
 
    return false;
  }
 
  bool Reset() {
    if (obj) return lib->TNReset(obj);
 
    return false;
  }
 
  bool SetSeed(uint64_t seed) { return obj && lib->TNSetSeed(obj, seed); }
 
  bool IsValid() const {
    if (obj) return lib->TNIsValid(obj);
 
    return false;
  }
 
  bool IsCreated() const {
    if (obj) return lib->TNIsCreated(obj);
 
    return false;
  }
 
  bool SetDataType(int useDoublePrecision) {
    if (obj) return lib->TNSetDataType(obj, useDoublePrecision);
 
    return false;
  }
 
  bool IsDoublePrecision() const {
    if (obj) return lib->TNIsDoublePrecision(obj);
 
    return false;
  }
 
  bool SetCutoff(double val) {
    if (obj) return lib->TNSetCutoff(obj, val);
 
    return false;
  }
 
  double GetCutoff() const {
    if (obj) return lib->TNGetCutoff(obj);
 
    return 0.;
  }
 
  // mode: 0 = RelativeToMax, 1 = DiscardedWeight (default). See
  // TruncationMode in the GPU library's lib/truncationmode.hpp.
  bool SetTruncationMode(int mode) {
    if (obj) return lib->TNSetTruncationMode(obj, mode);
 
    return false;
  }
 
  int GetTruncationMode() const {
    if (obj) return lib->TNGetTruncationMode(obj);
 
    return 0;
  }
 
  bool SetGesvdJ(int val) {
    if (obj) return lib->TNSetGesvdJ(obj, val);
 
    return false;
  }
 
  bool GetGesvdJ() const {
    if (obj) return lib->TNGetGesvdJ(obj);
 
    return false;
  }
 
  // Enabling any of J/P/R clears the other two selectors in the plugin.
  bool SetGesvdP(bool enable) {
    return obj && lib->TNSetGesvdP(obj, enable);
  }
  bool GetGesvdP() const { return lib->TNGetGesvdP(obj); }
  bool SetGesvdR(bool enable) {
    return obj && lib->TNSetGesvdR(obj, enable);
  }
  bool GetGesvdR() const { return lib->TNGetGesvdR(obj); }
 
  bool SetMaxExtent(long int val) {
    if (obj) return lib->TNSetMaxExtent(obj, val);
 
    return false;
  }
 
  long int GetMaxExtent() const {
    if (obj) return lib->TNGetMaxExtent(obj);
 
    return 0;
  }
 
  int GetNrQubits() const {
    if (obj) return lib->TNGetNrQubits(obj);
 
    return 0;
  }
 
  bool Amplitude(long int numFixedValues, long int *fixedValues, double *real,
                 double *imaginary) const {
    if (obj)
      return lib->TNAmplitude(obj, numFixedValues, fixedValues, real,
                              imaginary);
 
    return false;
  }
 
  double Probability0(unsigned int qubit) const {
    if (obj) return lib->TNProbability0(obj, qubit);
 
    return 0.;
  }
 
  bool Measure(unsigned int qubit) {
    if (obj) return lib->TNMeasure(obj, qubit);
 
    return 0;
  }
 
  bool MeasureQubits(long int numQubits, unsigned int *qubits, int *result) {
    if (obj) return lib->TNMeasureQubits(obj, numQubits, qubits, result);
 
    return false;
  }
 
  std::unordered_map<std::vector<bool>, int64_t> *GetMapForSample() const {
    if (lib) return lib->TNGetMapForSample();
 
    return nullptr;
  }
 
  bool FreeMapForSample(
      std::unordered_map<std::vector<bool>, int64_t> *map) const {
    if (lib) return lib->TNFreeMapForSample(map);
 
    return false;
  }
 
  bool Sample(long int numShots, long int numQubits, unsigned int *qubits,
              void *resultMap) {
    if (obj) return lib->TNSample(obj, numShots, numQubits, qubits, resultMap);
 
    return false;
  }
 
  bool SaveState() {
    if (obj) return lib->TNSaveState(obj);
 
    return false;
  }
 
  bool RestoreState() {
    if (obj) return lib->TNRestoreState(obj);
 
    return false;
  }
 
  bool CleanSavedState() {
    if (obj) return lib->TNCleanSavedState(obj);
 
    return false;
  }
 
  std::unique_ptr<GpuLibTNSim> Clone() const {
    // if (obj) return std::make_unique<GpuLibTNSim>(lib, lib->TNClone(obj));
 
    return nullptr;
  }
 
  double ExpectationValue(const std::string &pauliString) const {
    if (obj)
      return lib->TNExpectationValue(obj, pauliString.c_str(),
                                     pauliString.length());
 
    return 0.0;
  }
 
  bool ApplyX(unsigned int siteA) {
    if (obj) return lib->TNApplyX(obj, siteA);
 
    return false;
  }
 
  bool ApplyY(unsigned int siteA) {
    if (obj) return lib->TNApplyY(obj, siteA);
 
    return false;
  }
 
  bool ApplyZ(unsigned int siteA) {
    if (obj) return lib->TNApplyZ(obj, siteA);
 
    return false;
  }
 
  bool ApplyH(unsigned int siteA) {
    if (obj) return lib->TNApplyH(obj, siteA);
 
    return false;
  }
 
  bool ApplyS(unsigned int siteA) {
    if (obj) return lib->TNApplyS(obj, siteA);
 
    return false;
  }
 
  bool ApplySDG(unsigned int siteA) {
    if (obj) return lib->TNApplySDG(obj, siteA);
 
    return false;
  }
 
  bool ApplyT(unsigned int siteA) {
    if (obj) return lib->TNApplyT(obj, siteA);
 
    return false;
  }
 
  bool ApplyTDG(unsigned int siteA) {
    if (obj) return lib->TNApplyTDG(obj, siteA);
 
    return false;
  }
 
  bool ApplySX(unsigned int siteA) {
    if (obj) return lib->TNApplySX(obj, siteA);
 
    return false;
  }
 
  bool ApplySXDG(unsigned int siteA) {
    if (obj) return lib->TNApplySXDG(obj, siteA);
 
    return false;
  }
 
  bool ApplyK(unsigned int siteA) {
    if (obj) return lib->TNApplyK(obj, siteA);
 
    return false;
  }
 
  bool ApplyP(unsigned int siteA, double theta) {
    if (obj) return lib->TNApplyP(obj, siteA, theta);
 
    return false;
  }
 
  bool ApplyRx(unsigned int siteA, double theta) {
    if (obj) return lib->TNApplyRx(obj, siteA, theta);
 
    return false;
  }
 
  bool ApplyRy(unsigned int siteA, double theta) {
    if (obj) return lib->TNApplyRy(obj, siteA, theta);
 
    return false;
  }
 
  bool ApplyRz(unsigned int siteA, double theta) {
    if (obj) return lib->TNApplyRz(obj, siteA, theta);
 
    return false;
  }
 
  bool ApplyU(unsigned int siteA, double theta, double phi, double lambda,
              double gamma) {
    if (obj) return lib->TNApplyU(obj, siteA, theta, phi, lambda, gamma);
 
    return false;
  }
 
  bool ApplySwap(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplySwap(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCX(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCX(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCY(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCY(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCZ(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCZ(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCH(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCH(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCSX(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCSX(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCSXDG(unsigned int controlQubit, unsigned int targetQubit) {
    if (obj) return lib->TNApplyCSXDG(obj, controlQubit, targetQubit);
 
    return false;
  }
 
  bool ApplyCP(unsigned int controlQubit, unsigned int targetQubit,
               double theta) {
    if (obj) return lib->TNApplyCP(obj, controlQubit, targetQubit, theta);
 
    return false;
  }
 
  bool ApplyCRx(unsigned int controlQubit, unsigned int targetQubit,
                double theta) {
    if (obj) return lib->TNApplyCRx(obj, controlQubit, targetQubit, theta);
 
    return false;
  }
 
  bool ApplyCRy(unsigned int controlQubit, unsigned int targetQubit,
                double theta) {
    if (obj) return lib->TNApplyCRy(obj, controlQubit, targetQubit, theta);
 
    return false;
  }
 
  bool ApplyCRz(unsigned int controlQubit, unsigned int targetQubit,
                double theta) {
    if (obj) return lib->TNApplyCRz(obj, controlQubit, targetQubit, theta);
 
    return false;
  }
 
  bool ApplyCU(unsigned int controlQubit, unsigned int targetQubit,
               double theta, double phi, double lambda, double gamma) {
    if (obj)
      return lib->TNApplyCU(obj, controlQubit, targetQubit, theta, phi, lambda,
                            gamma);
 
    return false;
  }
 
  bool ApplyCCX(unsigned int controlQubit1, unsigned int controlQubit2,
                unsigned int targetQubit) {
    if (obj)
      return lib->TNApplyCCX(obj, controlQubit1, controlQubit2, targetQubit);
    return false;
  }
 
  bool ApplyCSwap(unsigned int controlQubit, unsigned int qubit1,
                  unsigned int qubit2) {
    if (obj) return lib->TNApplyCSwap(obj, controlQubit, qubit1, qubit2);
    return false;
  }
 
 private:
  GpuDeviceContext lib;
  void *obj;
};
 
}  // namespace Simulators
 
#endif  // __linux__
 
#endif  // _GPU_LIB_TN_SIM_H_
#pragma once