GpuStabilizer.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _GPU_STABILIZER_H
#define _GPU_STABILIZER_H 1
 
#ifdef __linux__
 
#include "GpuDeviceContext.h"
 
namespace Simulators
{
 
class GpuStabilizer
{
  public:
    explicit GpuStabilizer(const std::shared_ptr<GpuLibrary> &lib, int device = -1)
        : device(device == -1 && lib ? lib->GetCreationDevice() : device), lib(lib), obj(nullptr)
    {
    }
 
    int GetGpuDevice() const
    {
        return lib ? lib->GetStabilizerGpuId(obj) : -1;
    }
 
    GpuStabilizer() = delete;
    GpuStabilizer(const GpuStabilizer &) = delete;
    GpuStabilizer &operator=(const GpuStabilizer &) = delete;
    GpuStabilizer(GpuStabilizer &&) = default;
    GpuStabilizer &operator=(GpuStabilizer &&) = default;
 
    ~GpuStabilizer()
    {
        if (lib && obj)
            lib->DestroyStabilizerSimulator(obj);
    }
 
    bool CreateSimulator(long long int numQubits, long long int numShots, long long int numMeasurements, long long int numDetectors)
    {
        if (lib)
        {
            auto lock = lib->LockInitialization();
            if (!lib->SetGpuDevice(device))
                return false;
            if (obj)
                lib->DestroyStabilizerSimulator(obj);
            obj = nullptr;
            obj = lib->CreateStabilizerSimulator(numQubits, numShots, numMeasurements, numDetectors);
            return obj != nullptr;
        }
 
        return false;
    }
 
    bool ExecuteCircuit(const std::string &circuitStr, int randomizeMeasurements, unsigned long long int seed)
    {
        if (obj)
            return lib->ExecuteStabilizerCircuit(obj, circuitStr.c_str(), randomizeMeasurements, seed);
        return false;
    }
 
    bool Clear()
    {
        if (obj)
        {
            lib->DestroyStabilizerSimulator(obj);
            obj = nullptr;
            return true;
        }
 
        return false;
    }
 
    long long GetNumQubits()
    {
        if (obj)
            return lib->GetStabilizerNumQubits(obj);
        return 0;
    }
 
    long long GetNumShots()
    {
        if (obj)
            return lib->GetStabilizerNumShots(obj);
        return 0;
    }
 
    long long GetNumMeasurements()
    {
        if (obj)
            return lib->GetStabilizerNumMeasurements(obj);
        return 0;
    }
 
    long long GetNumDetectors()
    {
        if (obj)
            return lib->GetStabilizerNumDetectors(obj);
        return 0;
    }
 
    bool IsCreated() const
    {
        return obj != nullptr;
    }
 
    std::vector<std::vector<bool>> GetXTable()
    {
        if (!obj)
            return std::vector<std::vector<bool>>();
 
        std::vector<unsigned int> xTableRaw(GetStabilizerXZTableSize());
        lib->CopyStabilizerXTable(obj, xTableRaw.data());
 
        return ConvertToBoolVectorVector(xTableRaw, GetNumQubits(), GetNumShots());
    }
 
    std::vector<std::vector<bool>> GetZTable()
    {
        if (!obj)
            return std::vector<std::vector<bool>>();
 
        std::vector<unsigned int> zTableRaw(GetStabilizerXZTableSize());
        lib->CopyStabilizerZTable(obj, zTableRaw.data());
 
        return ConvertToBoolVectorVector(zTableRaw, GetNumQubits(), GetNumShots());
    }
 
    std::vector<std::vector<bool>> GetMTable()
    {
        if (!obj)
            return std::vector<std::vector<bool>>();
 
        std::vector<unsigned int> mTableRaw(GetStabilizerMTableSize());
        lib->CopyStabilizerMTable(obj, mTableRaw.data());
 
        return ConvertToBoolVectorVector(mTableRaw, GetNumMeasurements(), GetNumShots());
    }
 
