triton_cpp::InputData Struct Reference

Couple a Triton input descriptor with its backing storage. More...

#include <types.hpp>

Public Member Functions
	InputData ()=default
	Construct an empty input-storage descriptor.
	InputData (const InputData &other)
	Copy an input descriptor and rebind pointers into copied owned storage.
	InputData (InputData &&other) noexcept
	Move an input descriptor and preserve its storage association.
InputData &	operator= (const InputData &other)
	Copy an input descriptor while preserving storage ownership.
InputData &	operator= (InputData &&other) noexcept
	Move an input descriptor while preserving storage ownership.
	InputData (std::shared_ptr< triton::client::InferInput > input, std::vector< uint8_t > &&data)
	Construct an input backed by an owned host vector.
	InputData (std::shared_ptr< triton::client::InferInput > input, uint8_t *data_raw, std::size_t data_raw_size)
	Construct an input backed by externally owned host memory.
	InputData (std::shared_ptr< triton::client::InferInput > input, uint8_t *data_raw, uint8_t *device_data_raw, std::size_t data_raw_size)
	Construct an input backed by CUDA shared memory.
bool	isHostMappable () const
bool	isDeviceBacked () const

Public Attributes
std::shared_ptr< triton::client::InferInput >	input
std::vector< uint8_t >	data
uint8_t *	data_raw {nullptr}
uint8_t *	device_data_raw {nullptr}
std::size_t	data_raw_size {0}

Detailed Description

Couple a Triton input descriptor with its backing storage.

Storage may be an owned host vector, externally owned host shared memory, or CUDA device shared memory. Pointer validity follows the lifetime of the corresponding backing allocation.

Definition at line 157 of file types.hpp.

Constructor & Destructor Documentation

InputData() [1/6]

triton_cpp::InputData::InputData ( )

default

Construct an empty input-storage descriptor.

InputData() [2/6]

triton_cpp::InputData::InputData ( const InputData & other )

inline

Copy an input descriptor and rebind pointers into copied owned storage.

Parameters

other

Descriptor to copy.

Definition at line 176 of file types.hpp.

      : input{other.input},
        data{other.data},
        data_raw{other.ownsHostBuffer() ? data.data() : other.data_raw},
        device_data_raw{other.device_data_raw},
        data_raw_size{other.data_raw_size} {}

InputData() [3/6]

triton_cpp::InputData::InputData ( InputData && other )

inlinenoexcept

Move an input descriptor and preserve its storage association.

Parameters

other

Descriptor to move from.

Definition at line 187 of file types.hpp.

                                        {
    const bool owns_host_buffer = other.ownsHostBuffer();
    input = std::move(other.input);
    data = std::move(other.data);
    data_raw = owns_host_buffer ? data.data() : other.data_raw;
    device_data_raw = other.device_data_raw;
    data_raw_size = other.data_raw_size;
    other.data_raw = nullptr;
    other.device_data_raw = nullptr;
    other.data_raw_size = 0;
  }

References data, data_raw, data_raw_size, device_data_raw, and input.

InputData() [4/6]

triton_cpp::InputData::InputData ( std::shared_ptr< triton::client::InferInput > input, std::vector< uint8_t > && data )

inline

Construct an input backed by an owned host vector.

Parameters

input	Triton input descriptor.
data	Host buffer used to initialize this object's owned storage.

Definition at line 233 of file types.hpp.

      : input{std::move(input)},
        data{std::move(data)},
        data_raw{this->data.data()},
        device_data_raw{nullptr},
        data_raw_size{this->data.size()} {}

InputData() [5/6]

triton_cpp::InputData::InputData ( std::shared_ptr< triton::client::InferInput > input, uint8_t * data_raw, std::size_t data_raw_size )

inline

Construct an input backed by externally owned host memory.

Parameters

input	Triton input descriptor.
data_raw	Host buffer address.
data_raw_size	Buffer size in bytes.

