Struct MmaDefinitionExpand 

pub struct MmaDefinitionExpand<A: RudaType, B: RudaType, CD: RudaType> {
    pub m: usize,
    pub n: usize,
    pub k: usize,
    pub a_type: StorageType,
    pub b_type: StorageType,
    pub cd_type: StorageType,
    pub scales_factor: Option<usize>,
    pub scales_type: Option<StorageType>,
    /* private fields */
}

Expand type of MmaDefinition.

Fields

m: usize

n: usize

k: usize

a_type: StorageType

b_type: StorageType

cd_type: StorageType

scales_factor: Option<usize>

scales_type: Option<StorageType>

Implementations

impl<A: Scalar, B: Scalar, CD: Scalar> MmaDefinitionExpand<A, B, CD>

pub fn __expand_num_elems_method( &self, scope: &mut Scope, ident: MatrixIdent, ) -> usize

pub fn __expand_elems_per_lane_method( &self, scope: &mut Scope, ident: MatrixIdent, ) -> usize

pub fn __expand_vectors_per_lane_method( &self, scope: &mut Scope, ident: MatrixIdent, ) -> usize

pub fn __expand_vector_layout_method( &self, scope: &mut Scope, ident: MatrixIdent, ) -> MatrixLayout

pub fn __expand_vector_size_method( &self, scope: &mut Scope, ident: MatrixIdent, ) -> VectorSize

pub fn __expand_position_of_nth_method( &self, scope: &mut Scope, lane_id: <u32 as RudaType>::ExpandType, elem_idx: <u32 as RudaType>::ExpandType, ident: MatrixIdent, ) -> <(u32, u32) as RudaType>::ExpandType

pub fn __expand_scales_index_method( &self, scope: &mut Scope, lane_id: <u32 as RudaType>::ExpandType, ident: MatrixIdent, ) -> <u32 as RudaType>::ExpandType

pub fn __expand_scales_count_method(&self, scope: &mut Scope) -> usize

pub fn __expand_scales_vector_size_method( &self, scope: &mut Scope, ) -> VectorSize

