Implement Runtime::runOnce() and use it in the internal scheduler loop (#286)

This PR implements a C-sided API `Runtime::runOnce()` to run a singular
iteration of the scheduler loop. This returns an `std::variant` between
`StepErr` and `StepSuccess`, returning the `lua_State* L` which errored
if the variant is a `StepErr`. This is then utilized in
`Runtime::runToCompletion`, which simplifies some logic regarding
exiting the runtime loop.

Fixes #272

---------

Co-authored-by: ariel <[email protected]>

Author: ffrostfall

runtime/include/lute/runtime.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Luau/Variant.h"
+#include "lua.h"
 #include "lute/ref.h"
 
 #include <atomic>
@@ -19,19 +21,37 @@ struct ThreadToContinue
     std::function<void()> cont;
 };
 
+struct StepErr
+{
+    lua_State* L;
+};
+
+struct StepSuccess
+{
+    lua_State* L;
+};
+
+struct StepEmpty
+{
+};
+
+using RuntimeStep = Luau::Variant<StepSuccess, StepErr, StepEmpty>;
+
 struct Runtime
 {
     Runtime();
     ~Runtime();
 
     bool runToCompletion();
+    RuntimeStep runOnce();
 
     // For child runtimes, run a thread waiting for work
     void runContinuously();
 
     // Reports an error for a specified lua state.
     void reportError(lua_State* L);
 
+    bool hasWork();
     bool hasContinuations();
     bool hasThreads();
 

runtime/src/runtime.cpp

@@ -35,69 +35,93 @@ Runtime::~Runtime()
         runLoopThread.join();
 }
 
-bool Runtime::runToCompletion()
+bool Runtime::hasWork()
 {
-    // While there is some C++ or Luau code left to run (waiting for something to happen?)
-    while (!runningThreads.empty() || hasContinuations() || activeTokens.load() != 0)
+    return hasContinuations() || hasThreads() || activeTokens.load() != 0;
+}
+
+RuntimeStep Runtime::runOnce()
+{
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+    // Complete all C++ continuations
+    std::vector<std::function<void()>> copy;
+
     {
-        uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+        std::unique_lock lock(continuationMutex);
+        copy = std::move(continuations);
+        continuations.clear();
+    }
 
-        // Complete all C++ continuations
-        std::vector<std::function<void()>> copy;
+    for (auto&& continuation : copy)
+        continuation();
 
-        {
-            std::unique_lock lock(continuationMutex);
-            copy = std::move(continuations);
-            continuations.clear();
-        }
+    if (runningThreads.empty())
+        return StepEmpty{};
 
-        for (auto&& continuation : copy)
-            continuation();
+    auto next = std::move(runningThreads.front());
+    runningThreads.erase(runningThreads.begin());
 
-        if (runningThreads.empty())
-            continue;
+    next.ref->push(GL);
+    lua_State* L = lua_tothread(GL, -1);
 
-        auto next = std::move(runningThreads.front());
-        runningThreads.erase(runningThreads.begin());
+    if (L == nullptr)
+    {
+        fprintf(stderr, "Cannot resume a non-thread reference");
+        return StepErr{L};
+    }
 
-        next.ref->push(GL);
-        lua_State* L = lua_tothread(GL, -1);
+    // We still have 'next' on stack to hold on to thread we are about to run
+    lua_pop(GL, 1);
 
-        if (L == nullptr)
-        {
-            fprintf(stderr, "Cannot resume a non-thread reference");
-            return false;
-        }
+    int status = LUA_OK;
 
-        // We still have 'next' on stack to hold on to thread we are about to run
-        lua_pop(GL, 1);
+    if (!next.success)
+        status = lua_resumeerror(L, nullptr);
+    else
+        status = lua_resume(L, nullptr, next.argumentCount);
 
-        int status = LUA_OK;
+    if (status == LUA_YIELD)
+    {
+        return StepSuccess{L};
+    }
 
-        if (!next.success)
-            status = lua_resumeerror(L, nullptr);
-        else
-            status = lua_resume(L, nullptr, next.argumentCount);
+    if (status != LUA_OK)
+    {
+        return StepErr{L};
+    };
 
-        if (status == LUA_YIELD)
-        {
-            continue;
-        }
+    if (next.cont)
+        next.cont();
+
+    return StepSuccess{L};
+}
 
-        if (status != LUA_OK)
+bool Runtime::runToCompletion()
+{
+    while (hasWork())
+    {
+        auto step = runOnce();
+
+        if (auto err = Luau::get_if<StepErr>(&step))
         {
-            reportError(L);
+            if (err->L == nullptr)
+            {
+                fprintf(stderr, "lua_State* L is nullptr");
+                return false;
+            }
+
+            reportError(err->L);
 
-            // If we have no work to do, then exit the process.
-            if (!hasThreads() && !hasContinuations())
+            // ensure we exit the process with error code properly
+            if (!hasWork())
                 return false;
-            else
-                continue;
         }
-
-        if (next.cont)
-            next.cont();
-    }
+        else
+        {
+            continue;
+        }
+    };
 
     return true;
 }