Struct ViewMut 

pub struct ViewMut<'a, E: CubePrimitive, C: Coordinates> { /* private fields */ }

Mutable view Note: Clone and Copy should ideally not be there, but are required for good ergonomics until Reborrow and CoerceShared are implemented and stabilized.

Implementations

impl<'a, E: CubePrimitive, C: Coordinates + 'a> ViewMut<'a, E, C>

pub fn new<V: ViewOperationsMut<E, S> + 'a, S: Coordinates>( view: V, layout: impl Into<VirtualLayout<C, S>>, ) -> Self

Create a new tensor view from an underlying concrete storage and a layout to map it into the target coordinate space

pub fn __expand_new<V: ViewOperationsMut<E, S> + 'a, S: Coordinates + 'a>( scope: &Scope, view: V::ExpandType, layout: VirtualLayoutExpand<C, S>, ) -> ViewMutExpand<'a, E, C>

Expand function for View::new

impl<'a, E: CubePrimitive, C: Coordinates + 'a> ViewMut<'a, E, C>

pub fn view<T: Coordinates + 'a>( self, _layout: impl Into<VirtualLayout<T, C>>, ) -> ViewMut<'a, E, T>

pub fn __expand_view<T: Coordinates + 'a>( scope: &Scope, this: ViewMutExpand<'a, E, C>, layout: VirtualLayoutExpand<T, C>, ) -> ViewMutExpand<'a, E, T>

impl<'a, E: CubePrimitive, C: Coordinates> ViewMut<'a, E, C>

pub fn shape(&self) -> C

Calls Layout::shape on the view’s layout

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

Calls Layout::is_in_bounds on the view’s layout

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

Calls Layout::shape on the view’s layout

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

Calls Layout::is_in_bounds on the view’s layout

impl<'a, E: CubePrimitive, C: Coordinates> ViewMut<'a, E, C>

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

Read a value at pos. The layout handles translation into a concrete index.

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

Read a value at pos. The layout handles translation into a concrete index. Reading is done unchecked

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

Read a value at pos if it’s in bounds. The layout handles translation into a concrete index.

pub fn read_masked(&self, pos: C, mask_value: E) -> E

Read a value at pos if it’s in bounds, returning mask_value otherwise. The layout handles translation into a concrete index.

pub fn as_linear_slice(&self) -> &'a [E]

Interpret this view as a linear slice encompassing the entire view.

Safety

No checking is done on whether the slice is contiguous in memory.

pub fn vector_size(&self) -> VectorSize

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

Read a value at pos. The layout handles translation into a concrete index.

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

Read a value at pos. The layout handles translation into a concrete index. Reading is done unchecked

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

Read a value at pos if it’s in bounds. The layout handles translation into a concrete index.

pub fn __expand_read_masked( scope: &Scope, this: &<Self as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, mask_value: <E as CubeType>::ExpandType, ) -> <E as CubeType>::ExpandType

Read a value at pos if it’s in bounds, returning mask_value otherwise. The layout handles translation into a concrete index.

pub fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer <Self as CubeType>::ExpandType, ) -> &'a <[E] as CubeType>::ExpandType

Interpret this view as a linear slice encompassing the entire view.

Safety

No checking is done on whether the slice is contiguous in memory.

pub fn __expand_vector_size( scope: &Scope, this: &<Self as CubeType>::ExpandType, ) -> VectorSize

impl<'a, E: CubePrimitive, C: Coordinates + 'static> ViewMut<'a, E, C>

pub fn slice(self, pos: C, size: C) -> ViewMut<'a, E, C>

Create a slice starting from pos, with size. The layout handles translation into concrete indices. Size will be clamped to the current layout size.

pub fn slice_unchecked(self, pos: C, size: C) -> ViewMut<'a, E, C>

Create a slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size. #Safety Access is always unchecked

pub fn __expand_slice<'scope>( scope: &'scope Scope, this: <Self as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <ViewMut<'a, E, C> as CubeType>::ExpandType

Create a slice starting from pos, with size. The layout handles translation into concrete indices. Size will be clamped to the current layout size.

pub fn __expand_slice_unchecked<'scope>( scope: &'scope Scope, this: <Self as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <ViewMut<'a, E, C> as CubeType>::ExpandType

Create a slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size. #Safety Access is always unchecked

impl<'a, E: CubePrimitive, C: Coordinates + 'a> ViewMut<'a, E, C>

pub fn tensor_map_load( &self, barrier: &Barrier, shared_memory: &mut [E], pos: C, )

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

pub fn __expand_tensor_map_load( scope: &Scope, this: &<Self as CubeType>::ExpandType, barrier: &<Barrier as CubeType>::ExpandType, shared_memory: &mut <[E] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )

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

impl<'a, E: CubePrimitive, C: Coordinates + 'a> ViewMut<'a, E, C>

pub fn as_read(self) -> View<'a, E, C>

Reborrow this mutable view as a read-only View over the same storage. Lets a single ViewMut carrier serve both read and write paths without a second handle.

