Changed idfunc signature and contract to clarify that fact it is not lua-callable and to be able to require the module it was exported from in the target lanes.

8 files changed, 226 insertions, 188 deletions

diff --git a/CHANGES b/CHANGES
index 40362fb..64de559 100644
--- a/CHANGES
+++ b/CHANGES
@@ -3,6 +3,10 @@ CHANGES:
 
 CHANGE X:
 
+CHANGE 25 BGe 12-Feb-2011:
+    Changed idfunc signature and contract to clarify that fact it is not lua-callable
+    and to be able to require the module it was exported from in the target lanes
+
 CHANGE 24 DPtr 25-Jan-2011:
     Changed lanes.c to export functions as a module rather than writing them directly to the globals table.
 
diff --git a/dist.info b/dist.info
index 8e59368..6f824d7 100644
--- a/dist.info
+++ b/dist.info
@@ -1,7 +1,7 @@
 --- This file is part of LuaDist project
 
 name = "lanes"
-version = "2.0.10"
+version = "2.0.11"
 
 desc = "Lanes is a lightweight, native, lazy evaluating multithreading library for Lua 5.1."
 author = "Asko Kauppi"
diff --git a/docs/index.html b/docs/index.html
index fec2212..9d66510 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -21,11 +21,11 @@
     <tr>
       <td align="center">
       <a href="http://www.lua.org">
-        <img src="http://akauppi.googlepages.com/multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
-        <img src="http://akauppi.googlepages.com/multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
-        <img src="http://akauppi.googlepages.com/multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
-        <img src="http://akauppi.googlepages.com/multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
-        <img src="http://akauppi.googlepages.com/multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
+        <img src="multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
+        <img src="multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
+        <img src="multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
+        <img src="multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
+        <img src="multi.png" alt="Lua" align="middle" border="0" height="120" width="128" />
       </a></td>
     </tr>
     <tr>
@@ -56,7 +56,7 @@
 
 <p><br/><font size="-1"><i>Copyright &copy; 2007-11 Asko Kauppi. All rights reserved.</i>
     <br>Lua Lanes is published under the same <A HREF="http://en.wikipedia.org/wiki/MIT_License">MIT license</A> as Lua 5.1.
-    </p><p>This document was revised on 3-Jan-11, and applies to version 2.0.10.
+    </p><p>This document was revised on 12-Feb-11, and applies to version 2.0.11.
 </font></p>
 
 </center>
@@ -124,15 +124,14 @@
         <li>Windows 2000/XP and later <font size="-1">(MinGW or Visual C++ 2005/2008)</font></li>
 <!--
     Other OS'es here once people help test them. (and the tester's name)
-    
+
     Win64, BSD, Linux x64, Linux embedded, QNX, Solaris, ...
 -->
     </ul>
-    
-    <p>The underlying threading code can be compiled either towards Win32 API 
-    or <a TARGET="_blank" HREF="http://en.wikipedia.org/wiki/POSIX_Threads">Pthreads</a>. Unfortunately, thread prioritation under Pthreads is a JOKE, 
-    requiring OS specific tweaks and guessing undocumented behaviour. Other
-    features should be portable to any modern platform.
+
+    <p>The underlying threading code can be compiled either towards Win32 API
+    or <a TARGET="_blank" HREF="http://en.wikipedia.org/wiki/POSIX_Threads">Pthreads</a>. Unfortunately, thread prioritization under Pthreads is a JOKE,
+    requiring OS specific tweaks and guessing undocumented behaviour. Other features should be portable to any modern platform.
     </p>
 </p>
 
@@ -147,7 +146,7 @@ details and limitations.
 </p>
 
 <p>To install Lanes, all you need are the <tt>lanes.lua</tt> and <tt>lua51-lanes.so|dll</tt>
-files to be reachable by Lua (see LUA_PATH, LUA_CPATH). 
+files to be reachable by Lua (see LUA_PATH, LUA_CPATH).
 
 Or use <A HREF="http://www.luarocks.org" TARGET="_blank">Lua Rocks</A> package management.
 </p>
@@ -264,7 +263,7 @@ also in the new lanes.
     by platform. Especially Linux kernel 2.6 is not supporting priorities in user mode.
     </td></tr>
   </table>
-  
+
 </p>
 
 <h3>Free running lanes</h3>
@@ -383,7 +382,7 @@ for the request to be processed, or a timeout to occur.
 Returns <tt>true</tt> if the lane was already done (in <tt>"done"</tt>, <tt>"error"</tt> or <tt>"cancelled"</tt> status)
 or if the cancellation was fruitful within timeout period.
 </p><p>
-If the lane is still running and <tt>force_kill</tt> is <tt>true</tt>, the 
+If the lane is still running and <tt>force_kill</tt> is <tt>true</tt>, the
 OS thread running the lane is forcefully killed. This means no GC, and should
 generally be the last resort.
 </p>
@@ -404,16 +403,16 @@ or <tt>send</tt> call is currently not awakened, and may be a reason for a non-d
 </table>
 
 <p>The <tt>error</tt> call is used for throwing exceptions in Lua. What Lua
