Why doesn't detach force running a task to its first await point?

[cr1901]

Thank you to the developers of smol for creating this project- I've found it fun to hack on!

I have an embedded Linux UDP server I'm trying to use with smol. To minimize resource usage (as well as just because I want to), I'm trying to use a LocalExecutor only. My main server loop looks like this, where I register blocking functions to Dispatch to be run when there are UDP connections. The echo_handler simply echos the UDP input back to the client (after capitalizing the input):

pub async fn main_loop(self) -> Result<(), Error> {
        let default_addr: SocketAddr = "0.0.0.0:12000".parse().unwrap();
        let socket = UdpSocket::bind(self.addr.unwrap_or(default_addr)).await?;
        let mut buf = vec![0u8; 1024];
        let ex = Rc::new(LocalExecutor::new());
        let mut dispatch = Dispatch::<Context, Error, 16>::new(Context::new(&ex, socket.clone()));

        dispatch.add_handler::<EchoEndpoint>(echo_handler).map_err(|s| Error::Init(s))?;

        loop {
            let (n, addr) = socket.recv_from(&mut buf).await?;
            dispatch.context().addr = Some(addr);
            match dispatch.dispatch(&mut buf[..n]) {
                Ok(_) => {},
                Err(e) => { todo!("Need to handle error: {:?}", e) },
            }
        }
    }

The overview of the RPC crate I'm using to provide Dispatch suggests spawning tasks inside each dispatch handler:

fn echo_handler<'ex, 'b>(hdr: &WireHeader, ctx: &mut Context<'ex, 'b>, bytes: &[u8]) -> Result<(), Error> {
    let Context { ex, sock, addr , .. } = ctx;
    let addr = addr.unwrap().clone();
    let sock = sock.clone();
    let ex = Rc::clone(ex);
    // let ctx = ctx.clone();

    match postcard::from_bytes::<Echo>(bytes) {
        Ok(msg) => {
            ctx.ex.spawn(echo_task(ex, hdr.seq_no, hdr.key, (sock, addr), msg.0)).detach();
            ctx.ex.try_tick();
            Ok(())
        },
        Err(e) => {
            Err(Error::Parse(e))
        }
    }
}

async fn echo_task<'a, 'ex>(_ex: Rc<LocalExecutor<'ex>>, seq_no: u32, key: Key, (sock, addr): (UdpSocket, SocketAddr), msg: String) {
    let resp = EchoResponse(msg.to_uppercase());
    let mut buf = vec![0u8; 1024];

    if let Ok(used) = postcard_rpc::headered::to_slice_keyed(seq_no, key, &resp, &mut buf) {
        let _ = sock.send_to(used, addr).await;
    }
}

spawn returns a task, and if I want to run the task, I need to either .await on it or detach. Since I'm in a blocking function (which is not possible to change, not my crate), I can't .await on the task, so I opt to detach.

What I've noticed is that unless I immediately tell the LocalExecutor to try running scheduled tasks via try_tick, the echo_task task never runs at all. AFAICT, echo_handler returns to the main async server loop, tries to .await in socket.recv_from(&mut buf);, poll returns Pending, and the LocalExecutor goes to sleep without ever running echo_task at all despite me having detached in the dispatcher.

Is ctx.ex.try_tick();, _possibly looping over until try_tick returns false, the proper way to force a detached task to run in a LocalExecutor? If not, what is the appropriate way to ensure that any detached tasks I spawn in a LocalExecutor at least runs to the first await point?

[notgull]

Tasks do not run except inside of a scheduler. There are many reasons for this, such as the fact that blocking futures need to run on a blocking executor, and polling the blocking futures on the spawning thread would effectively deadlock the thread. Generally if you spawn something in a task you don't want to block the current future on it.

Also it's generally a bad idea to use try_tick, and run() should be used in most cases. See smol-rs/async-executor#88

[cr1901]

EDIT: I think what I'm expecting to happen is that "when my main_loop task spawns an echo_task, a single thread executor "magically" know that echo_task is a child of main_loop, and the executor should poll both as a prerequisite of making sure the main_loop completes.

Now that I wrote that out, it occurs to me that this is probably unreasonable to expect without somehow notifying the executor "Hi, I have a new task, plz run it!".

