Enum PlaceKind 

pub enum PlaceKind {
    Space {
        buf: BufferId,
        k: usize,
    },
    Data {
        buf: BufferId,
        k: usize,
    },
    Ready {
        sem: SemId,
        receiver: Site,
        k: usize,
    },
    Valid {
        sem: SemId,
        receiver: Site,
        k: usize,
    },
    McastData {
        group: GroupId,
        receiver: Site,
        k: usize,
    },
    Pc {
        site: Site,
        engine: Engine,
        k: usize,
    },
    Arrival {
        sem: SemId,
        at: Site,
        k: usize,
    },
}

Variants

Space

Fields

buf: BufferId

k: usize

Data

Fields

buf: BufferId

k: usize

Ready

Fields

sem: SemId

receiver: Site

k: usize

Valid

Fields

sem: SemId

receiver: Site

k: usize

McastData

Fields

group: GroupId

receiver: Site

k: usize

Pc

Fields

site: Site

engine: Engine

k: usize

Arrival

The k-th post landed at at on a RENDEZVOUS semaphore. A rendezvous is not a hand-off: a post is not consumed by one reader, because every engine program at the site that waits reads the same count. So this place has one producer (the post) and as many consumers as the site has waiters — one for a gather (its root), every program at the site for a release — and a wait for c consumes the first c posts at its own site. The liveness proof is the same DAG argument either way.

★ WHY NOT Ready. A ready counter is modelled per RECEIVER SITE and paired one round at a time with the sender’s wait; a rendezvous is waited on by several engines of one site at once, and that pairing does not describe it. Posts are keyed by the site they LAND on, which is exactly the counter a wait there reads.

Fields

sem: SemId

at: Site

k: usize

Trait Implementations

impl Clone for PlaceKind

fn clone(&self) -> PlaceKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlaceKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlaceKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for PlaceKind

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 Ord for PlaceKind

fn cmp(&self, other: &PlaceKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PlaceKind

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

fn partial_cmp(&self, other: &PlaceKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for PlaceKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for PlaceKind

impl Eq for PlaceKind

impl StructuralPartialEq for PlaceKind