onert::backend::trix::ops::BulkPipelineBuffer Class Reference

#include <BulkPipelineBuffer.h>

Public Types
enum class	BufferType { DMABUF_CONT , DMABUF_IOMMU }

Public Member Functions
	BulkPipelineBuffer (BufferType type, size_t size, int device_id)
	~BulkPipelineBuffer ()
	BulkPipelineBuffer (const BulkPipelineBuffer &)=delete
BulkPipelineBuffer &	operator= (const BulkPipelineBuffer &)=delete
void	allocate ()
void	deallocate ()
size_t	size () const
generic_buffer *	getGenericBuffer ()
void	fillFromFile (FILE *fp, size_t offset=0)
bool	isReady () const

Detailed Description

Definition at line 28 of file BulkPipelineBuffer.h.

Member Enumeration Documentation

BufferType

enum class onert::backend::trix::ops::BulkPipelineBuffer::BufferType

strong

Enumerator
DMABUF_CONT
DMABUF_IOMMU

Definition at line 31 of file BulkPipelineBuffer.h.

  {
    DMABUF_CONT, // Contiguous DMA buffer
    DMABUF_IOMMU // IOMMU DMA buffer
  };

Constructor & Destructor Documentation

BulkPipelineBuffer() [1/2]

onert::backend::trix::ops::BulkPipelineBuffer::BulkPipelineBuffer	(	BufferType	type,
		size_t	size,
		int	device_id
	)

Definition at line 40 of file BulkPipelineBuffer.cc.

  : _type(type), _size(size), _device_id(device_id)
{
  // DO NOTHING
}

~BulkPipelineBuffer()

onert::backend::trix::ops::BulkPipelineBuffer::~BulkPipelineBuffer

(

)

Definition at line 46 of file BulkPipelineBuffer.cc.

{ deallocate(); }

References deallocate().

BulkPipelineBuffer() [2/2]

onert::backend::trix::ops::BulkPipelineBuffer::BulkPipelineBuffer ( const BulkPipelineBuffer &  )

delete

Member Function Documentation

allocate()

void onert::backend::trix::ops::BulkPipelineBuffer::allocate

(

)

Definition at line 52 of file BulkPipelineBuffer.cc.

{
  if (_buffer && _buffer->addr != nullptr)
  {
    // Already allocated
    return;
  }
 
  if (!_buffer)
  {
    _buffer = new generic_buffer{};
  }
 
  // Open the device
  char devname[16];
  snprintf(devname, sizeof(devname), "/dev/triv2-%d", _device_id);
  _dev_fd = open(devname, O_RDWR);
  if (_dev_fd < 0)
  {
    throw std::runtime_error("Failed to open NPU device: " + std::string(devname));
  }
 
  // Allocate a buffer
  struct trix_ioctl_hwmem hwmem;
  hwmem.type = (_type == BufferType::DMABUF_CONT) ? 0 : 1;
  hwmem.size = getAlignedSize(_size);
 
  _buffer->dmabuf = ioctl(_dev_fd, TRIX_IOCTL_HWMEM_ALLOC, &hwmem);
  if (_buffer->dmabuf < 0)
  {
    close(_dev_fd);
    _dev_fd = -1;
    throw std::runtime_error("Failed to allocate DMA buffer, size: " + std::to_string(hwmem.size));
  }
 
  // Mapping the buffer
  _buffer->addr = mmap(nullptr, hwmem.size, PROT_READ | PROT_WRITE, MAP_SHARED, _buffer->dmabuf, 0);
  if (_buffer->addr == MAP_FAILED)
  {
    close(_buffer->dmabuf);
    close(_dev_fd);
    _buffer->dmabuf = -1;
    _dev_fd = -1;
    _buffer->addr = nullptr;
    throw std::runtime_error("Failed to mmap DMA buffer");
  }
 
  _buffer->size = _size;
  _buffer->type = BUFFER_DMABUF;
}

References DMABUF_CONT, onert::backend::trix::ops::trix_ioctl_hwmem::size, TRIX_IOCTL_HWMEM_ALLOC, and onert::backend::trix::ops::trix_ioctl_hwmem::type.

deallocate()

void onert::backend::trix::ops::BulkPipelineBuffer::deallocate

(

)

Definition at line 103 of file BulkPipelineBuffer.cc.

{
  if (!_buffer)
  {
    return;
  }
 
  if (_buffer->addr != nullptr)
  {
    size_t aligned_sz = getAlignedSize(_buffer->size);
    munmap(_buffer->addr, aligned_sz);
    _buffer->addr = nullptr;
  }
 
  if (_buffer->dmabuf >= 0)
  {
    struct trix_ioctl_hwmem hwmem;
    hwmem.dbuf_fd = _buffer->dmabuf;
    ioctl(_dev_fd, TRIX_IOCTL_HWMEM_DEALLOC, &hwmem);
    close(_buffer->dmabuf);
    _buffer->dmabuf = -1;
  }
 
  if (_dev_fd >= 0)
  {
    close(_dev_fd);
    _dev_fd = -1;
  }
 
  delete _buffer;
  _buffer = nullptr;
}

References onert::backend::trix::ops::trix_ioctl_hwmem::dbuf_fd, and TRIX_IOCTL_HWMEM_DEALLOC.

Referenced by ~BulkPipelineBuffer().

fillFromFile()

void onert::backend::trix::ops::BulkPipelineBuffer::fillFromFile	(	FILE *	fp,
		size_t	offset = 0
	)

Definition at line 136 of file BulkPipelineBuffer.cc.

{
  if (!isReady())
  {
    throw std::runtime_error("Buffer is not allocated");
  }
 
  if (!fp)
  {
    throw std::runtime_error("Invalid file pointer");
  }
 
  if (fseek(fp, static_cast<long>(offset), SEEK_SET) != 0)
  {
    throw std::runtime_error("Failed to seek file to offset: " + std::to_string(offset));
  }
 
  if (fread(_buffer->addr, _buffer->size, 1, fp) != 1)
  {
    throw std::runtime_error("Failed to read " + std::to_string(_buffer->size) +
                             " bytes from file");
  }
}

References isReady(), and offset().

getGenericBuffer()

generic_buffer * onert::backend::trix::ops::BulkPipelineBuffer::getGenericBuffer ( )

inline

Definition at line 50 of file BulkPipelineBuffer.h.

{ return _buffer; }

isReady()

bool onert::backend::trix::ops::BulkPipelineBuffer::isReady

(

)

const

Definition at line 50 of file BulkPipelineBuffer.cc.

{ return _buffer && _buffer->addr != nullptr; }

Referenced by fillFromFile().

operator=()

BulkPipelineBuffer & onert::backend::trix::ops::BulkPipelineBuffer::operator= ( const BulkPipelineBuffer &  )

delete

size()

size_t onert::backend::trix::ops::BulkPipelineBuffer::size

(

)

const

Definition at line 48 of file BulkPipelineBuffer.cc.

{ return _buffer ? _buffer->size : 0; }

---

The documentation for this class was generated from the following files:

• runtime/onert/backend/trix/ops/BulkPipelineBuffer.h
• runtime/onert/backend/trix/ops/BulkPipelineBuffer.cc