Understanding the interaction between async Rust functions and Lua coroutines

[benwilber]

I am trying to understand how Lua coroutines interact with async Rust functions. I have made a simple example like:

struct Sleep;

impl mlua::UserData for Sleep {
    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
        methods.add_async_meta_method(mlua::MetaMethod::Call, async |_lua, _this, millis: f64| {
            tokio::time::sleep(std::time::Duration::from_millis(millis as u64)).await;
            Ok(())
        });
    }
}

#[tokio::main]
async fn main() {
    let lua = mlua::Lua::new();
    let globals = lua.globals();
    globals.set("sleep", Sleep).unwrap();
    
    lua.load(r#"
        print("Sleep started")
        sleep(3000) -- Sleep for 3000 milliseconds (3 seconds)
        print("Sleep finished")
    "#).exec_async().await.unwrap();

    lua.load(r#"
        local function coro_sleep()
            print("Coro sleep started")
            sleep(3000) -- Sleep for 3000 milliseconds (3 seconds)
            print("Coro sleep finished")
        end

        local co = coroutine.create(coro_sleep)
        for i=1,math.huge do
            -- This loop runs 7.5 million times (debug mode, 25M+ in release)
            -- before the sleep finishes
            local status = coroutine.status(co)
            if status ~= "suspended" then
                print(i, "coroutine finished")
                break
            else
                coroutine.resume(co)
            end            
        end    
    "#).exec_async().await.unwrap();
}

This first Lua code just calling sleep works as I expect, but the 2nd code (wrapping sleep()) in a coroutine requires resuming it millions of times in a loop before it is completed. I don't really know what I'm expecting, but just trying to understand how it's supposed to be working, and if this is normal.

Thanks!
Ben

[dependencies]
mlua = { version = "0.10.3", features = ["async", "lua54", "vendored"] }
tokio = { version = "1.44.1", features = ["macros", "rt-multi-thread", "time"] }

[khvzak]

Some explanation is provided in Lua::create_async_function doc.

Any Rust+Lua async function calls coroutine.yield with Poll::Pending if Future is not ready.
When executing code via exec_async(), mlua receives Poll::Pending from Future and pass it to Waker.
Next time Future will be resumed by scheduler when result is ready.

When wrapping Rust async functions in coroutine.create, you break this process and taking control from mlua to your app.
In this case you need to check if Poll::Pending is returned and propagate it to mlua.
The reason why you need to make many millions of iterations, because every time Future tells you that result if not ready.