* keeper.lua is now embedded in text form instead of bytecode to improve LuaJIT2-compatibility (but this is not enough).

* moved keeper-related code in a separate source file

7 files changed, 313 insertions, 231 deletions

diff --git a/src/Makefile b/src/Makefile
index a17e9cd..df65926 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -7,7 +7,7 @@
 
 MODULE=lanes
 
-SRC=lanes.c threading.c tools.c
+SRC=lanes.c threading.c tools.c keeper.c
 
 OBJ=$(SRC:.c=.o)
 
@@ -134,10 +134,14 @@ lanes.o: keeper.lch
 # Note: 'luac -o -' could be used on systems other than Windows (where pipes
 #       are binary). We need to support MinGW as well, so a temporary file.
 #
+# mode 1: embed bytecode version
+#%.lch: %.lua
+#       $(LUAC) -o $@.tmp $<
+#       $(LUA) ../tools/bin2c.lua $@.tmp -o $@
+#       -rm $@.tmp
+# mode 2: embed text version (LuaJIT2-compatible)
 %.lch: %.lua
-        $(LUAC) -o $@.tmp $<
-        $(LUA) ../tools/bin2c.lua $@.tmp -o $@
-        -rm $@.tmp
+        $(LUA) ../tools/bin2c.lua $< -o $@
 
 #---
 # NSLU2 "slug" Linux ARM
