Some more code refactorization

1 files changed, 93 insertions, 23 deletions

diff --git a/src/universe.cpp b/src/universe.cpp
index bf64560..6adc314 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -1,11 +1,11 @@
 /*
- * UNIVERSE.C                  Copyright (c) 2017, Benoit Germain
+ * UNIVERSE.CPP                  Copyright (c) 2017-2024, Benoit Germain
  */
 
 /*
 ===============================================================================
 
-Copyright (C) 2017 Benoit Germain <bnt.germain@gmail.com>
+Copyright (C) 2017-2024 Benoit Germain <bnt.germain@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -28,18 +28,14 @@ THE SOFTWARE.
 ===============================================================================
 */
 
-#include <string.h>
-#include <assert.h>
-
 #include "universe.h"
-#include "compat.h"
-#include "macros_and_utils.h"
-#include "uniquekey.h"
 
-// xxh64 of string "kUniverseFullRegKey" generated at https://www.pelock.com/products/hash-calculator
-static constexpr RegistryUniqueKey kUniverseFullRegKey{ 0x1C2D76870DD9DD9Full };
-// xxh64 of string "kUniverseLightRegKey" generated at https://www.pelock.com/products/hash-calculator
-static constexpr RegistryUniqueKey kUniverseLightRegKey{ 0x48BBE9CEAB0BA04Full };
+#include "cancel.h"
+#include "compat.h"
+#include "deep.h"
+#include "keeper.h"
+#include "lanes_private.h"
+#include "tools.h"
 
 // #################################################################################################
 
@@ -72,7 +68,7 @@ Universe::Universe()
 // #################################################################################################
 
 // only called from the master state
-Universe* universe_create(lua_State* L_)
+[[nodiscard]] Universe* universe_create(lua_State* L_)
 {
     LUA_ASSERT(L_, universe_get(L_) == nullptr);
     Universe* const U{ lua_newuserdatauv<Universe>(L_, 0) }; // universe
@@ -86,20 +82,94 @@ Universe* universe_create(lua_State* L_)
 
 // #################################################################################################
 
-void universe_store(lua_State* L_, Universe* U_)
+void Universe::terminateFreeRunningLanes(lua_State* L_, lua_Duration shutdownTimeout_, CancelOp op_)
 {
-    LUA_ASSERT(L_, !U_ || universe_get(L_) == nullptr);
-    STACK_CHECK_START_REL(L_, 0);
-    kUniverseLightRegKey.setValue(L_, [U = U_](lua_State* L_) { U ? lua_pushlightuserdata(L_, U) : lua_pushnil(L_); });
-    STACK_CHECK(L_, 0);
+    if (selfdestructFirst != SELFDESTRUCT_END) {
+        // Signal _all_ still running threads to exit (including the timer thread)
+        {
+            std::lock_guard<std::mutex> guard{ selfdestructMutex };
+            Lane* lane{ selfdestructFirst };
+            lua_Duration timeout{ 1us };
+            while (lane != SELFDESTRUCT_END) {
+                // attempt the requested cancel with a small timeout.
+                // if waiting on a linda, they will raise a cancel_error.
+                // if a cancellation hook is desired, it will be installed to try to raise an error
+                if (lane->thread.joinable()) {
+                    std::ignore = thread_cancel(lane, op_, 1, timeout, true);
+                }
+                lane = lane->selfdestruct_next;
+            }
+        }
+
+        // When noticing their cancel, the lanes will remove themselves from the selfdestruct chain.
+        {
+            std::chrono::time_point<std::chrono::steady_clock> t_until{ std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(shutdownTimeout_) };
+
+            while (selfdestructFirst != SELFDESTRUCT_END) {
+                // give threads time to act on their cancel
+                std::this_thread::yield();
+                // count the number of cancelled thread that didn't have the time to act yet
+                int n{ 0 };
+                {
+                    std::lock_guard<std::mutex> guard{ selfdestructMutex };
+                    Lane* lane{ selfdestructFirst };
+                    while (lane != SELFDESTRUCT_END) {
+                        if (lane->cancelRequest != CancelRequest::None)
+                            ++n;
+                        lane = lane->selfdestruct_next;
+                    }
+                }
+                // if timeout elapsed, or we know all threads have acted, stop waiting
+                std::chrono::time_point<std::chrono::steady_clock> t_now = std::chrono::steady_clock::now();
+                if (n == 0 || (t_now >= t_until)) {
+                    DEBUGSPEW_CODE(fprintf(stderr, "%d uncancelled lane(s) remain after waiting %fs at process end.\n", n, shutdownTimeout_.count()));
+                    break;
+                }
+            }
+        }
+
+        // If some lanes are currently cleaning after themselves, wait until they are done.
+        // They are no longer listed in the selfdestruct chain, but they still have to lua_close().
+        while (selfdestructingCount.load(std::memory_order_acquire) > 0) {
+            std::this_thread::yield();
+        }
+    }
+
+    // If after all this, we still have some free-running lanes, it's an external user error, they should have stopped appropriately
+    {
+        std::lock_guard<std::mutex> guard{ selfdestructMutex };
+        Lane* lane{ selfdestructFirst };
+        if (lane != SELFDESTRUCT_END) {
+            // this causes a leak because we don't call U's destructor (which could be bad if the still running lanes are accessing it)
+            raise_luaL_error(L_, "Zombie thread %s refuses to die!", lane->debugName);
+        }
+    }
 }
 
 // #################################################################################################
 
-Universe* universe_get(lua_State* L_)
+// process end: cancel any still free-running threads
+int universe_gc(lua_State* L_)
 {
-    STACK_CHECK_START_REL(L_, 0);
-    Universe* const universe{ kUniverseLightRegKey.readLightUserDataValue<Universe>(L_) };
-    STACK_CHECK(L_, 0);
-    return universe;
+    lua_Duration const shutdown_timeout{ lua_tonumber(L_, lua_upvalueindex(1)) };
+    [[maybe_unused]] char const* const op_string{ lua_tostring(L_, lua_upvalueindex(2)) };
+    Universe* const U{ lua_tofulluserdata<Universe>(L_, 1) };
+    U->terminateFreeRunningLanes(L_, shutdown_timeout, which_cancel_op(op_string));
+
+    // no need to mutex-protect this as all threads in the universe are gone at that point
+    if (U->timerLinda != nullptr) { // test in case some early internal error prevented Lanes from creating the deep timer
+        [[maybe_unused]] int const prev_ref_count{ U->timerLinda->refcount.fetch_sub(1, std::memory_order_relaxed) };
+        LUA_ASSERT(L_, prev_ref_count == 1); // this should be the last reference
+        DeepFactory::DeleteDeepObject(L_, U->timerLinda);
+        U->timerLinda = nullptr;
+    }
+
+    close_keepers(U);
+
+    // remove the protected allocator, if any
+    U->protectedAllocator.removeFrom(L_);
+
+    U->Universe::~Universe();
+
+    return 0;
 }