Struct Levels 

pub struct Levels { /* private fields */ }

A partitioning stated from the leaf up.

Implementations

impl Levels

pub fn leaf(tile: &[(Axis, usize)]) -> Self

The tile one worker holds at the bottom, e.g. an instruction’s shape.

pub fn walk(self, counts: &[(Axis, usize)]) -> Self

Every worker steps through this many of the level below.

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

Every worker steps through every tile of the level below along axes.

pub fn units(self, counts: &[(Axis, usize)]) -> Self

This many of the thing below, one per unit of the plane.

pub fn units_distributed(self, axis: Axis, count: usize) -> Self

This many of the level below, taken in turns by however many units the launch runs.

pub fn planes(self, counts: &[(Axis, usize)]) -> Self

This many of the level below, one per plane of the cube.

pub fn plane_groups(self, planes: usize, counts: &[(Axis, usize)]) -> Self

This many of the level below, one per group of planes consecutive planes of the cube: an instruction the group’s planes issue together, a warpgroup MMA’s four, takes each tile.

pub fn planes_across(self, axis: Axis, planes: usize) -> Self

Every tile of the level below along axis, dealt to planes planes of the cube in runs: the planes need not divide the tiles, and a plane past the last whole run takes the rest. What splits a walk between the planes where its steps have no factor the planes fit.

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

One cube for every box these axes hold; the entries ride the grid’s X, Y, Z in order.

pub fn launch_planes(self, axes: &[Axis], order: PlaneOrder) -> Self

One plane of the launch for every tile these axes hold, the planes taking them in order: the outermost level of a partitioning with no cube level. A plane routine’s planes share nothing, so which cube a plane sits in is the launch’s grouping, not a level of the partitioning; the order sets the cubes’ size (PlaneOrder::planes_per_cube).

pub fn launch_units(self, axes: &[Axis], cube: UnitCube) -> Self

One unit of the launch for every tile these axes hold, in row order, the units grouped in cubes of cube: the outermost level of a partitioning with no cube or plane level. A unit routine’s units share nothing, so which cube or plane a unit sits in is the launch’s grouping, not a level of the partitioning, and for unit in &partitioning walks them.

pub fn across(self, axis: Axis, cubes: usize) -> Self

Distribute axis of the cube level just stated across cubes cubes, each a run (split-K).

pub fn shared_by(self, cubes: usize) -> Self

Distribute this level’s tiles to cubes cubes as one flat index (stream-K).

pub fn ordered(self, order: CubeOrder) -> Self

The order the cube level just stated distributes its boxes to the grid.

pub fn filled_by(self, n: usize) -> Self

This walk’s stages are filled by n extra planes that take no tile.

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

Batch axes this cube level hands out one of.

pub fn interleaved(self, axis: Axis) -> Self

The workers of the level just stated take axis’s tiles in turns rather than in runs.

pub fn reversed(self, axis: Axis) -> Self

The level just stated, a cube level or a plane level spanning the launch, hands out axis’s tiles from the last to the first: the first workers launched take the last tiles. Where the later tiles hold more work, the heaviest start first and the light ones fill in behind them.

pub fn build(self) -> Vec<Level>

The levels, outermost first.

pub fn level(self) -> Level

The single level this tiling states. Panics if it states several.

Trait Implementations

impl Clone for Levels

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Levels

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

Formats the value using the given formatter.