5 files changed, 169 insertions, 78 deletions

diff --git a/CHANGES b/CHANGES
index c2b14ed..8575e8d 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,10 @@
 CHANGES:
 
+CHANGE 94: BGe 22-Jan-14
+   * version 3.8.2
+   * new lane launcher option gc_cb to set a callback that is invoked when a lane is garbage collected
+   * Fix more invalid memory accesses when fetching the name of a joined lane with lanes:threads() (because its lua_State is closed)
+
 CHANGE 93: BGe 20-Jan-14
    * slightly improve linda performance when the producer/consumer scenario leaves leave the key empty
 
diff --git a/docs/index.html b/docs/index.html
index 7078b13..c662a14 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -63,14 +63,14 @@
 
                 <font size="-1">
                         <p>
-                                <br>
+                                <br/>
                                 <i>Copyright &copy; 2007-14 Asko Kauppi, Benoit Germain. All rights reserved.</i>
-                                <br>
+                                <br/>
                                 Lua Lanes is published under the same <a href="http://en.wikipedia.org/wiki/MIT_License">MIT license</a> as Lua 5.1 and 5.2.
                         </p>
 
                         <p>
-                                This document was revised on 20-Jan-14, and applies to version <tt>3.8.1</tt>.
+                                This document was revised on 22-Jan-14, and applies to version <tt>3.8.2</tt>.
                         </p>
                 </font>
         </center>
@@ -386,7 +386,7 @@
 
 <p>
         (Since v3.5.0) Once Lanes is configured, one should register with Lanes the modules exporting functions that will be transferred either during lane generation or through <a href="#lindas">lindas</a>.
-        <br>
+        <br/>
         Use <tt>lanes.require()</tt> for this purpose. This will call the original <tt>require()</tt>, then add the result to the lookup databases.
 </p>
 
@@ -418,7 +418,7 @@
                 </td>
         </tr>
 </table>
-<br>
+<br/>
 <table border=1 bgcolor="#E0E0FF" cellpadding="10" style="width:50%">
         <tr>
                 <td>
@@ -596,10 +596,19 @@
                                 These tables are built from the modules listed here. <tt>required</tt> must be a list of strings, each one being the name of a module to be required. Each module is required with <tt>require()</tt> before the lanes function is invoked.
                                 So, from the required module's point of view, requiring it manually from inside the lane body or having it required this way doesn't change anything. From the lane body's point of view, the only difference is that a module not creating a global won't be accessible.
                                 Therefore, a lane body will also have to require a module manually, but this won't do anything more (see Lua's <tt>require</tt> documentation).
-                                <br>
+                                <br/>
                                 ATTEMPTING TO TRANSFER A FUNCTION REGISTERED BY A MODULE NOT LISTED HERE WILL RAISE AN ERROR.
                         </td>
                 </tr>
+                <tr id="Tr1" valign=top>
+                        <td>
+                                <code>.gc_cb</code>
+                        </td>
+                        <td>function</td>
+                        <td>
+                                (Since version 3.8.2) Callback that gets invoked when the lane is garbage collected. The function receives two arguments (the lane name and a string, either <tt>"closed"</tt> or <tt>"selfdestruct"</tt>).
+                        </td>
+                </tr>
                 <tr valign=top>
                         <td>
                                 <code>.priority</code>
@@ -608,9 +617,9 @@
                         <td>
                                 The priority of lanes generated in the range -3..+3 (default is 0).
                                 These values are a mapping over the actual priority range of the underlying implementation.
-                                <br>
+                                <br/>
                                 Implementation and dependability of priorities varies by platform. Especially Linux kernel 2.6 is not supporting priorities in user mode.
-                                <br>
+                                <br/>
                                 A lane can also change its own thread priority dynamically with <a href="#priority"><tt>lanes.set_thread_priority()</tt></a>.
                         </td>
                 </tr>
@@ -621,9 +630,9 @@
                         <td> table</td>
                         <td>
                                 Introduced at version 3.0.
-                                <br>
+                                <br/>
                                 Specifying it when <code>libs_str</code> doesn't cause the <code>package</code> library to be loaded will generate an error.
-                                <br>
+                                <br/>
                                 If not specified, the created lane will receive the current values of <tt>package</tt>. Only <tt>path</tt>, <tt>cpath</tt>, <tt>preload</tt> and <tt>loaders</tt> (Lua 5.1)/<tt>searchers</tt> (Lua 5.2) are transfered.
                         </td>
                 </tr>
