Do I need to spawn to take advantage of a multi-threaded runtime?

[sylvain101010]

Hi,
I'm using tokio = "0.2" with a threaded scheduler

let mut runtime = tokio::runtime::Builder::new()
        .threaded_scheduler()
        // .max_threads(8)
        .enable_all()
        .build()
        .unwrap();

 runtime.block_on(worker::run(concurrency));

// worker.rs

pub async fn run(concurrency: usize) {
    let (mut tx, rx) = mpsc::channel(concurrency);
    let client = Client::new();

    tokio::spawn(async move {
        for i in 0..100 {
            println!("sending task: {}", i);
            tx.send(Task {
                event: "https://kerkour.fr".into(),
                payload: i.to_string(),
            })
            .await
            .unwrap();
        }
        drop(tx);
    });

    let consumer_stream = rx.for_each_concurrent(concurrency, |task| {
        let client = &client;
        println!("received request({:?})", &task.payload);
        async move {
            let resp = client.get(&task.event).send().await.unwrap();
            let _ = resp.text().await.unwrap();
            println!("completed request({:?})", task.payload);
        }
    });

    consumer_stream.await;
}

From what I understood from https://tokio.rs/blog/2019-10-scheduler the scheduler automatically balance the futures across all core threads, but this excellent writeup is saying the opposite: https://pkolaczk.github.io/benchmarking-cassandra-with-rust-streams/ and use multiple tokio::spawn calls to manually balance the work across all threads.

So do I need to manually use multiple spawn calls to multi-thread the code above?

[hawkw]

From what I understood from https://tokio.rs/blog/2019-10-scheduler the scheduler automatically balance the futures across all core threads,

The scheduler doesn't automatically balance futures across all core threads, it balances tasks. Tasks are lightweight units of work composed of one or more futures. Calling tokio::spawn or tokio::spawn_local with a future creates a new task that executes that future. awaiting a future in an async block or function waits for that future to complete as part of the current task.

Therefore, yes, in order to run work in parallel on multiple threads, it is necessary to spawn new tasks. Does that help?

[sylvain101010]

Yes thank you very much!

As you pointed out, the distinction between futures and tasks was not clear for me.

[hawkw]

Glad I could help! :)

[sylvain101010]

Another quick question @hawkw :
In order to implement my multi-threaded worker, should I better tokio::spawn for each received job, or should I better spawn one for each thread and use stream within the 'child' tasks (but then it requires SPMC channels which complicate the whole)?

i.e Are tokio::spawn cheap enough when taking in account that each job is ~(1 HTTP request + 3 database calls)?

[davidbarsky]

i.e Are tokio::spawn cheap enough when taking in account that each job is ~(1 HTTP request + 3 database calls)?

They're cheap enough for that—you can spawn millions of tasks without breaking a sweat.

[hawkw]

Yup, spawning one or more tasks for every request or job in a system is definitely an intended use-case!

[sylvain101010]

Ack, thank you very much!