Struct TestScopedRuntime 

pub struct TestScopedRuntime<C, T, const NODE_COUNT: usize, const EDGE_COUNT: usize>
where
    C: PlatformClock + Clone + Send + Sync + 'static,
    T: Telemetry + Clone + Send + 'static,
{ /* private fields */ }

Concurrent runtime that delegates to ScopedGraphApi::run_scoped.

Implements LimenRuntime. The runtime is the orchestrator:

• step(): sequential round-robin via GraphApi::step_node_by_index. For debug/test single-tick use.
• run(): overrides default. Creates a SimpleBackoffScheduler and calls graph.run_scoped(clock, telemetry, scheduler) — one scoped thread per node, true concurrent execution, scheduler-controlled stepping.

Implementations

impl<C, T, const NODE_COUNT: usize, const EDGE_COUNT: usize> TestScopedRuntime<C, T, NODE_COUNT, EDGE_COUNT>

where C: PlatformClock + Clone + Send + Sync + 'static, T: Telemetry + Clone + Send + 'static,

pub fn new() -> Self

Construct with pessimistic initial occupancy; init() will overwrite.

pub fn with_telemetry<F, R>(&mut self, f: F) -> Result<Option<R>, RuntimeError>

where F: FnOnce(&mut T) -> R,

Safely access telemetry by mutable reference, if present.

Trait Implementations

impl<C, T, const NODE_COUNT: usize, const EDGE_COUNT: usize> Default for TestScopedRuntime<C, T, NODE_COUNT, EDGE_COUNT>

where C: PlatformClock + Clone + Send + Sync + 'static, T: Telemetry + Clone + Send + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<Graph, C, T, const NODE_COUNT: usize, const EDGE_COUNT: usize> LimenRuntime<Graph, NODE_COUNT, EDGE_COUNT> for TestScopedRuntime<C, T, NODE_COUNT, EDGE_COUNT>

where Graph: GraphApi<NODE_COUNT, EDGE_COUNT> + ScopedGraphApi<NODE_COUNT, EDGE_COUNT>, C: PlatformClock + Clone + Send + Sync + 'static, T: Telemetry + Clone + Send + 'static,

fn step(&mut self, graph: &mut Graph) -> Result<bool, Self::Error>

Sequential scheduler-driven step for debug/test single-tick use.

For each node, consults SimpleBackoffScheduler using the stored per-node last_step to decide whether to step. This ensures the same scheduling policy governs both step() and run().

WaitMicros decisions are treated as “skip this tick” — the last_step is then cleared so the scheduler returns Step on the next step() call. This avoids permanent starvation in sequential mode where there is no real time passage between ticks.

fn run(&mut self, graph: &mut Graph) -> Result<(), Self::Error>

Concurrent execution via ScopedGraphApi::run_scoped.

Creates a SimpleBackoffScheduler and delegates to the graph’s scoped thread infrastructure. Each node gets its own thread; the scheduler controls per-worker stepping.

After all threads join, refreshes the occupancy snapshot.

type Clock = C

Clock abstraction stored by the runtime. Use () if not needed.

type Telemetry = T

Telemetry collector stored by the runtime. Use () if not needed.

type Error = RuntimeError

Error type produced by the runtime. Use core::convert::Infallible if none.

type StopHandle = RuntimeStopHandle

External stop handle type. Clone + Send + Sync + 'static. Only available under std.

fn init( &mut self, graph: &mut Graph, clock: Self::Clock, telemetry: Self::Telemetry, ) -> Result<(), Self::Error>

Initialize internal state and adopt the provided clock & telemetry.

fn reset(&mut self, graph: &Graph) -> Result<(), Self::Error>

Reset internal runtime state (keep graph/node state unless your policy requires otherwise).

fn request_stop(&mut self)

Request a cooperative stop.

fn stop_handle(&self) -> Option<Self::StopHandle>

Return an external stop handle, if the runtime supports it. Clone before calling run() to enable stopping from another thread.

fn is_stopping(&self) -> bool

Return true iff a stop has been requested.

fn occupancies(&self) -> &[EdgeOccupancy; EDGE_COUNT]

Borrow the runtime’s persistent edge-occupancy buffer.