diff --git a/src/keeper.c b/src/keeper.c
new file mode 100644
index 0000000..f19beed
--- /dev/null
+++ b/src/keeper.c
@@ -0,0 +1,199 @@
+/*
+ --
+ -- KEEPER.C
+ --
+ -- Keeper state logic
+ --
+ -- This code is read in for each "keeper state", which are the hidden, inter-
+ -- mediate data stores used by Lanes inter-state communication objects.
+ --
+ -- Author: Benoit Germain <bnt.germain@gmail.com>
+ --
+ -- C implementation replacement of the original keeper.lua
+ --
+ --[[
+ ===============================================================================
+
+ Copyright (C) 2011 Benoit Germain <bnt.germain@gmail.com>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ ===============================================================================
+ ]]--
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "threading.h"
+#include "tools.h"
+#include "keeper.h"
+
+/*---=== Keeper states ===---
+*/
+
+/* The selected number is not optimal; needs to be tested. Even using just
+* one keeper state may be good enough (depends on the number of Lindas used
+* in the applications).
+*/
+#define KEEPER_STATES_N 1   // 6
+
+/*
+* Pool of keeper states
+*
+* Access to keeper states is locked (only one OS thread at a time) so the 
+* bigger the pool, the less chances of unnecessary waits. Lindas map to the
+* keepers randomly, by a hash.
+*/
+static struct s_Keeper GKeepers[KEEPER_STATES_N];
+
+/* We could use an empty table in 'keeper.lua' as the sentinel, but maybe
+* checking for a lightuserdata is faster.
+*/
+static bool_t nil_sentinel = 0;
+
+/*
+* Lua code for the keeper states (baked in)
+*/
+static char const keeper_chunk[]= 
+#include "keeper.lch"
+
+/*
+* Initialize keeper states
+*
+* If there is a problem, return an error message (NULL for okay).
+*
+* Note: Any problems would be design flaws; the created Lua state is left
+*       unclosed, because it does not really matter. In production code, this
+*       function never fails.
+*/
+const char *init_keepers(void)
+{
+        unsigned int i;
+        for( i=0; i<KEEPER_STATES_N; i++ )
+        {
+
+                // Initialize Keeper states with bare minimum of libs (those required
+                // by 'keeper.lua')
+                //
+                lua_State *L= luaL_newstate();
+                if (!L)
+                        return "out of memory";
+
+                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" );
+
+                // Read in the preloaded chunk (and run it)
+                //
+                if (luaL_loadbuffer( L, keeper_chunk, sizeof(keeper_chunk), "=lanes_keeper" ))
+                        return "luaL_loadbuffer() failed";   // LUA_ERRMEM
+
+                if (lua_pcall( L, 0 /*args*/, 0 /*results*/, 0 /*errfunc*/ ))
+                {
+                        // LUA_ERRRUN / LUA_ERRMEM / LUA_ERRERR
+                        //
+                        const char *err= lua_tostring(L,-1);
+                        assert(err);
+                        return err;
+                }
+
+                MUTEX_INIT( &GKeepers[i].lock_ );
+                GKeepers[i].L= L;
+                //GKeepers[i].count = 0;
+        }
+        return NULL;    // ok
+}
+
+struct s_Keeper *keeper_acquire( const void *ptr)
+{
+        /*
+        * Any hashing will do that maps pointers to 0..KEEPER_STATES_N-1 
+        * consistently.
+        *
+        * Pointers are often aligned by 8 or so - ignore the low order bits
+        */
+        unsigned int i= ((unsigned long)(ptr) >> 3) % KEEPER_STATES_N;
+        struct s_Keeper *K= &GKeepers[i];
+
+        MUTEX_LOCK( &K->lock_);
+        //++ K->count;
+        return K;
+}
+
+void keeper_release( struct s_Keeper *K)
+{
+        //-- K->count;
+        MUTEX_UNLOCK( &K->lock_);
+}
+
+/*
+* Call a function ('func_name') in the keeper state, and pass on the returned
+* values to 'L'.
+*
+* 'linda':          deep Linda pointer (used only as a unique table key, first parameter)
+* 'starting_index': first of the rest of parameters (none if 0)
+*
+* Returns: number of return values (pushed to 'L') or -1 in case of error
+*/
+int keeper_call( lua_State *K, char const *func_name, lua_State *L, void *linda, uint_t starting_index)
+{
+        int const args = starting_index ? (lua_gettop(L) - starting_index +1) : 0;
+        int const Ktos = lua_gettop(K);
+        int retvals = -1;
+
+        STACK_GROW( K, 2);
+
+        lua_getglobal( K, func_name);
+        ASSERT_L( lua_isfunction(K, -1));
+
+        lua_pushlightuserdata( K, linda);
+
+        if( (args == 0) || luaG_inter_copy( L, K, args) == 0) // L->K
+        {
+                lua_call( K, 1 + args, LUA_MULTRET);
+
+                retvals = lua_gettop( K) - Ktos;
+                if( (retvals > 0) && luaG_inter_move( K, L, retvals) != 0) // K->L
+                {
+                        retvals = -1;
+                }
+        }
+        // whatever happens, restore the stack to where it was at the origin
+        lua_settop( K, Ktos);
+        return retvals;
+}
+
+void close_keepers(void)
+{
+        int i;
+        for(i=0;i<KEEPER_STATES_N;i++)
+        {
+                lua_close( GKeepers[i].L);
+                GKeepers[i].L = 0;
+                //assert( GKeepers[i].count == 0);
+        }
+}
diff --git a/src/keeper.h b/src/keeper.h
new file mode 100644
index 0000000..66d8d7e
--- /dev/null
+++ b/src/keeper.h
@@ -0,0 +1,18 @@
+#if !defined( __keeper_h__)
+#define __keeper_h__ 1
+
+struct s_Keeper
+{
+        MUTEX_T lock_;
+        lua_State *L;
+        //int count;
+};
+
+const char *init_keepers(void);
+struct s_Keeper *keeper_acquire( const void *ptr);
+void keeper_release( struct s_Keeper *K);
+int keeper_call( lua_State *K, char const *func_name, lua_State *L, void *linda, uint_t starting_index);
+void close_keepers(void);
+
+
+#endif // __keeper_h__
\ No newline at end of file
diff --git a/src/keeper.lua b/src/keeper.lua
index 9256a4b..2c38c0b 100644
--- a/src/keeper.lua
+++ b/src/keeper.lua
@@ -43,12 +43,26 @@ assert( nil_sentinel )
 local table_remove= assert( table.remove )
 local table_concat= assert( table.concat )
 