    bool InitXTable(const std::vector<std::vector<bool>> &xTable)
    {
        if (!obj)
            return false;
        const long long shots = GetNumShots();
        const long long words_per_qubitormeas = (shots + 31) / 32;
        const long long numQubits = GetNumQubits();
        std::vector<unsigned int> xTableRaw(numQubits * words_per_qubitormeas, 0);
        for (long long qubit = 0; qubit < numQubits; ++qubit)
        {
            for (long long shot = 0; shot < shots; ++shot)
            {
                if (xTable[qubit][shot])
                {
                    xTableRaw[qubit * words_per_qubitormeas + (shot / 32)] |= (1U << (shot % 32));
                }
            }
        }
        return lib->InitStabilizerXTable(obj, xTableRaw.data()) == 1;
    }
 
    bool InitXTableRepeat(const std::vector<bool> &xTable)
    {
        // repeat xTable for all shots
        if (!obj)
            return false;
        const long long shots = GetNumShots();
        const long long words_per_qubitormeas = (shots + 31) / 32;
        const long long numQubits = GetNumQubits();
        std::vector<unsigned int> xTableRaw(numQubits * words_per_qubitormeas, 0);
        for (long long qubit = 0; qubit < numQubits; ++qubit)
        {
            for (long long shot = 0; shot < shots; ++shot)
            {
                if (xTable[qubit])
                {
                    xTableRaw[qubit * words_per_qubitormeas + (shot / 32)] |= (1U << (shot % 32));
                }
            }
        }
 
        return lib->InitStabilizerXTable(obj, xTableRaw.data()) == 1;
    }
 
    bool InitZTable(const std::vector<std::vector<bool>> &zTable)
    {
        if (!obj)
            return false;
        const long long shots = GetNumShots();
        const long long words_per_qubitormeas = (shots + 31) / 32;
        const long long numQubits = GetNumQubits();
        std::vector<unsigned int> zTableRaw(numQubits * words_per_qubitormeas, 0);
        for (long long qubit = 0; qubit < numQubits; ++qubit)
        {
            for (long long shot = 0; shot < shots; ++shot)
            {
                if (zTable[qubit][shot])
                {
                    zTableRaw[qubit * words_per_qubitormeas + (shot / 32)] |= (1U << (shot % 32));
                }
            }
        }
        return lib->InitStabilizerZTable(obj, zTableRaw.data()) == 1;
    }
 
    bool InitZTableRepeat(const std::vector<bool> &zTable)
    {
        // repeat zTable for all shots
        if (!obj)
            return false;
        const long long shots = GetNumShots();
        const long long words_per_qubitormeas = (shots + 31) / 32;
        const long long numQubits = GetNumQubits();
        std::vector<unsigned int> zTableRaw(numQubits * words_per_qubitormeas, 0);
        for (long long qubit = 0; qubit < numQubits; ++qubit)
        {
            for (long long shot = 0; shot < shots; ++shot)
            {
                if (zTable[qubit])
                {
                    zTableRaw[qubit * words_per_qubitormeas + (shot / 32)] |= (1U << (shot % 32));
                }
            }
        }
        return lib->InitStabilizerZTable(obj, zTableRaw.data()) == 1;
    }
 
  protected:
    std::vector<std::vector<bool>> ConvertToBoolVectorVector(const std::vector<unsigned int> &tableRaw, long long int num, long long int shots)
    {
        const long long words_per_qubitormeas = (shots + 31) / 32;
 
        std::vector<std::vector<bool>> result(num);
 
        for (long long qubitormeas = 0; qubitormeas < num; ++qubitormeas)
        {
            for (long long shot = 0; shot < shots; ++shot)
            {
                const unsigned int word = tableRaw[qubitormeas * words_per_qubitormeas + (shot / 32)];
                const bool bit = ((word >> (shot % 32)) & 1) == 1;
                result[qubitormeas].push_back(bit);
            }
        }
 
        return result;
    }
 
    long long GetStabilizerXZTableSize()
    {
        if (obj)
            return lib->GetStabilizerXZTableSize(obj);
        return 0;
    }
 
    long long GetStabilizerMTableSize()
    {
        if (obj)
            return lib->GetStabilizerMTableSize(obj);
        return 0;
    }
 
    long long GetStabilizerTableStrideMajor()
    {
        if (obj)
            return lib->GetStabilizerTableStrideMajor(obj);
        return 0;
    }
 
  private:
    int device; // Fixed even when native creation is delayed or repeated.
    GpuDeviceContext lib;
    void *obj;
};
 
} // namespace Simulators
 
#endif
#endif