Struct TensorMap 

pub struct TensorMap<E, K>
where
    E: CubePrimitive,
    K: TensorMapKind,
{ /* private fields */ }

A CUDA CUtensorMap object. Represents a tensor encoded with a lot of metadata, and is an opaque packed object at runtime. Does not support retrieving any shapes or strides, nor does it give access to the pointer. So these need to be passed separately in an aliased Tensor if needed.

Also see cubecl_runtime::tma.

Implementations

impl<T, K> TensorMap<T, K>

where T: Scalar, K: TensorMapKind,

pub fn buffer<N>(&self) -> Tensor<Vector<T, N>>

where N: Size,

Get a reference to the underlying buffer for the tensor map.

pub fn stride(&self, _dim: usize) -> usize

Obtain the stride of input at dimension dim

pub fn shape(&self, _dim: usize) -> usize

Obtain the shape of input at dimension dim

pub fn coordinate(&self, _index: usize, _dim: usize) -> usize

Obtain the coordinate corresponding to the given index of the tensor at dimension dim.

A coordinate is a list of indices corresponding to the multi-dimensional position of an element in the tensor. The dim element in a coordinate is the position along the dim dimension of the tensor.

pub fn len(&self) -> usize

The number of vectorized elements in the tensor.

Warning

The length will be affected by the vectorization factor. To obtain the number of elements, you should multiply the length by the vectorization factor.

pub fn buffer_len(&self) -> usize

The length of the buffer representing the tensor in terms of vectorized elements.

Warning

The buffer length will be affected by the vectorization factor. To obtain the number of elements, you should multiply the length by the vectorization factor.

pub fn rank(&self) -> usize

Returns the rank of the tensor.

pub fn downcast<E>(&self) -> TensorMap<E, K>

where E: CubePrimitive,

Downcast the tensormap to the given type and panic if the type isn’t the same.

This function should only be used to satisfy the Rust type system, when two generic types are supposed to be the same.