+--[[
 local function WR(...)
     if io then 
         io.stderr:write( table_concat({...},'\t').."\n" ) 
     end
 end
 
+local function DEBUG(title,ud,key)
+    assert( title and ud and key )
+
+    local data,incoming,_= tables(ud)
+
+    local s= tostring(data[key])
+    for _,v in ipairs( incoming[key] or {} ) do
+        s= s..", "..tostring(v)
+    end
+    WR( "*** "..title.." ("..tostring(key).."): ", s )
+end
+--]]
+
 -----
 -- Actual data store
 --
@@ -92,20 +106,6 @@ local function tables( ud )
     return _data[ud], _incoming[ud], _limits[ud]
 end
 
-
-local function DEBUG(title,ud,key)
-    assert( title and ud and key )
-
-    local data,incoming,_= tables(ud)
-
-    local s= tostring(data[key])
-    for _,v in ipairs( incoming[key] or {} ) do
-        s= s..", "..tostring(v)
-    end
-    WR( "*** "..title.." ("..tostring(key).."): ", s )
-end
-
-
 -----
 -- bool= send( linda_deep_ud, key, ... )
 --
diff --git a/src/lanes.c b/src/lanes.c
index 0a89959..a8aba71 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -102,6 +102,7 @@ THE SOFTWARE.
 
 #include "threading.h"
 #include "tools.h"
+#include "keeper.h"
 
 #if !((defined PLATFORM_WIN32) || (defined PLATFORM_POCKETPC))
 # include <sys/time.h>
@@ -113,12 +114,6 @@ THE SOFTWARE.
 # include <sys/types.h>
 #endif
 
-/* The selected number is not optimal; needs to be tested. Even using just
-* one keeper state may be good enough (depends on the number of Lindas used
-* in the applications).
-*/
-#define KEEPER_STATES_N 1   // 6
-
 /* Do you want full call stacks, or just the line where the error happened?
 *
 * TBD: The full stack feature does not seem to work (try 'make error').
@@ -129,12 +124,6 @@ THE SOFTWARE.
 # define STACK_TRACE_KEY ((void*)lane_error)     // used as registry key
 #endif
 
-/*
-* Lua code for the keeper states (baked in)
-*/
-static char keeper_chunk[]= 
-#include "keeper.lch"
-
 // NOTE: values to be changed by either thread, during execution, without
 //       locking, are marked "volatile"
 //
@@ -254,199 +243,6 @@ static bool_t push_registry_table( lua_State *L, void *key, bool_t create ) {
 }
 
 
