CudaVmmAllocator.hpp

Go to the documentation of this file.

#pragma once
 
#include <Gfx/Graph/interop/CudaFunctions.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <cstddef>
 
namespace score::gfx::interop
{
 
class SCORE_PLUGIN_GFX_EXPORT CudaVmmAllocation
{
public:
  CudaVmmAllocation() noexcept = default;
 
  CudaVmmAllocation(CudaVmmAllocation&& other) noexcept
      : m_cu(other.m_cu)
      , m_dptr(other.m_dptr)
      , m_handle(other.m_handle)
      , m_size(other.m_size)
      , m_handleReleased(other.m_handleReleased)
  {
    other.detach();
  }
 
  CudaVmmAllocation& operator=(CudaVmmAllocation&& other) noexcept
  {
    if(this != &other)
    {
      destroy();
      m_cu = other.m_cu;
      m_dptr = other.m_dptr;
      m_handle = other.m_handle;
      m_size = other.m_size;
      m_handleReleased = other.m_handleReleased;
      other.detach();
    }
    return *this;
  }
 
  CudaVmmAllocation(const CudaVmmAllocation&) = delete;
  CudaVmmAllocation& operator=(const CudaVmmAllocation&) = delete;
 
  ~CudaVmmAllocation() { destroy(); }
 
  bool valid() const noexcept { return m_cu && m_dptr != 0 && m_size > 0; }
 
  CUdeviceptr devicePointer() const noexcept { return m_dptr; }
 
  std::size_t size() const noexcept { return m_size; }
 
  int exportPosixFd() const noexcept;
 
  int exportDmaBufFd(bool pciBar1 = false) const noexcept;
 
  void releaseHandleEarly() noexcept
  {
    if(m_cu && m_handle && !m_handleReleased)
    {
      m_cu->memRelease(m_handle);
      m_handleReleased = true;
    }
  }
 
private:
  friend class CudaVmmAllocator;
 
  void detach() noexcept
  {
    m_cu = nullptr;
    m_dptr = 0;
    m_handle = 0;
    m_size = 0;
    m_handleReleased = false;
  }
 
  void destroy() noexcept
  {
    if(!m_cu)
      return;
    if(m_dptr != 0 && m_size > 0)
    {
      m_cu->memUnmap(m_dptr, m_size);
      m_cu->memAddressFree(m_dptr, m_size);
    }
    if(m_handle && !m_handleReleased)
      m_cu->memRelease(m_handle);
    detach();
  }
 
  score::gfx::CudaFunctions* m_cu{};
  CUdeviceptr m_dptr{};
  CUmemGenericAllocationHandle m_handle{};
  std::size_t m_size{};
  bool m_handleReleased{};
};
 
class SCORE_PLUGIN_GFX_EXPORT CudaVmmAllocator
{
public:
  static CudaVmmAllocation allocate(
      score::gfx::CudaFunctions& cu, int device, std::size_t bytes,
      bool exportable = false) noexcept;
 
  static std::size_t alignedSize(
      score::gfx::CudaFunctions& cu, int device, std::size_t bytes) noexcept;
};
 
} // namespace score::gfx::interop