From 0d3b030eb92657dc276a6188f61e5cfdd7e265cb Mon Sep 17 00:00:00 2001 From: Benoit Germain Date: Mon, 27 May 2024 16:30:26 +0200 Subject: Optional Decoda support (disabled by default) --- docs/index.html | 20 +++++++++++--------- src/intercopycontext.cpp | 17 +++++++++-------- src/lane.cpp | 20 ++++++++++---------- src/lane.h | 11 +++++++---- src/lanes.cpp | 3 +++ src/lanesconf.h | 1 + src/uniquekey.h | 6 +++--- src/universe.cpp | 6 +++++- 8 files changed, 49 insertions(+), 35 deletions(-) diff --git a/docs/index.html b/docs/index.html index 92cc38a..f5a074f 100644 --- a/docs/index.html +++ b/docs/index.html @@ -183,7 +183,7 @@

- luaopen_lanes_embedded leaves the module table on the stack. lanes.configure() must still be called in order to use Lanes. + luaopen_lanes_embedded leaves the module table on the stack. lanes.configure() must still be called in order to use Lanes.
If _luaopen_lanes is nullptr, a default loader will simply attempt the equivalent of luaL_dofile(L, "lanes.lua").

@@ -249,17 +249,17 @@ Requiring the module follows Lua 5.2+ rules: the module is not available under the global name "lanes", but has to be accessed through require's return value.

- After lanes is required, it is necessary to call lanes.configure(), which is the only function exposed by the module at this point. Calling configure() will perform one-time initializations and make the rest of the API available. + After lanes is required, it is necessary to call lanes.configure(), which is the only function exposed by the module at this point. Calling lanes.configure() will perform one-time initializations and make the rest of the API available.

- At the same time, configure() itself will be replaced by another function that raises an error if called again with differing arguments, if any. + At the same time, lanes.configure() itself will be replaced by another function that raises an error if called again with differing arguments, if any.

Also, once Lanes is initialized, require() is replaced by another one that wraps it inside a mutex, both in the main state and in all created lanes. This prevents multiple thread-unsafe module initializations from several lanes to occur simultaneously. It remains to be seen whether this is actually useful or not: If a module is already threadsafe, protecting its initialization isn't useful. And if it is not, any parallel operation may crash without Lanes being able to do anything about it.

- IMPORTANT NOTE: Only the first occurence of require "lanes" must be followed by a call to .configure(). From this point, a simple require "lanes" will do wherever you need to require lanes again. + IMPORTANT NOTE: Only the first occurence of require "lanes" must be followed by a call to lanes.configure(). From this point, a simple require "lanes" will be enough wherever you need to require lanes again.

@@ -758,8 +758,10 @@

- Each lane also gets a global function set_debug_threadname() that it can use anytime to do as the name says. Supported debuggers are Microsoft Visual Studio (for the C side) and Decoda (for the Lua side). -
+ Each lane gets a global function set_debug_threadname() that it can use anytime to do as the name says. Supported debuggers are Microsoft Visual Studio (for the C side) and Decoda (for the Lua side).
+ Decoda support is limited to setting a special global variable decoda_name. This is disabled by default. Change HAVE_DECODA_NAME() in lanesconf.h if necessary.
+ The name is stored inside the Lua state registry so that it is available for error reporting. Changing decoda_name doesn't affect this hidden name or the OS thread name reported by MSVC.
+ When Lanes is initialized by the first lanes.configure() call, "main" is stored in the registry in the same fashion (but decoda_name and the OS thread name are left unchanged).
The lane also has a method lane:get_debug_threadname() that gives access to that name from the caller side (returns "<unnamed>" if unset, "<closed>" if the internal Lua state is closed).

@@ -1334,7 +1336,7 @@
  • Performance. Changing any slot in a Linda causes all pending threads for that Linda to be momentarily awakened (at least in the C level). - This can degrade performance due to unnecessary OS level context switches. The more keeper states you declared with lanes.configure() the less this should be a problem. + This can degrade performance due to unnecessary OS level context switches. The more keeper states you declared with lanes.configure() the less this should be a problem.
    • @@ -1356,7 +1358,7 @@ events to a common Linda, but... :).

    - Timers are implemented as a lane. They can be enabled by setting "with_timers" to true in lanes.configure() settings. + Timers are implemented as a lane. They can be enabled by setting "with_timers" to true in lanes.configure() settings.

    @@ -1373,7 +1375,7 @@ events to a common Linda, but... :). 
     	local lanes = require "lanes"
-	lanes.configure()
+	lanes.configure{with_timers = true}
 
 	local linda = lanes.linda()
 
diff --git a/src/intercopycontext.cpp b/src/intercopycontext.cpp
index 6c72b1c..893305e 100644
--- a/src/intercopycontext.cpp
+++ b/src/intercopycontext.cpp
@@ -29,6 +29,7 @@ THE SOFTWARE.
 #include "debugspew.h"
 #include "deep.h"
 #include "keeper.h"
+#include "lane.h"
 #include "linda.h"
 #include "universe.h"
 
@@ -106,11 +107,11 @@ THE SOFTWARE.
     if (_fqn.empty() && !lua_istable(L1, L1_i)) { // raise an error if we try to send an unknown function (but not for tables)
         _fqn = std::string_view{}; // just in case
         // try to discover the name of the function we want to send
-        lua_getglobal(L1, "decoda_name");                                                          // L1: ... v ... decoda_name
+        kLaneNameRegKey.pushValue(L1);                                                             // L1: ... v ... lane_name
         char const* _from{ lua_tostring(L1, -1) };
-        lua_pushcfunction(L1, luaG_nameof);                                                        // L1: ... v ... decoda_name luaG_nameof
-        lua_pushvalue(L1, L1_i);                                                                   // L1: ... v ... decoda_name luaG_nameof t
-        lua_call(L1, 1, 2);                                                                        // L1: ... v ... decoda_name "type" "name"|nil
+        lua_pushcfunction(L1, luaG_nameof);                                                        // L1: ... v ... lane_name luaG_nameof
+        lua_pushvalue(L1, L1_i);                                                                   // L1: ... v ... lane_name luaG_nameof t
+        lua_call(L1, 1, 2);                                                                        // L1: ... v ... lane_name "type" "name"|nil
         char const* _typewhat{ (lua_type(L1, -2) == LUA_TSTRING) ? lua_tostring(L1, -2) : luaL_typename(L1, -2) };
         // second return value can be nil if the table was not found
         // probable reason: the function was removed from the source Lua state before Lanes was required.
@@ -325,10 +326,10 @@ void InterCopyContext::lookup_native_func() const
         // nil means we don't know how to transfer stuff: user should do something
         // anything other than function or table should not happen!
         if (!lua_isfunction(L2, -1) && !lua_istable(L2, -1)) {
-            lua_getglobal(L1, "decoda_name"); // L1: ... f ... decoda_name
+            kLaneNameRegKey.pushValue(L1);                                                         // L1: ... f ... lane_name
             char const* const _from{ lua_tostring(L1, -1) };
             lua_pop(L1, 1);                                                                        // L1: ... f ...
-            lua_getglobal(L2, "decoda_name");                                                      // L1: ... f ...                                  L2: {} f decoda_name
+            kLaneNameRegKey.pushValue(L2);                                                         // L1: ... f ...                                  L2: {} f lane_name
             char const* const _to{ lua_tostring(L2, -1) };
             lua_pop(L2, 1);                                                                        //                                                L2: {} f
             // when mode_ == LookupMode::FromKeeper, L is a keeper state and L2 is not, therefore L2 is the state where we want to raise the error
@@ -449,10 +450,10 @@ void InterCopyContext::copy_cached_func() const
             STACK_CHECK(L2, 0);
             return false;
         } else if (!lua_istable(L2, -1)) { // this can happen if someone decides to replace same already registered item (for a example a standard lib function) with a table
-            lua_getglobal(L1, "decoda_name"); // L1: ... t ... decoda_name
+            kLaneNameRegKey.pushValue(L1);                                                         // L1: ... t ... lane_name
             char const* _from{ lua_tostring(L1, -1) };
             lua_pop(L1, 1);                                                                        // L1: ... t ...
-            lua_getglobal(L2, "decoda_name");                                                      // L1: ... t ...                                  L2: {} t decoda_name
+            kLaneNameRegKey.pushValue(L2);                                                         // L1: ... t ...                                  L2: {} t lane_name
             char const* _to{ lua_tostring(L2, -1) };
             lua_pop(L2, 1);                                                                        // L1: ... t ...                                  L2: {} t
             raise_luaL_error(
diff --git a/src/lane.cpp b/src/lane.cpp
index f220bce..ada1846 100644
--- a/src/lane.cpp
+++ b/src/lane.cpp
@@ -802,20 +802,20 @@ Lane::~Lane()
 
 // #################################################################################################
 
-void Lane::changeDebugName(int nameIdx_)
+void Lane::changeDebugName(int const nameIdx_)
 {
-    // xxh64 of string "debugName" generated at https://www.pelock.com/products/hash-calculator
-    static constexpr RegistryUniqueKey kRegKey{ 0xA194E2645C57F6DDull };
-    nameIdx_ = lua_absindex(L, nameIdx_);
-    luaL_checktype(L, nameIdx_, LUA_TSTRING);                                                      // L: ... "name" ...
+    int const _nameIdx{ lua_absindex(L, nameIdx_) };
+    luaL_checktype(L, _nameIdx, LUA_TSTRING);                                                      // L: ... "name" ...
     STACK_CHECK_START_REL(L, 0);
     // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
-    kRegKey.setValue(L, [nameIdx = nameIdx_](lua_State* L_) { lua_pushvalue(L_, nameIdx); });      // L: ... "name" ...
+    kLaneNameRegKey.setValue(L, [idx = _nameIdx](lua_State* L_) { lua_pushvalue(L_, idx); });      // L: ... "name" ...
     // keep a direct pointer on the string
-    debugName = lua_tostringview(L, nameIdx_);
-    // to see VM name in Decoda debugger Virtual Machine window
-    lua_pushvalue(L, nameIdx_);                                                                    // L: ... "name" ... "name"
-    lua_setglobal(L, "decoda_name");                                                               // L: ... "name" ...
+    debugName = lua_tostringview(L, _nameIdx);
+    if constexpr (HAVE_DECODA_NAME()) {
+        // to see VM name in Decoda debugger Virtual Machine window
+        lua_pushvalue(L, _nameIdx);                                                                // L: ... "name" ... "name"
+        lua_setglobal(L, "decoda_name");                                                           // L: ... "name" ...
+    }
     // and finally set the OS thread name
     THREAD_SETNAME(debugName.data());
     STACK_CHECK(L, 0);
diff --git a/src/lane.h b/src/lane.h
index 1fdd955..4dcb99e 100644
--- a/src/lane.h
+++ b/src/lane.h
@@ -13,6 +13,9 @@
 
 // #################################################################################################
 
+// xxh64 of string "kExtendedStackTraceRegKey" generated at https://www.pelock.com/products/hash-calculator
+static constexpr RegistryUniqueKey kExtendedStackTraceRegKey{ 0x38147AD48FB426E2ull }; // used as registry key
+
 /*
  * registry[FINALIZER_REG_KEY] is either nil (no finalizers) or a table
  * of functions that Lanes will call after the executing 'pcall' has ended.
@@ -24,15 +27,15 @@
 // xxh64 of string "kFinalizerRegKey" generated at https://www.pelock.com/products/hash-calculator
 static constexpr RegistryUniqueKey kFinalizerRegKey{ 0xFE936BFAA718FEEAull };
 
-// xxh64 of string "kExtendedStackTraceRegKey" generated at https://www.pelock.com/products/hash-calculator
-static constexpr RegistryUniqueKey kExtendedStackTraceRegKey{ 0x38147AD48FB426E2ull }; // used as registry key
-
 // xxh64 of string "kLaneGC" generated at https://www.pelock.com/products/hash-calculator
 static constexpr UniqueKey kLaneGC{ 0x5D6122141727F960ull };
 
 // xxh64 of string "kLanePointerRegKey" generated at https://www.pelock.com/products/hash-calculator
 static constexpr RegistryUniqueKey kLanePointerRegKey{ 0x2D8CF03FE9F0A51Aull }; // used as registry key
 
+    // xxh64 of string "debugName" generated at https://www.pelock.com/products/hash-calculator
+static constexpr RegistryUniqueKey kLaneNameRegKey{ 0xA194E2645C57F6DDull };
+
 // #################################################################################################
 
 // The chain is ended by '(Lane*)(-1)', not nullptr: 'selfdestructFirst -> ... -> ... -> (-1)'
@@ -124,7 +127,7 @@ class Lane
     Lane(Universe* U_, lua_State* L_, ErrorTraceLevel errorTraceLevel_);
     ~Lane();
 
-    void changeDebugName(int nameIdx_);
+    void changeDebugName(int const nameIdx_);
     void close() { lua_State* _L{ L }; L = nullptr; lua_close(_L); }
     [[nodiscard]] std::string_view errorTraceLevelString() const;
     [[nodiscard]] int pushErrorHandler() const;
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 20636b2..0ea0900 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -676,6 +676,9 @@ LUAG_FUNC(configure)
         // increment refcount so that this linda remains alive as long as the universe exists.
         _U->timerLinda->refcount.fetch_add(1, std::memory_order_relaxed);
         lua_pop(L_, 1);                                                                            // L_: settings
+        // store a hidden reference in the registry to make sure the string is kept around even if a lane decides to manually change the "decoda_name" global...
+        kLaneNameRegKey.setValue(L_, [](lua_State* L_) { std::ignore = lua_pushstringview(L_, "main"); });
+
     }
     STACK_CHECK(L_, 1);
 
diff --git a/src/lanesconf.h b/src/lanesconf.h
index 3836848..2df7a71 100644
--- a/src/lanesconf.h
+++ b/src/lanesconf.h
@@ -42,3 +42,4 @@
 #endif // (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
 
 #define USE_DEBUG_SPEW() 0
+#define HAVE_DECODA_NAME() 0
diff --git a/src/uniquekey.h b/src/uniquekey.h
index 9981bb8..cfc8ab0 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -62,9 +62,9 @@ class RegistryUniqueKey
     void setValue(lua_State* L_, OP operation_) const
     {
         // Note we can't check stack consistency because operation is not always a push (could be insert, replace, whatever)
-        pushKey(L_); // ... key
-        operation_(L_); // ... key value
-        lua_rawset(L_, LUA_REGISTRYINDEX); // ...
+        pushKey(L_);                                                                               // ... key
+        operation_(L_);                                                                            // ... key value
+        lua_rawset(L_, LUA_REGISTRYINDEX);                                                         // ...
     }
     // ---------------------------------------------------------------------------------------------
     template 
diff --git a/src/universe.cpp b/src/universe.cpp
index 9e1ac5f..5fe53d5 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -286,7 +286,11 @@ void Universe::initializeKeepers(lua_State* L_)
 
         // 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:
+        if constexpr (HAVE_DECODA_NAME()) {
+            lua_pushvalue(_K, -1);                                                                 //                                                 K: "Keeper #n" Keeper #n"
+            lua_setglobal(_K, "decoda_name");                                                      // L_: settings                                    K: "Keeper #n"
+        }
+        kLaneNameRegKey.setValue(_K, [](lua_State* L_) { lua_insert(L_, -2); });                   //                                                 K:
         // create the fifos table in the keeper state
         Keepers::CreateFifosTable(_K);
         STACK_CHECK(_K, 0);
-- 
cgit v1.2.3-55-g6feb