remove Arc

pvdrz · pvdrz · commit 13ac242ca476 · 2022-08-25T15:45:29.000-05:00
diff --git a/src/concurrency/thread.rs b/src/concurrency/thread.rs
@@ -3,8 +3,6 @@
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::num::TryFromIntError;
-use std::sync::atomic::AtomicU64;
-use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
 use log::trace;
@@ -19,7 +17,7 @@ use rustc_target::spec::abi::Abi;
 
 use crate::concurrency::data_race;
 use crate::concurrency::sync::SynchronizationState;
-use crate::shims::time::TimeAnchor;
+use crate::shims::time::Clock;
 use crate::*;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -188,22 +186,17 @@ impl<'mir, 'tcx> Thread<'mir, 'tcx> {
 #[derive(Debug)]
 pub enum Time {
     Monotonic(Instant),
-    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>,
-    },
+    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) -> Duration {
+    fn get_wait_time(&self, clock: &Clock) -> Duration {
         match self {
             Time::Monotonic(instant) => instant.saturating_duration_since(Instant::now()),
-            Time::Virtual { instant, time_anchor } =>
-                Duration::from_nanos(instant - time_anchor.load(Ordering::Relaxed)),
+            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)),
         }
@@ -246,8 +239,6 @@ pub struct ThreadManager<'mir, 'tcx> {
     yield_active_thread: bool,
     /// Callbacks that are called once the specified time passes.
     timeout_callbacks: FxHashMap<ThreadId, TimeoutCallbackInfo<'mir, 'tcx>>,
-    /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
-    pub(crate) time_anchor: TimeAnchor,
 }
 
 impl<'mir, 'tcx> Default for ThreadManager<'mir, 'tcx> {
@@ -262,7 +253,6 @@ impl<'mir, 'tcx> Default for ThreadManager<'mir, 'tcx> {
             thread_local_alloc_ids: Default::default(),
             yield_active_thread: false,
             timeout_callbacks: FxHashMap::default(),
-            time_anchor: TimeAnchor::new(false),
         }
     }
 }
@@ -273,8 +263,6 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
             // The main thread can *not* be joined on except on windows.
             ecx.machine.threads.threads[ThreadId::new(0)].join_status = ThreadJoinStatus::Detached;
         }
-
-        ecx.machine.threads.time_anchor = TimeAnchor::new(ecx.machine.communicate());
     }
 
     /// Check if we have an allocation for the given thread local static for the
@@ -503,13 +491,16 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
     }
 
     /// Get a callback that is ready to be called.
