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) -> LogicalTime

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.

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 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) -> Self

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() -> Self

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.