@@ -678,7 +687,7 @@
         </table>
 <p>
         Besides setting a default priority in the generator <a href="#generator_settings">settings</a>, each thread can change its own priority at will. This is also true for the main Lua state.
-        <br>
+        <br/>
         The priority must be in the range <tt>[-3,+3]</tt>.
 </p>
 
@@ -793,7 +802,7 @@
 
 <p>
         Only available if lane tracking feature is compiled (see <tt>HAVE_LANE_TRACKING</tt> in <tt>lanes.c</tt>) and <a href="#track_lanes"><tt>track_lanes</tt></a> is set.
-        <br>
+        <br/>
         Returns a table where keys are a lane's name and values are the lane's status. Returns <tt>nil</tt> if no lane is running.
 </p>
 
@@ -820,7 +829,7 @@
 
 <p>
         Makes sure lane has finished, and gives its first (maybe only) return value. Other return values will be available in other <tt>lane_h</tt> indices.
-        <br>
+        <br/>
         If the lane ended in an error, it is propagated to master state at this place.
 </p>
 
@@ -835,9 +844,9 @@
 
 <p>
   <tt>stack_tbl</tt> is a table describing where the error was thrown.
-        <br>
+        <br/>
   In <tt>"extended"</tt> mode, <tt>stack_tbl</tt> is an array of tables containing info gathered with <tt>lua_getinfo()</tt> (<tt>"source"</tt>,<tt>"currentline"</tt>,<tt>"name"</tt>,<tt>"namewhat"</tt>,<tt>"what"</tt>).
-        <br>
+        <br/>
         In <tt>"basic mode"</tt>, <tt>stack_tbl</tt> is an array of "&lt;filename&gt;:&lt;line&gt;" strings. Use <tt>table.concat()</tt> to format it to your liking (or just ignore it).
 </p>
 
@@ -908,11 +917,11 @@
 
 <p>
         Cancellation is tested <u>before</u> going to sleep in <tt>receive()</tt> or <tt>send()</tt> calls and after executing <tt>cancelstep</tt> Lua statements. Starting with version 3.0-beta, a pending <tt>receive()</tt>or <tt>send()</tt> call is awakened.
-        <br>
+        <br/>
         This means the execution of the lane will resume although the operation has not completed, to give the lane a chance to detect cancellation (even in the case the code waits on a <a href="#lindas">linda</a> with infinite timeout).
-        <br>
+        <br/>
         The code should be able to handle this situation appropriately if required (in other words, it should gracefully handle the fact that it didn't receive the expected values).
-        <br>
+        <br/>
         It is also possible to manually test for cancel requests with <tt>cancel_test()</tt>.
 </p>
 
@@ -1103,13 +1112,13 @@
 
 <p>
         Returns some information about the contents of the linda.
-        <br>
+        <br/>
         If no key is specified, and the linda is empty, returns nothing.
-        <br>
+        <br/>
         If no key is specified, and the linda is not empty, returns a table of key/count pairs that counts the number of items in each of the exiting keys of the linda. This count can be 0 if the key has been used but is empty.
-        <br>
+        <br/>
         If a single key is specified, returns the number of pending items, or nothing if the key is unknown.
-        <br>
+        <br/>
         If more than one key is specified, return a table of key/count pairs for the known keys.
 </p>
 
@@ -1125,17 +1134,17 @@
 
 <p>
         A linda is a gateway to read and write data inside some hidden Lua states, called keeper states. Lindas are hashed to a fixed number of keeper states, which are a locking entity.
-        <br>
+        <br/>
         The data sent through a linda is stored inside the associated keeper state in a Lua table where each linda slot is the key to another table containing a FIFO for that slot.
-        <br>
+        <br/>
         Each keeper state is associated with an OS mutex, to prevent concurrent access to the keeper state. The linda itself uses two signals to be made aware of operations occuring on it.
-        <br>
+        <br/>
         Whenever Lua code reads from or writes to a linda, the mutex is acquired. If linda limits don't block the operation, it is fulfilled, then the mutex is released.
-        <br>
+        <br/>
         If the linda has to block, the mutex is released and the OS thread sleeps, waiting for a linda operation to be signalled. When an operation occurs on the same linda, possibly fufilling the condition, or a timeout expires, the thread wakes up.
-        <br>
+        <br/>
         If the thread is woken but the condition is not yet fulfilled, it goes back to sleep, until the timeout expires.
-        <br>
+        <br/>
         When a lane is cancelled, the signal it is waiting on (if any) is signalled. In that case, the linda operation will return no data.
 </p>
 
@@ -1264,9 +1273,9 @@ events to a common Linda, but... :).</font>
 
 <p>
         The generated function acquires M tokens from the N available, or releases them if the value is negative. The acquiring call will suspend the lane, if necessary. Use <tt>M=N=1</tt> for a critical section lock (only one lane allowed to enter).