If I want a single-threaded executor, what is the correct way to spawn tasks from a Future so that those spawned tasks will run when the spawning Future returns Pending (so the executor does useful work, possibly driving the spawned tasks to completion, before the spawning Future has signaled to wake)?

Original Minddump Follows

Generally if you spawn something in a task you don't want to block the current future on it.

Indeed, I don't want to want to block the current future from running. What I want is:

• echo_task gets created as part of spawn.
• I detach the task to make it "the executor's problem" to run the future.
• echo_handler, a blocking function, returns to my main_loop future.
• Assuming I have no more connections to my server loop, the executor gets Pending back from socket.recv_from(&mut buf).await?;, so the main_loop future sets a Waker, etc that will notify the executor when main_loop is ready w/ a new connection.
• The executor sees that echo_task is ready to run, and hasn't started at all, and polls that future.

Without try_tick, the last part doesn't happen at all. echo_task never runs. I don't want to run the echo_task to completion; I want the executor to interleave main_loop and echo_task, polling each one in a single thread. How do I force echo_task to at least start so that main_loop and echo_task are active tasks?

run() should be used in most cases.

run blocks until the future completes, so I don't think that will allow main_loop and echo_task to be schedule to run/interleaved.

[cr1901]

@notgull is correct re: "use run". My original main, which I didn't think to include, looked like this:

fn main() {
    let server = Server::new();
    smol::block_on(server.main_loop());
}

It should've looked like this:

fn main() {
    let server = Server::new();
    let ex = Rc::new(LocalExecutor::new());
    smol::block_on(ex.run(server.main_loop(ex.clone())));
}

I.e. "I need to pass a reference to the LocalExecutor down into async code, not create the LocalExecutor in my top-level future."

The remaining code is also basically identical to above, except accommodating the passed-down LocalExecutor and removing try_tick:

pub async fn main_loop(self, ex: Rc<LocalExecutor<'_>>) -> Result<(), Error> {
        let default_addr: SocketAddr = "0.0.0.0:12000".parse().unwrap();
        let socket = UdpSocket::bind(self.addr.unwrap_or(default_addr)).await?;
        let mut buf = vec![0u8; 1024];
        let mut dispatch = Dispatch::<Context, Error, 16>::new(Context::new(&ex, socket.clone()));

        dispatch.add_handler::<EchoEndpoint>(echo_handler).map_err(|s| Error::Init(s))?;

        loop {
            let (n, addr) = socket.recv_from(&mut buf).await?;
            dispatch.context().addr = Some(addr);
            match dispatch.dispatch(&mut buf[..n]) {
                Ok(_) => {},
                Err(e) => { todo!("Need to handle error: {:?}", e) },
            }
        }
    }

fn echo_handler<'ex, 'b>(hdr: &WireHeader, ctx: &mut Context<'ex, 'b>, bytes: &[u8]) -> Result<(), Error> {
    let Context { ex, sock, addr , .. } = ctx;
    let addr = addr.unwrap().clone();
    let sock = sock.clone();
    // let ctx = ctx.clone();

    match postcard::from_bytes::<Echo>(bytes) {
        Ok(msg) => {
            ex.spawn(echo_task(ex.clone(), hdr.seq_no, hdr.key, (sock, addr), msg.0)).detach();
            Ok(())
        },
        Err(e) => {
            Err(Error::Parse(e))
        }
    }
}

async fn echo_task<'a, 'ex>(_ex: Rc<LocalExecutor<'ex>>, seq_no: u32, key: Key, (sock, addr): (UdpSocket, SocketAddr), msg: String) {
    let resp = EchoResponse(msg.to_uppercase());
    let mut buf = vec![0u8; 1024];

    if let Ok(used) = postcard_rpc::headered::to_slice_keyed(seq_no, key, &resp, &mut buf) {
        let _ = sock.send_to(used, addr).await;
    }
}

My original try_tick call was indeed making forward progress in the executor I created in main_loop. But that doesn't help ensure that echo_task gets scheduled by a different "executor" that's blocking on main_loop :).

Also credit to this comment for pointing out the issue once I stared at the code snippet long enough :).