Enum VectorRequirement 

pub enum VectorRequirement<O> {
    Access {
        operand: O,
        elements: usize,
    },
    Elementwise {
        operand: O,
    },
    Masked {
        operand: O,
    },
    Together {
        operand: O,
        with: O,
    },
    Aligned {
        operand: O,
        alignment: ElemAlignment,
    },
}

Why an operand’s width must be narrower than the device reads it at.

A requirement is about the tiles of an operand a component touches, never about the memory they live in: a microkernel is handed tiles and does not know whether its walker staged them. That holds because an operand keeps one width down the whole chain — the global buffer is bound at it, a stage the ring fills keeps it, a fragment loads the stage at it — so every requirement on an operand, from every component, narrows the same width.

A requirement’s elements lie along the operand’s contiguous axis, and a stretch starts at a multiple of its own length, since every tile is a regular cut of its parent: a width dividing the length never has a line cross the end of a stretch.

Variants

Access

A component reads or writes operand’s tiles in stretches of elements consecutive elements, so the width divides them.

Fields

operand: O

elements: usize

Elementwise

A component reads or writes operand one element at a time, as out of shared-memory atomics, which hand back a scalar: the width is one.

Fields

operand: O

Masked

The launch binds operand masked one element at a time, as it does where a tile reaches past the operand’s edge along its contiguous axis: a line in the last, short tile would reach past it, so the width is one.

Fields

operand: O

Together

A component lines operand together with with, one line of each per step, as a register block lines the rhs along n with its accumulator: the two share one width, the narrowest of what every operand lined with either admits alone.

Fields

operand: O

with: O

Aligned

The launch binds operand’s buffer, whose layout is aligned to alignment elements along its innermost dim: a line must read its elements and no others.

Fields

operand: O

alignment: ElemAlignment

Implementations

impl<O: Copy + Eq> VectorRequirement<O>

pub fn operand(&self) -> O

The operand this requirement narrows.

pub fn restated<P>( self, operand: impl Fn(O) -> Option<P>, ) -> Option<VectorRequirement<P>>

This requirement on the operands operand maps its own onto, where it maps every one: what a family running a shared microkernel on its own operands requires of them. None for an operand the family binds no buffer for, as a product it keeps in registers.

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

Whether a line of width meets this requirement.

Trait Implementations

impl<O: Clone> Clone for VectorRequirement<O>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Copy> Copy for VectorRequirement<O>

impl<O: Debug> Debug for VectorRequirement<O>

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

Formats the value using the given formatter.

impl<O: Eq> Eq for VectorRequirement<O>

impl<O: PartialEq> PartialEq for VectorRequirement<O>

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

Equality operator ==.

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

Inequality operator !=.

impl<O: PartialEq> StructuralPartialEq for VectorRequirement<O>