Struct SectionSpan 

pub struct SectionSpan {
    pub name: String,
    pub stages: (usize, usize),
    pub buffers: (usize, usize),
    pub edges: (usize, usize),
    pub semaphores: (usize, usize),
    pub items: (usize, usize),
    pub plan: Option<BlockPlan>,
    pub k_tiles: usize,
    pub output: Option<TensorId>,
    pub barrier_after: Option<Rendezvous>,
}

One SECTION of a composed program: the half-open range this section owns in every id space, the plan and work list it was lowered under, the tensor it writes, and the rendezvous every engine passes through before the next section begins.

★ A SECTION IS A SCOPE, NOT A LABEL. Three invariants read the spans rather than the whole program, and each is wrong without them: output coverage is counted over the section’s OWN work items (the union across sections would report every tile stored a hundred times), local memory may be REUSED across sections and must not overlap within one (which is the whole point of a persistent decoder), and the item loop of an engine program indexes the items of the section the op belongs to.

Fields

name: String

stages: (usize, usize)

Half-open [start, end) in the composed program’s stage list.

buffers: (usize, usize)

edges: (usize, usize)

semaphores: (usize, usize)

items: (usize, usize)

plan: Option<BlockPlan>

k_tiles: usize

output: Option<TensorId>

The tensor this section writes (its result).

barrier_after: Option<Rendezvous>

The rendezvous every engine program passes through between its last op of this section and its first op of the next. None on the last section, which has nothing to be ordered before.

Implementations

impl SectionSpan

pub fn holds_stage(&self, s: StageId) -> bool

pub fn holds_buffer(&self, b: BufferId) -> bool

pub fn holds_item(&self, i: WorkItemId) -> bool

Trait Implementations

impl Clone for SectionSpan

fn clone(&self) -> SectionSpan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SectionSpan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SectionSpan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SectionSpan

fn eq(&self, other: &SectionSpan) -> 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 SectionSpan

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 SectionSpan

impl StructuralPartialEq for SectionSpan