Struct ElemAlignment 

pub struct ElemAlignment(/* private fields */);

The alignment of a buffer’s layout, counted in elements along its innermost dim: the number every line width that reads the buffer’s elements and no others divides.

Not a byte or address alignment: the tile launcher refuses a width that does not divide the innermost extent or any coarser stride, and every width past one where the innermost stride is not one. Those are all “divides”, so the layout is aligned to their greatest common divisor, and that is the whole of what this holds, read once off the geometry so a derivation can ask it without the tensor. It is one of three things a bound width answers to: the device’s ceiling, this, and a kernel’s own requirements (Vectorization).

A view’s start is the one address it reads: a view starting partway into its buffer is aligned to its offset in elements (at_start), the buffer’s own start being the runtime’s to align.

Implementations

impl ElemAlignment

pub const ONE: Self

A layout aligned to one element, read one element at a time: a strided or broadcast view, whose innermost dim strides past one.

pub fn in_stride_order(shape: &[usize], strides: &[usize]) -> Self

The alignment of a buffer of shape at strides, its dims taken in the order the buffer steps them, whatever order the view names them in.

pub fn dense_rows(columns: usize) -> Self

The alignment of rows of columns elements laid one after another: a buffer a launch allocates or copies dense. Its rows count for nothing, as only the step between them does.

pub fn new(shape: &[usize], strides: &[usize]) -> Self

The alignment of a buffer of shape at strides, innermost last.

A dim of one element steps nowhere, so its stride reads no address and aligns nothing: a view [1, k] swapped out of a column [k, 1] keeps the column’s stride of one on its single row, and is as aligned as the dense row it is.

pub fn at_start(start_bytes: u64, element_bytes: usize) -> Self

The alignment a view starting start_bytes into its buffer gives lines of element_bytes elements: the start’s offset in elements, which every line’s first element sits a whole number of lines past, so a width dividing it keeps each line on its own boundary. A start at no whole element is aligned to one; a view at its buffer’s start, to any width.

pub const fn stored_piece(read: usize) -> Self

The alignment of a buffer stored in pieces read elements wide, which a reader takes whole: a storage-tiled one’s.

pub fn is_stored_piece(self) -> bool

Whether the buffer is read in the pieces it is stored in, a storage-tiled one’s, rather than along rows.

pub fn admits(self, width: usize) -> bool

Whether a line width wide reads this buffer’s elements and no others.

Trait Implementations

impl Clone for ElemAlignment

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 ElemAlignment

impl Debug for ElemAlignment

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

Formats the value using the given formatter.

impl Eq for ElemAlignment

impl From<&TensorBinding> for ElemAlignment

fn from(binding: &TensorBinding) -> Self

The alignment of a bound matrix operand: its geometry’s, or, for a storage-tiled one, the piece its storage partitioning states as the finest along its columns, and a piece one element wide where none does: no partitioning describes it, or its tiles step down a column first, which the matmul kernels refuse before reading this.

impl Hash for ElemAlignment

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 ElemAlignment

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ElemAlignment