Struct DLTensor 

#[repr(C)]
pub struct DLTensor {
    pub data: *mut c_void,
    pub device: DLDevice,
    pub ndim: i32,
    pub dtype: DLDataType,
    pub shape: *mut i64,
    pub strides: *mut i64,
    pub byte_offset: u64,
}

\brief Plain C Tensor object, does not manage memory.

Fields

data: *mut c_void

\brief The data pointer points to the allocated data. This will be CUDA device pointer or cl_mem handle in OpenCL. It may be opaque on some device types. This pointer is always aligned to 256 bytes as in CUDA. The byte_offset field should be used to point to the beginning of the data.

Note that as of Nov 2021, multiply libraries (CuPy, PyTorch, TensorFlow, TVM, perhaps others) do not adhere to this 256 byte aligment requirement on CPU/CUDA/ROCm, and always use byte_offset=0. This must be fixed (after which this note will be updated); at the moment it is recommended to not rely on the data pointer being correctly aligned.

For given DLTensor, the size of memory required to store the contents of data is calculated as follows:

\code{.c} static inline size_t GetDataSize(const DLTensor* t) { size_t size = 1; for (tvm_index_t i = 0; i < t->ndim; ++i) { size *= t->shape[i]; } size *= (t->dtype.bits * t->dtype.lanes + 7) / 8; return size; } \endcode

device: DLDevice

\brief The device of the tensor

ndim: i32

\brief Number of dimensions

dtype: DLDataType

\brief The data type of the pointer

shape: *mut i64

\brief The shape of the tensor

strides: *mut i64

\brief strides of the tensor (in number of elements, not bytes) can be NULL, indicating tensor is compact and row-majored.

byte_offset: u64

\brief The offset in bytes to the beginning pointer to data

Trait Implementations

impl Clone for DLTensor

fn clone(&self) -> DLTensor

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DLTensor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DLTensor

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for DLTensor

fn eq(&self, other: &DLTensor) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DLTensor

impl Eq for DLTensor

impl StructuralPartialEq for DLTensor