-    fn get_ready_callback(&mut self) -> Option<(ThreadId, TimeoutCallback<'mir, 'tcx>)> {
+    fn get_ready_callback(
+        &mut self,
+        clock: &Clock,
+    ) -> Option<(ThreadId, TimeoutCallback<'mir, 'tcx>)> {
         // We iterate over all threads in the order of their indices because
         // this allows us to have a deterministic scheduler.
         for thread in self.threads.indices() {
             match self.timeout_callbacks.entry(thread) {
                 Entry::Occupied(entry) =>
-                    if entry.get().call_time.get_wait_time() == Duration::new(0, 0) {
+                    if entry.get().call_time.get_wait_time(clock) == Duration::new(0, 0) {
                         return Some((thread, entry.remove().callback));
                     },
                 Entry::Vacant(_) => {}
@@ -566,7 +557,7 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
     /// used in stateless model checkers such as Loom: run the active thread as
     /// long as we can and switch only when we have to (the active thread was
     /// blocked, terminated, or has explicitly asked to be preempted).
-    fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
+    fn schedule(&mut self, clock: &Clock) -> InterpResult<'tcx, SchedulingAction> {
         // Check whether the thread has **just** terminated (`check_terminated`
         // checks whether the thread has popped all its stack and if yes, sets
         // the thread state to terminated).
@@ -593,7 +584,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()).min();
+            self.timeout_callbacks.values().map(|info| info.call_time.get_wait_time(clock)).min();
         if potential_sleep_time == Some(Duration::new(0, 0)) {
             return Ok(SchedulingAction::ExecuteTimeoutCallback);
         }
@@ -629,7 +620,7 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
             // timeout_callbacks, which may unblock some of the threads. Hence,
             // sleep until the first callback.
 
-            self.time_anchor.sleep(sleep_time);
+            clock.sleep(sleep_time);
             Ok(SchedulingAction::ExecuteTimeoutCallback)
         } else {
             throw_machine_stop!(TerminationInfo::Deadlock);
@@ -892,18 +883,19 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     #[inline]
     fn run_timeout_callback(&mut self) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
-        let (thread, callback) =
-            if let Some((thread, callback)) = this.machine.threads.get_ready_callback() {
-                (thread, callback)
-            } else {
-                // get_ready_callback can return None if the computer's clock
-                // was shifted after calling the scheduler and before the call
-                // to get_ready_callback (see issue
-                // https://github.com/rust-lang/miri/issues/1763). In this case,
-                // just do nothing, which effectively just returns to the
-                // scheduler.
-                return Ok(());
-            };
+        let (thread, callback) = if let Some((thread, callback)) =
+            this.machine.threads.get_ready_callback(&this.machine.clock)
+        {
+            (thread, callback)
+        } else {
+            // get_ready_callback can return None if the computer's clock
+            // was shifted after calling the scheduler and before the call
+            // to get_ready_callback (see issue
+            // https://github.com/rust-lang/miri/issues/1763). In this case,
+            // just do nothing, which effectively just returns to the
+            // scheduler.
+            return Ok(());
+        };
         // This back-and-forth with `set_active_thread` is here because of two
         // design decisions:
         // 1. Make the caller and not the callback responsible for changing
@@ -920,7 +912,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     #[inline]
     fn schedule(&mut self) -> InterpResult<'tcx, SchedulingAction> {
         let this = self.eval_context_mut();
-        this.machine.threads.schedule()
+        this.machine.threads.schedule(&this.machine.clock)
     }
 
     /// Handles thread termination of the active thread: wakes up threads joining on this one,
diff --git a/src/machine.rs b/src/machine.rs
@@ -27,7 +27,7 @@ use rustc_target::spec::abi::Abi;
 
 use crate::{
     concurrency::{data_race, weak_memory},
-    shims::unix::FileHandler,
+    shims::{unix::FileHandler, time::Clock},
     *,
 };
 
@@ -293,6 +293,9 @@ pub struct Evaluator<'mir, 'tcx> {
     /// The table of directory descriptors.
     pub(crate) dir_handler: shims::unix::DirHandler,
 
+    /// FIXME: docs
+    pub(crate) clock: Clock,
+
     /// The set of threads.
     pub(crate) threads: ThreadManager<'mir, 'tcx>,
 
@@ -407,6 +410,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             preemption_rate: config.preemption_rate,
             report_progress: config.report_progress,
             since_progress_report: 0,
+            clock: Clock::new(config.isolated_op == IsolatedOp::Allow),
         }
     }
 
@@ -957,7 +961,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         // These are our preemption points.
         ecx.maybe_preempt_active_thread();
 
-        ecx.machine.threads.time_anchor.tick();
+        ecx.machine.clock.tick();
 
         Ok(())
     }
diff --git a/src/shims/time.rs b/src/shims/time.rs
@@ -1,5 +1,4 @@
 use std::sync::atomic::AtomicU64;
-use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime};
 
 use rustc_data_structures::sync::Ordering;
@@ -8,60 +7,75 @@ use crate::concurrency::thread::Time;
 use crate::*;
 
 #[derive(Debug)]
-pub enum TimeAnchor {
-    Host(Instant),
-    Virtual(Arc<AtomicU64>),
+pub enum Clock {
+    Host {
+        /// The "time anchor" for this machine's monotone clock (for `Instant` simulation).
+        time_anchor: Instant,
+    },
+    Virtual {
+        /// The "current virtual time".
+        nanoseconds: AtomicU64,
+    },
 }
 
-impl TimeAnchor {
+impl Clock {
     pub fn new(communicate: bool) -> Self {
-        if communicate { Self::Host(Instant::now()) } else { Self::Virtual(Arc::new(0.into())) }
+        if communicate {
+            Self::Host { time_anchor: Instant::now() }
+        } else {
+            Self::Virtual { nanoseconds: 0.into() }
+        }
     }
 
     pub fn get(&self) -> Duration {
         match self {
-            Self::Host(instant) => Instant::now().saturating_duration_since(*instant),
-            Self::Virtual(nanoseconds) => Duration::from_nanos(nanoseconds.load(Ordering::Relaxed)),
+            Self::Host { time_anchor } => Instant::now().saturating_duration_since(*time_anchor),
+            Self::Virtual { nanoseconds } =>
+                Duration::from_nanos(nanoseconds.load(Ordering::Relaxed)),
         }
     }
 
     pub fn tick(&self) {
         match self {
-            Self::Host(_) => (),
-            Self::Virtual(nanoseconds) => {
+            Self::Host { .. } => (),
+            Self::Virtual { nanoseconds } => {
                 nanoseconds.fetch_add(1, Ordering::Relaxed);
             }
         }
     }
 
     pub fn sleep(&self, duration: Duration) {
         match self {
-            Self::Host(_) => std::thread::sleep(duration),
-            Self::Virtual(nanoseconds) => {
+            Self::Host { .. } => std::thread::sleep(duration),
+            Self::Virtual { nanoseconds } => {
                 nanoseconds.fetch_add(duration.as_nanos().try_into().unwrap(), Ordering::Relaxed);
             }
         }
     }
 
     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(time_anchor) =>
-                time_anchor
+            Self::Host { .. } => Instant::now().checked_add(duration).map(Time::Monotonic),
+            Self::Virtual { nanoseconds } =>
+                nanoseconds
                     .load(Ordering::Relaxed)
                     .checked_add(duration.as_nanos().try_into().unwrap())
-                    .map(|instant| Time::Virtual { instant, time_anchor: time_anchor.clone() }),
+                    .map(|nanoseconds| Time::Virtual { nanoseconds }),
         }
     }
 
     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(time_anchor) =>
-                Some(Time::Virtual {
-                    instant: duration.as_nanos().try_into().unwrap(),
-                    time_anchor: time_anchor.clone(),
-                }),
+            Self::Host { time_anchor } => time_anchor.checked_add(duration).map(Time::Monotonic),
+            Self::Virtual { .. } =>
+                Some(Time::Virtual { nanoseconds: duration.as_nanos().try_into().unwrap() }),
+        }
+    }
+
+    pub(crate) fn assert_virtual(&self) -> &AtomicU64 {
+        match self {
+            Clock::Host { .. } => panic!(),
+            Clock::Virtual { nanoseconds } => nanoseconds,
         }
     }
 }
