Struct Tensor 

pub struct Tensor<S, M, A = <S as TensorType>::H>
where
    A: HalideType,
    M: TensorMachine,
    S: TensorType<H = A>,
{ /* private fields */ }

A generic tensor that can of host / device / owned / borrowed

Every Tensor owns the C++ MNN::Tensor object it wraps and destroys it on drop. The S parameter only describes who owns the data: Owned tensors allocate it, the View tensors created by Tensor::borrowed / Tensor::borrowed_mut borrow a user slice (which MNN never frees). To borrow a tensor itself use &TensorRef / &mut TensorRef, the Deref target of Tensor.

Implementations

impl<H, T, M> Tensor<T, M>

where T: TensorType<H = H>, H: HalideType, M: TensorMachine,

pub unsafe fn from_ptr(tensor: *mut Tensor) -> Self

This function constructs a Tensor type from a raw pointer

The returned tensor takes ownership of the MNN::Tensor object and destroys it on drop. Use from_raw_parts / from_raw_parts_mut to borrow a tensor instead.

Safety

Since this constructs a Tensor from a raw pointer we have no way to guarantee that it’s a valid tensor, that nothing else owns it, or its lifetime

pub fn print(&self)

Print the tensor

pub unsafe fn halide_buffer(&self) -> *const halide_buffer_t

DO not use this function directly

Safety

This is just provided as a 1:1 compat mostly for possible later use

pub unsafe fn halide_buffer_mut(&self) -> *mut halide_buffer_t

Do not use this function directly

Safety

This is just provided as a 1:1 compat mostly for possible later use

pub fn get_type(&self) -> halide_type_t

Get the data type of the tensor

pub unsafe fn as_any_tensor(&self) -> &AnyTensorRef

Safety

Type erase the tensor

pub unsafe fn as_any_tensor_mut(&mut self) -> &mut AnyTensorRef

Safety

Type erase the tensor mutably

impl<H> Tensor<Owned<H>, Host>

where H: HalideType + Copy,

pub fn from_shape_data( shape: impl AsTensorShape, dm_type: DimensionType, data: &[H], ) -> Self

Create a new tensor with the specified shape and dimension type and fill it with the data from the provided vector

Panics

Panics if the shape is dynamic or the number of elements MNN allocates for the shape (which includes channel padding for DimensionType::CaffeC4) differs from data.len().

impl<H, M> Tensor<Owned<H>, M>

where H: HalideType, M: TensorMachine,

pub fn new(shape: impl AsTensorShape, dm_type: DimensionType) -> Self

Create a new tensor with the specified shape and dimension type this allocates the tensor internally and the data is “owned” by the tensor itself.

Panics

Host tensors are allocated immediately, so their shape must not be dynamic (contain -1). Device tensors are only described, not allocated, so any shape is accepted.

impl<'a, A> Tensor<View<&'a A>, Host, A>

where A: HalideType,