-does not offer, however, is scoped <a href="http://en.wikipedia.org/wiki/Finalizer">finalizers</a> 
+does not offer, however, is scoped <a href="http://en.wikipedia.org/wiki/Finalizer">finalizers</a>
 that would get called when a certain block of instructions gets exited, whether
 through peaceful return or abrupt <tt>error</tt>.
 </p>
-<p>Since 2.0.3, Lanes prepares a function <tt>set_finalizer</tt> for doing this. 
-Any functions given to it will be called in the lane Lua state, just prior to 
+<p>Since 2.0.3, Lanes prepares a function <tt>set_finalizer</tt> for doing this.
+Any functions given to it will be called in the lane Lua state, just prior to
 closing it. They are not called in any particular order.
 </p>
 <p>An error in a finalizer itself overrides the state of the regular chunk
-(in practise, it would be highly preferable <i>not</i> to have errors in finalizers). 
+(in practise, it would be highly preferable <i>not</i> to have errors in finalizers).
 If one finalizer errors, the others may not get called.
 </p>
 
@@ -424,7 +423,7 @@ If one finalizer errors, the others may not get called.
 
 <p>Communications between lanes is completely detached from the lane handles
 themselves. By itself, a lane can only provide return values once it's finished,
-or throw an error. Needs to communicate during runtime are handled by <A HREF="http://en.wikipedia.org/wiki/Linda_%28coordination_language%29" TARGET="_blank">Linda objects</A>, which are 
+or throw an error. Needs to communicate during runtime are handled by <A HREF="http://en.wikipedia.org/wiki/Linda_%28coordination_language%29" TARGET="_blank">Linda objects</A>, which are
 <A HREF="#deep_userdata">deep userdata</A> instances. They can be provided to a lane
 as startup parameters, upvalues or in some other Linda's message.
 </p><p>
@@ -445,7 +444,7 @@ level locking is required; each Linda operation is atomic.
         linda:send( "x", i )    -- linda as upvalue
     end
   end
-  
+
   a= lanes.gen("",loop)( 10000 )
 
   while true do
@@ -512,7 +511,7 @@ many producers, and many consumers. It's up to you.
 if the queue limit was met, and the queue did not empty enough during the given
 timeout.
 </p><p>
-Equally, <tt>receive</tt> returns a value and the key that provided the value, 
+Equally, <tt>receive</tt> returns a value and the key that provided the value,
 or nothing for timeout. Note that <tt>nil</tt>s can be sent and received;
 the <tt>key</tt> value will tell it apart from a timeout.
 </p><p>
@@ -537,8 +536,8 @@ be used for making priority queues.
 The table access methods are for accessing a slot without queuing or consuming.
 They can be used for making shared tables of storage among the lanes.
 </p><p>
-Writing to a slot overwrites existing value, and clears any possible queued 
-entries. Table access and <tt>send</tt>/<tt>receive</tt> can be used together; 
+Writing to a slot overwrites existing value, and clears any possible queued
+entries. Table access and <tt>send</tt>/<tt>receive</tt> can be used together;
 reading a slot essentially peeks the next outcoming value of a queue.
 </p>
 
@@ -554,7 +553,7 @@ discussing it is good for a preview of how deep userdata works.
 Because proxy objects (<tt>linda_h</tt>) are just pointers to the real, deep
 userdata, they cannot be used to identify a certain Linda from the others.
 The internal timer system needs to do this, and the <tt>:deep()</tt> method
-has been added for its use. It returns a light userdata pointing to the 
+has been added for its use. It returns a light userdata pointing to the
 <i>actual</i> deep object, and thus can be used for seeing, which proxies actually
 mean the same underlying object. You might or might not need a similar system
 with your own deep userdata.
@@ -574,13 +573,13 @@ you want to use several?
     for the other. This keeps your code clear and readable. You can pass
     multiple Linda handles to a lane with practically no added cost.
     </li>
-    
+
     <li>Namespace control. Linda keys have a "flat" namespace, so collisions
     are possible if you try to use the same Linda for too many separate uses.
     </li>
-    
+
     <li>Performance. Changing any slot in a Linda causes all pending threads
-    for that Linda to be momentarily awakened (at least in the C level). 
+    for that Linda to be momentarily awakened (at least in the C level).
     This can degrade performance due to unnecessary OS level context switches.
     </li>
 </ul>
@@ -603,13 +602,13 @@ events to a common Linda, but... :).</font>
 </table>
 
 <p>
-Timers can be run once, or in a reoccurring fashion (<tt>period_secs > 0</tt>). 
-The first occurrence can be given either as a date or as a relative delay in seconds. 
-The <tt>date</tt> table is like what <tt>os.date("*t")</tt> returns, in the 
+Timers can be run once, or in a reoccurring fashion (<tt>period_secs > 0</tt>).
+The first occurrence can be given either as a date or as a relative delay in seconds.
+The <tt>date</tt> table is like what <tt>os.date("*t")</tt> returns, in the
 local time zone.
 </p><p>
 Once a timer expires, the <tt>key</tt> is set with the current time