-/*---=== Serialize require ===---
-*/
-
-static MUTEX_T require_cs;
-
-//---
-// [val]= new_require( ... )
-//
-// Call 'old_require' but only one lane at a time.
-//
-// Upvalues: [1]: original 'require' function
-//
-static int new_require( lua_State *L ) {
-    int rc;
-    int args= lua_gettop(L);
-
-  STACK_GROW(L,1);
-  STACK_CHECK(L)
-    
-    // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
-    // leave us locked, blocking any future 'require' calls from other lanes.
-    //
-    MUTEX_LOCK( &require_cs );
-    {
-        lua_pushvalue( L, lua_upvalueindex(1) );
-        lua_insert( L, 1 );
-
-        rc= lua_pcall( L, args, 1 /*retvals*/, 0 /*errfunc*/ );
-            //
-            // LUA_ERRRUN / LUA_ERRMEM
-    }
-    MUTEX_UNLOCK( &require_cs );
-
-    if (rc) lua_error(L);   // error message already at [-1]
-
-  STACK_END(L,0)
-    return 1;
-}
-
-/*
-* Serialize calls to 'require', if it exists
-*/
-static 
-void serialize_require( lua_State *L ) {
-
-  STACK_GROW(L,1);  
-  STACK_CHECK(L)
-    
-    // Check 'require' is there; if not, do nothing
-    //
-    lua_getglobal( L, "require" );
-    if (lua_isfunction( L, -1 )) {
-        // [-1]: original 'require' function
-
-        lua_pushcclosure( L, new_require, 1 /*upvalues*/ );
-        lua_setglobal( L, "require" );
-
-    } else {
-        // [-1]: nil
-        lua_pop(L,1);
-    }
-
-  STACK_END(L,0)
-}
-
-
-/*---=== Keeper states ===---
-*/
-
-/*
-* Pool of keeper states
-*
-* Access to keeper states is locked (only one OS thread at a time) so the 
-* bigger the pool, the less chances of unnecessary waits. Lindas map to the
-* keepers randomly, by a hash.
-*/
-struct s_Keeper
-{
-        MUTEX_T lock_;
-        lua_State *L;
-        //int count;
-} GKeepers[KEEPER_STATES_N];
-
-/* We could use an empty table in 'keeper.lua' as the sentinel, but maybe
-* checking for a lightuserdata is faster.
-*/
-static bool_t nil_sentinel;
-
-/*
-* Initialize keeper states
-*
-* If there is a problem, return an error message (NULL for okay).
-*
-* Note: Any problems would be design flaws; the created Lua state is left
-*       unclosed, because it does not really matter. In production code, this
-*       function never fails.
-*/
-static const char *init_keepers(void) {
-    unsigned int i;
-    for( i=0; i<KEEPER_STATES_N; i++ ) {
-        
-        // Initialize Keeper states with bare minimum of libs (those required
-        // by 'keeper.lua')
-        //
-        lua_State *L= luaL_newstate();
-        if (!L) return "out of memory";
-
-        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" );
-
-        // Read in the preloaded chunk (and run it)
-        //
-        if (luaL_loadbuffer( L, keeper_chunk, sizeof(keeper_chunk), "=lanes_keeper" ))
-            return "luaL_loadbuffer() failed";   // LUA_ERRMEM
-
-        if (lua_pcall( L, 0 /*args*/, 0 /*results*/, 0 /*errfunc*/ )) {
-            // LUA_ERRRUN / LUA_ERRMEM / LUA_ERRERR
-            //
-            const char *err= lua_tostring(L,-1);
-            assert(err);
-            return err;
-        }
-
-        MUTEX_INIT( &GKeepers[i].lock_ );
-        GKeepers[i].L= L;
-        //GKeepers[i].count = 0;
-    }
-    return NULL;    // ok
-}
-
-static struct s_Keeper *keeper_acquire( const void *ptr)
-{
-        /*
-        * Any hashing will do that maps pointers to 0..KEEPER_STATES_N-1 
-        * consistently.
-        *
-        * Pointers are often aligned by 8 or so - ignore the low order bits
-        */
-        unsigned int i= ((unsigned long)(ptr) >> 3) % KEEPER_STATES_N;
-        struct s_Keeper *K= &GKeepers[i];
-
-        MUTEX_LOCK( &K->lock_);
-        //++ K->count;
-        return K;
-}
-
-static void keeper_release( struct s_Keeper *K)
-{
-        //-- K->count;
-        MUTEX_UNLOCK( &K->lock_);
-}
-
-/*
-* Call a function ('func_name') in the keeper state, and pass on the returned
-* values to 'L'.
-*
-* 'linda':          deep Linda pointer (used only as a unique table key, first parameter)
-* 'starting_index': first of the rest of parameters (none if 0)
-*
-* Returns: number of return values (pushed to 'L') or -1 in case of error
-*/
-static int keeper_call( lua_State *K, char const *func_name, lua_State *L, struct s_Linda *linda, uint_t starting_index)
-{
-        int const args = starting_index ? (lua_gettop(L) - starting_index +1) : 0;
-        int const Ktos = lua_gettop(K);
-        int retvals = -1;
-
-        STACK_GROW( K, 2);
-
-        lua_getglobal( K, func_name);
-        ASSERT_L( lua_isfunction(K, -1));
-
-        lua_pushlightuserdata( K, linda);
-
-        if( (args == 0) || luaG_inter_copy( L, K, args) == 0) // L->K
-        {
-                lua_call( K, 1 + args, LUA_MULTRET);
-
-                retvals = lua_gettop( K) - Ktos;
-                if( (retvals > 0) && luaG_inter_move( K, L, retvals) != 0) // K->L
-                {
-                        retvals = -1;
-                }
-        }
-        // whatever happens, restore the stack to where it was at the origin
-        lua_settop( K, Ktos);
-        return retvals;
-}
-
-
 /*---=== Linda ===---
 */
 