pub fn borrowed( shape: impl AsTensorShape, dm_type: DimensionType, input: &'a [A], ) -> Self

Create a tensor that borrows input as its storage.

Panics

Panics if the shape is dynamic or if the number of elements MNN needs for shape in the dm_type layout differs from input.len(). Note that DimensionType::CaffeC4 pads the channel dimension to a multiple of 4, so the slice must already be laid out (and sized) accordingly.

impl<'a, A> Tensor<View<&'a mut A>, Host, A>

where A: HalideType,

pub fn borrowed_mut( shape: impl AsTensorShape, dm_type: DimensionType, input: &'a mut [A], ) -> Self

Create a tensor that mutably borrows input as its storage.

Panics

Panics if the shape is dynamic or if the number of elements MNN needs for shape in the dm_type layout differs from input.len(). Note that DimensionType::CaffeC4 pads the channel dimension to a multiple of 4, so the slice must already be laid out (and sized) accordingly.

Methods from Deref<Target = TensorRef<H, M>>

pub fn copy_from_host_tensor( &mut self, tensor: &TensorRef<H, Host>, ) -> Result<()>

Copies the data from a host tensor to the self.as_ptr()

The tensors must have the same logical shape; MNN converts between layouts (e.g. NCHW <-> NC4HW4) as part of the copy.

pub fn copy_to_host_tensor(&self, tensor: &mut TensorRef<H, Host>) -> Result<()>

Copies the data from the self.as_ptr() to a host tensor

The tensors must have the same logical shape; MNN converts between layouts (e.g. NCHW <-> NC4HW4) as part of the copy.

pub fn fill(&mut self, value: T) -> Result<()>

where T: Copy,

Fill the tensor with the specified value

Fails if the tensor has a different element type, has not been resized yet (dynamic shape) or, for device tensors, if MNN refuses the copy (e.g. no backend is attached).

Methods from Deref<Target = AnyTensorRef>

pub fn device_id(&self) -> u64

Get the device id of the tensor

pub fn shape(&self) -> TensorShape

Get the shape of the tensor

pub fn dimensions(&self) -> usize

Get the dimensions of the tensor

pub fn width(&self) -> u32

Get the width of the tensor

pub fn height(&self) -> u32

Get the height of the tensor

pub fn channel(&self) -> u32

Get the channel size of the tensor

pub fn batch(&self) -> u32

Get the batch size of the tensor

pub fn size(&self) -> usize

Get the size of the tensor when counted by bytes

Note that for packed layouts (NC4HW4) this includes the padding MNN adds to the channel dimension, so it can be larger than the product of the shape.

pub fn element_size(&self) -> usize

Get the size of the tensor when counted by elements

Note that for packed layouts (NC4HW4) this includes the padding MNN adds to the channel dimension, so it can be larger than the product of the shape.

pub fn get_type(&self) -> halide_type_t

Get the halide data type of the tensor

pub fn is_type_of<Ha: HalideType>(&self) -> bool

Check if the tensor is of the specified data type

pub fn is_same_type(&self, other: &AnyTensorRef) -> bool

Check if both tensors have the same halide data type

pub fn get_dimension_type(&self) -> DimensionType

Get the dimension type of the tensor

pub fn is_dynamic_unsized(&self) -> bool

Check if the tensor is dynamic and needs resizing

pub fn copy_from_host_tensor(&mut self, tensor: &AnyTensorRef) -> Result<()>

Copies the data from a host tensor to the self.as_ptr()

pub fn copy_to_host_tensor(&self, tensor: &mut AnyTensorRef) -> Result<()>

Copies the data from the self.as_ptr() to a host tensor

pub fn create_host_tensor_from_device<T: HalideType + Copy>( &self, copy_data: bool, ) -> Tensor<Owned<T>, Host>

Create a host tensor from the device tensor with same dimensions and data type and optionally copy the data from the device tensor

Panics

Panics if the tensor’s element type is not T or the copy fails.

Trait Implementations

impl<H> Clone for Tensor<Owned<H>, Host>

where H: HalideType + Copy,

fn clone(&self) -> Tensor<Owned<H>, Host>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, M, A> Debug for Tensor<S, M, A>

where A: HalideType + Debug, M: TensorMachine + Debug, S: TensorType<H = A> + Debug,

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

Formats the value using the given formatter.

impl<S, M, H> Deref for Tensor<S, M, H>

where S: TensorType<H = H>, H: HalideType, M: TensorMachine,

type Target = TensorRef<H, M>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S, M, H> DerefMut for Tensor<S, M, H>

where S: MutableTensorType<H = H>, H: HalideType, M: TensorMachine,

Only tensors that own their data or hold a mutable borrow of it can be mutated through the TensorRef; a Tensor<View<&H>, _> built over a shared slice must not be able to write through that slice.

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S, M, A> Drop for Tensor<S, M, A>

where A: HalideType, S: TensorType<H = A>, M: TensorMachine,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, H> PartialEq for Tensor<T, Host>

where T: TensorType<H = H>, H: HalideType + PartialEq,

fn eq(&self, other: &Self) -> 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<T, H> Eq for Tensor<T, Host>

where T: TensorType<H = H>, H: HalideType + Eq,