Struct ElemAccess 

pub struct ElemAccess {
    pub base: i64,
    pub terms: Vec<(LoopVar, i64)>,
    pub indirect: Option<IndirectTerm>,
}

A FLAT, SIGNED affine map from the iteration space to one operand’s element offset: base + Σ var·stride, over the operand’s page read as a row-major plane of tile.rows rows and page_tiles · tile.cols columns. The evaluator recovers (row, col) = (off / width, off % width), and an offset outside the plane reads 0.0 — never a fault — so an unselected TensorBody::Select branch may point past the page.

★ AN ABSENT AXIS IS A BROADCAST. This is deliberately the same shape as TileAddr, which has described data MOVEMENT since the IR began (base + Σ var·stride, axes it does not mention being axes it does not move along). Compute was the half that never got it, and that asymmetry is why every new workload used to need a new operator.

★ THE ROW STRIDE IS THE PAGE WIDTH. Because the offset is flat, the identity over a page W elements wide is [(row, W), (col, 1)], a per-row scalar is [(row, W)], a per-column value is [(col, 1)], and a TRANSPOSE is [(row, 1), (col, W)] — a map, not an operator. B-P3 made the map signed and flat exactly so that transpose, head slicing, a rope pair’s c ± hd/2 read and a window shift are all maps; before it the evaluator read each axis’ own term only, and an operand’s row could never depend on the column iterator.

Fields

base: i64

terms: Vec<(LoopVar, i64)>

indirect: Option<IndirectTerm>

Implementations

impl ElemAccess

pub fn offset(&self, env: &BTreeMap<LoopVar, usize>) -> i64

The affine offset under env (the indirect term, if any, is the evaluator’s to add).

pub fn offset_at(&self, row: LoopVar, r: usize, col: LoopVar, c: usize) -> i64

The affine offset at one point (r, c) of a (row, col) iteration space.

pub fn offset_at_k( &self, row: LoopVar, r: usize, col: LoopVar, c: usize, k: LoopVar, x: usize, ) -> i64

Self::offset_at at a point of a space with a contraction axis k at x as well.

pub fn varies_along(&self, var: LoopVar) -> bool

Whether this operand varies along var — false is exactly “broadcast along var”.

pub fn broadcast_class( &self, row: LoopVar, col: LoopVar, width: usize, ) -> Option<(bool, bool)>

The (varies along row, varies along col) class of a map that is EXACTLY one of the four tile-aligned broadcast forms over a page width elements wide — identity [(row, W), (col, 1)], per-row [(row, W)], per-column [(col, 1)], constant [] — with base 0 and no indirect term. None for every other map (a transpose, a shifted window, a strided read, a gather).

★ THIS IS THE PRINTERS’ GUARD. A printer that reads only varies_along would spell a transposed map as a tile-for-tile copy; a printer with no instruction for a general map must refuse it by name, and this is the predicate that says which maps those are.

Trait Implementations

impl Clone for ElemAccess

fn clone(&self) -> ElemAccess

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ElemAccess

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

Formats the value using the given formatter.

impl Default for ElemAccess

fn default() -> ElemAccess

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ElemAccess

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ElemAccess

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 ElemAccess

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ElemAccess

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ElemAccess

impl StructuralPartialEq for ElemAccess