-        <br>
+        <br/>
         When passsing <tt>"try"</tt> as second argument when acquiring, then <tt>lock_func</tt> operates on the linda with a timeout of 0 to emulate a TryLock() operation. If locking fails, <tt>lock_func</tt> returns <tt>false</tt>. <tt>"try"</tt> is ignored when releasing (as it it not expected to ever have to wait unless the acquisition/release pairs are not properly matched).
-        <br>
+        <br/>
         Upon successful lock/unlock, <tt>lock_func</tt> returns <tt>true</tt> (always the case when block-waiting for completion).
 </p>
 
@@ -1364,7 +1373,7 @@ events to a common Linda, but... :).</font>
 
 <p>
         This has the main drawback of not being LuaJIT-compatible, because some functions registered by LuaJIT are not regular C functions, but specially optimized implementations. As a result, <tt>lua_tocfunction()</tt> returns <tt>NULL</tt> for them.
-        <br>
+        <br/>
         Therefore, Lanes no longer transfers functions that way. Instead, functions are transfered as follows (more or less):
 </p>
 
@@ -1385,15 +1394,15 @@ events to a common Linda, but... :).</font>
 
 <p>
         Since functions are first class values, they don't have a name. All we know for sure is that when a C module registers some functions, they are accessible to the script that required the module through some exposed variables.
-        <br>
+        <br/>
         For example, loading the <tt>string</tt> base library creates a table accessible when indexing the global environment with key <tt>"string"</tt>. Indexing this table with <tt>"match"</tt>, <tt>"gsub"</tt>, etc. will give us a function.
-        <br>
+        <br/>
         When a lane generator creates a lane and performs initializations described by the list of base libraries and the list of required modules, it recursively scans the table created by the initialisation of the module, looking for all values that are C functions.
-        <br>
+        <br/>
         Each time a function is encountered, the sequence of keys that reached that function is contatenated in a (hopefully) unique name. The [name, function] and [function, name] pairs are both stored in a lookup table in all involved Lua states (main Lua state and lanes states).
-        <br>
+        <br/>
         Then when a function is transfered from one state to another, all we have to do is retrieve the name associated to a function in the source Lua state, then with that name retrieve the equivalent function that already exists in the destination state.
-        <br>
+        <br/>
         Note that there is no need to transfer upvalues, as they are already bound to the function registered in the destination state. (And in any event, it is not possible to create a closure from a C function pushed on the stack, it can only be created with a <tt>lua_CFunction</tt> pointer).
 </p>
 