pub fn __expand_buffer( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<Tensor<T>>

pub fn __expand_stride( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_shape( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_coordinate( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, index: NativeExpand<usize>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>

pub fn __expand_len( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>

pub fn __expand_buffer_len( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>

pub fn __expand_rank( scope: &mut Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>

Trait Implementations

impl<E> AsTensorView<E> for TensorMap<E, Tiled>

where E: CubePrimitive,

fn view_1d<C>(&self, layout: impl Into<VirtualLayout<C, usize>>) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_1d<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, usize>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_2d<C>( &self, layout: impl Into<VirtualLayout<C, (u32, u32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_2d<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_3d<C>( &self, layout: impl Into<VirtualLayout<C, (u32, u32, u32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_3d<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_4d<C>( &self, layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_4d<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_5d<C>( &self, layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32, u32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_5d<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (u32, u32, u32, u32, u32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_1i<C>(&self, layout: impl Into<VirtualLayout<C, i32>>) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_1i<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, i32>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_2i<C>( &self, layout: impl Into<VirtualLayout<C, (i32, i32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_2i<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_3i<C>( &self, layout: impl Into<VirtualLayout<C, (i32, i32, i32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_3i<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_4i<C>( &self, layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_4i<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

fn view_5i<C>( &self, layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32, i32)>>, ) -> View<E, C>

where C: Coordinates + 'static,

fn __expand_view_5i<C>( scope: &mut Scope, this: Self::ExpandType, layout: VirtualLayoutExpand<C, (i32, i32, i32, i32, i32)>, ) -> ViewExpand<E, C>

where C: Coordinates + 'static,

impl<E> AsTensorViewMut<E> for TensorMap<E, Tiled>

where E: CubePrimitive,

fn view_mut_1d<C>( &mut self, layout: impl Into<VirtualLayout<C, usize>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_2d<C>( &mut self, layout: impl Into<VirtualLayout<C, (u32, u32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_3d<C>( &mut self, layout: impl Into<VirtualLayout<C, (u32, u32, u32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_4d<C>( &mut self, layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_5d<C>( &mut self, layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32, u32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_1i<C>( &mut self, layout: impl Into<VirtualLayout<C, i32>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_2i<C>( &mut self, layout: impl Into<VirtualLayout<C, (i32, i32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_3i<C>( &mut self, layout: impl Into<VirtualLayout<C, (i32, i32, i32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_4i<C>( &mut self, layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

fn view_mut_5i<C>( &mut self, layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32, i32)>>, ) -> View<E, C, ReadWrite>

where C: Coordinates + 'static,

impl<E, K> Clone for TensorMap<E, K>

where E: Clone + CubePrimitive, K: Clone + TensorMapKind,

fn clone(&self) -> TensorMap<E, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, K> CubeType for TensorMap<E, K>

where E: CubePrimitive, K: TensorMapKind,

type ExpandType = NativeExpand<TensorMap<E, K>>

impl<E, K> LaunchArg for TensorMap<E, K>

where E: CubePrimitive, K: TensorMapKind,

type RuntimeArg<R: Runtime> = TensorMapArg<R, K>

The runtime argument for the kernel.

type CompilationArg = ()

Compilation argument.

fn register<R>( arg: <TensorMap<E, K> as LaunchArg>::RuntimeArg<R>, launcher: &mut KernelLauncher<R>, ) -> <TensorMap<E, K> as LaunchArg>::CompilationArg

where R: Runtime,

fn expand( _arg: &<TensorMap<E, K> as LaunchArg>::CompilationArg, builder: &mut KernelBuilder, ) -> NativeExpand<TensorMap<E, K>>

Register an input variable during compilation that fill the KernelBuilder.

fn expand_output( _arg: &<TensorMap<E, K> as LaunchArg>::CompilationArg, builder: &mut KernelBuilder, ) -> NativeExpand<TensorMap<E, K>>

Register an output variable during compilation that fill the KernelBuilder.

impl<E, K> Vectorized for TensorMap<E, K>

where E: CubePrimitive, K: TensorMapKind,

fn vector_size(&self) -> usize

fn __expand_vector_size(_scope: &mut Scope, this: Self::ExpandType) -> usize

impl<T> ViewOperations<T, ((i32, i32, i32), usize)> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, ((i32, i32, i32, i32), (u32, u32))> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, ((i32, i32, i32, i32, i32), (u32, u32, u32))> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, ((u32, u32, u32), usize)> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, ((u32, u32, u32, u32), (u32, u32))> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, ((u32, u32, u32, u32, u32), (u32, u32, u32))> for TensorMap<T, Im2col>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T, P, O> ViewOperations<T, (Sequence<P>, Sequence<O>)> for TensorMap<T, Im2col>

where T: CubePrimitive, P: CubePrimitive + Coordinates, O: CubePrimitive + Coordinates,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (i32, i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (i32, i32, i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (u32, u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, (u32, u32, u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T, N> ViewOperations<T, Sequence<N>> for TensorMap<T, Tiled>

where T: CubePrimitive, N: CubePrimitive + Coordinates,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, i32> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperations<T, usize> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn read(&self, pos: C) -> T

fn read_checked(&self, pos: C) -> T

fn read_masked(&self, pos: C, value: T) -> T

fn read_unchecked(&self, pos: C) -> T

fn to_linear_slice(&self, pos: C, size: C) -> Slice<T>

Create a slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut Slice<T, ReadWrite>, pos: C, )

.Execute a TMA load into shared memory, if the underlying storage supports it. Panics if it’s unsupported.

fn shape(&self) -> C

fn is_in_bounds(&self, pos: C) -> bool

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_masked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_to_linear_slice( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T> as CubeType>::ExpandType

fn __expand_tensor_map_load( scope: &mut Scope, this: Self::ExpandType, barrier: <Barrier as CubeType>::ExpandType, shared_memory: <Slice<T, ReadWrite> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, ) -> <C as CubeType>::ExpandType

fn __expand_is_in_bounds( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (i32, i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (i32, i32, i32, i32, i32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (u32, u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, (u32, u32, u32, u32, u32)> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T, N> ViewOperationsMut<T, Sequence<N>> for TensorMap<T, Tiled>

where T: CubePrimitive, N: CubePrimitive + Coordinates,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, i32> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<T> ViewOperationsMut<T, usize> for TensorMap<T, Tiled>

where T: CubePrimitive,

fn write(&self, pos: C, value: T)

fn write_checked(&self, pos: C, value: T)

fn to_linear_slice_mut(&self, pos: C, size: C) -> Slice<T, ReadWrite>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices.

fn tensor_map_store(&self, shared_memory: &Slice<T>, pos: C)

.Execute a TMA store into global memory, if the underlying storage supports it. Panics if it’s unsupported.

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_write_checked( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_to_linear_slice_mut( scope: &mut Scope, this: Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <Slice<T, ReadWrite> as CubeType>::ExpandType

fn __expand_tensor_map_store( scope: &mut Scope, this: Self::ExpandType, shared_memory: <Slice<T> as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<E, N> VirtualTensorOperations<E, N> for TensorMap<E, Tiled>

where E: Numeric, N: Size,

fn as_tensor_map(&self) -> ComptimeOption<TensorMap<E, Tiled>>

fn read(&self, _index: usize) -> Vector<E, N>

Read the tensor at the given index.

fn read_window(&self, _start: usize, _end: usize) -> Slice<Vector<E, N>>

fn write(&self, _index: usize, _value: Vector<E, N>)

Write the tensor at the given index.

fn shape(&self, _axis: usize) -> usize

Get the shape of the tensor at the given axis.

fn stride(&self, _axis: usize) -> usize

Get the stride of the tensor at the given axis.

fn rank(&self) -> usize

Get the rank of the tensor.

fn len(&self) -> usize

fn buffer_len(&self) -> usize

fn __expand_as_tensor_map( scope: &mut Scope, this: Self::ExpandType, ) -> <ComptimeOption<TensorMap<E, Tiled>> as CubeType>::ExpandType

fn __expand_read( scope: &mut Scope, this: Self::ExpandType, _index: <usize as CubeType>::ExpandType, ) -> <Vector<E, N> as CubeType>::ExpandType

fn __expand_read_window( scope: &mut Scope, this: Self::ExpandType, _start: <usize as CubeType>::ExpandType, _end: <usize as CubeType>::ExpandType, ) -> <Slice<Vector<E, N>> as CubeType>::ExpandType

fn __expand_write( scope: &mut Scope, this: Self::ExpandType, _index: <usize as CubeType>::ExpandType, _value: <Vector<E, N> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn __expand_shape( scope: &mut Scope, this: Self::ExpandType, _axis: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

fn __expand_stride( scope: &mut Scope, this: Self::ExpandType, _axis: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType

fn __expand_rank( scope: &mut Scope, this: Self::ExpandType, ) -> <usize as CubeType>::ExpandType

fn __expand_len( scope: &mut Scope, this: Self::ExpandType, ) -> <usize as CubeType>::ExpandType

fn __expand_buffer_len( scope: &mut Scope, this: Self::ExpandType, ) -> <usize as CubeType>::ExpandType

impl<E, K> Copy for TensorMap<E, K>

where E: CubePrimitive, K: TensorMapKind,