Definition at line 246 of file types.hpp.

      : input{input}, data{}, data_raw{data_raw}, device_data_raw{nullptr}, data_raw_size{data_raw_size} {}

InputData() [6/6]

triton_cpp::InputData::InputData ( std::shared_ptr< triton::client::InferInput > input, uint8_t * data_raw, uint8_t * device_data_raw, std::size_t data_raw_size )

inline

Construct an input backed by CUDA shared memory.

Parameters

input	Triton input descriptor.
data_raw	Optional host address; normally nullptr for CUDA-only storage.
device_data_raw	CUDA device address.
data_raw_size	Buffer size in bytes.

Definition at line 256 of file types.hpp.

      : input{input}, data{}, data_raw{data_raw}, device_data_raw{device_data_raw}, data_raw_size{data_raw_size} {}

Member Function Documentation

isDeviceBacked()

bool triton_cpp::InputData::isDeviceBacked ( ) const

inline

Returns

true when the input is backed by a CUDA device allocation.

Definition at line 265 of file types.hpp.

{ return device_data_raw != nullptr; }

References device_data_raw.

isHostMappable()

bool triton_cpp::InputData::isHostMappable ( ) const

inline

Returns

true when the input exposes a host-accessible address.

Definition at line 263 of file types.hpp.

{ return data_raw != nullptr; }

References data_raw.

operator=() [1/2]

InputData & triton_cpp::InputData::operator= ( const InputData & other )

inline

Copy an input descriptor while preserving storage ownership.

Definition at line 200 of file types.hpp.

                                               {
    if (this != &other) {
      const bool owns_host_buffer = other.ownsHostBuffer();
      input = other.input;
      data = other.data;
      data_raw = owns_host_buffer ? data.data() : other.data_raw;
      device_data_raw = other.device_data_raw;
      data_raw_size = other.data_raw_size;
    }
    return *this;
  }

References data, data_raw, data_raw_size, device_data_raw, and input.

operator=() [2/2]

InputData & triton_cpp::InputData::operator= ( InputData && other )

inlinenoexcept

Move an input descriptor while preserving storage ownership.

Definition at line 213 of file types.hpp.

                                                   {
    if (this != &other) {
      const bool owns_host_buffer = other.ownsHostBuffer();
      input = std::move(other.input);
      data = std::move(other.data);
      data_raw = owns_host_buffer ? data.data() : other.data_raw;
      device_data_raw = other.device_data_raw;
      data_raw_size = other.data_raw_size;
      other.data_raw = nullptr;
      other.device_data_raw = nullptr;
      other.data_raw_size = 0;
    }
    return *this;
  }

References data, data_raw, data_raw_size, device_data_raw, and input.

Member Data Documentation

data

std::vector<uint8_t> triton_cpp::InputData::data

Owned storage used by standard host inputs.

Definition at line 161 of file types.hpp.

Referenced by InputData(), operator=(), and operator=().

data_raw

uint8_t* triton_cpp::InputData::data_raw {nullptr}

Host-mappable buffer address, or nullptr for device-only storage.

Definition at line 163 of file types.hpp.

{nullptr};

Referenced by InputData(), isHostMappable(), operator=(), and operator=().

data_raw_size

std::size_t triton_cpp::InputData::data_raw_size {0}

Buffer size in bytes.

Definition at line 167 of file types.hpp.

{0};

Referenced by InputData(), operator=(), and operator=().

device_data_raw

uint8_t* triton_cpp::InputData::device_data_raw {nullptr}

CUDA device buffer address, or nullptr for host storage.

Definition at line 165 of file types.hpp.

{nullptr};

Referenced by InputData(), isDeviceBacked(), operator=(), and operator=().

input

std::shared_ptr<triton::client::InferInput> triton_cpp::InputData::input

Triton input descriptor.

Definition at line 159 of file types.hpp.

Referenced by InputData(), operator=(), and operator=().

---

The documentation for this struct was generated from the following file:

• include/triton_cpp/types.hpp