@@ -105,7 +119,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             this.check_no_isolation("`clock_gettime` with real time clocks")?;
             system_time_to_duration(&SystemTime::now())?
         } else if relative_clocks.contains(&clk_id) {
-            this.machine.threads.time_anchor.get()
+            this.machine.clock.get()
         } else {
             let einval = this.eval_libc("EINVAL")?;
             this.set_last_error(einval)?;
@@ -190,7 +204,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // QueryPerformanceCounter uses a hardware counter as its basis.
         // Miri will emulate a counter with a resolution of 1 nanosecond.
-        let duration = this.machine.threads.time_anchor.get();
+        let duration = this.machine.clock.get();
         let qpc = i64::try_from(duration.as_nanos()).map_err(|_| {
             err_unsup_format!("programs running longer than 2^63 nanoseconds are not supported")
         })?;
@@ -231,7 +245,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // This returns a u64, with time units determined dynamically by `mach_timebase_info`.
         // We return plain nanoseconds.
-        let duration = this.machine.threads.time_anchor.get();
+        let duration = this.machine.clock.get();
         let res = u64::try_from(duration.as_nanos()).map_err(|_| {
             err_unsup_format!("programs running longer than 2^64 nanoseconds are not supported")
         })?;
@@ -276,10 +290,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         };
         // If adding the duration overflows, let's just sleep for an hour. Waking up early is always acceptable.
         let timeout_time =
-            this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap_or_else(|| {
+            this.machine.clock.checked_add_since_now(duration).unwrap_or_else(|| {
                 this.machine
-                    .threads
-                    .time_anchor
+                    .clock
                     .checked_add_since_now(Duration::from_secs(3600))
                     .unwrap()
             });
@@ -309,7 +322,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         let duration = Duration::from_millis(timeout_ms.into());
         let timeout_time =
-            this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap();
+            this.machine.clock.checked_add_since_now(duration).unwrap();
 
         let active_thread = this.get_active_thread();
         this.block_thread(active_thread);
diff --git a/src/shims/unix/linux/sync.rs b/src/shims/unix/linux/sync.rs
@@ -106,14 +106,14 @@ pub fn futex<'tcx>(
                     if op & futex_realtime != 0 {
                         Time::RealTime(SystemTime::UNIX_EPOCH.checked_add(duration).unwrap())
                     } else {
-                        this.machine.threads.time_anchor.checked_add_since_start(duration).unwrap()
+                        this.machine.clock.checked_add_since_start(duration).unwrap()
                     }
                 } else {
                     // FUTEX_WAIT uses a relative timestamp.
                     if op & futex_realtime != 0 {
                         Time::RealTime(SystemTime::now().checked_add(duration).unwrap())
                     } else {
-                        this.machine.threads.time_anchor.checked_add_since_now(duration).unwrap()
+                        this.machine.clock.checked_add_since_now(duration).unwrap()
                     }
                 })
             };
diff --git a/src/shims/unix/sync.rs b/src/shims/unix/sync.rs
@@ -859,7 +859,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let timeout_time = if clock_id == this.eval_libc_i32("CLOCK_REALTIME")? {
             Time::RealTime(SystemTime::UNIX_EPOCH.checked_add(duration).unwrap())
         } else if clock_id == this.eval_libc_i32("CLOCK_MONOTONIC")? {
-            this.machine.threads.time_anchor.checked_add_since_start(duration).unwrap()
+            this.machine.clock.checked_add_since_start(duration).unwrap()
         } else {
             throw_unsup_format!("unsupported clock id: {}", clock_id);
         };
