document Time::Virtual

Author: pvdrz

src/concurrency/thread.rs

@@ -188,7 +188,12 @@ impl<'mir, 'tcx> Thread<'mir, 'tcx> {
 #[derive(Debug)]
 pub enum Time {
     Monotonic(Instant),
-    Virtual(u64, Arc<AtomicU64>),
+    Virtual {
+        /// The instant for this moment.
+        instant: u64,
+        /// A reference to the time anchor used to read the current global virtual time.
+        time_anchor: Arc<AtomicU64>,
+    },
     RealTime(SystemTime),
 }
 
@@ -197,8 +202,8 @@ impl Time {
     fn get_wait_time(&self) -> Duration {
         match self {
             Time::Monotonic(instant) => instant.saturating_duration_since(Instant::now()),
-            Time::Virtual(nanoseconds, now) =>
-                Duration::from_nanos(nanoseconds - now.load(Ordering::Relaxed)),
+            Time::Virtual { instant, time_anchor } =>
+                Duration::from_nanos(instant - time_anchor.load(Ordering::Relaxed)),
             Time::RealTime(time) =>
                 time.duration_since(SystemTime::now()).unwrap_or(Duration::new(0, 0)),
         }

src/shims/time.rs

@@ -46,19 +46,22 @@ impl TimeAnchor {
     pub fn checked_add_since_now(&self, duration: Duration) -> Option<Time> {
         match self {
             Self::Host(_) => Instant::now().checked_add(duration).map(Time::Monotonic),
-            Self::Virtual(nanoseconds) =>
-                nanoseconds
+            Self::Virtual(time_anchor) =>
+                time_anchor
                     .load(Ordering::Relaxed)
                     .checked_add(duration.as_nanos().try_into().unwrap())
-                    .map(|duration| Time::Virtual(duration, nanoseconds.clone())),
+                    .map(|instant| Time::Virtual { instant, time_anchor: time_anchor.clone() }),
         }
     }
 
     pub fn checked_add_since_start(&self, duration: Duration) -> Option<Time> {
         match self {
             Self::Host(instant) => instant.checked_add(duration).map(Time::Monotonic),
-            Self::Virtual(now) =>
-                Some(Time::Virtual(duration.as_nanos().try_into().unwrap(), now.clone())),
+            Self::Virtual(time_anchor) =>
+                Some(Time::Virtual {
+                    instant: duration.as_nanos().try_into().unwrap(),
+                    time_anchor: time_anchor.clone(),
+                }),
         }
     }
 }