time: advance frozen time in park_timeout (#2059)

This patch improves the behavior of frozen time (a testing utility made
available with the `test-util` feature flag). Instead of of requiring
`time::advance` to be called in order to advance the value returned by
`Instant::now`, calls to `time::Driver::park_timeout` will use the
provided duration to advance the time.

This is the desired behavior as the timeout is used to indicate when the
next scheduled delay needs to be fired.

tokio/src/runtime/context.rs

@@ -81,18 +81,6 @@ impl ThreadContext {
         })
     }
 
-    #[cfg(all(feature = "test-util", feature = "time", test))]
-    pub(crate) fn with_time_handle(mut self, handle: crate::runtime::time::Handle) -> Self {
-        self.time_handle = handle;
-        self
-    }
-
-    #[cfg(all(feature = "test-util", feature = "time", test))]
-    pub(crate) fn with_clock(mut self, clock: crate::runtime::time::Clock) -> Self {
-        self.clock.replace(clock);
-        self
-    }
-
     #[cfg(all(feature = "io-driver", not(loom)))]
     pub(crate) fn io_handle() -> crate::runtime::io::Handle {
         CONTEXT.with(|ctx| match *ctx.borrow() {

tokio/src/time/clock.rs

@@ -5,7 +5,7 @@
 //! configurable.
 
 cfg_not_test_util! {
-    use crate::time::Instant;
+    use crate::time::{Duration, Instant};
 
     #[derive(Debug, Clone)]
     pub(crate) struct Clock {}
@@ -22,6 +22,14 @@ cfg_not_test_util! {
         pub(crate) fn now(&self) -> Instant {
             now()
         }
+
+        pub(crate) fn is_frozen(&self) -> bool {
+            false
+        }
+
+        pub(crate) fn advance(&self, _dur: Duration) {
+            unreachable!();
+        }
     }
 }
 
@@ -137,6 +145,10 @@ cfg_test_util! {
             }
         }
 
+        pub(crate) fn is_frozen(&self) -> bool {
+            self.inner.frozen.lock().unwrap().is_some()
+        }
+
         pub(crate) fn advance(&self, duration: Duration) {
             let mut frozen = self.inner.frozen.lock().unwrap();
 

tokio/src/time/driver/entry.rs

@@ -104,8 +104,8 @@ const ERROR: u64 = u64::MAX;
 // ===== impl Entry =====
 
 impl Entry {
-    pub(crate) fn new(deadline: Instant, duration: Duration) -> Arc<Entry> {
-        let inner = Handle::current().inner().unwrap();
+    pub(crate) fn new(handle: &Handle, deadline: Instant, duration: Duration) -> Arc<Entry> {
+        let inner = handle.inner().unwrap();
         let entry: Entry;
 
         // Increment the number of active timeouts

tokio/src/time/driver/mod.rs

@@ -4,7 +4,7 @@ mod atomic_stack;
 use self::atomic_stack::AtomicStack;
 
 mod entry;
-use self::entry::Entry;
+pub(super) use self::entry::Entry;
 
 mod handle;
 pub(crate) use self::handle::Handle;
@@ -245,7 +245,14 @@ where
                 let deadline = self.expiration_instant(when);
 
                 if deadline > now {
-                    self.park.park_timeout(deadline - now)?;
+                    let dur = deadline - now;
+
+                    if self.clock.is_frozen() {
+                        self.park.park_timeout(Duration::from_secs(0))?;
+                        self.clock.advance(dur);
+                    } else {
+                        self.park.park_timeout(dur)?;
+                    }
                 } else {
                     self.park.park_timeout(Duration::from_secs(0))?;
                 }
@@ -269,7 +276,14 @@ where
                 let deadline = self.expiration_instant(when);
 
                 if deadline > now {
-                    self.park.park_timeout(cmp::min(deadline - now, duration))?;
+                    let duration = cmp::min(deadline - now, duration);
+
+                    if self.clock.is_frozen() {
+                        self.park.park_timeout(Duration::from_secs(0))?;
+                        self.clock.advance(duration);
+                    } else {
+                        self.park.park_timeout(duration)?;
+                    }
                 } else {
                     self.park.park_timeout(Duration::from_secs(0))?;
                 }

tokio/src/time/driver/registration.rs

@@ -1,4 +1,4 @@
-use crate::time::driver::Entry;
+use crate::time::driver::{Entry, Handle};
 use crate::time::{Duration, Error, Instant};
 
 use std::sync::Arc;
@@ -15,8 +15,10 @@ pub(crate) struct Registration {
 
 impl Registration {
     pub(crate) fn new(deadline: Instant, duration: Duration) -> Registration {
+        let handle = Handle::current();
+
         Registration {
-            entry: Entry::new(deadline, duration),
+            entry: Entry::new(&handle, deadline, duration),
         }
     }
 

tokio/src/time/tests/mod.rs

@@ -1,6 +1,4 @@
-mod mock_clock;
 mod test_delay;
-mod test_queue;
 
 use crate::time::{self, Instant};
 use std::time::Duration;