pub fn __expand_load_matrix_method<E: RudaPrimitive, NO: Size>( &self, scope: &mut Scope, row: <Slice<E> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <Array<Vector<E::Scalar, NO>> as RudaType>::ExpandType

pub fn __expand_load_matrix_inplace_method<E: Scalar, N: Size>( &self, scope: &mut Scope, row: <Slice<E> as RudaType>::ExpandType, fragment: <Array<Vector<E, N>> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <() as RudaType>::ExpandType

pub fn __expand_store_matrix_method<E: RudaPrimitive, N: Size>( &self, scope: &mut Scope, row: <Slice<E, ReadWrite> as RudaType>::ExpandType, registers: <Array<Vector<E::Scalar, N>> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <() as RudaType>::ExpandType

pub fn __expand_execute_method<NA: Size, NB: Size, NC: Size>( &self, scope: &mut Scope, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, ) -> <Array<Vector<CD, NC>> as RudaType>::ExpandType

pub fn __expand_execute_inplace_method<NA: Size, NB: Size, NC: Size>( &self, scope: &mut Scope, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_execute_scaled_method<S: Scalar, NA: Size, NB: Size, NC: Size, NS: Size>( &self, scope: &mut Scope, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, scales_a: <Vector<S, NS> as RudaType>::ExpandType, scales_b: <Vector<S, NS> as RudaType>::ExpandType, ) -> <Array<Vector<CD, NC>> as RudaType>::ExpandType

pub fn __expand_new(scope: &mut Scope, m: usize, n: usize, k: usize) -> Self

pub fn __expand_new_scaled<S: RudaPrimitive>( scope: &mut Scope, m: usize, n: usize, k: usize, scale_factor: usize, ) -> Self

pub fn __expand_num_elems( scope: &mut Scope, this: &Self, ident: MatrixIdent, ) -> usize

pub fn __expand_elems_per_lane( scope: &mut Scope, this: &Self, ident: MatrixIdent, ) -> usize

pub fn __expand_vectors_per_lane( scope: &mut Scope, this: &Self, ident: MatrixIdent, ) -> usize

pub fn __expand_vector_layout( scope: &mut Scope, this: &Self, ident: MatrixIdent, ) -> MatrixLayout

pub fn __expand_vector_size( scope: &mut Scope, this: &Self, ident: MatrixIdent, ) -> VectorSize

pub fn __expand_position_of_nth( scope: &mut Scope, this: &Self, lane_id: <u32 as RudaType>::ExpandType, elem_idx: <u32 as RudaType>::ExpandType, ident: MatrixIdent, ) -> <(u32, u32) as RudaType>::ExpandType

pub fn __expand_scales_index( scope: &mut Scope, this: &Self, lane_id: <u32 as RudaType>::ExpandType, ident: MatrixIdent, ) -> <u32 as RudaType>::ExpandType

pub fn __expand_scales_count(scope: &mut Scope, this: &Self) -> usize

pub fn __expand_scales_vector_size(scope: &mut Scope, this: &Self) -> VectorSize

pub fn __expand_load_matrix<E: RudaPrimitive, NO: Size>( scope: &mut Scope, this: &Self, row: <Slice<E> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <Array<Vector<E::Scalar, NO>> as RudaType>::ExpandType

pub fn __expand_load_matrix_inplace<E: Scalar, N: Size>( scope: &mut Scope, this: &Self, row: <Slice<E> as RudaType>::ExpandType, fragment: <Array<Vector<E, N>> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <() as RudaType>::ExpandType

pub fn __expand_store_matrix<E: RudaPrimitive, N: Size>( scope: &mut Scope, this: &Self, row: <Slice<E, ReadWrite> as RudaType>::ExpandType, registers: <Array<Vector<E::Scalar, N>> as RudaType>::ExpandType, ident: MatrixIdent, num_matrices: usize, transpose: bool, ) -> <() as RudaType>::ExpandType

pub fn __expand_execute<NA: Size, NB: Size, NC: Size>( scope: &mut Scope, this: &Self, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, ) -> <Array<Vector<CD, NC>> as RudaType>::ExpandType

pub fn __expand_execute_inplace<NA: Size, NB: Size, NC: Size>( scope: &mut Scope, this: &Self, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, ) -> <() as RudaType>::ExpandType

pub fn __expand_execute_scaled<S: Scalar, NA: Size, NB: Size, NC: Size, NS: Size>( scope: &mut Scope, this: &Self, registers_a: <Array<Vector<A, NA>> as RudaType>::ExpandType, registers_b: <Array<Vector<B, NB>> as RudaType>::ExpandType, registers_c: <Array<Vector<CD, NC>> as RudaType>::ExpandType, scales_a: <Vector<S, NS> as RudaType>::ExpandType, scales_b: <Vector<S, NS> as RudaType>::ExpandType, ) -> <Array<Vector<CD, NC>> as RudaType>::ExpandType

Trait Implementations

impl<A: RudaType, B: RudaType, CD: RudaType> Clone for MmaDefinitionExpand<A, B, CD>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + RudaType, B: Debug + RudaType, CD: Debug + RudaType> Debug for MmaDefinitionExpand<A, B, CD>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: RudaType, B: RudaType, CD: RudaType> IntoMut for MmaDefinitionExpand<A, B, CD>

fn into_mut(self, _scope: &mut Scope) -> Self

Convert the variable into a potentially new mutable variable in scope, copying if needed.

impl<A: RudaType, B: RudaType, CD: RudaType> RudaDebug for &MmaDefinitionExpand<A, B, CD>

fn set_debug_name(&self, scope: &mut Scope, name: &'static str)

Set the debug name of this type’s expansion. Should do nothing for types that don’t appear at runtime

impl<A: RudaType, B: RudaType, CD: RudaType> RudaDebug for MmaDefinitionExpand<A, B, CD>

fn set_debug_name(&self, scope: &mut Scope, name: &'static str)

Set the debug name of this type’s expansion. Should do nothing for types that don’t appear at runtime