Struct Accelerated 

pub struct Accelerated;

Trait Implementations

impl MatmulConfigFactory for Accelerated

type Input = TileMatmulConfigInput

type Config = Config

Configuration tailored to the matmul implementation

fn check_config(config: &Self::Config) -> Result<(), InvalidConfigError>

Asserts that the configuration for this matmul will lead to a valid computation

fn check_availability<R: Runtime, MP: MatmulPrecision>( client: &ComputeClient<R::Server, R::Channel>, config: &Self::Config, ) -> Result<(), MatmulAvailabilityError>

Checks if the client can handle the features used in this computation

fn make_config( input: Self::Input, problem: &MatmulProblem, cube_dim: &CubeDim, _cube_count: &CubeCount, _quantized: bool, ) -> Self::Config

Create config for this matmul, given launch information

impl<MP: MatmulPrecision> TileMatmul<MP> for Accelerated

type Config = Config

type Lhs = Matrix<<MP as MatmulPrecision>::ES>

Contains LHS data that can be split across the units

type Rhs = Matrix<<MP as MatmulPrecision>::ES>

Contains RHS data that can be split across the units

type Accumulator = Matrix<<MP as MatmulPrecision>::EA>

Contains output data that can be split across the units

fn execute( lhs: &Self::Lhs, rhs: &Self::Rhs, out: &mut Self::Accumulator, _config: Config, )

Executes the matrix multiplication of LHS and RHS, adding the result to the output

fn allocate_lhs(config: Config) -> Self::Lhs

Create the container for LHS data

fn allocate_rhs(config: Config) -> Self::Rhs

Create the container for RHS data

fn fill_lhs(tile: &Tile<MP::ES>, lhs: &mut Self::Lhs, config: Config)

Fill the container of LHS with data

fn fill_rhs(tile: &Tile<MP::ES>, rhs: &mut Self::Rhs, config: Config)

Fill the container of RHS with data

fn fill_accumulator( tile: &Tile<MP::EA>, acc: &mut Self::Accumulator, config: Config, )

Fill the accumulator with data

fn read_accumulator<C: Numeric>( out: &Self::Accumulator, slice: &mut SliceMut<Line<C>>, config: Config, )

Write the content of the output container to the given slice

fn allocate_accumulator(config: Self::Config) -> Self::Accumulator

Allocate the container to receive the execution output.

fn zero_accumulator(acc: &mut Self::Accumulator, _config: Self::Config)

Fill the accumulator with zeros.

fn __expand_execute( context: &mut Scope, lhs: <Self::Lhs as CubeType>::ExpandType, rhs: <Self::Rhs as CubeType>::ExpandType, out: <Self::Accumulator as CubeType>::ExpandType, _config: Config, ) -> <() as CubeType>::ExpandType

fn __expand_allocate_lhs( context: &mut Scope, config: Config, ) -> <Self::Lhs as CubeType>::ExpandType

fn __expand_allocate_rhs( context: &mut Scope, config: Config, ) -> <Self::Rhs as CubeType>::ExpandType

fn __expand_fill_lhs( context: &mut Scope, tile: <Tile<MP::ES> as CubeType>::ExpandType, lhs: <Self::Lhs as CubeType>::ExpandType, config: Config, ) -> <() as CubeType>::ExpandType

fn __expand_fill_rhs( context: &mut Scope, tile: <Tile<MP::ES> as CubeType>::ExpandType, rhs: <Self::Rhs as CubeType>::ExpandType, config: Config, ) -> <() as CubeType>::ExpandType

fn __expand_fill_accumulator( context: &mut Scope, tile: <Tile<MP::EA> as CubeType>::ExpandType, acc: <Self::Accumulator as CubeType>::ExpandType, config: Config, ) -> <() as CubeType>::ExpandType

fn __expand_read_accumulator<C: Numeric>( context: &mut Scope, out: <Self::Accumulator as CubeType>::ExpandType, slice: <SliceMut<Line<C>> as CubeType>::ExpandType, config: Config, ) -> <() as CubeType>::ExpandType

fn __expand_allocate_accumulator( context: &mut Scope, config: Self::Config, ) -> <Self::Accumulator as CubeType>::ExpandType

fn __expand_zero_accumulator( context: &mut Scope, acc: <Self::Accumulator as CubeType>::ExpandType, _config: Self::Config, ) -> <() as CubeType>::ExpandType

impl TileMatmulFamily for Accelerated

type Matmul<MP: MatmulPrecision> = Accelerated

fn tile_shape(config: &Self::Config) -> MatmulSize

fn requires_tensor_cores() -> bool