Trait ViewOperations 

pub trait ViewOperations<T: CubePrimitive, C: Coordinates>: Vectorized + CubeType<ExpandType: ViewOperationsExpand<T, C>> {
    // Provided methods
    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, ReadOnly> { ... }
    fn tensor_map_load(
        &self,
        barrier: &Barrier,
        shared_memory: &mut Slice<T, ReadWrite>,
        pos: C,
    ) { ... }
    fn shape(&self) -> C { ... }
    fn is_in_bounds(&self, pos: C) -> bool { ... }
    fn __expand_read(
        scope: &mut Scope,
        this: <Self as CubeType>::ExpandType,
        pos: <C as CubeType>::ExpandType,
    ) -> <T as CubeType>::ExpandType { ... }
    fn __expand_read_checked(
        scope: &mut Scope,
        this: <Self as CubeType>::ExpandType,
        pos: <C as CubeType>::ExpandType,
    ) -> <T as CubeType>::ExpandType { ... }
    fn __expand_read_masked(
        scope: &mut 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: &mut Scope,
        this: <Self as CubeType>::ExpandType,
        pos: <C as CubeType>::ExpandType,
    ) -> <T as CubeType>::ExpandType { ... }
    fn __expand_to_linear_slice(
        scope: &mut Scope,
        this: <Self as CubeType>::ExpandType,
        pos: <C as CubeType>::ExpandType,
        size: <C as CubeType>::ExpandType,
    ) -> <Slice<T, ReadOnly> as CubeType>::ExpandType { ... }
    fn __expand_tensor_map_load(
        scope: &mut Scope,
        this: <Self as CubeType>::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 as CubeType>::ExpandType,
    ) -> <C as CubeType>::ExpandType { ... }
    fn __expand_is_in_bounds(
        scope: &mut Scope,
        this: <Self as CubeType>::ExpandType,
        pos: <C as CubeType>::ExpandType,
    ) -> <bool as CubeType>::ExpandType { ... }
}

Type from which we can read values in cube functions. For a mutable version, see ListMut.

Provided Methods

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, ReadOnly>

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

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

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

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

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

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, T: CubePrimitive, C: Coordinates, L: ViewOperations<T, C>> ViewOperations<T, C> for &'a mut L

where &'a mut L: CubeType<ExpandType = L::ExpandType>,

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

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

impl<'a, T: CubePrimitive, C: Coordinates, V: ViewOperations<T, C>> ViewOperations<T, C> for &'a V

where &'a V: CubeType<ExpandType = V::ExpandType>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T: CubePrimitive> ViewOperations<T, usize> for Array<T>

impl<T: CubePrimitive> ViewOperations<T, usize> for SharedMemory<T>

impl<T: CubePrimitive> ViewOperations<T, usize> for Tensor<T>

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

impl<T: CubePrimitive, IO: SliceVisibility> ViewOperations<T, usize> for Slice<T, IO>

impl<T: CubePrimitive, N: CubePrimitive + Coordinates> ViewOperations<T, Sequence<N>> for TensorMap<T, Tiled>

impl<T: CubePrimitive, P: CubePrimitive + Coordinates, O: CubePrimitive + Coordinates> ViewOperations<T, (Sequence<P>, Sequence<O>)> for TensorMap<T, Im2col>

Implementors

impl<Q: Scalar, NQ: Size, S: Scalar, F: Numeric, NF: Size, C: Coordinates + 'static> ViewOperations<Vector<F, NF>, C> for QuantizedView<Q, NQ, S, F, NF, C>

impl<T: CubePrimitive, C: Coordinates, IO: Clone> ViewOperations<T, C> for View<T, C, IO>

impl<T: CubePrimitive, C: Coordinates, S: Coordinates, V> ViewOperations<T, C> for VirtualView<T, C, S, V>

where V: ViewOperations<T, S>,

impl<T: CubePrimitive, C: Coordinates, S: Coordinates, V> ViewOperations<T, C> for VirtualViewMut<T, C, S, V>

where V: ViewOperationsMut<T, S>,

impl<T: Numeric, N: Size, IO: Clone> ViewOperations<Vector<T, N>, usize> for VirtualTensor<T, N, IO>