1 files changed, 221 insertions, 1 deletions

diff --git a/src/universe.cpp b/src/universe.cpp
index dd293f2..9ab1290 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -31,8 +31,10 @@ THE SOFTWARE.
 #include "universe.h"
 
 #include "deep.h"
+#include "intercopycontext.h"
 #include "keeper.h"
 #include "lane.h"
+#include "state.h"
 
 // #################################################################################################
 
@@ -78,6 +80,224 @@ Universe::Universe()
 }
 
 // #################################################################################################
+// ################################### custom allocator support ####################################
+// #################################################################################################
+
+// same as PUC-Lua l_alloc
+extern "C" [[nodiscard]] static void* libc_lua_Alloc([[maybe_unused]] void* ud_, [[maybe_unused]] void* ptr_, [[maybe_unused]] size_t osize_, size_t nsize_)
+{
+    if (nsize_ == 0) {
+        free(ptr_);
+        return nullptr;
+    } else {
+        return realloc(ptr_, nsize_);
+    }
+}
+
+// #################################################################################################
+
+[[nodiscard]] static int luaG_provide_protected_allocator(lua_State* L_)
+{
+    Universe* const _U{ universe_get(L_) };
+    // push a new full userdata on the stack, giving access to the universe's protected allocator
+    [[maybe_unused]] AllocatorDefinition* const def{ new (L_) AllocatorDefinition{ _U->protectedAllocator.makeDefinition() } };
+    return 1;
+}
+
+// #################################################################################################
+
+/*
+ * Pool of keeper states
+ *
+ * Access to keeper states is locked (only one OS thread at a time) so the
+ * bigger the pool, the less chances of unnecessary waits. Lindas map to the
+ * keepers randomly, by a hash.
+ */
+
+// called as __gc for the keepers array userdata
+void Universe::closeKeepers()
+{
+    if (keepers != nullptr) {
+        int _nbKeepers{ keepers->nb_keepers };
+        // NOTE: imagine some keeper state N+1 currently holds a linda that uses another keeper N, and a _gc that will make use of it
+        // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
+        // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
+        // which is early-outed with a keepers->nbKeepers null-check
+        keepers->nb_keepers = 0;
+        for (int _i = 0; _i < _nbKeepers; ++_i) {
+            lua_State* const _K{ keepers->keeper_array[_i].L };
+            keepers->keeper_array[_i].L = KeeperState{ nullptr };
+            if (_K != nullptr) {
+                lua_close(_K);
+            } else {
+                // detected partial init: destroy only the mutexes that got initialized properly
+                _nbKeepers = _i;
+            }
+        }
+        for (int _i = 0; _i < _nbKeepers; ++_i) {
+            keepers->keeper_array[_i].~Keeper();
+        }
+        // free the keeper bookkeeping structure
+        internalAllocator.free(keepers, sizeof(Keepers) + (_nbKeepers - 1) * sizeof(Keeper));
+        keepers = nullptr;
+    }
+}
+
+// #################################################################################################
+
+// called once at the creation of the universe (therefore L_ is the master Lua state everything originates from)
+// Do I need to disable this when compiling for LuaJIT to prevent issues?
+void Universe::initializeAllocatorFunction(lua_State* L_)
+{
+    STACK_CHECK_START_REL(L_, 1);                                                                  // L_: settings
+    lua_getfield(L_, -1, "allocator");                                                             // L_: settings allocator|nil|"protected"
+    if (!lua_isnil(L_, -1)) {
+        // store C function pointer in an internal variable
+        provideAllocator = lua_tocfunction(L_, -1);                                            // L_: settings allocator
+        if (provideAllocator != nullptr) {
+            // make sure the function doesn't have upvalues
+            char const* upname = lua_getupvalue(L_, -1, 1);                                        // L_: settings allocator upval?
+            if (upname != nullptr) {   // should be "" for C functions with upvalues if any
+                raise_luaL_error(L_, "config.allocator() shouldn't have upvalues");
+            }
+            // remove this C function from the config table so that it doesn't cause problems
+            // when we transfer the config table in newly created Lua states
+            lua_pushnil(L_);                                                                       // L_: settings allocator nil
+            lua_setfield(L_, -3, "allocator");                                                     // L_: settings allocator
+        } else if (lua_type(L_, -1) == LUA_TSTRING) { // should be "protected"
+            LUA_ASSERT(L_, strcmp(lua_tostring(L_, -1), "protected") == 0);
+            // set the original allocator to call from inside protection by the mutex
+            protectedAllocator.initFrom(L_);
+            protectedAllocator.installIn(L_);
+            // before a state is created, this function will be called to obtain the allocator
+            provideAllocator = luaG_provide_protected_allocator;
+        }
+    } else {
+        // just grab whatever allocator was provided to lua_newstate
+        protectedAllocator.initFrom(L_);
+    }
+    lua_pop(L_, 1); // L_: settings
+    STACK_CHECK(L_, 1);
+
+    lua_getfield(L_, -1, "internal_allocator");                                                    // L_: settings "libc"|"allocator"
+    {
+        char const* const _allocator{ lua_tostring(L_, -1) };
+        if (strcmp(_allocator, "libc") == 0) {
+            internalAllocator = AllocatorDefinition{ libc_lua_Alloc, nullptr };
+        } else if (provideAllocator == luaG_provide_protected_allocator) {
+            // user wants mutex protection on the state's allocator. Use protection for our own allocations too, just in case.
+            internalAllocator = protectedAllocator.makeDefinition();
+        } else {
+            // no protection required, just use whatever we have as-is.
+            internalAllocator = protectedAllocator;
+        }
+    }
+    lua_pop(L_, 1);                                                                                // L_: settings
+    STACK_CHECK(L_, 1);
+}
+
+// #################################################################################################
+
+/*
+ * Initialize keeper states
+ *
+ * If there is a problem, returns nullptr and pushes the error message on the stack
+ * else returns the keepers bookkeeping structure.
+ *
+ * Note: Any problems would be design flaws; the created Lua state is left
+ *       unclosed, because it does not really matter. In production code, this
+ *       function never fails.
+ * settings table is expected at position 1 on the stack
+ */
+void Universe::initializeKeepers(lua_State* L_)
+{
+    LUA_ASSERT(L_, lua_gettop(L_) == 1 && lua_istable(L_, 1));
+    STACK_CHECK_START_REL(L_, 0);                                                                  // L_: settings
+    lua_getfield(L_, 1, "nb_keepers");                                                             // L_: settings nb_keepers
+    int const _nb_keepers{ static_cast<int>(lua_tointeger(L_, -1)) };
+    lua_pop(L_, 1);                                                                                // L_: settings
+    if (_nb_keepers < 1) {
+        raise_luaL_error(L_, "Bad number of keepers (%d)", _nb_keepers);
+    }
+    STACK_CHECK(L_, 0);
+
+    lua_getfield(L_, 1, "keepers_gc_threshold");                                                   // L_: settings keepers_gc_threshold
+    int const keepers_gc_threshold{ static_cast<int>(lua_tointeger(L_, -1)) };
+    lua_pop(L_, 1);                                                                                // L_: settings
+    STACK_CHECK(L_, 0);
+
+    // Keepers contains an array of 1 Keeper, adjust for the actual number of keeper states
+    {
+        size_t const bytes = sizeof(Keepers) + (_nb_keepers - 1) * sizeof(Keeper);
+        keepers = static_cast<Keepers*>(internalAllocator.alloc(bytes));
+        if (keepers == nullptr) {
+            raise_luaL_error(L_, "out of memory while creating keepers");
+        }
+        keepers->Keepers::Keepers();
+        keepers->gc_threshold = keepers_gc_threshold;
+        keepers->nb_keepers = _nb_keepers;
+
+        for (int _i = 0; _i < _nb_keepers; ++_i) {
+            keepers->keeper_array[_i].Keeper::Keeper();
+        }
+    }
+    for (int _i = 0; _i < _nb_keepers; ++_i) {
+        // note that we will leak K if we raise an error later
+        KeeperState const _K{ create_state(this, L_) };                                            // L_: settings                                    K:
+        if (_K == nullptr) {
+            raise_luaL_error(L_, "out of memory while creating keeper states");
+        }
+
+        keepers->keeper_array[_i].L = _K;
+
+        if (keepers->gc_threshold >= 0) {
+            lua_gc(_K, LUA_GCSTOP, 0);
+        }
+
+        STACK_CHECK_START_ABS(_K, 0);
+
+        // copy the universe pointer in the keeper itself
+        universe_store(_K, this);
+        STACK_CHECK(_K, 0);
+
+        // make sure 'package' is initialized in keeper states, so that we have require()
+        // this because this is needed when transferring deep userdata object
+        luaL_requiref(_K, LUA_LOADLIBNAME, luaopen_package, 1);                                    // L_: settings                                    K: package
+        lua_pop(_K, 1);                                                                            // L_: settings                                    K:
+        STACK_CHECK(_K, 0);
+        serialize_require(DEBUGSPEW_PARAM_COMMA(this) _K);
+        STACK_CHECK(_K, 0);
+
+        // copy package.path and package.cpath from the source state
+        if (luaG_getmodule(L_, LUA_LOADLIBNAME) != LuaType::NIL) {                                 // L_: settings package                            K:
+            // when copying with mode LookupMode::ToKeeper, error message is pushed at the top of the stack, not raised immediately
+            InterCopyContext _c{ this, DestState{ _K }, SourceState{ L_ }, {}, SourceIndex{ lua_absindex(L_, -1) }, {}, LookupMode::ToKeeper, {} };
+            if (_c.inter_copy_package() != InterCopyResult::Success) {                             // L_: settings ... error_msg                      K:
+                // if something went wrong, the error message is at the top of the stack
+                lua_remove(L_, -2);                                                                // L_: settings error_msg
+                raise_lua_error(L_);
+            }
+        }
+        lua_pop(L_, 1);                                                                            // L_: settings                                    K:
+        STACK_CHECK(L_, 0);
+        STACK_CHECK(_K, 0);
+
+        // attempt to call on_state_create(), if we have one and it is a C function
+        // (only support a C function because we can't transfer executable Lua code in keepers)
+        // will raise an error in L_ in case of problem
+        CallOnStateCreate(this, _K, L_, LookupMode::ToKeeper);
+
+        // to see VM name in Decoda debugger
+        lua_pushfstring(_K, "Keeper #%d", _i + 1);                                                 // L_: settings                                    K: "Keeper #n"
+        lua_setglobal(_K, "decoda_name");                                                          // L_: settings                                    K:
+        // create the fifos table in the keeper state
+        Keepers::CreateFifosTable(_K);
+        STACK_CHECK(_K, 0);
+    }
+    STACK_CHECK(L_, 0);
+}
+
+// #################################################################################################
 
 void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTimeout_, CancelOp op_)
 {
@@ -160,7 +380,7 @@ int universe_gc(lua_State* L_)
         _U->timerLinda = nullptr;
     }
 
-    close_keepers(_U);
+    _U->closeKeepers();
 
     // remove the protected allocator, if any
     _U->protectedAllocator.removeFrom(L_);