Struct GlobalTime 

pub struct GlobalTime { /* private fields */ }

Deterministic global time, combining local times.

Implementations

impl GlobalTime

pub fn new(cfg: &Config) -> Self

Create a fresh global time, respecting the Config.

pub fn update_global_time( &mut self, tid: DetTid, newtime: LogicalTime, inherited: LogicalDuration, )

Tick the time of a particular thread.

pub fn add_scheduler_time(&mut self) -> Result<LogicalTime, ClockExhausted>

Add time that passage is not driven by the internal events within guest threads. This is effectively used to account for “time” consumed by the scheduler, and to ensure monotonic increase of global time while scheduling.

With a configured --scheduler-turn-cost, a turn whose charge would pass the end of representable time is refused with ClockExhausted and adds nothing: a saturated clock would let later turns advance nothing while the run went on. The scheduler turns the error into a fatal exit. Without the option the default charge saturates, as it always did, and this never fails.

pub fn add_capped_scheduler_time( &mut self, cap: u64, ) -> Result<LogicalTime, ClockExhausted>

Self::add_scheduler_time for a turn charged at most cap nanoseconds: the scheduler’s charge for a turn that ends a timeslice under --cap-preemption-charge, whose cap is the virtual time the thread ran since its previous turn. The capped charge is at least one nanosecond, so the turn still advances the clock, as a configured --scheduler-turn-cost must (Config::scheduler_turn_charge); a default charge that the clock multiplier truncates to zero stays zero, as it always was. A cap at or above the turn’s charge changes nothing.

pub fn add_extra_time(&mut self, delta: Duration) -> LogicalTime

Update the global clock to account for time not driven by internal within guest threads. This is a central or external expenditure of time, rather than a thread-internal one.

The argument is in nanosecods and should have had any clock multiplier applied alreday.

pub fn threads_time(&self, dtid: DetTid) -> LogicalTime

Project a thread’s absolute local clock, including its inherited history and the epoch. Exec recovery and scheduler replay use this projection.

pub fn contains_thread(&self, dtid: DetTid) -> bool

Returns whether this clock has observed work from a thread.

pub fn reassign_thread(&mut self, from: DetTid, to: DetTid)

Move a surviving thread’s clock component to the process-leader TID installed by Linux after a non-leader thread successfully execs.

Work previously performed by the old leader remains part of aggregate time, but no longer belongs to the new image’s local thread clock.

pub fn retire_thread(&mut self, dtid: DetTid)

Drop the clock component of a thread that is gone, keeping its own work in aggregate time. A later thread that Linux gives the same ID then starts a component of its own, with its own inherited baseline, instead of continuing the old thread’s clock.

pub fn threads_inherited_time(&self, dtid: DetTid) -> LogicalTime

The absolute clock inherited when this thread started. Its first report can arrive after scheduler registration; work since startup is the current thread clock minus this baseline, not minus the epoch.

pub fn threads_duration(&self, dtid: DetTid) -> LogicalDuration

Project a thread’s local duration, including inherited history but excluding the epoch. This is the duration used by scheduler replay; aggregate time separately excludes the inherited part.

pub fn as_nanos(&self) -> LogicalTime

Deterministic lower bound on the amount of work that has happened across all threads, starting with the same epoch time as individual thread clocks.

This roughly models something like real time if all threads were running on one core.

pub fn elapsed_nanos(&self) -> Option<LogicalDuration>

Elapsed virtual time in the same precision domain as this clock’s baseline. DetTime stores the epoch at microsecond precision, so subtracting the original nanosecond DateTime can underflow for an otherwise empty run whose epoch has a sub-microsecond component.

Global time never falls behind its own baseline; None reports that broken invariant in every build profile instead of wrapping in release.

Trait Implementations

impl Clone for GlobalTime

fn clone(&self) -> GlobalTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalTime

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

Formats the value using the given formatter.

impl Default for GlobalTime

fn default() -> GlobalTime

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GlobalTime

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GlobalTime

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.