Struct TileArg 

pub struct TileArg<'a> {
    pub spec: TileSpec,
    pub element: ElemType,
    /* private fields */
}

An operand as a single launch argument: its values, a buffer or a TMA tensor map, its comptime TileSpec, the element its buffer holds, and the scales they are read under.

The element is data the argument carries, stated where the operand is bound (TileArgLaunch::new), not a type of the kernel’s: what the buffer holds, width of them a line. A packed buffer holds u32 words, its spec’s packing naming the fields in them; a reader decodes them into the element it asks for (Tile::dequantized), or f32 where it asks for none.

Scales are levels innermost first, so each covers more than the one inside it: NVFP4’s values carry their block scales, which carry the per-tensor scale. A plain level holding u32 is words of block scales, which only the block-scaled instruction reads; any other, a packed one included, is scales read as numbers.

Values stored as indices (Field::Index) read through the table they index, their codebook (TileArgLaunch::codebook); a gather’s runtime coefficients and offsets (TileArgLaunch::runtime_map) ride the argument too, as does the table that places their windows (TileArgLaunch::indexed), a routed product’s experts or a pool’s pages. A kernel serves every operand the same way, with tile.

Fields

spec: TileSpec

element: ElemType

The element the buffer holds.

Implementations

impl<'a> TileArg<'a>

pub fn last_arrival<'t, V: Size>( &self, partitioning: &Partitioning, portion: &Portion, i: usize, arrivals: &'t [Atomic<u32>], ) -> LastArrival<'t>

This operand as the slots of a LastArrival at the i-th box portion touches, under partitioning, whose cube level shares its steps (shared_by). The operand is laid out as Partitioning::arrival_slots says for its axes.

pub fn __expand_last_arrival<'infer, 't, 'scope, V: Size>( scope: &'scope Scope, this: &'infer <Self as CubeType>::ExpandType, partitioning: &'infer <Partitioning as CubeType>::ExpandType, portion: &'infer <Portion as CubeType>::ExpandType, i: <usize as CubeType>::ExpandType, arrivals: &'t <[Atomic<u32>] as CubeType>::ExpandType, ) -> <LastArrival<'t> as CubeType>::ExpandType

This operand as the slots of a LastArrival at the i-th box portion touches, under partitioning, whose cube level shares its steps (shared_by). The operand is laid out as Partitioning::arrival_slots says for its axes.

impl<'a> TileArg<'a>

pub fn relay<'t, V: Size>( &self, partitioning: &Partitioning, turns: &'t [Atomic<u32>], ) -> Relay<'t>

This operand as the carry of a Relay: the box the cubes splitting the contraction along its across axis take their turns at, under partitioning, whose first level is the cube level. turns arrives holding zero and is left holding zero.

pub fn __expand_relay<'infer, 't, 'scope, V: Size>( scope: &'scope Scope, this: &'infer <Self as CubeType>::ExpandType, partitioning: &'infer <Partitioning as CubeType>::ExpandType, turns: &'t <[Atomic<u32>] as CubeType>::ExpandType, ) -> <Relay<'t> as CubeType>::ExpandType

This operand as the carry of a Relay: the box the cubes splitting the contraction along its across axis take their turns at, under partitioning, whose first level is the cube level. turns arrives holding zero and is left holding zero.

impl TileArg<'_>

pub fn tile(&self, _partitioning: &Partitioning) -> Tile

Serve the operand as a Tile over the kernel’s one partitioning, under its scales.

pub fn lines<E: Numeric, V: Size>(&self) -> &Tensor<Vector<E, V>>

The buffer as lines of V of E, which must be the element it holds and the width it is bound at: what a write that adds into a line reads and writes it as. A launch that bound the buffer at another element is refused as the kernel expands.

Trait Implementations

impl<'a> CubeType for TileArg<'a>

type ExpandType = TileArgExpand<'a>

impl LaunchArg for TileArg<'static>

type RuntimeArg = TileArgLaunch

The runtime argument for the kernel.

type CompilationArg = TileArgCompilationArg

Compilation argument.

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

fn expand( arg: &Self::CompilationArg, builder: &mut KernelBuilder, ) -> TileArgExpand<'static>

Register a variable during compilation that fill the KernelBuilder.