Struct Scheduling 

pub struct Scheduling<T>
where
    T: Trace,
{ /* private fields */ }

A Trace that passes on only the events a schedule is made of.

What this is for

Turning tickless idle on changes a trace, so a raw byte-diff against the C kernel’s cannot survive it – 15.2% of the conformance corpus is TASK_INCREMENT_TICK. But it does not change the SCHEDULE: a task still runs at the tick it would have run at, because the port winds the count forward across the sleep.

This is the projection that says so. Wrap any sink in it and the events that reach the sink are exactly the ones a correct tickless port must not disturb – so two runs that differ only in whether they slept produce the same output, and a run that reordered, dropped or added a scheduling decision does not.

It is a claim about what is being proved, so it is worth being narrow: is_suppressible names the three events dropped, and every other event – every switch, every list move, every queue and event-group and timer operation, with its tick stamp – goes through untouched.

use rusty_rtos_core::trace::{CountTrace, Event, Scheduling, Trace};

let mut projected = Scheduling::new(CountTrace::default());
projected.event(7, Event::TaskIncrementTick { tick: 7 });
projected.event(7, Event::StartingScheduler);
// The tick did not reach the sink; the scheduler start did.
assert_eq!(projected.into_inner().events, 1);

Implementations

impl<T> Scheduling<T>

where T: Trace,

pub const fn new(inner: T) -> Scheduling<T>

Project onto inner.

pub fn into_inner(self) -> T

The sink back out, to read whatever it collected.

pub const fn inner(&self) -> &T

The sink, borrowed.

Trait Implementations

impl<T> Clone for Scheduling<T>

where T: Clone + Trace,

fn clone(&self) -> Scheduling<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Scheduling<T>

where T: Copy + Trace,

impl<T> Debug for Scheduling<T>

where T: Debug + Trace,

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

Formats the value using the given formatter.

impl<T> Default for Scheduling<T>

where T: Default + Trace,

fn default() -> Scheduling<T>

Returns the “default value” for a type.

impl<T> Eq for Scheduling<T>

where T: Eq + Trace,

impl<T> Hash for Scheduling<T>

where T: Hash + Trace,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Scheduling<T>

where T: PartialEq + Trace,

fn eq(&self, other: &Scheduling<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> StructuralPartialEq for Scheduling<T>

where T: PartialEq + Trace,

impl<T> Trace for Scheduling<T>

where T: Trace,

const WANTS_NAMES: bool = T::WANTS_NAMES

Whether this sink reads the name an event carries.

fn note_exits(&mut self, exits: u64)

The port’s outermost critical-section exit count, as it stands at the moment of the next Trace::event.

fn event(&mut self, tick: u64, event: Event<'_>)

An event, at the kernel’s current tick count.