Struct boomerang::Scheduler

pub struct Scheduler<V> where
    V: EventValue,  {
    pub stop_requested: bool,
    // some fields omitted
}

Fields

stop_requested: bool

Indicator that the execution should stop after the completion of the current logical time. This can be set to true by calling the stop() function in a reaction.

Methods

impl<V> Scheduler<V> where
    V: EventValue, 

pub fn new() -> Self

pub fn print_event_queue(&self)

pub fn print_reaction_queue(&self)

pub fn next(&mut self) -> bool

Wait until physical time matches or exceeds the time of the least tag on the event queue. If there is no event in the queue, return 0. After this wait, advance current_time to match this tag. Then pop the next event(s) from the event queue that all have the same tag, and extract from those events the reactions that are to be invoked at this logical time. Sort those reactions by index (determined by a topological sort) and then execute the reactions in order. Each reaction may produce outputs, which places additional reactions into the index-ordered priority queue. All of those will also be executed in order of indices. If the -timeout option has been given on the command line, then return 0 when the logical time duration matches the specified duration. Also return 0 if there are no more events in the queue and the keepalive command-line option has not been given. Otherwise, return 1.

Trait Implementations

impl<V: Debug> Debug for Scheduler<V> where
    V: EventValue, 

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

Formats the value using the given formatter.

impl<V> Sched for Scheduler<V> where
    V: EventValue, 

type Value = V

EventValue type

fn get_elapsed_logical_time(&self) -> Duration

Return the elpased logical time in nanoseconds since the start of execution.

fn get_logical_time(&self) -> Instant

Return the current logical time in nanoseconds since January 1, 1970.

fn get_physical_time(&self) -> Instant

Return the current physical time in nanoseconds since January 1, 1970.

fn stop(&mut self)

Function to request stopping execution at the end of the current logical time.

fn schedule(
    &mut self,
    trigger: Rc<Trigger<Self>>,
    extra_delay: Duration,
    value: Option<Self::Value>
)

Schedule the specified trigger at current_time plus the offset of the specified trigger plus the delay. The value is required to be a pointer returned by malloc because it will be freed after having been delivered to all relevant destinations unless it is NULL, in which case it will be ignored. If the trigger offset plus the extra delay is greater than zero and stop has been requested, then ignore this and return 0. Also, if the trigger argument is null, ignore and return 0. Otherwise, return a handle to the scheduled trigger, which is an integer greater than 0.

fn print_snapshot(&self)

Return the elapsed physical time. Print a snapshot of the priority queues used during execution.