The tokio::io::empty combinator does not participate in coop

[francis-starlab]

Version
List the versions of all tokio crates you are using. The easiest way to get
this information is using cargo tree subcommand:

cargo tree | grep tokio

└── tokio v1.14.0
    └── tokio-macros v1.6.0 (proc-macro)

Platform
The output of uname -a (UNIX), or version and 32 or 64-bit (Windows)
Linux francis-debian 5.10.0-9-amd64 #1 SMP Debian 5.10.70-1 (2021-09-30) x86_64 GNU/Linux

Description

I tried this code:

use std::time::Duration;
use tokio::io::AsyncReadExt;
use tokio::time::timeout;

#[tokio::main]
async fn main() {
    if timeout(Duration::from_millis(1000), async {
        loop {
            let mut buf = [0u8; 4096];
            let _ = tokio::io::empty().read(&mut buf).await;
        }
    }).await.is_err() {
        println!("timedout");
    };
}

I expected to see this happen:

I expected a timeout to occur after 1 second and for the process to exit. Instead it hangs forever.

[hawkw]

Reading from io::empty always returns immediately, so the loop will never yield. The timeout cannot fire unless the main task yields, because it's blocking the thread.

If you spawn the async block inside the timeout as a separate task, you should see it time out as expected: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=8c1de2e3ce490e8d57ff848f32ae95db

[hawkw]

It occurs to me that io::empty should maybe participate in cooperative yielding to prevent busy-loops like this from hanging the entire runtime...

[Darksonn]

Thanks for reporting this. We should make sure that io::empty and friends participate in coop.

[francis-starlab]

Possibly related/same thing:

use std::process::Stdio;
use std::time::Duration;
use tokio::io::AsyncReadExt;
use tokio::process::Command;
use tokio::time::timeout;

#[tokio::main]
async fn main() {
    let mut command = Command::new("yes");
     command.stdout(Stdio::piped());
    let mut spawned = command.spawn().expect("error spawning");
    let mut stdout = spawned.stdout.take().expect("no stdout?");
    if timeout(Duration::from_millis(1000), async {
        loop {
            let mut buf = [0u8; 1];
            let _ = stdout.read(&mut buf).await;
        }
    }).await.is_err() {
        println!("timedout");
    };
}

Assuming you have a fast enough yes on your system, then the above also doesn't timeout when it should.

[BraulioVM]

Actually the original issue isn't fixed yet because of #4300 (comment) . I should have updated the PR body. Anyway, I'm working on a PR that finally fixes this problem.

tokio::io::empty does participate in coop now, which is what the currrent title of the issue refers to, so I guess it could make sense to keep it closed.