Struct SimulationState 

pub struct SimulationState<B: SimBackend> { /* private fields */ }

Backend-independent state and execution rules for timed simulation.

Implementations

impl<B: SimBackend> SimulationState<B>

pub fn synchronize_event_values(&mut self, backend: &B)

Rebase edge detection after state was advanced outside this scheduler.

pub fn new( backend: &B, topo_signals: Vec<(SignalRef, usize, usize)>, domain_kinds: Vec<Option<DomainKind>>, event_info: Vec<EventInfo<B>>, processes: Vec<ProcessRefs>, ) -> Self

Every process in processes starts at time zero, in list order.

pub fn add_clock( &mut self, event: B::Event, signal: SignalRef, period: u64, initial_delay: u64, )

pub fn schedule( &mut self, event: B::Event, signal: SignalRef, time: u64, value: u8, )

pub fn step<E>( &mut self, executor: &mut E, ) -> Result<Option<u64>, SimulatorErrorCode>

where E: SimulationExecutor<Backend = B>,

pub fn is_finished(&self) -> bool

Whether a process requested the end of the simulation.

pub fn settle_at<E>( &mut self, executor: &mut E, time: u64, ) -> Result<Option<u64>, SimulatorErrorCode>

where E: SimulationExecutor<Backend = B>,

Settle externally driven state against the previous edge baseline even when no clock/reset signal is explicitly scheduled at this timestamp.

pub fn time(&self) -> u64

pub fn set_time(&mut self, time: u64)

pub fn next_event_time(&self) -> Option<u64>

Time of the next scheduled event or process wakeup. None once a process has finished the simulation.

pub fn clock_periods(&self) -> Vec<(usize, u64)>

Periodic clocks as (event id, period).

pub fn snapshot(&self) -> SimulationSnapshot<B>

Capture the mutable scheduling state: time, pending events, clocks and the clock values edge detection compares against.

pub fn restore( &mut self, snapshot: &SimulationSnapshot<B>, remap: impl FnMut(B::Event) -> Option<B::Event>, ) -> Result<(), B::Event>

Return to a state captured by Self::snapshot on a state built for the same design.

Event handles may point into the compiled code of the instance that took the snapshot, so remap translates each pending event into a handle of this instance. If an event cannot be translated, nothing is changed and that event is returned.

impl<B: SimBackend> SimulationState<B>

pub fn export_schedule(&self, backend: &B) -> ScheduleParts<B>

Express the scheduling state with backend’s event handles.

pub fn import_schedule(&mut self, parts: ScheduleParts<B>)

Replace the scheduling state with parts, whose handles belong to this state’s backend.