lua-users home
lua-l archive

[Date Prev][Date Next][Thread Prev][Thread Next] [Date Index] [Thread Index]


My problem is : In most case, open sources projects uses the OS default Lua
library. This is useful because the task of OS maintainer is providing
libraries updates (fixing bug or security fail), and this is not the
task of the open source project maintainer.

Actually, the “lock interface” is defined using defines at compilation.
I guess this is for performances reason: it is useless to call function
or set a lock if multithread is not enabled. So, with this built-time
solution, the distribs cannot propose a package multithread-ready.

I propose myself to write a patch about multithread and lock, but first
I need your opinion. What do you think about integration of build-optional
"lock manager" for multithread usage of Lua ?

This seems match with requirements:

- No thread and performance requirement, build Lua without lock manager

- Thread and very specific integration, use your own lock with the actual

- Distribs packaging build with the manager, and each software using the
  distrib lib can use the lock manager or no. The overhead is just a call
  to empty function

The patch could be something like that (this is a very quick idea which
is not perfect):

Make with option:

and in the llimits.h file:

   #if !defined(lua_lock)
   #define lua_lock(__L) lua_internal_lock(__L)
   #define lua_lock(__L) lua_internal_unlock(__L)
   #define lua_lock(L)  ((void) 0)
   #define lua_unlock(L)   ((void) 0)

In lua.h

   void lua_register_lock_manager(void (*lua_lock)(lua_State *L),
                                  void (*lua_unlock)(lua_State *L));

In lapi.c (or other file):

   static void (*lua_internal_lock_function)(lua_State *L) = NULL;
   static void (*lua_internal_unlock_function)(lua_State *L) = NULL;

   void lua_register_lock_manager(void (*lua_lock_fcn)(lua_State *L),

   void (*lua_unlock_fcn)(lua_State *L))
      lua_internal_lock_function = lua_lock_fcn;
      lua_internal_unlock_function = lua_unlock_fcn;

   void lua_internal_lock(lua_State *L)
      if (lua_internal_lock_function)

   void lua_internal_unlock(lua_State *L)
      if (lua_internal_unlock_function)