pub fn __expand_as_read( scope: &Scope, this: ViewMutExpand<'a, E, C>, ) -> ViewExpand<'a, E, C>

impl<'a, E: CubePrimitive, C: Coordinates + 'a> ViewMut<'a, E, C>

pub fn view_mut<'b, T: Coordinates + 'a>( self, _layout: impl Layout<Coordinates = T, SourceCoordinates = C>, ) -> ViewMut<'b, E, T>

where 'a: 'b,

pub fn __expand_view_mut<T: Coordinates + 'a>( scope: &Scope, this: ViewMutExpand<'a, E, C>, layout: VirtualLayoutExpand<T, C>, ) -> ViewMutExpand<'a, E, T>

impl<'a, E: CubePrimitive, C: Coordinates> ViewMut<'a, E, C>

pub fn write(&mut self, pos: C, value: E)

Write a value to pos. The layout handles translation into a concrete index.

pub fn write_checked(&mut self, pos: C, value: E)

Write a value to pos if it’s in bounds. The layout handles translation into a concrete index.

pub fn as_linear_slice_mut(&mut self) -> &'a mut [E]

Interpret this view as a mutable linear slice encompassing the entire view.

Safety

No checking is done on whether the slice is contiguous in memory.

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

Write a value to pos. The layout handles translation into a concrete index.

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

Write a value to pos if it’s in bounds. The layout handles translation into a concrete index.

pub fn __expand_as_linear_slice_mut<'infer, 'scope>( scope: &'scope Scope, this: &'infer mut <Self as CubeType>::ExpandType, ) -> &'a mut <[E] as CubeType>::ExpandType

Interpret this view as a mutable linear slice encompassing the entire view.

Safety

No checking is done on whether the slice is contiguous in memory.

impl<'a, E: CubePrimitive, C: Coordinates + 'static> ViewMut<'a, E, C>

pub fn slice_mut(self, pos: C, size: C) -> ViewMut<'a, E, C>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size.

pub fn slice_mut_unchecked(self, pos: C, size: C) -> ViewMut<'a, E, C>

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size.

Safety

Access is always unchecked.

pub fn __expand_slice_mut<'scope>( scope: &'scope Scope, this: <Self as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <ViewMut<'a, E, C> as CubeType>::ExpandType

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size.

pub fn __expand_slice_mut_unchecked<'scope>( scope: &'scope Scope, this: <Self as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, size: <C as CubeType>::ExpandType, ) -> <ViewMut<'a, E, C> as CubeType>::ExpandType

Create a mutable slice starting from pos, with size. The layout handles translation into concrete indices. Size and pos will be clamped to the current layout size.

Safety

Access is always unchecked.

impl<'a, E: CubePrimitive, C: Coordinates> ViewMut<'a, E, C>

pub fn tensor_map_store(&self, shared_memory: &[E], pos: C)

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

pub fn __expand_tensor_map_store( scope: &Scope, this: &<Self as CubeType>::ExpandType, shared_memory: &<[E] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )

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

Trait Implementations

impl<'a, E: Clone + CubePrimitive, C: Clone + Coordinates> Clone for ViewMut<'a, E, C>

fn clone(&self) -> ViewMut<'a, E, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, E: Copy + CubePrimitive, C: Copy + Coordinates> Copy for ViewMut<'a, E, C>

impl<'a, E: CubePrimitive, C: Coordinates + 'a> CubeType for ViewMut<'a, E, C>

type ExpandType = ViewMutExpand<'a, E, C>

impl<E: CubePrimitive, C: Coordinates + 'static> LaunchArg for ViewMut<'static, E, C>

type RuntimeArg<R: Runtime> = ViewArg<C, R>

The runtime argument for the kernel.

type CompilationArg = ViewCompilationArg<C>

Compilation argument.

fn register<R: Runtime>( arg: Self::RuntimeArg<R>, launcher: &mut KernelLauncher<R>, ) -> Self::CompilationArg

fn expand( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> <Self as CubeType>::ExpandType

Register a variable during compilation that fill the KernelBuilder.

impl<'a, T: CubePrimitive, C: Coordinates + 'a> Vectorized for ViewMut<'a, T, C>

fn vector_size(&self) -> usize

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

impl<'a, T: CubePrimitive, C: Coordinates + 'a> ViewOperations<T, C> for ViewMut<'a, T, C>

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 as_linear_slice(&self, pos: C, size: C) -> &[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 [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 as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

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

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

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

fn __expand_as_linear_slice<'infer, 'scope>( scope: &'scope Scope, this: &'infer <Self as CubeType>::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 as CubeType>::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 as CubeType>::ExpandType, ) -> <C as CubeType>::ExpandType

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

impl<'a, T: CubePrimitive, C: Coordinates + 'a> ViewOperationsMut<T, C> for ViewMut<'a, T, C>

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

fn write_checked(&self, pos: C, value: 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.

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 as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, value: <T as CubeType>::ExpandType, )

fn __expand_write_checked( scope: &Scope, this: &<Self as CubeType>::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 as CubeType>::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 as CubeType>::ExpandType, shared_memory: &<[T] as CubeType>::ExpandType, pos: <C as CubeType>::ExpandType, )