diff --git a/src/lanes.c b/src/lanes.c
index 604e43d..a806c16 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.8.1";
+char const* VERSION = "3.8.2";
 
 /*
 ===============================================================================
@@ -209,6 +209,19 @@ static inline struct s_lane* get_lane_from_registry( lua_State* L)
         return s;
 }
 
+// intern the debug name in the specified lua state so that the pointer remains valid when the lane's state is closed
+static void securize_debug_threadname( lua_State* L, struct s_lane* s)
+{
+        STACK_CHECK( L);
+        STACK_GROW( L, 3);
+        lua_getuservalue( L, 1);
+        lua_newtable( L);
+        s->debug_name = lua_pushstring( L, s->debug_name);
+        lua_rawset( L, -3);
+        lua_pop( L, 1);
+        STACK_END( L, 0);
+}
+
 /*
 * Check if the thread in question ('L') has been signalled for cancel.
 *
@@ -1766,7 +1779,7 @@ LUAG_FUNC( get_debug_threadname)
 {
         struct s_lane* const s = lua_toLane( L, 1);
         luaL_argcheck( L, lua_gettop( L) == 1, 2, "too many arguments");
-        lua_pushstring( L, s->debug_name ? s->debug_name : "<unnamed>");
+        lua_pushstring( L, s->debug_name);
         return 1;
 }
 
@@ -1998,6 +2011,8 @@ LUAG_FUNC( require)
         return 1;
 }
 
+LUAG_FUNC( thread_gc);
+#define GCCB_KEY (void*)LG_thread_gc
 //---
 // lane_ud= thread_new( function, [libs_str], 
 //                          [cancelstep_uint=0], 
@@ -2005,6 +2020,7 @@ LUAG_FUNC( require)
 //                          [globals_tbl],
 //                          [package_tbl],
 //                          [required],
+//                          [gc_cb],
 //                          [... args ...] )
 //
 // Upvalues: metatable to use for 'lane_ud'
@@ -2022,8 +2038,9 @@ LUAG_FUNC( thread_new)
         uint_t glob = lua_isnoneornil( L, 5) ? 0 : 5;
         uint_t package = lua_isnoneornil( L, 6) ? 0 : 6;
         uint_t required = lua_isnoneornil( L, 7) ? 0 : 7;
+        uint_t gc_cb = lua_isnoneornil( L, 8) ? 0 : 8;
 
-#define FIXED_ARGS 7
+#define FIXED_ARGS 8
         uint_t args = lua_gettop(L) - FIXED_ARGS;
 
         // public Lanes API accepts a generic range -3/+3
@@ -2203,7 +2220,7 @@ LUAG_FUNC( thread_new)
         }
         STACK_MID( L, 0);
 
-        ASSERT_L( (uint_t)lua_gettop( L2) == 1+args);
+        ASSERT_L( (uint_t)lua_gettop( L2) == 1 + args);
         ASSERT_L( lua_isfunction( L2, 1));
 
         // 's' is allocated from heap, not Lua, since its life span may surpass 
@@ -2217,9 +2234,9 @@ LUAG_FUNC( thread_new)
 
         //memset( s, 0, sizeof(struct s_lane) );
         s->L = L2;
-        s->status= PENDING;
+        s->status = PENDING;
         s->waiting_on = NULL;
-        s->debug_name = NULL;
+        s->debug_name = "<unnamed>";
         s->cancel_request = CANCEL_NONE;
 
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
@@ -2238,25 +2255,32 @@ LUAG_FUNC( thread_new)
         lua_setmetatable( L, -2);
         STACK_MID( L, 1);
 
-        // Clear environment for the userdata
-        //
+        // Create uservalue for the userdata
+        // (this is where lane body return values will be stored when the handle is indexed by a numeric key)
         lua_newtable( L);
+
+        // Store the gc_cb callback in the uservalue
+        if( gc_cb > 0)
+        {
+                lua_pushlightuserdata( L, GCCB_KEY);
+                lua_pushvalue( L, gc_cb);
+                lua_rawset( L, -3);
+        }
+
         lua_setuservalue( L, -2);
 
-        // Place 's' in registry, for 'cancel_test()' (even if 'cs'==0 we still
-        // do cancel tests at pending send/receive).
-        //
+        // Store 's' in the lane's registry, for 'cancel_test()' (even if 'cs'==0 we still do cancel tests at pending send/receive).
         lua_pushlightuserdata( L2, CANCEL_TEST_KEY);
         lua_pushlightuserdata( L2, s);
         lua_rawset( L2, LUA_REGISTRYINDEX);
 
         if( cs)
         {
-                lua_sethook( L2, cancel_hook, LUA_MASKCOUNT, cs );
+                lua_sethook( L2, cancel_hook, LUA_MASKCOUNT, cs);
         }
 
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "thread_new: launching thread\n" INDENT_END));
-        THREAD_CREATE( &s->thread, lane_main, s, prio );
+        THREAD_CREATE( &s->thread, lane_main, s, prio);
         STACK_END( L, 1);
 
         DEBUGSPEW_CODE( -- debugspew_indent_depth);
@@ -2279,7 +2303,23 @@ LUAG_FUNC( thread_new)
 //
 LUAG_FUNC( thread_gc)
 {
-        struct s_lane* s = lua_toLane( L, 1);
+        bool_t have_gc_cb = FALSE;
+        struct s_lane* s = lua_toLane( L, 1);                               // ud
+
+        // if there a gc callback?
+        lua_getuservalue( L, 1);                                            // ud uservalue
+        lua_pushlightuserdata( L, GCCB_KEY);                                // ud uservalue __gc
+        lua_rawget( L, -2);                                                 // ud uservalue gc_cb|nil
+        if( !lua_isnil( L, -1))
+        {
+                lua_remove( L, -2);                                               // ud gc_cb|nil
+                lua_pushstring( L, s->debug_name);                                // ud gc_cb name
+                have_gc_cb = TRUE;
+        }
+        else
+        {
+                lua_pop( L, 2);                                                   // ud
+        }
 
         // We can read 's->status' without locks, but not wait for it
         // test KILLED state first, as it doesn't need to enter the selfdestruct chain
@@ -2291,13 +2331,17 @@ LUAG_FUNC( thread_gc)
                 DEBUGSPEW_CODE( fprintf( stderr, "** Joining with a killed thread (needs testing) **"));
                 // make sure the thread is no longer running, just like thread_join()
                 if(! THREAD_ISNULL( s->thread))
+                {
                         THREAD_WAIT( &s->thread, -1, &s->done_signal, &s->done_lock, &s->status);
-                // we know the thread was killed while the Lua VM was not doing anything: we should be able to close it without crashing
-                // now, thread_cancel() will not forcefully kill a lane with s->status >= DONE, so I am not sure it can ever happen
+                }
                 if( s->status >= DONE && s->L)
                 {
+                        // we know the thread was killed while the Lua VM was not doing anything: we should be able to close it without crashing
+                        // now, thread_cancel() will not forcefully kill a lane with s->status >= DONE, so I am not sure it can ever happen
                         lua_close( s->L);
                         s->L = 0;
+                        // just in case, but s will be freed soon so...
+                        s->debug_name = "<gc>";
                 }
                 DEBUGSPEW_CODE( fprintf( stderr, "** Joined ok **"));
         }
@@ -2306,18 +2350,31 @@ LUAG_FUNC( thread_gc)
                 // still running: will have to be cleaned up later
                 selfdestruct_add( s);
                 assert( s->selfdestruct_next);
+                if( have_gc_cb)
+                {
+                        lua_pushliteral( L, "selfdestruct");                            // ud gc_cb name status
+                        lua_call( L, 2, 0);                                             // ud
+                }
                 return 0;
-
         }
         else if( s->L)
         {
                 // no longer accessing the Lua VM: we can close right now
                 lua_close( s->L);
                 s->L = 0;
+                // just in case, but s will be freed soon so...
+                s->debug_name = "<gc>";
         }
 
         // Clean up after a (finished) thread
         lane_cleanup( s);
+
+        // do this after lane cleanup in case the callback triggers an error
+        if( have_gc_cb)
+        {
+                lua_pushliteral( L, "closed");                                    // ud gc_cb name status
+                lua_call( L, 2, 0);                                               // ud
+        }
         return 0;
 }
 
@@ -2422,23 +2479,26 @@ LUAG_FUNC( thread_join)
         bool_t done;
 
         done = THREAD_ISNULL( s->thread) || THREAD_WAIT( &s->thread, wait_secs, &s->done_signal, &s->done_lock, &s->status);
-        if (!done || !L2)
+        if( !done || !L2)
+        {
                 return 0;      // timeout: pushes none, leaves 'L2' alive
+        }
 
         // Thread is DONE/ERROR_ST/CANCELLED; all ours now
 
-        STACK_GROW( L, 1);
-
         if( s->mstatus == KILLED) // OS thread was killed if thread_cancel was forced
         {
                 // in that case, even if the thread was killed while DONE/ERROR_ST/CANCELLED, ignore regular return values
-                
+                STACK_GROW( L, 1);
                 lua_pushnil( L);
                 lua_pushliteral( L, "killed");
                 ret = 2;
         }
         else
         {
+                // debug_name is a pointer to string possibly interned in the lane's state, that no longer exists when the state is closed
+                // so store it in the userdata uservalue at a key that can't possibly collide
+                securize_debug_threadname( L, s);
                 switch( s->status)
                 {
                         case DONE:
@@ -2467,11 +2527,9 @@ LUAG_FUNC( thread_join)
 
                         default:
                         DEBUGSPEW_CODE( fprintf( stderr, "Status: %d\n", s->status));
-                        ASSERT_L( FALSE ); ret= 0;
+                        ASSERT_L( FALSE); ret = 0;
                 }
                 lua_close( L2);
-                // debug_name is a pointer to an interned string, that no longer exists when the state is closed
-                s->debug_name = "<closed>";
         }
         s->L = 0;
 
@@ -2652,10 +2710,7 @@ LUAG_FUNC( threads)
                 lua_newtable( L);                                          // {}
                 while( s != TRACKING_END)
                 {
-                        if( s->debug_name)
-                                lua_pushstring( L, s->debug_name);                     // {} "name"
-                        else
-                                lua_pushfstring( L, "Lane %p", s);                     // {} "name"
+                        lua_pushstring( L, s->debug_name);                       // {} "name"
                         push_thread_status( L, s);                               // {} "name" "status"
                         lua_rawset( L, -3);                                      // {}
                         s = s->tracking_next;
diff --git a/src/lanes.lua b/src/lanes.lua
index 9a0287d..1286099 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -196,7 +196,10 @@ end
 --
 --        .globals:  table of globals to set for a new thread (passed by value)
 --
---        .required:  table of packages to require
+--        .required: table of packages to require
+--
+--        .gc_cb:    function called when the lane handle is collected
+--
 --        ... (more options may be introduced later) ...
 --
 -- Calling with a function parameter ('lane_func') ends the string/table
@@ -272,10 +275,11 @@ local function gen( ... )
         end
     end
     
-    local prio, cs, g_tbl, package_tbl, required
+    local prio, cs, g_tbl, package_tbl, required, gc_cb
 
     for k,v in pairs(opt) do
-            if k=="priority" then prio= v
+        if k == "priority" then
+            prio = (type( v) == "number") and v or error( "Bad 'prio' option: expecting number, got " .. type( v), lev)
         elseif k=="cancelstep" then
             cs = (v==true) and 100 or
                 (v==false) and 0 or 
@@ -286,6 +290,8 @@ local function gen( ... )
             package_tbl = (type( v) == "table") and v or error( "Bad package: " .. tostring( v), lev)
         elseif k=="required" then
             required= (type( v) == "table") and v or error( "Bad 'required' option: expecting table, got " .. type( v), lev)
+        elseif k == "gc_cb" then
+            gc_cb = (type( v) == "function") and v or error( "Bad 'gc_cb' option: expecting function, got " .. type( v), lev)
         --..
         elseif k==1 then error( "unkeyed option: ".. tostring(v), lev )
         else error( "Bad option: ".. tostring(k), lev )
@@ -296,7 +302,7 @@ local function gen( ... )
     -- Lane generator
     --
     return function(...)
-        return thread_new( func, libs, cs, prio, g_tbl, package_tbl, required, ...)     -- args
+        return thread_new( func, libs, cs, prio, g_tbl, package_tbl, required, gc_cb, ...)     -- args
     end
 end
 
diff --git a/tests/basic.lua b/tests/basic.lua
index 5b0d8a7..16919a3 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -25,6 +25,11 @@ local function PRINT(...)
     end
 end
 
+local gc_cb = function( name_, status_)
+        PRINT( "                                ---> lane '" .. name_ .. "' collected with status " .. status_)
+end
+--gc_cb = nil
+
 
 ---=== Local helpers ===---
 
@@ -71,7 +76,7 @@ local function task( a, b, c )
     return v, hey
 end
 
-local task_launch= lanes_gen( "", { globals={hey=true} }, task )
+local task_launch= lanes_gen( "", { globals={hey=true}, gc_cb = gc_cb}, task )
         -- base stdlibs, normal priority
 
 -- 'task_launch' is a factory of multithreaded tasks, we can launch several:
@@ -100,6 +105,8 @@ assert( v2_hey == true )
 
 assert( lane1.status == "done" )
 assert( lane1.status == "done" )
+lane1, lane2 = nil
+collectgarbage()
 
 --##############################################################
 --##############################################################
@@ -107,7 +114,7 @@ assert( lane1.status == "done" )
 
 PRINT( "\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
 
-local task_launch2= lanes_gen( "", { cancelstep=100, globals={hey=true} }, task )
+local task_launch2= lanes_gen( "", { cancelstep=100, globals={hey=true}, gc_cb = gc_cb}, task )
 
 local N=999999999
 local lane9= task_launch2(1,N,1)   -- huuuuuuge...
@@ -196,7 +203,7 @@ PRINT( "\n\n", "---=== Communications ===---", "\n\n")
 local function WR(...) io.stderr:write(...) end
 
 local chunk= function( linda )
-
+        set_debug_threadname "chunk"
     local function receive() return linda:receive( "->" ) end
     local function send(...) linda:send( "<-", ... ) end
 
@@ -226,7 +233,7 @@ local function PEEK() return linda:get("<-") end
 local function SEND(...) linda:send( "->", ... ) end
 local function RECEIVE() local k,v = linda:receive( 1, "<-" ) return v end
 
-local t= lanes_gen("io",chunk)(linda)     -- prepare & launch
+local t= lanes_gen("io", {gc_cb = gc_cb}, chunk)(linda)     -- prepare & launch
 
 SEND(1);  WR( "1 sent\n" )
 SEND(2);  WR( "2 sent\n" )
@@ -256,6 +263,8 @@ assert( tables_match( a, {'a','b','c',d=10} ) )
 assert( PEEK() == nil )
 SEND(4)
 
+t = nil
+collectgarbage()
 -- wait
 linda: receive( 1, "wait")
 
@@ -266,6 +275,7 @@ linda: receive( 1, "wait")
 PRINT( "\n\n", "---=== Stdlib naming ===---", "\n\n")
 
 local function dump_g( _x)
+        set_debug_threadname "dump_g"
         assert(print)
         print( "### dumping _G for '" .. _x .. "'")
         for k, v in pairs( _G) do
@@ -275,6 +285,7 @@ local function dump_g( _x)
 end
 
 local function io_os_f( _x)
+        set_debug_threadname "io_os_f"
         assert(print)
         print( "### checking io and os libs existence for '" .. _x .. "'")
         assert(io)
@@ -283,13 +294,14 @@ local function io_os_f( _x)
 end
 
 local function coro_f( _x)
+        set_debug_threadname "coro_f"
         assert(print)
         print( "### checking coroutine lib existence for '" .. _x .. "'")
         assert(coroutine)
         return true
 end
 
-assert.fails( function() lanes_gen( "xxx", io_os_f ) end )
+assert.fails( function() lanes_gen( "xxx", {gc_cb = gc_cb}, io_os_f ) end )
 
 local stdlib_naming_tests =
 {
@@ -305,10 +317,12 @@ local stdlib_naming_tests =
 }
 
 for _, t in ipairs( stdlib_naming_tests) do
-        local f= lanes_gen( t[1], t[2])     -- any delimiter will do
+        local f= lanes_gen( t[1], {gc_cb = gc_cb}, t[2])     -- any delimiter will do
         assert( f(t[1])[1] )
 end
 
+collectgarbage()
+
 --##############################################################
 --##############################################################
 --##############################################################
@@ -317,9 +331,9 @@ PRINT( "\n\n", "---=== Comms criss cross ===---", "\n\n")
 
 -- We make two identical lanes, which are using the same Linda channel.
 --
-local tc= lanes_gen( "io",
+local tc= lanes_gen( "io", {gc_cb = gc_cb},
   function( linda, ch_in, ch_out )
-
+                set_debug_threadname( "criss cross " .. ch_in .. " -> " .. ch_out)
     local function STAGE(str)
         io.stderr:write( ch_in..": "..str.."\n" )
         linda:send( nil, ch_out, str )
@@ -338,6 +352,8 @@ local a,b= tc(linda, "A","B"), tc(linda, "B","A")   -- launching two lanes, twis
 
 local _= a[1],b[1]  -- waits until they are both ready
 
+a, b = nil
+collectgarbage()
 
 --##############################################################
 --##############################################################
@@ -378,7 +394,7 @@ local function chunk2( linda )
 end
 
 local linda= lanes.linda()
-local t2= lanes_gen( "debug,string,io", chunk2 )(linda)     -- prepare & launch
+local t2= lanes_gen( "debug,string,io", {gc_cb = gc_cb}, chunk2 )(linda)     -- prepare & launch
 linda:send( "down", function(linda) linda:send( "up", "ready!" ) end,
                     "ok" )
 -- wait to see if the tiny function gets executed
@@ -411,7 +427,7 @@ PRINT( "\n\n", "---=== :join test ===---", "\n\n")
 --       (unless [1..n] has been read earlier, in which case it would seemingly
 --       work).
 
-local S= lanes_gen( "table",
+local S= lanes_gen( "table", {gc_cb = gc_cb},
   function(arg)
                 set_debug_threadname "join test lane"
                 set_finalizer( function() end)