Does the loop + select! construct block the executor?

[TuhinNair]

Hey, just getting started with Async Rust and I was hoping I could get some feedback.

I'm trying to implement a heartbeat, i.e, run a async function and run something else on an interval while the first one is still in progress.
This async function is to be executed in parallel using a bunch of identical tasks. The total number of tasks executing at the same time should be capped.

A rough gist of the code I'm attempting is below but my main query is whether running select! in a loop is blocking or not? If it's not blocking when and where does it yield?

I ask because most examples I've seen of loop+select! are in the main function.

const HEARTBEAT_INTERVAL: u64 = 5;

async fn spawns_many_tasks(num_tasks: usize) {
    for _ in 0..num_tasks {
        tokio::spawn(process_task_with_heartbeat());
    }
}

async fn process_task_with_heartbeat() {
    // Use an mpsc channel here as recv is cancellation safe
    let (tx, mut rx) = mpsc::unbounded_channel();

    tokio::spawn(async move {
        let network_call_result = rest_api.call_something().await;

        let _ = tx.send(network_call_result);
    });

    let duration = tokio::time::Duration::from_secs(HEARTBEAT_INTERVAL);
    let mut heartbeat = tokio::time::interval(duration);
    heartbeat.tick().await; // First tick is immediate

    loop {
        tokio::select! {
            biased;
            network_call_result = rx.recv() => {
                              unimplemented!(),
                              // run another async function to process the result and break out of the loop here
            },
            _ = heartbeat.tick() => {
                // Run an async function on every tick while the network call is still in progress.
            },
        }
    }
}

[asonix]

select internally builds a poll_fn(|cx| { /* */ }) which polls each of the futures until one is ready or until all have been polled. it puts a .await on the poll_fn which yields to the executor if all the futures polled inside returned Pending, otherwise it will execute the branch associated with the ready future. You can see the code yourself with cargo-expand

[TuhinNair]

Got it! Thanks.

As an aside, given my description of an heartbeat, would this be considered an idiomatic implementation? Are there alternatives to achieving the same behavior? But again, thanks!

[asonix]

I think what you have done makes sense, but I think somebody else might be more qualified to answer that definitively