pub struct TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,{ /* private fields */ }Expand description
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§
Source§impl<T, K> TensorMap<T, K>where
T: Scalar,
K: TensorMapKind,
impl<T, K> TensorMap<T, K>where
T: Scalar,
K: TensorMapKind,
Sourcepub fn coordinate(&self, index: usize, dim: usize) -> usize
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.
Sourcepub fn __expand_coordinate(
scope: &Scope,
this: &<TensorMap<T, K> as CubeType>::ExpandType,
index: <usize as CubeType>::ExpandType,
dim: <usize as CubeType>::ExpandType,
) -> <usize as CubeType>::ExpandType
pub fn __expand_coordinate( scope: &Scope, this: &<TensorMap<T, K> as CubeType>::ExpandType, index: <usize as CubeType>::ExpandType, dim: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType
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.
Source§impl<T, K> TensorMap<T, K>where
T: Scalar,
K: TensorMapKind,
impl<T, K> TensorMap<T, K>where
T: Scalar,
K: TensorMapKind,
Sourcepub fn len(&self) -> usize
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.
Sourcepub fn buffer_len(&self) -> usize
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.
Sourcepub fn downcast<E>(&self) -> TensorMap<E, K>where
E: CubePrimitive,
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_stride( scope: &Scope, expand: NativeExpand<TensorMap<T, K>>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>
pub fn __expand_shape( scope: &Scope, expand: NativeExpand<TensorMap<T, K>>, dim: NativeExpand<usize>, ) -> NativeExpand<usize>
pub fn __expand_len( scope: &Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>
pub fn __expand_buffer_len( scope: &Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>
pub fn __expand_rank( scope: &Scope, expand: NativeExpand<TensorMap<T, K>>, ) -> NativeExpand<usize>
Trait Implementations§
Source§impl<E> AsTensorView<E> for TensorMap<E, Tiled>where
E: CubePrimitive,
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: &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: &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: &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: &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: &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: &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: &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: &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: &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: &Scope,
this: Self::ExpandType,
layout: VirtualLayoutExpand<C, (i32, i32, i32, i32, i32)>,
) -> ViewExpand<'_, E, C>where
C: Coordinates + 'static,
Source§impl<E> AsTensorViewMut<E> for TensorMap<E, Tiled>where
E: CubePrimitive,
impl<E> AsTensorViewMut<E> for TensorMap<E, Tiled>where
E: CubePrimitive,
fn view_mut_1d<C>(
&mut self,
layout: impl Into<VirtualLayout<C, usize>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_2d<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (u32, u32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_3d<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (u32, u32, u32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_4d<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_5d<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (u32, u32, u32, u32, u32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_1i<C>(
&mut self,
layout: impl Into<VirtualLayout<C, i32>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_2i<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (i32, i32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_3i<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (i32, i32, i32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_4i<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
fn view_mut_5i<C>(
&mut self,
layout: impl Into<VirtualLayout<C, (i32, i32, i32, i32, i32)>>,
) -> ViewMut<'_, E, C>where
C: Coordinates + 'static,
impl<E, K> Copy for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
Source§impl<E, K> CubeType for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
impl<E, K> CubeType for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
type ExpandType = NativeExpand<TensorMap<E, K>>
Source§impl<E, K> LaunchArg for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
impl<E, K> LaunchArg for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
Source§type RuntimeArg<R: Runtime> = TensorMapArg<R, K>
type RuntimeArg<R: Runtime> = TensorMapArg<R, K>
The runtime argument for the kernel.
Source§type CompilationArg = ()
type CompilationArg = ()
Compilation argument.
fn register<R>(
arg: <TensorMap<E, K> as LaunchArg>::RuntimeArg<R>,
launcher: &mut KernelLauncher<R>,
) -> <TensorMap<E, K> as LaunchArg>::CompilationArgwhere
R: Runtime,
Source§fn expand(
_arg: &<TensorMap<E, K> as LaunchArg>::CompilationArg,
builder: &mut KernelBuilder,
) -> NativeExpand<TensorMap<E, K>>
fn expand( _arg: &<TensorMap<E, K> as LaunchArg>::CompilationArg, builder: &mut KernelBuilder, ) -> NativeExpand<TensorMap<E, K>>
Register a variable during compilation that fill the
KernelBuilder.Source§impl<E, K> Vectorized for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
impl<E, K> Vectorized for TensorMap<E, K>where
E: CubePrimitive,
K: TensorMapKind,
fn vector_size(&self) -> usize
fn __expand_vector_size(scope: &Scope, this: &Self::ExpandType) -> usize
Source§impl<T> ViewOperations<T, ((i32, i32, i32), usize)> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, ((i32, i32, i32, i32), (u32, u32))> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, ((i32, i32, i32, i32, i32), (u32, u32, u32))> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, ((u32, u32, u32), usize)> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, ((u32, u32, u32, u32), (u32, u32))> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, ((u32, u32, u32, u32, u32), (u32, u32, u32))> for TensorMap<T, Im2col>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T, P, O> ViewOperations<T, (Sequence<P>, Sequence<O>)> for TensorMap<T, Im2col>
impl<T, P, O> ViewOperations<T, (Sequence<P>, Sequence<O>)> for TensorMap<T, Im2col>
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (i32, i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (i32, i32, i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (u32, u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, (u32, u32, u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T, N> ViewOperations<T, Sequence<N>> for TensorMap<T, Tiled>
impl<T, N> ViewOperations<T, Sequence<N>> for TensorMap<T, Tiled>
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, i32> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperations<T, usize> for TensorMap<T, Tiled>where
T: CubePrimitive,
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
Source§fn as_linear_slice(&self, pos: C, size: C) -> &[T]
fn as_linear_slice(&self, pos: C, size: C) -> &[T]
Create a slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], pos: C)
fn tensor_map_load(&self, barrier: &Barrier, shared_memory: &mut [T], 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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_masked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_read_unchecked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType
fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_load( scope: &Scope, this: &Self::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, ) -> <C as CubeType>::ExpandType
fn __expand_is_in_bounds( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <bool as CubeType>::ExpandType
Source§impl<T> ViewOperationsMut<T, (i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (i32, i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (i32, i32, i32, i32, i32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (u32, u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, (u32, u32, u32, u32, u32)> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T, N> ViewOperationsMut<T, Sequence<N>> for TensorMap<T, Tiled>
impl<T, N> ViewOperationsMut<T, Sequence<N>> for TensorMap<T, Tiled>
fn write(&self, pos: C, value: T)
fn write_checked(&self, pos: C, value: T)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, i32> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<T> ViewOperationsMut<T, usize> for TensorMap<T, Tiled>where
T: CubePrimitive,
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)
Source§fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
fn as_linear_slice_mut(&self, pos: C, size: C) -> &mut [T]
Create a mutable slice starting from
pos, with size.
The layout handles translation into concrete indices.Source§fn tensor_map_store(&self, shared_memory: &[T], pos: C)
fn tensor_map_store(&self, shared_memory: &[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: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_write_checked( scope: &Scope, this: &Self::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )
fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> &'infer mut <[T] as CubeType>::ExpandType ⓘ
fn __expand_tensor_map_store( scope: &Scope, this: &Self::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )
Source§impl<E, N> VirtualTensorOperations<E, N> for TensorMap<E, Tiled>
impl<E, N> VirtualTensorOperations<E, N> for TensorMap<E, Tiled>
fn as_tensor_map(&self) -> ComptimeOption<TensorMap<E, Tiled>>
fn read_window(&self, _start: usize, _end: usize) -> &[Vector<E, N>]
fn len(&self) -> usize
fn buffer_len(&self) -> usize
fn __expand_as_tensor_map( scope: &Scope, this: &Self::ExpandType, ) -> <ComptimeOption<TensorMap<E, Tiled>> as CubeType>::ExpandType
fn __expand_read( scope: &Scope, this: &Self::ExpandType, _index: <usize as CubeType>::ExpandType, ) -> <Vector<E, N> as CubeType>::ExpandType
fn __expand_read_window<'infer, 'scope>( scope: &'scope Scope, this: &'infer Self::ExpandType, _start: <usize as CubeType>::ExpandType, _end: <usize as CubeType>::ExpandType, ) -> &'infer <[Vector<E, N>] as CubeType>::ExpandType ⓘ
fn __expand_write( scope: &Scope, this: &mut Self::ExpandType, _index: <usize as CubeType>::ExpandType, value: <Vector<E, N> as CubeType>::ExpandType, )
fn __expand_shape( scope: &Scope, this: &Self::ExpandType, _axis: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType
fn __expand_stride( scope: &Scope, this: &Self::ExpandType, _axis: <usize as CubeType>::ExpandType, ) -> <usize as CubeType>::ExpandType
fn __expand_rank( scope: &Scope, this: &Self::ExpandType, ) -> <usize as CubeType>::ExpandType
fn __expand_len( scope: &Scope, this: &Self::ExpandType, ) -> <usize as CubeType>::ExpandType
fn __expand_buffer_len( scope: &Scope, this: &Self::ExpandType, ) -> <usize as CubeType>::ExpandType
Auto Trait Implementations§
impl<E, K> Freeze for TensorMap<E, K>
impl<E, K> RefUnwindSafe for TensorMap<E, K>
impl<E, K> Send for TensorMap<E, K>
impl<E, K> Sync for TensorMap<E, K>
impl<E, K> Unpin for TensorMap<E, K>
impl<E, K> UnsafeUnpin for TensorMap<E, K>
impl<E, K> UnwindSafe for TensorMap<E, K>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneExpand for Twhere
T: Clone,
impl<T> CloneExpand for Twhere
T: Clone,
fn __expand_clone_method(&self, _: &Scope) -> T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Converts
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Converts
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Converts
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Converts
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreimpl<T> NativeCubeType for T
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<T> TuneInputs for T
impl<T> TuneInputs for T
Source§impl<T> ViewLayoutLaunchArg for T
impl<T> ViewLayoutLaunchArg for T
Source§type RuntimeArg<R: Runtime> = <T as LaunchArg>::RuntimeArg<R>
type RuntimeArg<R: Runtime> = <T as LaunchArg>::RuntimeArg<R>
The runtime argument for the kernel.
Source§type CompilationArg = <T as LaunchArg>::CompilationArg
type CompilationArg = <T as LaunchArg>::CompilationArg
Compilation argument.
fn register<R, B>( arg: <T as ViewLayoutLaunchArg>::RuntimeArg<R>, _buffer: &B, _ty: Type, launcher: &mut KernelLauncher<R>, ) -> <T as ViewLayoutLaunchArg>::CompilationArg
Source§fn expand(
arg: &<T as ViewLayoutLaunchArg>::CompilationArg,
_ty: Type,
builder: &mut KernelBuilder,
) -> <T as CubeType>::ExpandType
fn expand( arg: &<T as ViewLayoutLaunchArg>::CompilationArg, _ty: Type, builder: &mut KernelBuilder, ) -> <T as CubeType>::ExpandType
Register an input variable during compilation that fill the
KernelBuilder.Source§fn expand_output(
arg: &Self::CompilationArg,
ty: Type,
builder: &mut KernelBuilder,
) -> Self::ExpandType
fn expand_output( arg: &Self::CompilationArg, ty: Type, builder: &mut KernelBuilder, ) -> Self::ExpandType
Register an output variable during compilation that fill the
KernelBuilder.