Struct HappensBeforeProgram 

pub struct HappensBeforeProgram {
    pub version: u32,
    pub anchors: BTreeMap<String, Anchor>,
    pub edges: Vec<HappensBeforeEdge>,
    pub max_hold_ns: Option<u64>,
}

A validated, normalized happens-before program: anchors indexed by name plus the edge list, guaranteed acyclic with all references resolved.

Fields

version: u32

The spec’s schema version.

anchors: BTreeMap<String, Anchor>

Normalized anchors, keyed by event name.

edges: Vec<HappensBeforeEdge>

The validated, acyclic edge list.

max_hold_ns: Option<u64>

The hold budget in committed virtual nanoseconds: Some for a version-2 spec (its max_hold_ns, or DEFAULT_MAX_HOLD_NS), None for version 1, which has no budget.

Implementations

impl HappensBeforeProgram

pub fn unresolved_locations(&self) -> impl Iterator<Item = &Anchor>

Anchors that still require debug-info resolution (an unresolved RIP from a code location, i.e. a func/line that has not been turned into an address yet).

pub fn may_have_syscall_count_anchor_at( &self, dettid: DetTid, count: u64, ) -> bool

True when thread dettid must check in with the scheduler at its syscall number count: some anchor sits at exactly Position::SyscallCount(count) and names dettid, or names its thread by spawn ordinal (which only the scheduler can resolve, so the guest side must ask). For any other (thread, count) the scheduler’s checkpoint finds no anchor and does nothing, so skipping it changes no gate. It costs one scheduler round trip per anchor its thread reaches, not one per syscall (https://github.com/rrnewton/hermit/issues/3877), and threads a spec does not name keep their schedule: a count another thread passes early (QEMU’s main loop makes about a million syscalls a run) no longer adds a scheduler turn there.

pub fn has_syscall_occurrence_anchors(&self) -> bool

True when the program has any enforced syscall-occurrence anchor (Anchor::is_syscall_occurrence), so the guest must count its calls.

pub fn count_syscall_occurrences( &self, counters: &mut HbThreadCounters, dettid: DetTid, sysno: Sysno, args: [usize; 2], entry_count: u64, ) -> Vec<String>

Count one syscall entry of thread dettid (sysno, first two arguments args, the thread’s entry_countth syscall) in that thread’s counters, and return the names of the syscall-occurrence anchors this entry fires.

counters belongs to one thread and is kept with its other per-thread counts (the syscall count that count anchors use), so it starts empty for every new thread. Per entry, in this order:

1. Every distinct occurrence key (syscall, fd, futex operation) an anchor names that the entry matches is incremented once; an entry that matches both an fd-specific and an fd-agnostic anchor counts toward each.
2. Each relative anchor whose base this entry reaches gets its origin: its own key’s count after step 1, so the base entry is never counted in its window. A count base is reached when entry_count equals its count, whether or not the entry matches any key.
3. An absolute anchor fires when its key’s count equals nth; a relative anchor fires when its count minus its origin equals nth.

An entry is counted exactly once, when the thread enters the syscall, so a thread held at an anchor and re-admitted does not count again. The result names anchors on dettid or on a spawn ordinal; the scheduler resolves spawn ordinals and fires only the anchors on this thread.

pub fn is_version_2(&self) -> bool

True for a version-2 program, which carries a hold budget and needs an effective preemption timer to charge it.

pub fn relative_anchors(&self) -> impl Iterator<Item = (&Anchor, &Anchor)>

The relative anchors and their bases, in name order.

pub fn unenforced_positions(&self) -> impl Iterator<Item = &Anchor>

Anchors whose position kind the current scheduler does not yet enforce: everything other than Position::SyscallCount and the syscall occurrence anchors (Anchor::is_syscall_occurrence). Reported so a run does not silently ignore an authored ordering constraint it cannot honor.

Trait Implementations

impl Clone for HappensBeforeProgram

fn clone(&self) -> HappensBeforeProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HappensBeforeProgram

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

Formats the value using the given formatter.

impl Eq for HappensBeforeProgram

impl PartialEq for HappensBeforeProgram

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for HappensBeforeProgram