Struct Trip 

pub struct Trip {
    pub tensor: TensorId,
    pub elem: usize,
    pub admit: (i64, i64),
    pub bias: i64,
    pub per: usize,
}

★ A LOOP COUNT THE PROGRAM READS FROM ITS OWN DATA. Element elem of the input tensor — a program argument, set before the program runs and never written by it — gives v, and every loop run to the trip runs n = ⌈(v + bias) / per⌉ times. The program admits the values admit.0 ..= admit.1, stated in the value’s own units — a position against the cache it indexes — so a value outside them is refused before anything runs, by the same range the program’s own checks hold it to, never as a clamped or wrapped count. The counts run from Trip::lo to Trip::hi, the bound every static question takes (a loop’s LoopCount::Trip::max is exactly it).

It is the loop bound a Plasticine or Spatial controller takes from a scalar argument, and the one a GPU decode kernel reads from its sequence length: a decode step at position P folds the ⌈P / tile⌉ cache blocks its position reaches instead of every block the cache is declared with.

Fields

tensor: TensorId

elem: usize

admit: (i64, i64)

bias: i64

per: usize

Implementations

impl Trip

pub fn lo(&self) -> usize

The least count: the least admitted value’s.

pub fn hi(&self) -> usize

The greatest count: the greatest admitted value’s.

pub fn count_of(&self, v: f64) -> Option<usize>

The count the value v gives, or None when v is not a whole number or not admitted.

Trait Implementations

impl Clone for Trip

fn clone(&self) -> Trip

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Trip

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Trip

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Trip

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 Trip

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

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 Trip

impl StructuralPartialEq for Trip