-(in seconds, same offset as <tt>os.time()</tt> but with millisecond accuracy). 
+(in seconds, same offset as <tt>os.time()</tt> but with millisecond accuracy).
 The key can be waited upon using the regular Linda <tt>:receive()</tt>
 method.
 </p><p>
@@ -632,17 +631,17 @@ A timer can be stopped simply by <tt>first_secs=0</tt> and no period.
   t.sec= 0
 
   lanes.timer( linda, "min", t, 60 )   -- reoccur every minute (sharp)
-    
+
   while true do
     local v,key= linda:receive( "sec", "min" )
     print( "Timer "..key..": "..v )
-  end  
+  end
 </pre>
 </table>
 
 </p><p>
 NOTE: Timer keys are set, not queued, so missing a beat is possible especially
-if the timer cycle is extremely small. The key value can be used to know the 
+if the timer cycle is extremely small. The key value can be used to know the
 actual time passed.
 </p><p>
 <table>
@@ -704,7 +703,7 @@ Similar sugar exists for atomic counters:
 </table>
 </p><p>
 
-Each time called, the generated function will change <tt>linda[key]</tt> 
+Each time called, the generated function will change <tt>linda[key]</tt>
 atomically, without other lanes being able to interfere. The new value is
 returned. You can use either <tt>diff 0.0</tt> or <tt>get</tt> to just read the current
 value.
@@ -725,7 +724,7 @@ Note that the generated functions can be passed on to other lanes.
 <p><ul>
         <li>Booleans, numbers, strings, light userdata, Lua functions and tables of such can always be passed.
         </li>
-        <li>Cyclic tables and/or duplicate references are allowed and reproduced appropriately, 
+        <li>Cyclic tables and/or duplicate references are allowed and reproduced appropriately,
         but only <u>within the same transmission</u>.
            <ul>
                <li>using the same source table in multiple Linda messages keeps no ties between the tables
@@ -777,14 +776,14 @@ should be covered into a one-time-only construct such as below.
  int luaopen_module( lua_State *L )
  {
     static char been_here;  /* 0 by ANSI C */
-    
+
     /* Calls to 'require' serialized by Lanes; this is safe.&nbsp;&nbsp;
     */
     if (!been_here) {
         been_here= 1;
         ... one time initializations ...
     }
-    
+
     ... binding to Lua ...
  }
 </pre>
@@ -804,8 +803,9 @@ used for creation and deletion of your deep userdata (the shared resource),
 and for making metatables for the state-specific proxies for accessing it.
 Take a look at <tt>linda_id</tt> in <tt>lanes.c</tt>.
     </li>
-    <li>Create your userdata using <tt>luaG_deep_userdata()</tt>, which is
-    a Lua-callable function. Given an <tt>idfunc</tt>, it sets up the support
+    <li>Instanciate your userdata using <tt>luaG_deep_userdata()</tt>,
+        instead of the regular <tt>lua_newuserdata()</tt>.
+        Given an <tt>idfunc</tt>, it sets up the support
     structures and returns a state-specific proxy userdata for accessing your
     data. This proxy can also be copied over to other lanes.
     </li>
@@ -815,7 +815,7 @@ Take a look at <tt>linda_id</tt> in <tt>lanes.c</tt>.
 </ol>
 
 <p>Deep userdata management will take care of tying to <tt>__gc</tt> methods,
-and doing reference counting to see how many proxies are still there for 
+and doing reference counting to see how many proxies are still there for
 accessing the data. Once there are none, the data will be freed through a call
 to the <tt>idfunc</tt> you provided.
 </p>
@@ -850,7 +850,7 @@ something like this:
 <pre>
   A:  print( 1, 2, 3, 4 )
   B:  print( 'a', 'b', 'c', 'd' )
-  
+
   1   a   b   2   3   c   d   4
 </pre>
 
