Struct Space 

pub struct Space { /* private fields */ }

Every axis with its extent, in canonical order, plus the runtime sizes of dynamic axes.

Implementations

impl Space

pub fn shape(&self) -> &Shape

pub fn rank(&self) -> usize

pub fn axis_at(&self, i: usize) -> Axis

pub fn position(&self, axis: Axis) -> usize

pub fn contains(&self, axis: Axis) -> bool

pub fn axes(&self) -> impl Iterator<Item = Axis> + '_

pub fn extent(&self, axis: Axis) -> usize

The axis’s comptime size; panics on a Dynamic axis.

pub fn extent_at(&self, i: usize) -> usize

pub fn is_dynamic(&self, axis: Axis) -> bool

pub fn subspace(&self, axes: &[Axis]) -> Space

The listed axes with their extents, in the order listed.

impl Space

pub fn count(&self, p: usize, edge: usize) -> usize

Axis p’s tile count for a sub-tile edge; comptime for a Static axis.

pub fn __expand_count( scope: &Scope, this: &<Self as CubeType>::ExpandType, p: usize, edge: usize, ) -> <usize as CubeType>::ExpandType

Axis p’s tile count for a sub-tile edge; comptime for a Static axis.

impl Space

pub const MAX_RANK: usize = 6

The most axes a space holds inline.

pub fn new(extents: &[(Axis, usize)]) -> Self

pub fn dynamic(axes: &[Axis]) -> Self

Every axis dynamic, extents resolved in-kernel from the tensors.

pub fn with_dynamic(self, axes: &[Axis]) -> Self

Flip the listed axes to Dynamic.

pub fn all_dynamic(self) -> Self

Every axis dynamic (see with_dynamic).

pub fn extents(&self) -> Vec<(Axis, usize)>

The static extents, in axis order.

pub fn merge(parts: &[&Space]) -> Space

The smallest space containing every part, axes in first-appearance order, shared axes broadcast-merged. E.g. {M,K} ∪ {K,N} ∪ {M,N} = {M,N,K}.

pub fn covering(parts: &[&Space]) -> Space

The smallest space every one of parts tiles evenly: on each axis the least common multiple of the parts’ extents, axes in first-appearance order. The box a step covers so that each operand’s load fills it whole: NVFP4 values loaded {k 16, n 2}, their scales {k 16, n 16} and an f16 activation {k 8} cover {k 16, n 16}.

Panics

On a dynamic extent, which has no multiple.

pub fn tiles(&self, tile: &Space) -> usize

How many tiles this space holds, laid side by side along every axis tile names; an axis it does not name it spans whole, one tile serving every position along it. An f16 activation loaded {k 8} fills a step {k 16, n 16} in two loads.

Panics

Where tile names an axis this space lacks, or does not divide its extent there.

pub fn difference(&self, output: &Space) -> SmallVec<[Axis; 6]>

The axes in this space but not in output: those contracted.

pub fn contracted(operands: &[&Space], output: &Space) -> SmallVec<[Axis; 6]>

The axes operands jointly contract against output.

pub fn cells(&self) -> usize

How many cells the space holds.

pub fn slices_along(&self, axis: Axis) -> usize

How many slices along axis the space holds: one for every index of its other axes. The extent of axis itself may be one a walk has yet to cut, which only the launch knows.

Trait Implementations

impl Clone for Space

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CubeType for Space

type ExpandType = SpaceExpand

impl Debug for Space

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

Formats the value using the given formatter.

impl Eq for Space

impl Hash for Space

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LaunchArg for Space

type RuntimeArg = SpaceLaunch

The runtime argument for the kernel.

type CompilationArg = SpaceCompilationArg

Compilation argument.

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

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

Register a variable during compilation that fill the KernelBuilder.

impl PartialEq for Space

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.