What am I doing wrong? - Async Program hanging at 128 Futures

[emogames]

New to rust, new to tokio, new to async...
I want to create a Set holding a large number of Futures to understand how well this works.

Once I have more than 128 Futures in a FuturesUnordered struct though the program keeps running at 100% CPU and won't finish.
Works as expected until 127 Futures.

Behavior looks similar to rust-lang/futures-rs#2140 though I´m not using join_all (tried that before).

        
        #[tokio::main]
        async fn main() {
            block_on(as_main());
        }
        
        async fn as_main() {
        
            let mut v= FuturesUnordered::new();
        
            // Works fine like this:
            // for i in 0 .. 128 {
        
            // Will keep hanging at 100% CPU with >= 128 futures
            for i in 0 .. 129 {
                let future = rnd_delay(i);
                v.push(future);
            }
        
            println!("Handles pushed...");
        
            loop {
                let res = v.next().await;
                match res {
                    Some(_) => (),
                    None => {
                        println!("Done");
                        break
                    },
                }
            }
        }
        
        async fn rnd_delay(i : u32) {
            let mut rng = rand::thread_rng();
            let millis: u64 = rng.gen_range(99..101);
        
            tokio::time::sleep(Duration::from_millis(millis)).await;
        
            let mut msg:String = String::from("Message from: ");
            msg.push_str(&i.to_string());
            println!("{}" , msg);
        }

tokio version 1.17.0
futures verision 0.3.21

[taiki-e]

Perhaps this block_on is causing the problem

  async fn main() {
-     block_on(as_main());
+     as_main().await;
  }

[emogames]

Thanks for the quick answer. This indeed solves the problem!

Though I do not really understand why,
since the code executes with <=128 Futures and stops working once that number is exceeded.

[Darksonn]

When it hits the coop limit at 128 operations, the task must yield to the Tokio runtime before the remaining sleeps will be able to complete. However, the block_on call prevents it from yielding to the runtime.