1 files changed, 199 insertions, 0 deletions

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);
+        }
+}