time: Improve Instant::now() perf with test-util

benches/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.0.0"
 publish = false
 edition = "2018"
 
+[features]
+test-util = ["tokio/test-util"]
+
 [dependencies]
 tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
 bencher = "0.1.5"
@@ -67,3 +70,8 @@ harness = false
 name = "copy"
 path = "copy.rs"
 harness = false
+
+[[bench]]
+name = "time_now"
+path = "time_now.rs"
+harness = false

benches/time_now.rs

@@ -0,0 +1,28 @@
+//! Benchmark spawning a task onto the basic and threaded Tokio executors.
+//! This essentially measure the time to enqueue a task in the local and remote
+//! case.
+
+#[macro_use]
+extern crate bencher;
+
+use bencher::{black_box, Bencher};
+
+fn time_now_current_thread(bench: &mut Bencher) {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_time()
+        .build()
+        .unwrap();
+
+    bench.iter(|| {
+        rt.block_on(async {
+            black_box(tokio::time::Instant::now());
+        })
+    })
+}
+
+bencher::benchmark_group!(
+    time_now,
+    time_now_current_thread,
+);
+
+bencher::benchmark_main!(time_now);

tokio/src/time/clock.rs

@@ -30,6 +30,7 @@ cfg_not_test_util! {
 cfg_test_util! {
     use crate::time::{Duration, Instant};
     use crate::loom::sync::Mutex;
+    use crate::loom::sync::atomic::{AtomicBool, Ordering};
 
     cfg_rt! {
         #[track_caller]
@@ -65,6 +66,13 @@ cfg_test_util! {
         inner: Mutex<Inner>,
     }
 
+    // Used to track if the clock was ever paused. This is an optimization to
+    // avoid touching the mutex if `test-util` was accidentally enabled in
+    // release mode.
+    //
+    // A static is used so we can avoid accessing the thread-local as well.
+    static DID_PAUSE_CLOCK: AtomicBool = AtomicBool::new(false);
+
     #[derive(Debug)]
     struct Inner {
         /// True if the ability to pause time is enabled.
@@ -199,6 +207,10 @@ cfg_test_util! {
 
     /// Returns the current instant, factoring in frozen time.
     pub(crate) fn now() -> Instant {
+        if !DID_PAUSE_CLOCK.load(Ordering::Acquire) {
+            return Instant::from_std(std::time::Instant::now());
+        }
+
         with_clock(|maybe_clock| {
             Ok(if let Some(clock) = maybe_clock {
                 clock.now()
@@ -241,6 +253,9 @@ cfg_test_util! {
                         This is the default Runtime used by `#[tokio::test].");
             }
 
+            // Track that we paused the clock
+            DID_PAUSE_CLOCK.store(true, Ordering::Release);
+
             let elapsed = match inner.unfrozen.as_ref() {
                 Some(v) => v.elapsed(),
                 None => return Err("time is already frozen")