@@ -1189,14 +985,7 @@ static void selfdestruct_atexit( void ) {
         DEBUGEXEC(fprintf( stderr, "Killed %d lane(s) at process end.\n", n ));
 #endif
     }
-        {
-    int i;
-    for(i=0;i<KEEPER_STATES_N;i++){
-      lua_close( GKeepers[i].L);
-      GKeepers[i].L = 0;
-      //assert( GKeepers[i].count == 0);
-    }
-  }
+    close_keepers();
 }
 
 
diff --git a/src/tools.c b/src/tools.c
index 29959a8..d475fc0 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -1278,3 +1278,72 @@ int luaG_inter_move( lua_State* L, lua_State *L2, uint_t n )
         lua_pop( L, (int) n);
         return ret;
 }
+
+/*---=== Serialize require ===---
+*/
+
+MUTEX_T require_cs;
+
+//---
+// [val]= new_require( ... )
+//
+// Call 'old_require' but only one lane at a time.
+//
+// Upvalues: [1]: original 'require' function
+//
+static int new_require( lua_State *L )
+{
+        int rc;
+        int args= lua_gettop(L);
+
+        STACK_GROW(L,1);
+        STACK_CHECK(L)
+
+        // Using 'lua_pcall()' to catch errors; otherwise a failing 'require' would
+        // leave us locked, blocking any future 'require' calls from other lanes.
+        //
+        MUTEX_LOCK( &require_cs);
+        {
+                lua_pushvalue( L, lua_upvalueindex(1) );
+                lua_insert( L, 1 );
+
+                rc= lua_pcall( L, args, 1 /*retvals*/, 0 /*errfunc*/ );
+                //
+                // LUA_ERRRUN / LUA_ERRMEM
+        }
+        MUTEX_UNLOCK( &require_cs);
+
+        if (rc)
+                lua_error(L);   // error message already at [-1]
+
+        STACK_END(L,0)
+        return 1;
+}
+
+/*
+* Serialize calls to 'require', if it exists
+*/
+void serialize_require( lua_State *L )
+{
+        STACK_GROW(L,1);
+        STACK_CHECK(L)
+
+        // Check 'require' is there; if not, do nothing
+        //
+        lua_getglobal( L, "require" );
+        if (lua_isfunction( L, -1 ))
+        {
+                // [-1]: original 'require' function
+
+                lua_pushcclosure( L, new_require, 1 /*upvalues*/ );
+                lua_setglobal( L, "require" );
+
+        }
+        else
+        {
+                // [-1]: nil
+                lua_pop(L,1);
+        }
+
+        STACK_END(L,0)
+}
diff --git a/src/tools.h b/src/tools.h
index 0907df2..a080257 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -72,5 +72,8 @@ int luaG_inter_move( lua_State *L, lua_State *L2, uint_t n);
 extern MUTEX_T deep_lock;
 extern MUTEX_T mtid_lock;
 
+void serialize_require( lua_State *L);
+extern MUTEX_T require_cs;
+
 #endif
     // TOOLS_H