move all time related pattern matching inside shims::time

Author: pvdrz

src/concurrency/thread.rs

@@ -3,12 +3,11 @@
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::num::TryFromIntError;
-use std::time::{Duration, Instant, SystemTime};
+use std::time::{Duration, SystemTime};
 
 use log::trace;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::sync::Ordering;
 use rustc_hir::def_id::DefId;
 use rustc_index::vec::{Idx, IndexVec};
 use rustc_middle::mir::Mutability;
@@ -17,7 +16,7 @@ use rustc_target::spec::abi::Abi;
 
 use crate::concurrency::data_race;
 use crate::concurrency::sync::SynchronizationState;
-use crate::shims::time::Clock;
+use crate::shims::time::{Clock, Instant};
 use crate::*;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -186,23 +185,9 @@ impl<'mir, 'tcx> Thread<'mir, 'tcx> {
 #[derive(Debug)]
 pub enum Time {
     Monotonic(Instant),
-    Virtual { nanoseconds: u64 },
     RealTime(SystemTime),
 }
 
-impl Time {
-    /// How long do we have to wait from now until the specified time?
-    fn get_wait_time(&self, clock: &Clock) -> Duration {
-        match self {
-            Time::Monotonic(instant) => instant.saturating_duration_since(Instant::now()),
-            Time::Virtual { nanoseconds } =>
-                Duration::from_nanos(nanoseconds - clock.assert_virtual().load(Ordering::Relaxed)),
-            Time::RealTime(time) =>
-                time.duration_since(SystemTime::now()).unwrap_or(Duration::new(0, 0)),
-        }
-    }
-}
-
 /// Callbacks are used to implement timeouts. For example, waiting on a
 /// conditional variable with a timeout creates a callback that is called after
 /// the specified time and unblocks the thread. If another thread signals on the
@@ -500,7 +485,7 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
         for thread in self.threads.indices() {
             match self.timeout_callbacks.entry(thread) {
                 Entry::Occupied(entry) =>
-                    if entry.get().call_time.get_wait_time(clock) == Duration::new(0, 0) {
+                    if clock.get_wait_time(&entry.get().call_time) == Duration::new(0, 0) {
                         return Some((thread, entry.remove().callback));
                     },
                 Entry::Vacant(_) => {}
@@ -584,7 +569,7 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
         // at the time of the call".
         // <https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_cond_timedwait.html>
         let potential_sleep_time =
-            self.timeout_callbacks.values().map(|info| info.call_time.get_wait_time(clock)).min();
+            self.timeout_callbacks.values().map(|info| clock.get_wait_time(&info.call_time)).min();
         if potential_sleep_time == Some(Duration::new(0, 0)) {
             return Ok(SchedulingAction::ExecuteTimeoutCallback);
         }

src/shims/time.rs

@@ -1,5 +1,5 @@
 use std::sync::atomic::AtomicU64;
-use std::time::{Duration, Instant, SystemTime};
+use std::time::{Duration, Instant as StdInstant, SystemTime};
 
 use rustc_data_structures::sync::Ordering;
 
@@ -10,12 +10,18 @@ use crate::*;
 /// are passing for each basic block.
 const NANOSECOND_PER_BASIC_BLOCK: u64 = 10;
 
+#[derive(Debug)]
+pub enum Instant {
+    Host(StdInstant),
+    Virtual { nanoseconds: u64 },
+}
+
 /// A monotone clock used for `Instant` simulation.
 #[derive(Debug)]
 pub enum Clock {
     Host {
         /// The "time anchor" for this machine's monotone clock.
-        time_anchor: Instant,
+        time_anchor: StdInstant,
     },
     Virtual {
         /// The "current virtual time".
@@ -27,7 +33,7 @@ impl Clock {
     /// Create a new clock based on the availability of communication with the host.
     pub fn new(communicate: bool) -> Self {
         if communicate {
-            Self::Host { time_anchor: Instant::now() }
+            Self::Host { time_anchor: StdInstant::now() }
         } else {
             Self::Virtual { nanoseconds: 0.into() }
         }
@@ -36,7 +42,7 @@ impl Clock {
     /// Get the current time relative to this clock.
     pub fn get(&self) -> Duration {
         match self {
-            Self::Host { time_anchor } => Instant::now().saturating_duration_since(*time_anchor),
+            Self::Host { time_anchor } => StdInstant::now().saturating_duration_since(*time_anchor),
             Self::Virtual { nanoseconds } =>
                 Duration::from_nanos(nanoseconds.load(Ordering::Relaxed)),
         }
@@ -68,30 +74,48 @@ impl Clock {
     /// Compute `now + duration` relative to this clock.
     pub fn get_time_relative(&self, duration: Duration) -> Option<Time> {
         match self {
-            Self::Host { .. } => Instant::now().checked_add(duration).map(Time::Monotonic),
+            Self::Host { .. } =>
+                StdInstant::now()
+                    .checked_add(duration)
+                    .map(|instant| Time::Monotonic(Instant::Host(instant))),
             Self::Virtual { nanoseconds } =>
                 nanoseconds
                     .load(Ordering::Relaxed)
                     .checked_add(duration.as_nanos().try_into().unwrap())
-                    .map(|nanoseconds| Time::Virtual { nanoseconds }),
+                    .map(|nanoseconds| Time::Monotonic(Instant::Virtual { nanoseconds })),
         }
     }
 
     /// Compute `start + duration` relative to this clock where `start` is the instant of time when
     /// this clock was created.
     pub fn get_time_absolute(&self, duration: Duration) -> Option<Time> {
         match self {
-            Self::Host { time_anchor } => time_anchor.checked_add(duration).map(Time::Monotonic),
+            Self::Host { time_anchor } =>
+                time_anchor
+                    .checked_add(duration)
+                    .map(|instant| Time::Monotonic(Instant::Host(instant))),
             Self::Virtual { .. } =>
-                Some(Time::Virtual { nanoseconds: duration.as_nanos().try_into().unwrap() }),
+                Some(Time::Monotonic(Instant::Virtual {
+                    nanoseconds: duration.as_nanos().try_into().unwrap(),
+                })),
         }
     }
 
-    /// Assert that this clock is a virtual one and get the current time in nanoseconds.
-    pub(crate) fn assert_virtual(&self) -> &AtomicU64 {
-        match self {
-            Clock::Host { .. } => panic!(),
-            Clock::Virtual { nanoseconds } => nanoseconds,
+    /// How long do we have to wait from now until the specified time?
+    pub fn get_wait_time(&self, time: &Time) -> Duration {
+        match time {
+            Time::Monotonic(instant) =>
+                match (instant, self) {
+                    (Instant::Host(instant), Clock::Host { .. }) =>
+                        instant.saturating_duration_since(StdInstant::now()),
+                    (
+                        Instant::Virtual { nanoseconds },
+                        Clock::Virtual { nanoseconds: current_ns },
+                    ) => Duration::from_nanos(nanoseconds - current_ns.load(Ordering::Relaxed)),
+                    _ => panic!(),
+                },
+            Time::RealTime(time) =>
+                time.duration_since(SystemTime::now()).unwrap_or(Duration::new(0, 0)),
         }
     }
 }