Ability to (temporarily) disable time auto-advance when paused

[sjoerdsimons]

The timer wheel auto-advancing while in pause is obviously helpful when tasks blocked on timers however when doing a bit of I/O as well things get quite unpredictable. In my particular case the crate i'm testing runs a interval loop in one task while another task is doing some prep with I/O (only). Depending on timing (hah) this causes the time to auto-advance some of the time but not always

Describe the solution you'd like

The ability to pause time while turning auto-advance on and off again so it's easier for the author to ensure there are no auto-advances for at least a given scope

Describe alternatives you've considered

There really no way to always have the right trade-of when mixing tasks in sleep and tasks in i/o as the runtime/test framework can't be omniscient.. auto-advancing the timer is for sure needed to avoid deadlocks if progress relies on timers expiring, but it gets quite awkward if one only wants those to expire after some I/O bound prep has been done (creating files, reading test data, interacting with a mock).

Additional context

Below is an example showing where the clock can unexpectedly; In real situation both the directory creation and the interval will be hidden deeper in the code that's being tested though

on playground:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=e0e11bdc8e604a646186c5e9a4a9422c

relevant code:

let start = Instant::now();
tokio::spawn(async {
    let mut interval = interval(Duration::from_secs(1));
    loop {
        interval.tick().await;
    }
});
  
for i in 0..1000 {
    let _ = tokio::fs::create_dir("/tmp/test").await;
    assert_eq!(start, Instant::now(), "Failed after {} times", i);
}   

[sjoerdsimons]

If this feature request seems reasonable i'd love to know if the draft PR is going in the right direction :) Though there is a good chunk of work there still (documentations && tests). But it does solve the issue for me at least

[Darksonn]

Regardless of this feature request, it does seem unfortunate that spawn_blocking tasks don't prevent the timer from advancing.

[njam]

I'm not a tokio maintainer, but I'd love to see this feature as well.
Would you be able to give feedback on this feature request @Darksonn ?

My use case is to test time-related behaviour in unit tests, for which I'd like to control tokio time precisely, and never have the clock forward automatically.

Basically if I sleep(..) in a paused runtime, I'd like it to wait until the runtime gets advance(..)d the according duration.
For example in this case I'd like the sleep() to wait indefinitely. Instead the function finishes immediately currently.

#[tokio::main(flavor = "current_thread")]
async fn main() {
    tokio::time::pause();

    let instant_tokio = tokio::time::Instant::now();
    let instant_system = std::time::Instant::now();
    
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    
    println!("tokio={:?} system={:?}",instant_tokio.elapsed(), instant_system.elapsed());
}

[Darksonn]

If someone wants to write a PR, then I am ok with adding this.