Struct QuantizedView 

pub struct QuantizedView<Q: Scalar, NQ: Size, S: Scalar, F: Numeric, NF: Size, C: Coordinates + 'static> { /* private fields */ }

View that dequantizes after loads. Scales layout should take values coordinates and map them to the corresponding scale.

Warning

Assumes only one scale maps to a single load. Adjust vector size of values or block size to ensure this. Must ensure block_size.is_multiple_of(vector_size * scheme.num_quants()).

Implementations

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

pub fn new( values: View<Vector<Q, NQ>, C>, scales: View<S, C>, scheme: QuantScheme, ) -> Self

pub fn __expand_new( scope: &mut Scope, values: <View<Vector<Q, NQ>, C> as CubeType>::ExpandType, scales: <View<S, C> as CubeType>::ExpandType, scheme: QuantScheme, ) -> <Self as CubeType>::ExpandType

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

pub fn view(self) -> View<Vector<F, NF>, C>

pub fn __expand_view( scope: &mut Scope, this: QuantizedViewExpand<Q, NQ, S, F, NF, C>, ) -> ViewExpand<Vector<F, NF>, C, ReadOnly>

Trait Implementations

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

fn clone(&self) -> QuantizedView<Q, NQ, S, F, NF, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

type ExpandType = QuantizedViewExpand<Q, NQ, S, F, NF, C>

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

where View<Vector<Q, NQ>, C>: LaunchArg, View<S, C>: LaunchArg,

type RuntimeArg<R: Runtime> = QuantizedViewLaunch<Q, NQ, S, F, NF, C, R>

The runtime argument for the kernel.

type CompilationArg = QuantizedViewCompilationArg<Q, NQ, S, F, NF, 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 an input variable during compilation that fill the KernelBuilder.

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

Register an output variable during compilation that fill the KernelBuilder.

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

fn vector_size(&self) -> usize

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

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>

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

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