Struct burn::backend::wgpu::JitTensor

pub struct JitTensor<R, E>
where
    R: JitRuntime,
    E: JitElement,
{
    pub client: ComputeClient<<R as Runtime>::Server, <R as Runtime>::Channel>,
    pub handle: Handle,
    pub shape: Shape,
    pub device: <R as Runtime>::Device,
    pub strides: Vec<usize>,
    /* private fields */
}

The basic tensor primitive struct.

Fields

client: ComputeClient<<R as Runtime>::Server, <R as Runtime>::Channel>

Compute client for the runtime.

handle: Handle

The buffer where the data are stored.

shape: Shape

The shape of the tensor.

device: <R as Runtime>::Device

The device of the tensor.

strides: Vec<usize>

The strides of the tensor.

Implementations

impl<R, E> JitTensor<R, E>

where R: JitRuntime, E: JitElement,

pub fn new( client: ComputeClient<<R as Runtime>::Server, <R as Runtime>::Channel>, handle: Handle, shape: Shape, device: <R as Runtime>::Device, strides: Vec<usize>, ) -> JitTensor<R, E>

Constructs a new JitTensor.

impl<R, E> JitTensor<R, E>

where R: JitRuntime, E: JitElement,

pub fn new_contiguous( client: ComputeClient<<R as Runtime>::Server, <R as Runtime>::Channel>, device: <R as Runtime>::Device, shape: Shape, handle: Handle, ) -> JitTensor<R, E>

Create a new tensor with a contiguous memory layout.

pub fn to_client( &self, client: ComputeClient<<R as Runtime>::Server, <R as Runtime>::Channel>, device: <R as Runtime>::Device, ) -> JitTensor<R, E>

Change the context of the current tensor and return the newly transferred tensor.

pub fn as_handle_ref(&self) -> TensorHandleRef<'_, R>

Return the reference to a tensor handle.

pub fn as_tensor_arg<'a>(&'a self, vectorisation: u8) -> TensorArg<'a, R>

Return the reference to a tensor argument.

pub fn copy(&self) -> JitTensor<R, E>

Copy the current tensor.

pub fn can_mut(&self) -> bool

Check if the tensor is safe to mutate.

pub fn assert_is_on_same_device(&self, other: &JitTensor<R, E>)

Assert that both tensors are on the same device.

pub fn is_contiguous(&self) -> bool

Check if the current tensor is contiguous.

Trait Implementations

impl<R, E> Clone for JitTensor<R, E>

where R: JitRuntime, E: JitElement,

fn clone(&self) -> JitTensor<R, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, E> Debug for JitTensor<R, E>

where R: JitRuntime, E: JitElement,

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

Formats the value using the given formatter.

impl<R, E> From<JitTensor<R, E>> for TensorHandle<R, E>

where R: JitRuntime, E: JitElement,

fn from(val: JitTensor<R, E>) -> TensorHandle<R, E>

Converts to this type from the input type.