Struct DepthwiseSpace 

pub struct DepthwiseSpace { /* private fields */ }

The space one launch runs over, in the terms the kernel builds it from: the problem’s extents and the tiling. The kernel’s comptime argument, so the space the launch sizes its grid from is the space the kernel walks.

Implementations

impl DepthwiseSpace

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

The space’s axes and their extents, every one static.

pub fn levels(&self) -> Vec<Level>

Three levels, outermost first. The first separates the output across the launch grid: an all-sequential level would put the whole convolution in one instance, which is a correct kernel and a useless one. The next two separate what one cube took across the cube’s own threads: rows go to planes, channels to lanes. The taps stay whole throughout: they are the contraction, and every tap of one output position accumulates into the same register. The levels, stated from the leaf up, in counts: one lane’s channel line by the cube’s columns by one row; the plane’s lanes across channels, in turns; the channel lines a lane holds past its first, where the tile is wider than the plane; the cube’s rows across its planes; and a cube per box, the taps whole. The channel axis takes X so that the fastest-moving cube index is the one memory is contiguous along.

Round-robin across the lanes, so a lane holding several channel lines takes every plane_size-th rather than a contiguous run: a contiguous run puts a stride between what neighbouring lanes read and breaks the coalescing the whole NHWC layout is for. Columns stay whole: they are the register block, not a split. The walk over a lane’s further lines is stated only where there are any — the old lanes level was that walk as well, its length found by dividing the tile.

pub fn space(&self) -> Space

pub fn partitioning(&self) -> Partitioning

The space with the levels that cut it: what the leaf and the overhangs are read off.

pub fn grid(&self) -> (CubeCount, CubeDim)

The grid this launch runs on: channels on X, columns on Y, rows and batches on Z, a plane per row of the cube.

Trait Implementations

impl Clone for DepthwiseSpace

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DepthwiseSpace

impl Debug for DepthwiseSpace

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

Formats the value using the given formatter.

impl Eq for DepthwiseSpace

impl Hash for DepthwiseSpace

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 PartialEq for DepthwiseSpace

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DepthwiseSpace