Improved multi-keeper tests

5 files changed, 178 insertions, 125 deletions

diff --git a/src/deep.cpp b/src/deep.cpp
index f5716bf..34cc4b4 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -78,9 +78,9 @@ namespace {
 
         // can work without a universe if creating a deep userdata from some external C module when Lanes isn't loaded
         // in that case, we are not multithreaded and locking isn't necessary anyway
-        bool const isLastRef{ _p->refcount.fetch_sub(1, std::memory_order_relaxed) == 1 };
+        bool const _isLastRef{ _p->refcount.fetch_sub(1, std::memory_order_relaxed) == 1 };
 
-        if (isLastRef) {
+        if (_isLastRef) {
             // retrieve wrapped __gc, if any
             lua_pushvalue(L_, lua_upvalueindex(1));                                                // L_: self __gc?
             if (!lua_isnil(L_, -1)) {
@@ -123,6 +123,7 @@ namespace {
 // #################################################################################################
 // #################################################################################################
 
+// NEVER call deleteDeepObjectInternal by itself, ALWAYS go through DeleteDeepObject()
 void DeepFactory::DeleteDeepObject(lua_State* const L_, DeepPrelude* const o_)
 {
     STACK_CHECK_START_REL(L_, 0);
@@ -310,7 +311,7 @@ int DeepFactory::pushDeepUserdata(DestState const L_, int const nuv_) const
 
     if (_prelude->magic != kDeepVersion) {
         // just in case, don't leak the newly allocated deep userdata object
-        deleteDeepObjectInternal(L_, _prelude);
+        DeleteDeepObject(L_, _prelude);
         raise_luaL_error(L_, "Bad Deep Factory: kDeepVersion is incorrect, rebuild your implementation with the latest deep implementation");
     }
 
@@ -319,7 +320,7 @@ int DeepFactory::pushDeepUserdata(DestState const L_, int const nuv_) const
 
     if (lua_gettop(L_) - _oldtop != 0) {
         // just in case, don't leak the newly allocated deep userdata object
-        deleteDeepObjectInternal(L_, _prelude);
+        DeleteDeepObject(L_, _prelude);
         raise_luaL_error(L_, "Bad DeepFactory::newDeepObjectInternal overload: should not push anything on the stack");
     }
 
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 4b4f9a8..41450f3 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -664,7 +664,7 @@ LUAG_FUNC(configure)
 
     STACK_CHECK(L_, 2);
     DeepFactory::PushDeepProxy(DestState{ L_ }, _U->timerLinda, 0, LookupMode::LaneBody, L_);      // L_: settings M timerLinda
-    lua_setfield(L_, -2, "timer_gateway");                                                         // L_: settings M
+    lua_setfield(L_, -2, "timerLinda");                                                            // L_: settings M
     STACK_CHECK(L_, 2);
 
     // prepare the metatable for threads
diff --git a/src/lanes.lua b/src/lanes.lua
index 1c36b46..d5a04e5 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -376,8 +376,9 @@ local timer = function() error "timers are not active" end
 local timers = timer
 local timer_lane = nil
 
--- timer_gateway should always exist, even when the settings disable the timers
-local timer_gateway
+-- timerLinda should always exist, even when the settings disable the timers
+-- is upvalue of timer stuff and lanes.sleep()
+local timerLinda
 
 local TGW_KEY = "(timer control)"    -- the key does not matter, a 'weird' key may help debugging
 local TGW_QUERY, TGW_REPLY = "(timer query)", "(timer reply)"
@@ -387,7 +388,7 @@ local TGW_QUERY, TGW_REPLY = "(timer query)", "(timer reply)"
 local configure_timers = function()
     -- On first 'require "lanes"', a timer lane is spawned that will maintain
     -- timer tables and sleep in between the timer events. All interaction with
-    -- the timer lane happens via a 'timer_gateway' Linda, which is common to
+    -- the timer lane happens via a 'timerLinda' Linda, which is common to
     -- all that 'require "lanes"'.
     --
     -- Linda protocol to timer lane:
@@ -399,8 +400,8 @@ local configure_timers = function()
 
     -- Timer lane; initialize only on the first 'require "lanes"' instance (which naturally has 'table' always declared)
     local first_time_key = "first time"
-    local first_time = timer_gateway:get(first_time_key) == nil
-    timer_gateway:set(first_time_key, true)
+    local first_time = timerLinda:get(first_time_key) == nil
+    timerLinda:set(first_time_key, true)
     if first_time then
 
         assert(type(now_secs) == "function")
@@ -552,7 +553,7 @@ local configure_timers = function()
                 return next_wakeup  -- may be 'nil'
             end -- check_timers()
 
-            local timer_gateway_batched = timer_gateway.batched
+            local timer_gateway_batched = timerLinda.batched
             set_finalizer(function(err, stk)
                 if err and type(err) ~= "userdata" then
                     error("LanesTimer error: "..tostring(err))
@@ -572,18 +573,18 @@ local configure_timers = function()
                     secs =  next_wakeup - now_secs()
                     if secs < 0 then secs = 0 end
                 end
-                local key, what = timer_gateway:receive(secs, TGW_KEY, TGW_QUERY)
+                local key, what = timerLinda:receive(secs, TGW_KEY, TGW_QUERY)
 
                 if key == TGW_KEY then
                     assert(getmetatable(what) == "Linda") -- 'what' should be a linda on which the client sets a timer
-                    local _, key, wakeup_at, period = timer_gateway:receive(0, timer_gateway_batched, TGW_KEY, 3)
+                    local _, key, wakeup_at, period = timerLinda:receive(0, timer_gateway_batched, TGW_KEY, 3)
                     assert(key)
                     set_timer(what, key, wakeup_at, period and period > 0 and period or nil)
                 elseif key == TGW_QUERY then
                     if what == "get_timers" then
-                        timer_gateway:send(TGW_REPLY, get_timers())
+                        timerLinda:send(TGW_REPLY, get_timers())
                     else
-                        timer_gateway:send(TGW_REPLY, "unknown query " .. what)
+                        timerLinda:send(TGW_REPLY, "unknown query " .. what)
                     end
                 --elseif secs == nil then -- got no value while block-waiting?
                 --      WR("timer lane: no linda, aborted?")
@@ -610,7 +611,7 @@ local configure_timers = function()
             linda_:set(key_, now_secs())
 
             if not period_ or period_ == 0.0 then
-                timer_gateway:send(TGW_KEY, linda_, key_, nil, nil )   -- clear the timer
+                timerLinda:send(TGW_KEY, linda_, key_, nil, nil )   -- clear the timer
                 return  -- nothing more to do
             end
             when_ = period_
@@ -620,7 +621,7 @@ local configure_timers = function()
                                             or (when_ and now_secs()+when_ or nil)
         -- queue to timer
         --
-        timer_gateway:send(TGW_KEY, linda_, key_, wakeup_at, period_)
+        timerLinda:send(TGW_KEY, linda_, key_, wakeup_at, period_)
     end -- timer()
 
     -----
@@ -628,11 +629,11 @@ local configure_timers = function()
     --
     -- PUBLIC LANES API
     timers = function()
-        timer_gateway:send(TGW_QUERY, "get_timers")
-        local _, r = timer_gateway:receive(TGW_REPLY)
+        timerLinda:send(TGW_QUERY, "get_timers")
+        local _, r = timerLinda:receive(TGW_REPLY)
         return r
     end -- timers()
-end
+end -- configure_timers()
 
 -- #################################################################################################
 -- ###################################### lanes.sleep() ############################################
@@ -651,8 +652,8 @@ local sleep = function(seconds_)
         error("invalid duration " .. string_format("%q", tostring(seconds_)))
     end
     -- receive data on a channel no-one ever sends anything, thus blocking for the specified duration
-    return timer_gateway:receive(seconds_, "ac100de1-a696-4619-b2f0-a26de9d58ab8")
-end -- sleep
+    return timerLinda:receive(seconds_, "ac100de1-a696-4619-b2f0-a26de9d58ab8")
+end -- sleep()
 
 -- #################################################################################################
 -- ##################################### lanes.genlock() ###########################################
@@ -782,7 +783,7 @@ local configure = function(settings_)
     -- avoid pulling the whole core module as upvalue when cancel_error is enough
     -- these are locals declared above, that we need to set prior to calling configure_timers()
     cancel_error = assert(core.cancel_error)
-    timer_gateway = assert(core.timer_gateway)
+    timerLinda = assert(core.timerLinda)
 
     if settings.with_timers then
         configure_timers(settings)
diff --git a/tests/keeper.lua b/tests/keeper.lua
index d08dd98..2d432f4 100644
--- a/tests/keeper.lua
+++ b/tests/keeper.lua
@@ -4,99 +4,170 @@
 -- Test program for Lua Lanes
 --
 -- TODO: there is a random crash when nb_user_keepers > 1. Will have to investigate if it rears its ugly head again
-local lanes = require "lanes".configure{ nb_user_keepers = 3, keepers_gc_threshold = 500 }
+-- 3 keepers in addition to the one reserved for the timer linda
+local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure{nb_user_keepers = 3, keepers_gc_threshold = 500}
+print("require_lanes_result:", require_lanes_result_1, require_lanes_result_2)
+local lanes = require_lanes_result_1
 
-do
-    print "Linda names test:"
-    local unnamedLinda = lanes.linda(1)
+local require_assert_result_1, require_assert_result_2 = require "assert"    -- assert.fails()
+print("require_assert_result:", require_assert_result_1, require_assert_result_2)
+
+-- #################################################################################################
+
+local print_id = 0
+local P = function(whence_, ...)
+    print_id = print_id + 1
+    print(whence_, print_id .. ".", ...)
+end
+
+local PRINT = function(...) P("main", ...) end
+
+local DONE = function()
+    PRINT "collecting garbage"
+    collectgarbage()
+    PRINT "SUCCESS\n"
+end
+
+-- #################################################################################################
+-- #################################################################################################
+
+if false then
+    PRINT "========================================================================================="
+    PRINT "Linda groups test:"
+
+    local createLinda = function(...)
+        return lanes.linda(...)
+    end
+
+    -- should succeed
+    assert.failsnot(function() createLinda("zero", 0) end)
+    assert.failsnot(function() createLinda("one", 1) end)
+    assert.failsnot(function() createLinda("two", 2) end)
+    assert.failsnot(function() createLinda("three", 3) end)
+    -- should fail (and not create the lindas)
+    assert.fails(function() createLinda("minus 1", -1) end)
+    assert.fails(function() createLinda("none") end)
+    assert.fails(function() createLinda("four", 4) end)
+
+end
+-- should only collect the 4 successfully created lindas
+DONE()
+
+-- #################################################################################################
+
+if false then
+    PRINT "========================================================================================="
+    PRINT "Linda names test:"
+    local unnamedLinda1 = lanes.linda(1)
     local unnamedLinda2 = lanes.linda("", 2)
-    local veeeerrrryyyylooongNamedLinda= lanes.linda( "veeeerrrryyyylooongNamedLinda", 3)
-    print(unnamedLinda, unnamedLinda2, veeeerrrryyyylooongNamedLinda)
-    print "GC deadlock test start"
-    -- store a linda in another linda (-> in a keeper)
-    unnamedLinda:set("here", lanes.linda("temporary linda", 0))
-    -- repeatedly add and remove stuff in the linda so that a GC happens during the keeper operation
+    local veeeerrrryyyylooongNamedLinda3 = lanes.linda( "veeeerrrryyyylooongNamedLinda", 3)
+    assert(tostring(veeeerrrryyyylooongNamedLinda3) == "Linda: veeeerrrryyyylooongNamedLinda")
+    local shortNamedLinda0 = lanes.linda( "short", 0)
+    assert(tostring(shortNamedLinda0) == "Linda: short")
+    PRINT(shortNamedLinda0, unnamedLinda1, unnamedLinda2, veeeerrrryyyylooongNamedLinda3)
+end
+-- collect the 4 lindas we created
+DONE()
+
+-- #################################################################################################
+
+if true then
+    PRINT "========================================================================================="
+    PRINT "Linda GC test:"
+    local a = lanes.linda("A", 1)
+    local b = lanes.linda("B", 2)
+    local c = lanes.linda("C", 3)
+
+    -- store lindas in each other and in themselves
+    a:set("here", lanes.linda("temporary linda", 0))
+    b:set("here", a, b, c)
+    c:set("here", a, b, c)
+
+    -- repeatedly add and remove stuff in the linda 'a' so that a GC happens during the keeper operation
     for i = 1, 100 do
+        io.stdout:write "."
         for j = 1, 1000 do -- send 1000 tables
-            -- print("send #" .. j)
-            unnamedLinda:send("here", {"a", "table", "with", "some", "stuff"})
+            -- PRINT("send #" .. j)
+            a:send("here", {"a", "table", "with", "some", "stuff"}, j)
         end
-        -- print(clearing)
-        unnamedLinda:set("here") -- clear everything
+        -- PRINT(clearing)
+        a:set("here") -- clear everything, including the temporary linda for which we have no reference
     end
+    io.stdout:write "\n"
+    b:set("here")
+    c:set("here")
 end
-print "collecting garbage"
-collectgarbage()
-print "GC deadlock test done"
+-- should successfully collect a, b, and c and destroy the underlying Deep objects
+DONE()
 
-local print_id = 0
-local PRINT = function(...)
-    print_id = print_id + 1
-    print("main", print_id .. ".", ...)
-end
+-- #################################################################################################
 
-local function keeper(linda)
-    local mt= {
-        __index= function( _, key )
-            return linda:get( key )
-        end,
-        __newindex= function( _, key, val ) 
-            linda:set( key, val )
-        end
-    }
-    return setmetatable( {}, mt )
-end
+if false then
+    PRINT "========================================================================================="
+    PRINT "General test:"
 
---
-local lindaA= lanes.linda( "A", 1)
-local A= keeper( lindaA )
-
-local lindaB= lanes.linda( "B", 2)
-local B= keeper( lindaB )
-
-local lindaC= lanes.linda( "C", 3)
-local C= keeper( lindaC )
-print("Created", lindaA, lindaB, lindaC)
-
-A.some= 1
-PRINT("A.some == " .. A.some )
-assert( A.some==1 )
-
-B.some= "hoo"
-PRINT("B.some == " .. B.some )
-assert( B.some=="hoo" )
-assert( A.some==1 )
-assert( C.some==nil )
-
-function lane()
-    local print_id = 0
-    local PRINT = function(...)
-        print_id = print_id + 1
-        print("lane", print_id .. ".", ...)
+    local function keeper(linda)
+        local mt= {
+            __index= function( _, key )
+                return linda:get( key )
+            end,
+            __newindex= function( _, key, val ) 
+                linda:set( key, val )
+            end
+        }
+        return setmetatable( {}, mt )
     end
+
+    --
+    local lindaA= lanes.linda( "A", 1)
+    local A= keeper( lindaA )
+
+    local lindaB= lanes.linda( "B", 2)
+    local B= keeper( lindaB )
+
+    local lindaC= lanes.linda( "C", 3)
+    local C= keeper( lindaC )
+    PRINT("Created", lindaA, lindaB, lindaC)
+
+    A.some= 1
+    PRINT("A.some == " .. A.some )
+    assert( A.some==1 )
+
+    B.some= "hoo"
+    PRINT("B.some == " .. B.some )
+    assert( B.some=="hoo" )
+    assert( A.some==1 )
+    assert( C.some==nil )
+
+    function lane()
+        local PRINT = function(...) P("lane", ...) end
     
-    local a= keeper(lindaA)
-    PRINT("a.some == " .. a.some )
-    assert( a.some==1 )
-    a.some= 2
-    assert( a.some==2 )
-    PRINT("a.some == " .. a.some )
-
-    local c = keeper(lindaC)
-    assert( c.some==nil )
-    PRINT("c.some == " .. tostring(c.some))
-    c.some= 3
-    assert( c.some==3 )
-    PRINT("c.some == " .. c.some)
-end
+        local a= keeper(lindaA)
+        PRINT("a.some == " .. a.some )
+        assert( a.some==1 )
+        a.some= 2
+        assert( a.some==2 )
+        PRINT("a.some == " .. a.some )
 
-PRINT("lane started")
-local h= lanes.gen( "io", lane )()
-PRINT("lane joined:", h:join())
+        local c = keeper(lindaC)
+        assert( c.some==nil )
+        PRINT("c.some == " .. tostring(c.some))
+        c.some= 3
+        assert( c.some==3 )
+        PRINT("c.some == " .. c.some)
+    end
+
+    PRINT("lane started")
+    local h= lanes.gen( "io", lane )()
+    PRINT("lane joined:", h:join())
+
+    PRINT("A.some = " .. A.some )
+    assert( A.some==2 )
+    PRINT("C.some = " .. C.some )
+    assert( C.some==3 )
+    lindaC:set("some")
+    assert( C.some==nil )
+end
+DONE()
 
-PRINT("A.some = " .. A.some )
-assert( A.some==2 )
-PRINT("C.some = " .. C.some )
-assert( C.some==3 )
-lindaC:set("some")
-assert( C.some==nil )
+print "\nTEST OK"
\ No newline at end of file
diff --git a/tests/nb_keepers.lua b/tests/nb_keepers.lua
deleted file mode 100644
index 575138c..0000000
--- a/tests/nb_keepers.lua
+++ /dev/null
@@ -1,20 +0,0 @@
--- 2 keepers in addition to the one reserved for the timer linda
-local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure{nb_user_keepers = 2}
-print("require_lanes_result:", require_lanes_result_1, require_lanes_result_2)
-local lanes = require_lanes_result_1
-
-local require_assert_result_1, require_assert_result_2 = require "assert"    -- assert.fails()
-print("require_assert_result:", require_assert_result_1, require_assert_result_2)
-
-local createLinda = function(...)
-        return lanes.linda(...)
-end
-
--- should succeed
-assert.failsnot(function() createLinda("one", 1) end)
-assert.failsnot(function() createLinda("two", 2) end)
--- should fail
-assert.fails(function() createLinda("none") end)
-assert.fails(function() createLinda("zero", 0) end)
-assert.fails(function() createLinda("three", 3) end)
-print "TEST OK"