Struct Engine 

pub struct Engine {
    pub executor: Executor,
    /* private fields */
}

Single-threaded asynchronous simulation runtime.

An application normally creates an Engine, obtains one or more clocks, constructs components or models with new_and_register constructors, connects their ports, and then calls run. Connections are intentionally part of setup: a port that is still unconnected when a task tries to use it represents a model-topology error.

The engine owns the executor, a spawner for additional tasks, the top-level trace Entity, the shared Tracker, and the registry of components that should begin running when simulation starts.

Fields

executor: Executor

Implementations

impl Engine

pub fn new(tracker: &Tracker) -> Self

Create a standalone engine.

pub fn register(&self, component: Component)

Register a component that will be run as the simulation starts.

Registration should happen during construction, before the engine run begins. Passive helper objects that do not have independent async behavior do not need to be registered.

pub fn run(&mut self) -> SimResult

pub fn run_with_executor_observer( &mut self, interval: Duration, observer: impl FnMut(ExecutorSnapshot) -> SimResult, ) -> SimResult

Run the simulation while reporting executor activity after each wall-clock interval at completed executor step boundaries.

Queued task entries in each snapshot do not include futures parked on clocks, ports, or events. Returns an error when interval is zero.

pub fn spawner(&self) -> Spawner

pub fn spawn(&self, future: impl Future<Output = SimResult> + 'static)

pub fn set_randomize_task_order(&self, randomize: bool)

pub fn set_task_order_seed(&self, seed: u64)

pub fn default_clock(&mut self) -> Clock

pub fn clock_hz(&mut self, freq_hz: f64) -> Clock

pub fn clock_khz(&mut self, freq_khz: f64) -> Clock

pub fn clock_mhz(&mut self, freq_mhz: f64) -> Clock

pub fn clock_ghz(&mut self, freq_ghz: f64) -> Clock

pub fn time_now_ns(&self) -> f64

pub fn executor_stats(&self) -> ExecutorStats

Return cumulative future activity from the most recent run.

pub fn top(&self) -> &Rc<Entity>

pub fn tracker(&self) -> Tracker

Trait Implementations

impl Default for Engine

Create a default engine that sends Track events to stdout.

This is provided to keep documentation examples simple with fewer concepts to have to consider at once.

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Engine

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.