@@ -870,7 +870,7 @@ Here are some things one should consider, if best performance is vital:
 <ul>
     <li>Data passing (parameters, upvalues, Linda messages) is generally fast,
     doing two binary state-to-state copies (from source state to hidden state,
-    hidden state to target state). Remember that not only the function you 
+    hidden state to target state). Remember that not only the function you
     specify but also its upvalues, their upvalues, etc. etc. will get copied.
     </li>
     <li>Lane startup is fast (1000's of lanes a second), depending on the
@@ -894,7 +894,7 @@ Here are some things one should consider, if best performance is vital:
     merged into one main timer state (see <tt>timer.lua</tt>); no OS side
     timers are utilized.
     </li>
-    <li>Lindas are hashed to a fixed number of "keeper states", which are a locking entity. 
+    <li>Lindas are hashed to a fixed number of "keeper states", which are a locking entity.
     If you are using a lot of Linda objects,
     it may be useful to try having more of these keeper states. By default,
     only one is used (see <tt>KEEPER_STATES_N</tt>), but this is an implementation detail.
@@ -907,7 +907,7 @@ Here are some things one should consider, if best performance is vital:
 
 <p>
 Cancellation of lanes uses the Lua error mechanism with a special lightuserdata
-error sentinel. 
+error sentinel.
 If you use <tt>pcall</tt> in code that needs to be cancellable
 from the outside, the special error might not get through to Lanes, thus
 preventing the Lane from being cleanly cancelled. You should throw any
@@ -929,6 +929,13 @@ its actual value.
 <h2 id="changes">Change log</h2>
 
 <p>
+Feb-2011 (2.0.11):
+<ul>
+  <li>Fixed bug where reference to Linda object was dropped for a short time (crashing if GC was run during that time).</li>
+  <li>Changed the atexit code to trip the timer thread's write signal.</li>
+  <li>Changed lanes.c to export functions as a module rather than writing them directly to the globals table.</li>
+</ul>
+
 Jan-2011 (2.0.10):
 <ul>
   <li>linda_send was waiting on the wrong signal</li>
diff --git a/src/lanes.c b/src/lanes.c
index f4bef7b..16a8edc 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -64,7 +64,7 @@
  *      ...
  */
 
-const char *VERSION= "2.0.10";
+const char *VERSION= "2.0.11";
 
 /*
 ===============================================================================
@@ -359,7 +359,8 @@ static const char *init_keepers(void) {
         lua_State *L= luaL_newstate();
         if (!L) return "out of memory";
 
-        luaG_openlibs( L, "io,table" );     // 'io' for debugging messages
+        luaG_openlibs( L, "io,table,package" );     // 'io' for debugging messages, package because we need to require modules exporting idfuncs
+        serialize_require( L);
 
         lua_pushlightuserdata( L, &nil_sentinel );
         lua_setglobal( L, "nil_sentinel" );
@@ -449,9 +450,9 @@ struct s_Linda {
     SIGNAL_T write_happened;
 };
 
-static int LG_linda_id( lua_State* );
+static void linda_id( lua_State*, char const * const which);
 
-#define lua_toLinda(L,n) ((struct s_Linda *)luaG_todeep( L, LG_linda_id, n ))
+#define lua_toLinda(L,n) ((struct s_Linda *)luaG_todeep( L, linda_id, n ))
 
 
 /*
@@ -462,7 +463,8 @@ static int LG_linda_id( lua_State* );
 * Returns:  'true' if the value was queued
 *           'false' for timeout (only happens when the queue size is limited)
 */
-LUAG_FUNC( linda_send ) {
+LUAG_FUNC( linda_send )
+{
     struct s_Linda *linda= lua_toLinda( L, 1 );
     bool_t ret;
     bool_t cancel= FALSE;
@@ -750,21 +752,22 @@ LUAG_FUNC( linda_deep ) {
 * Returns a metatable for the proxy objects ('__gc' method not needed; will
 * be added by 'luaG_...')
 *
+*   string= linda_id( "module")
+*
+* Returns the name of the module that a state should require
+* in order to keep a handle on the shared library that exported the idfunc
+*
 *   = linda_id( str, ... )
 *
 * For any other strings, the ID function must not react at all. This allows
 * future extensions of the system. 
 */
-LUAG_FUNC( linda_id ) {
-    const char *which= lua_tostring(L,1);
-
-    if (strcmp( which, "new" )==0) {
+static void linda_id( lua_State *L, char const * const which)
+{
+    if (strcmp( which, "new" )==0)
+    {
         struct s_Linda *s;
 
-        /* We don't use any parameters, but one could (they're at [2..TOS])
-        */
-        ASSERT_L( lua_gettop(L)==1 );
-
         /* The deep data is allocated separately of Lua stack; we might no
         * longer be around when last reference to it is being released.
         * One can use any memory allocation scheme.
@@ -776,11 +779,11 @@ LUAG_FUNC( linda_id ) {
         SIGNAL_INIT( &s->write_happened );
 
         lua_pushlightuserdata( L, s );
-        return 1;
-
-    } else if (strcmp( which, "delete" )==0) {
+    }
+    else if (strcmp( which, "delete" )==0)
+    {
         struct s_Keeper *K;
-        struct s_Linda *s= lua_touserdata(L,2);
+        struct s_Linda *s= lua_touserdata(L,1);
         ASSERT_L(s);
 
         /* Clean associated structures in the keeper state.
@@ -797,18 +800,20 @@ LUAG_FUNC( linda_id ) {
         SIGNAL_FREE( &s->read_happened );
         SIGNAL_FREE( &s->write_happened );
         free(s);
+    }
+    else if (strcmp( which, "metatable" )==0)
+    {
 
-        return 0;
-
-    } else if (strcmp( which, "metatable" )==0) {
-
-      STACK_CHECK(L)
+        STACK_CHECK(L)
         lua_newtable(L);
-        lua_newtable(L);
-            //
-            // [-2]: linda metatable
-            // [-1]: metatable's to-be .__index table
-    
+        // metatable is its own index
+        lua_pushvalue( L, -1);
+        lua_setfield( L, -2, "__index");
+        // protect metatable from external access
+        lua_pushboolean( L, 0);
+        lua_setfield( L, -2, "__metatable");
+        //
+        // [-1]: linda metatable
         lua_pushcfunction( L, LG_linda_send );
         lua_setfield( L, -2, "send" );
     
@@ -827,13 +832,17 @@ LUAG_FUNC( linda_id ) {
         lua_pushcfunction( L, LG_linda_deep );
         lua_setfield( L, -2, "deep" );
 
-        lua_setfield( L, -2, "__index" );
-      STACK_END(L,1)
-    
-        return 1;
+        STACK_END(L,1)
     }
-    
-    return 0;   // unknown request, be quiet
+    else if( strcmp( which, "module") == 0)
+    {
+        lua_pushliteral( L, "lua51-lanes");
+    }
+}
+
+LUAG_FUNC( linda)
+{
+    return luaG_deep_userdata( L, linda_id);
 }
 
 
@@ -1014,8 +1023,10 @@ static void selfdestruct_atexit( void ) {
     MUTEX_UNLOCK( &selfdestruct_cs );
 
     // Tell the timer thread to check it's cancel request
-    struct s_Linda *td = timer_deep->deep;
-    SIGNAL_ALL( &td->write_happened);
+    {
+        struct s_Linda *td = timer_deep->deep;
+        SIGNAL_ALL( &td->write_happened);
+    }
 
     // When noticing their cancel, the lanes will remove themselves from
     // the selfdestruct chain.
@@ -1855,21 +1866,21 @@ LUAG_FUNC( wakeup_conv )
 */
 
 static const struct luaL_reg lanes_functions [] = {
-    {"linda_id", LG_linda_id},
+    {"linda", LG_linda},
     {"thread_status", LG_thread_status},
     {"thread_join", LG_thread_join},
     {"thread_cancel", LG_thread_cancel},
     {"now_secs", LG_now_secs},
     {"wakeup_conv", LG_wakeup_conv},
     {"_single", LG__single},
-    {"_deep_userdata", luaG_deep_userdata},
     {NULL, NULL}
 };
 
 /*
 * One-time initializations
 */
-static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_ref ) {
+static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_ref )
+{
     const char *err;
 
 #if (defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC)
@@ -1919,8 +1930,9 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
         }
   #endif
 #endif
-        err= init_keepers();
-    if (err) {
+    err= init_keepers();
+    if (err)
+    {
             luaL_error( L, "Unable to initialize: %s", err );
     }
     
@@ -1928,13 +1940,11 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
     //
     ASSERT_L( timer_deep_ref && (!(*timer_deep_ref)) );
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
     {
         // proxy_ud= deep_userdata( idfunc )
         //
-        lua_pushcfunction( L, luaG_deep_userdata );
-        lua_pushcfunction( L, LG_linda_id );
-        lua_call( L, 1 /*args*/, 1 /*retvals*/ );
+        luaG_deep_userdata( L, linda_id);
 
         ASSERT_L( lua_isuserdata(L,-1) );
         
@@ -1950,7 +1960,7 @@ static void init_once_LOCKED( lua_State *L, volatile DEEP_PRELUDE ** timer_deep_
         lua_rawset(L, LUA_REGISTRYINDEX);
 
     }
-  STACK_END(L,0)
+    STACK_END(L,0)
 }
 
 int 
@@ -2014,7 +2024,7 @@ __declspec(dllexport)
     lua_pushcclosure( L, LG_thread_new, 1 );    // metatable as closure param
     lua_setfield(L, -2, "thread_new");
 
-    luaG_push_proxy( L, LG_linda_id, (DEEP_PRELUDE *) timer_deep );
+    luaG_push_proxy( L, linda_id, (DEEP_PRELUDE *) timer_deep );
     lua_setfield(L, -2, "timer_gateway");
 
     lua_pushstring(L, VERSION);
diff --git a/src/lanes.lua b/src/lanes.lua
index 42e946b..b6fbc08 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -45,8 +45,6 @@ local mm = require "lua51-lanes"
 assert( type(mm)=="table" )
 
 
-local linda_id=    assert( mm.linda_id )
-
 local thread_new=   assert(mm.thread_new)
 local thread_status= assert(mm.thread_status)
 local thread_join=  assert(mm.thread_join)
@@ -55,8 +53,6 @@ local thread_cancel= assert(mm.thread_cancel)
 local _single= assert(mm._single)
 local _version= assert(mm._version)
 
-local _deep_userdata= assert(mm._deep_userdata)
-
 local now_secs= assert( mm.now_secs )
 local wakeup_conv= assert( mm.wakeup_conv )
 local timer_gateway= assert( mm.timer_gateway )
@@ -336,11 +332,7 @@ end
 -----
 -- linda_ud= lanes.linda()
 --
-function linda()
-    local proxy= _deep_userdata( linda_id )
-    assert( (type(proxy) == "userdata") and getmetatable(proxy) )
-    return proxy
-end
+linda = mm.linda
 
 
 ---=== Timers ===---
@@ -505,7 +497,7 @@ if first_time then
     -- We let the timer lane be a "free running" thread; no handle to it
     -- remains.
     --
-    gen( "io", { priority=max_prio, globals={threadName="LanesTimer"} }, function()
+    gen( "io,package", { priority=max_prio, globals={threadName="LanesTimer"} }, function()
 
         while true do
             local next_wakeup= check_timers()
diff --git a/src/tools.c b/src/tools.c
index 6692890..d09b11e 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -280,26 +280,27 @@ void get_deep_lookup( lua_State *L ) {
 * or NULL if 'index' is not a deep userdata proxy.
 */
 static
-lua_CFunction get_idfunc( lua_State *L, int index ) {
-    lua_CFunction ret;
+luaG_IdFunction get_idfunc( lua_State *L, int index )
+{
+    luaG_IdFunction ret;
 
     index= STACK_ABS(L,index);
 
     STACK_GROW(L,1);
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
     if (!lua_getmetatable( L, index ))
         return NULL;    // no metatable
     
     // [-1]: metatable of [index]
 
     get_deep_lookup(L);
-        //    
-        // [-1]: idfunc/nil
+    //    
+    // [-1]: idfunc/nil
 
-    ret= lua_tocfunction(L,-1);
+    ret= (luaG_IdFunction)lua_touserdata(L,-1);
     lua_pop(L,1);
-  STACK_END(L,0)
+    STACK_END(L,0)
     return ret;
 }
 
@@ -311,7 +312,8 @@ lua_CFunction get_idfunc( lua_State *L, int index ) {
 * it up if reaches 0.
 */
 static
-int deep_userdata_gc( lua_State *L ) {
+int deep_userdata_gc( lua_State *L )
+{
     DEEP_PRELUDE **proxy= (DEEP_PRELUDE**)lua_touserdata( L, 1 );
     DEEP_PRELUDE *p= *proxy;
     int v;
@@ -319,27 +321,26 @@ int deep_userdata_gc( lua_State *L ) {
     *proxy= 0;  // make sure we don't use it any more
 
     MUTEX_LOCK( &deep_lock );
-      v= --(p->refcount);
+    v= --(p->refcount);
     MUTEX_UNLOCK( &deep_lock );
 
-    if (v==0) {
-        int pushed;
-
+    if (v==0)
+    {
         // Call 'idfunc( "delete", deep_ptr )' to make deep cleanup
         //
-        lua_CFunction idfunc= get_idfunc(L,1);
+        luaG_IdFunction idfunc = get_idfunc(L,1);
         ASSERT_L(idfunc);
         
-        lua_settop(L,0);    // clean stack so we can call 'idfunc' directly
+        lua_settop( L, 0);    // clean stack so we can call 'idfunc' directly
 
         // void= idfunc( "delete", lightuserdata )
         //
-        lua_pushliteral( L, "delete" );
         lua_pushlightuserdata( L, p->deep );
-        pushed= idfunc(L);
-        
-        if (pushed)
-            luaL_error( L, "Bad idfunc on \"delete\": returned something" );
+        idfunc( L, "delete");
+
+        // top was set to 0, then userdata was pushed. "delete" might want to pop the userdata (we don't care), but should not push anything!
+        if ( lua_gettop( L) > 1)
+            luaL_error( L, "Bad idfunc on \"delete\": returned something");
 
         DEEP_FREE( (void*)p );
     }
@@ -354,28 +355,31 @@ int deep_userdata_gc( lua_State *L ) {
 * used in this Lua state (metatable, registring it). Otherwise, increments the
 * reference count.
 */
-void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude ) {
+void luaG_push_proxy( lua_State *L, luaG_IdFunction idfunc, DEEP_PRELUDE *prelude )
+{
     DEEP_PRELUDE **proxy;
 
     // Check if a proxy already exists
     push_registry_subtable_mode(L, DEEP_PROXY_CACHE_KEY, "v");
     lua_pushlightuserdata(L, prelude->deep);
     lua_rawget(L, -2);
-    if (!lua_isnil(L, -1)) {
+    if (!lua_isnil(L, -1))
+    {
         lua_remove(L, -2); // deep proxy cache table
         return;
-    } else {
+    }
+    else
+    {
         lua_pop(L, 2); // Pop the nil and proxy cache table
     }
 
-
     MUTEX_LOCK( &deep_lock );
-      ++(prelude->refcount);  // one more proxy pointing to this deep data
+    ++(prelude->refcount);  // one more proxy pointing to this deep data
     MUTEX_UNLOCK( &deep_lock );
 
     STACK_GROW(L,4);
 
-  STACK_CHECK(L)
+    STACK_CHECK(L)
 
     proxy= lua_newuserdata( L, sizeof( DEEP_PRELUDE* ) );
     ASSERT_L(proxy);
@@ -383,28 +387,32 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
 
     // Get/create metatable for 'idfunc' (in this state)
     //
-    lua_pushcfunction( L, idfunc );    // key
+    lua_pushlightuserdata( L, idfunc );    // key
     get_deep_lookup(L);
         //
         // [-2]: proxy
         // [-1]: metatable / nil
     
-    if (lua_isnil(L,-1)) {
-        // No metatable yet; make one and register it
-        //
+    if (lua_isnil(L,-1))
+    {
+        int oldtop;
+        // No metatable yet. We have two things to do:
+
+        // 1 - make one and register it
         lua_pop(L,1);
 
         // tbl= idfunc( "metatable" )
         //
-        lua_pushcfunction( L, idfunc );
-        lua_pushliteral( L, "metatable" );
-        lua_call( L, 1 /*args*/, 1 /*results*/ );
-            //
-            // [-2]: proxy
-            // [-1]: metatable (returned by 'idfunc')
+        oldtop = lua_gettop( L);
+        idfunc( L, "metatable");
+        //
+        // [-2]: proxy
+        // [-1]: metatable (returned by 'idfunc')
 
-        if (!lua_istable(L,-1))
+        if (lua_gettop( L) - oldtop != 1 || !lua_istable(L, -1))
+        {
             luaL_error( L, "Bad idfunc on \"metatable\": did not return one" );
+        }
 
         // Add '__gc' method
         //
@@ -414,16 +422,40 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
         // Memorize for later rounds
         //
         lua_pushvalue( L,-1 );
-        lua_pushcfunction( L, idfunc );
-            //
-            // [-4]: proxy
-            // [-3]: metatable (2nd ref)
-            // [-2]: metatable
-            // [-1]: idfunc
+        lua_pushlightuserdata( L, idfunc );
+        //
+        // [-4]: proxy
+        // [-3]: metatable (2nd ref)
+        // [-2]: metatable
+        // [-1]: idfunc
 
         set_deep_lookup(L);
-    } 
-  STACK_MID(L,2)
+
+        // 2 - cause the target state to require the module that exported the idfunc
+        // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc
+        lua_getglobal( L, "require");
+        if( lua_isfunction( L, -1)) // just in case...
+        {
+            // make sure the function pushed a single value on the stack!
+            int oldtop = lua_gettop( L);
+            idfunc( L, "module");
+            if( lua_gettop( L) - oldtop != 1 || !lua_isstring( L, -1))
+            {
+                luaL_error( L, "Bad idfunc on \"module\": should return a string");
+            }
+            // if we are inside a call to require, this will raise a "reentrency" error that we absorb silently (we don't care, this probably means the module is already being required, which is what we need)
+            if( lua_pcall( L, 1, 0, 0) != 0)
+            {
+                //char const * const errMsg = lua_tostring( L, -1); // just to see it in the debugger
+                lua_pop( L, 1);
+            }
+        }
+        else
+        {
+            lua_pop( L, 1);
+        }
+    }
+    STACK_MID(L,2)
     ASSERT_L( lua_isuserdata(L,-2) );
     ASSERT_L( lua_istable(L,-1) );
 
@@ -439,7 +471,7 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
     lua_rawset(L, -3);
     lua_pop(L, 1); // Remove the cache proxy table
 
-  STACK_END(L,1)
+    STACK_END(L,1)
     // [-1]: proxy userdata
 }
 
@@ -466,9 +498,9 @@ void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *prelude
 *
 * Returns:  'proxy' userdata for accessing the deep data via 'luaG_todeep()'
 */
-int luaG_deep_userdata( lua_State *L ) {
-    lua_CFunction idfunc= lua_tocfunction( L,1 );
-    int pushed;
+int luaG_deep_userdata( lua_State *L, luaG_IdFunction idfunc)
+{
+    int oldtop;
 
     DEEP_PRELUDE *prelude= DEEP_MALLOC( sizeof(DEEP_PRELUDE) );
     ASSERT_L(prelude);
@@ -476,20 +508,17 @@ int luaG_deep_userdata( lua_State *L ) {
     prelude->refcount= 0;   // 'luaG_push_proxy' will lift it to 1
 
     STACK_GROW(L,1);
-  STACK_CHECK(L)
-
-    // Replace 'idfunc' with "new" in the stack (keep possible other params)
-    //
-    lua_remove(L,1);
-    lua_pushliteral( L, "new" );
-    lua_insert(L,1);
+    STACK_CHECK(L)
 
     // lightuserdata= idfunc( "new" [, ...] )
     //
-    pushed= idfunc(L);
+                oldtop = lua_gettop( L);
+    idfunc(L, "new");
 
-    if ((pushed!=1) || lua_type(L,-1) != LUA_TLIGHTUSERDATA)
-        luaL_error( L, "Bad idfunc on \"new\": did not return light userdata" );
+    if( lua_gettop( L) - oldtop != 1 || lua_type( L, -1) != LUA_TLIGHTUSERDATA)
+    {
+        luaL_error( L, "Bad idfunc on \"new\": did not return light userdata");
+    }
 
     prelude->deep= lua_touserdata(L,-1);
     ASSERT_L(prelude->deep);
@@ -497,10 +526,10 @@ int luaG_deep_userdata( lua_State *L ) {
     lua_pop(L,1);   // pop deep data
 
     luaG_push_proxy( L, idfunc, prelude );
-        //
-        // [-1]: proxy userdata
+    //
+    // [-1]: proxy userdata
 
-  STACK_END(L,1)
+    STACK_END(L,1)
     return 1;
 }
 
@@ -511,15 +540,16 @@ int luaG_deep_userdata( lua_State *L ) {
 * Reference count is not changed, and access to the deep userdata is not
 * serialized. It is the module's responsibility to prevent conflicting usage.
 */
-void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index ) {
+void *luaG_todeep( lua_State *L, luaG_IdFunction idfunc, int index )
+{
     DEEP_PRELUDE **proxy;
 
-  STACK_CHECK(L)
-    if (get_idfunc(L,index) != idfunc)
+    STACK_CHECK(L)
+    if( get_idfunc(L,index) != idfunc)
         return NULL;    // no metatable, or wrong kind
 
     proxy= (DEEP_PRELUDE**)lua_touserdata( L, index );
-  STACK_END(L,0)
+    STACK_END(L,0)
 
     return (*proxy)->deep;
 }
@@ -533,14 +563,14 @@ void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index ) {
 *   (not copied)
 */
 static
-lua_CFunction luaG_copydeep( lua_State *L, lua_State *L2, int index ) {
+luaG_IdFunction luaG_copydeep( lua_State *L, lua_State *L2, int index )
+{
     DEEP_PRELUDE **proxy;
     DEEP_PRELUDE *p;
 
-    lua_CFunction idfunc;
-    
-    idfunc= get_idfunc( L, index );
-    if (!idfunc) return NULL;   // not a deep userdata
+    luaG_IdFunction idfunc = get_idfunc( L, index);
+    if (!idfunc)
+        return NULL;   // not a deep userdata
 
     // Increment reference count
     //
diff --git a/src/tools.h b/src/tools.h
index aad26df..05bee59 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -48,19 +48,21 @@
 
 #define luaG_typename( L, index ) lua_typename( L, lua_type(L,index) )
 
+typedef void (*luaG_IdFunction)( lua_State *L, char const * const which);
+
 void luaG_dump( lua_State* L );
 
 const char *luaG_openlibs( lua_State *L, const char *libs );
 
-int luaG_deep_userdata( lua_State *L );
-void *luaG_todeep( lua_State *L, lua_CFunction idfunc, int index );
+int luaG_deep_userdata( lua_State *L, luaG_IdFunction idfunc);
+void *luaG_todeep( lua_State *L, luaG_IdFunction idfunc, int index );
 
 typedef struct {
     volatile int refcount;
     void *deep;
 } DEEP_PRELUDE;
 
-void luaG_push_proxy( lua_State *L, lua_CFunction idfunc, DEEP_PRELUDE *deep_userdata );
+void luaG_push_proxy( lua_State *L, luaG_IdFunction idfunc, DEEP_PRELUDE *deep_userdata );
 
 void luaG_inter_copy( lua_State *L, lua_State *L2, uint_t n );
 void luaG_inter_move( lua_State *L, lua_State *L2, uint_t n );
diff --git a/tests/basic.lua b/tests/basic.lua
index b1e8fd3..352e029 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -171,7 +171,7 @@ local function PEEK() return linda:get("<-") end
 local function SEND(...) linda:send( "->", ... ) end
 local function RECEIVE() return linda:receive( "<-" ) end
 
-local t= lanes_gen("io",chunk)(linda)     -- prepare & launch
+local t= lanes_gen("io,package",chunk)(linda)     -- prepare & launch
 
 SEND(1);  WR( "1 sent\n" )
 SEND(2);  WR( "2 sent\n" )
@@ -230,7 +230,7 @@ local tc= lanes_gen( "io",
     end
     STAGE("Hello")
     STAGE("I was here first!")
-    STAGE("So waht?")
+    STAGE("So what?")
   end
 )
 
@@ -247,7 +247,6 @@ local upvalue="123"
 
 local function chunk2( linda )
     assert( upvalue=="123" )    -- even when running as separate thread
-
     -- function name & line number should be there even as separate thread
     --
     local info= debug.getinfo(1)    -- 1 = us
@@ -256,17 +255,14 @@ local function chunk2( linda )
 
     assert( info.nups == 2 )    -- one upvalue + PRINT
     assert( info.what == "Lua" )
-
     --assert( info.name == "chunk2" )   -- name does not seem to come through
-    assert( string.match( info.source, "^@basic.lua$" ) )
-    assert( string.match( info.short_src, "^basic.lua$" ) )
-
+    assert( string.match( info.source, "^@.*basic.lua$" ) )
+    assert( string.match( info.short_src, "^.*basic.lua$" ) )
     -- These vary so let's not be picky (they're there..)
     --
     assert( info.linedefined > 200 )   -- start of 'chunk2'
     assert( info.currentline > info.linedefined )   -- line of 'debug.getinfo'
     assert( info.lastlinedefined > info.currentline )   -- end of 'chunk2'
-
     local func,k= linda:receive( "down" )
     assert( type(func)=="function" )
     assert( k=="down" )
@@ -280,12 +276,9 @@ local function chunk2( linda )
 end
 
 local linda= lanes.linda()
-
-local t2= lanes_gen( "debug,string", chunk2 )(linda)     -- prepare & launch
-
+local t2= lanes_gen( "debug,string,io", chunk2 )(linda)     -- prepare & launch
 linda:send( "down", function(linda) linda:send( "up", "ready!" ) end,
                     "ok" )
-
 -- wait to see if the tiny function gets executed
 --
 local s= linda:receive( "up" )