Why is tokio::time::sleep less accurate in its sleep duration compared to std::time::sleep?

[phil-skillwon]

Why is tokio::time::sleep less accurate in its sleep duration compared to std::time::sleep?
For instance, if I set it to sleep for 100 milliseconds, using tokio::time::sleep.await might actually sleep for 101 milliseconds, while using std::time::sleep genuinely sleeps for 100 milliseconds. Is there any way to make tokio::time::sleep more precise?

[Darksonn]

The Tokio timer only has a resolution of one millisecond, so it may be incorrect by up to one millisecond.

If you need a more precise timer, then use one of these options:

• The tokio-timerfd crate.
• The timer from async-io.

[hawkw]

There may also be some additional lag because, once a timer completes, the sleeping task is woken by placing it a queue of woken tasks. Other tasks may be ahead of it in the queue, so polling those tasks may add an additional delay before the task is actually executed, especially if all of the runtime's worker threads are busy.

[wathenjiang]

I write a benchmark to show the accuracy of tokio::time.

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use tokio::{time::Instant, runtime::Runtime};

fn bench_sleep_accuracy_concurrent_thread(c: &mut Criterion) {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_time()
        .build()
        .unwrap();
    sleep_accuracy(c, rt, "bench_sleep_accuracy_concurrent_thread");
}

fn bench_sleep_accuracy_multi(c: &mut Criterion) {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_time()
        .build()
        .unwrap();
    sleep_accuracy(c, rt, "bench_sleep_accuracy_multi_thread");
}


fn sleep_accuracy(c: &mut Criterion, rt : Runtime, bench_id: &str) {
    c.bench_function(bench_id, |b| {
        b.iter_custom(|iters| {
            let start:Instant = Instant::now();
            rt.block_on(async {
                for _ in 0..iters {
                    tokio::time::sleep(tokio::time::Duration::from_millis(black_box(10))).await;
                }
                start.elapsed()
            })
        })
    });
}

criterion_group!(sleep, bench_sleep_accuracy_concurrent_thread,bench_sleep_accuracy_multi);

criterion_main!(sleep);

Here are the benchmark result on the Linux:

    Finished bench [optimized] target(s) in 0.07s
     Running sleep.rs (/root/rustproject/fork-tokio/tokio/target/release/deps/sleep-c1dc3960030284bd)
Gnuplot not found, using plotters backend
bench_sleep_accuracy_concurrent_thread
                        time:   [11.065 ms 11.076 ms 11.086 ms]
                        change: [-0.0487% +0.0911% +0.2289%] (p = 0.21 > 0.05)
                        No change in performance detected.
Found 7 outliers among 100 measurements (7.00%)
  7 (7.00%) low severe

bench_sleep_accuracy_multi_thread
                        time:   [11.072 ms 11.087 ms 11.102 ms]
                        change: [-0.2595% -0.0848% +0.0760%] (p = 0.34 > 0.05)
                        No change in performance detected.
Found 18 outliers among 100 measurements (18.00%)
  18 (18.00%) low severe

[wathenjiang]

For comparison, the test result of sleeping for 5 ms is

bench_sleep_accuracy_concurrent_thread
                        time:   [6.0673 ms 6.0726 ms 6.0770 ms]
                        change: [-0.1190% -0.0054% +0.1131%] (p = 0.93 > 0.05)
                        No change in performance detected.
Found 5 outliers among 100 measurements (5.00%)
  5 (5.00%) low severe

bench_sleep_accuracy_multi_thread
                        time:   [6.0780 ms 6.0869 ms 6.0952 ms]
                        change: [-0.2478% -0.0445% +0.1319%] (p = 0.66 > 0.05)
                        No change in performance detected.
Found 19 outliers among 100 measurements (19.00%)
  19 (19.00%) low severe

[phil-skillwon]

Based on the results, the execution time of the two configurations is very close, which implies that the accuracy of tokio::time::sleep is similar under these two configurations. Is my perspective accurate?

[wathenjiang]

The docs has given the accuracy: Sleep operates at millisecond granularity.