runtime overhead? #5986

ibigbug · 2023-09-06T17:34:23Z

ibigbug
Sep 6, 2023

I have a test code below


    #[tokio::test]
    async fn test_connect_tcp() {
        let mut futs = vec![];

        for i in 0..100 { // number of here matters
            futs.push(tokio::spawn(async move {
                let now = std::time::Instant::now();
                tokio::time::sleep(Duration::from_millis(100)).await;  // manually adding a sleep to simulate but it doesn't seem to matter
                let socket =
                    socket2::Socket::new(socket2::Domain::IPV4, socket2::Type::DGRAM, None)
                        .unwrap();

                timeout(
                    Duration::from_secs(10),
                    TcpSocket::from_std_stream(socket.into())
                        .connect(("1.1.1.1".parse::<IpAddr>().unwrap(), 443).into()),
                )
                .await
                .unwrap()
                .unwrap();

                println!("fut {} took {:?}", i, now.elapsed().as_millis());
            }));
        }

        futures::stream::iter(futs)
            .buffer_unordered(10)
            .collect::<Vec<_>>()
            .await;
    }

I noticed if I only make 10 loops, the print will say about ~105ms (5ms + the 100ms sleep)

when I increase it to 100 loops, it prints ~120ms (20ms + 100ms sleep).

I'm guessing there's some runtime schedule overhead which is adding the latency? or I missed anything?

basically what I want to do is to measure the time spent in executing a future, excluding the runtime overhead.

and apparently establishing the conn should only takes 5ms which is the case when there are 10 futs executing.

so what's the correct way to:

run the list of futures, so they run "fast"? I also tried join_all which doesn't seem to make any difference.
if 1 is the case due to the fact that the runtime need to poll each future which takes time, how to measure the time spent in execution?