Enum ChoreoFault 

pub enum ChoreoFault {
    NotScheduled,
    MissingInput(TensorId),
    TripOutOfRange {
        trip: TripId,
        value: f64,
        admitted: (i64, i64),
    },
    Deadlock {
        runnable: Vec<(Site, Engine)>,
        blocked_at: Vec<(Site, Engine, usize, ChoreoOp)>,
    },
    BufferOverflow {
        buf: BufferId,
        at: (Site, Engine, usize),
    },
    Underflow {
        buf: BufferId,
        at: (Site, Engine, usize),
    },
    PushWithoutData {
        buf: BufferId,
        at: (Site, Engine, usize),
    },
    ReadBeforeWait {
        buf: BufferId,
        at: (Site, Engine, usize),
    },
    PopBeforeWait {
        buf: BufferId,
        at: (Site, Engine, usize),
    },
    Unconsumed {
        buf: BufferId,
        pages_left: usize,
    },
    OutstandingReservation {
        buf: BufferId,
        pages: usize,
    },
    McastIntoUnreserved {
        group: GroupId,
        receiver: Site,
    },
    SemaphoreProtocol {
        sem: SemId,
        expected: SemCond,
        found: usize,
    },
    AccOverflow {
        requested: usize,
        available: usize,
    },
    AliasClobber {
        buf: BufferId,
        alias: BufferId,
        at: (Site, Engine, usize),
    },
    AccProtocol {
        at: (Site, Engine, usize),
    },
    StoreConflict {
        tensor: TensorId,
        tile: usize,
        first: Site,
        second: Site,
    },
    OutputTileNeverStored {
        tensor: TensorId,
        tile: usize,
    },
    ReadOutOfRange {
        tensor: TensorId,
        tile: usize,
    },
    StaleStateRead {
        tensor: TensorId,
        tile: usize,
        read_in: usize,
        written_in: usize,
        already_written: bool,
    },
    NonDeterministic {
        scheduler_a: &'static str,
        scheduler_b: &'static str,
        tensor: TensorId,
    },
    GatherOutOfRange {
        at: (Site, Engine, usize),
        index: f64,
        extent: usize,
    },
    IntegerArithmetic {
        at: (Site, Engine, usize),
        what: &'static str,
    },
    TileGatherOutOfBound {
        at: (Site, Engine, usize),
        index: f64,
        bound: (usize, usize),
    },
    Unsupported(String),
}

Variants

NotScheduled

MissingInput(TensorId)

TripOutOfRange

A trip’s input holds a value the program does not admit (Trip::count_of) — refused before any op runs, against the admitted range it names, so no loop ever runs a count its bound was not proved for.

Fields

trip: TripId

value: f64

admitted: (i64, i64)

Deadlock

Fields

runnable: Vec<(Site, Engine)>

blocked_at: Vec<(Site, Engine, usize, ChoreoOp)>

BufferOverflow

Fields

buf: BufferId

at: (Site, Engine, usize)

Underflow

Fields

buf: BufferId

at: (Site, Engine, usize)

PushWithoutData

Fields

buf: BufferId

at: (Site, Engine, usize)

ReadBeforeWait

A consumer read a page it never waited for (hardware would read stale local memory).

Fields

buf: BufferId

at: (Site, Engine, usize)

PopBeforeWait

A consumer popped more pages than it had waited for.

Fields

buf: BufferId

at: (Site, Engine, usize)

Unconsumed

Fields

buf: BufferId

pages_left: usize

OutstandingReservation

Fields

buf: BufferId

pages: usize

McastIntoUnreserved

Fields

group: GroupId

receiver: Site

SemaphoreProtocol

Fields

sem: SemId

expected: SemCond

found: usize

AccOverflow

Fields

requested: usize

available: usize

AliasClobber

A page was written into local memory an ALIAS of the buffer still holds: a page the alias pushed and its consumer has not popped. Two buffers sharing one region (Buffer::alias_of) keep separate counters, so nothing else stops a producer of one from overwriting what the consumer of the other is about to read.

Fields

buf: BufferId

alias: BufferId

at: (Site, Engine, usize)

AccProtocol

Fields

at: (Site, Engine, usize)

StoreConflict

Fields

tensor: TensorId

tile: usize

first: Site

second: Site

OutputTileNeverStored

Fields

tensor: TensorId

tile: usize

ReadOutOfRange

Fields

tensor: TensorId

tile: usize

StaleStateRead

A CARRIED tensor was read out of step with its writer: a section after the writing section read a tile the writer has not produced yet (last step’s value), or a section before it read a tile the writer had already overwritten (this step’s value).

★ THIS FAULT EXISTS BECAUSE STATE CANNOT FAULT ANY OTHER WAY. An activation starts a run EMPTY, so reading it early is ReadOutOfRange and the evaluator notices for free. A state tensor starts a run FULL — that is what carrying means — so an unordered read returns a perfectly well-formed number from the previous token, and every check downstream passes. Dropping a barrier would be silently, plausibly wrong. So the read is checked against the section the writer lives in, which is a fact about the program, not about this scheduler’s luck.

Fields

tensor: TensorId

tile: usize

read_in: usize

written_in: usize

already_written: bool

NonDeterministic

Fields

scheduler_a: &'static str

scheduler_b: &'static str

tensor: TensorId

GatherOutOfRange

A GATHER read an index outside its declared extent — [0, modulus) of its IndirectTerm — or one that is not a whole number. ★ AN OUT-OF-RANGE INDEX IS A FAULT, NEVER A WRAP. A token id past the vocabulary, a cache position past the cache: a wrapped or clamped index reads SOMEBODY ELSE’S row and every check downstream passes. So the data run stops, naming the value and the extent.

Fields

at: (Site, Engine, usize)

index: f64

extent: usize

IntegerArithmetic

An integer stage’s arithmetic left i64 — a product, a sum or a shifted value past ±2⁶³ — or divided by zero. The VM carries such a value exactly, as a big integer, or refuses the division; an evaluator that wrapped or rounded would report another number as the answer, so the run stops here, naming the operation.

Fields

at: (Site, Engine, usize)

what: &'static str

TileGatherOutOfBound

A TILE gather or scatter (IndirectTile) read an index outside its declared bound, or one that is not a whole number. The same promise as ChoreoFault::GatherOutOfRange at tile granularity: a row that is not the table’s is never read, and a write that has nowhere legal to land is never silently dropped.

Fields

at: (Site, Engine, usize)

index: f64

bound: (usize, usize)

Unsupported(String)

Trait Implementations

impl Clone for ChoreoFault

fn clone(&self) -> ChoreoFault

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChoreoFault

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

Formats the value using the given formatter.

impl PartialEq for ChoreoFault

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