Merge pull request #4 from uphantom/master

fastnn first version, include follow submodular

5 files changed, 851 insertions, 0 deletions

diff --git a/fastnn/threads/lib/THThread.c b/fastnn/threads/lib/THThread.c
new file mode 100644
index 0000000..7abc044
--- /dev/null
+++ b/fastnn/threads/lib/THThread.c
@@ -0,0 +1,349 @@
+#ifndef TH_THREAD_INC
+#define TH_THREAD_INC
+
+#include <stdlib.h>
+#include <string.h>
+
+/*#include "TH.h" */
+#include "THThread.h"
+
+#if defined(USE_PTHREAD_THREADS)
+#include <pthread.h>
+
+#elif defined(USE_WIN32_THREADS)
+
+/* very basic emulation to suit our needs */
+
+#include <process.h>
+#include <windows.h>
+
+typedef HANDLE pthread_t;
+typedef DWORD pthread_attr_t;
+typedef HANDLE pthread_mutex_t;
+typedef HANDLE pthread_cond_t;
+
+static int pthread_create(pthread_t *restrict thread,
+                          const pthread_attr_t *restrict attr, void *(*start_routine)(void *),
+                          void *restrict arg)
+{
+  *thread = (HANDLE)_beginthreadex(NULL, 0, (THREAD_FUNCTION)start_routine, arg, 0, NULL);
+  return (int)(*thread == NULL);
+}
+
+static int pthread_join(pthread_t thread, void **value_ptr)
+{
+  return ((WaitForSingleObject((thread), INFINITE) != WAIT_OBJECT_0) || !CloseHandle(thread));
+}
+
+static int pthread_mutex_init(pthread_mutex_t *restrict mutex,
+                              const pthread_mutexattr_t *restrict attr)
+{
+  *mutex = CreateMutex(NULL, FALSE, NULL);
+  return (int)(*mutex == NULL);
+}
+
+static int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+  return WaitForSingleObject(*mutex, INFINITE) == 0;
+}
+
+static int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+  return ReleaseMutex(*mutex) == 0;
+}
+
+static int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+  return CloseHandle(*mutex) == 0;
+}
+
+static int pthread_cond_init(pthread_cond_t *restrict cond,
+                             const pthread_condattr_t *restrict attr)
+{
+  *cond = CreateEvent(NULL, FALSE, FALSE, NULL);
+  return (int)(*cond == NULL);
+}
+
+static int pthread_cond_wait(pthread_cond_t *restrict cond,
+                             pthread_mutex_t *restrict mutex)
+{
+  SignalObjectAndWait(*mutex, *cond, INFINITE, FALSE);
+  return WaitForSingleObject(*mutex, INFINITE) == 0;
+}
+
+static int pthread_cond_destroy(pthread_cond_t *cond)
+{
+  return CloseHandle(*cond) == 0;
+}
+
+int pthread_cond_signal(pthread_cond_t *cond)
+{
+  return SetEvent(*cond) == 0;
+}
+
+#else
+#error no thread system available
+#endif
+
+typedef struct THThread_ {
+  pthread_t id;
+  int (*func)(void*);
+  void* data;
+  int status;
+} THThread;
+
+typedef struct THMutex_{
+  pthread_mutex_t id;
+  int refcount;
+} THMutex;
+
+typedef struct THCondition_ {
+  pthread_cond_t id;
+  int refcount;
+} THCondition;
+
+typedef struct THSemaphore_ {
+	pthread_mutex_t mutex_;
+	pthread_cond_t cond_;
+	int 	counter_;
+	int	refcount;
+}THSemaphore;
+
+static void* thread_closure(void *data)
+{
+  THThread *thread = data;
+  thread->status = thread->func(thread->data);
+  return NULL;
+}
+
+THThread* THThread_new(int (*func)(void*), void *data)
+{
+  THThread *self = malloc(sizeof(THThread));
+  self->func = func;
+  self->data = data;
+  self->status = 0;
+  if(!self)
+    return NULL;
+  if(pthread_create(&self->id, NULL, thread_closure, self)) {
+    free(self);
+    return NULL;
+  }
+  return self;
+}
+
+long THThread_id(THThread *self)
+{
+  return (long)(self);
+}
+
+int THThread_free(THThread *self)
+{
+  int status = 1;
+  if(self) {
+    if(pthread_join(self->id, NULL))
+      return 1;
+    status = self->status;
+    free(self);
+	self = NULL;
+  }
+  return status;
+}
+
+THMutex* THMutex_new(void)
+{
+  THMutex *self = malloc(sizeof(THMutex));
+  if(!self)
+    return NULL;
+  if(pthread_mutex_init(&self->id, NULL) != 0) {
+    free(self);
+    return NULL;
+  }
+  self->refcount = 1;
+  return self;
+}
+
+THMutex* THMutex_newWithId(long id)
+{
+  THMutex *self = (THMutex*)id;
+  __sync_fetch_and_add(&self->refcount, 1);
+  return self;
+}
+
+long THMutex_id(THMutex *self)
+{
+  return (long)(self);
+}
+
+int THMutex_lock(THMutex *self)
+{
+  if(pthread_mutex_lock(&self->id) != 0)
+    return 1;
+  return 0;
+}
+
+int THMutex_trylock(THMutex *self)
+{
+  if (pthread_mutex_trylock(&self->id) != 0)
+	return 1; 
+  return 0;
+}
+
+int THMutex_unlock(THMutex *self)
+{
+  if(pthread_mutex_unlock(&self->id) != 0)
+    return 1;
+  return 0;
+}
+
+void THMutex_free(THMutex *self)
+{
+  if(self) {
+    if(__sync_fetch_and_add(&self->refcount, -1) == 1) {
+      pthread_mutex_destroy(&self->id);
+      free(self);
+	self = NULL;
+    }
+  }
+}
+
+THCondition* THCondition_new(void)
+{
+  THCondition *self = malloc(sizeof(THCondition));
+  if(!self)
+    return NULL;
+  if(pthread_cond_init(&self->id, NULL)) {
+    free(self);
+    return NULL;
+  }
+  self->refcount = 1;
+  return self;
+}
+
+THCondition* THCondition_newWithId(long id)
+{
+  THCondition *self = (THCondition*)id;
+  __sync_fetch_and_add(&self->refcount, 1);
+  return self;
+}
+
+long THCondition_id(THCondition *self)
+{
+  return (long)(self);
+}
+
+int THCondition_signal(THCondition *self)
+{
+  if(pthread_cond_signal(&self->id))
+    return 1;
+  return 0;
+}
+
+int THCondition_wait(THCondition *self, THMutex *mutex)
+{
+  if(pthread_cond_wait(&self->id, &mutex->id))
+    return 1;
+  return 0;
+}
+
+void THCondition_free(THCondition *self)
+{
+  if(self) {
+    if(__sync_fetch_and_add(&self->refcount, -1) == 1) {
+      pthread_cond_destroy(&self->id);
+	free(self);
+	self = NULL;
+    }
+  }
+}
+
+THSemaphore* THSemaphore_new(int initValue)
+{
+	THSemaphore *self = malloc(sizeof(THSemaphore));
+  	if(!self)
+    		return NULL;
+	self->counter_ = initValue;	
+  	if(pthread_mutex_init(&self->mutex_, NULL) != 0) 
+	{
+    		free(self);
+    		return NULL;
+  	}
+
+	if(pthread_cond_init(&self->cond_, NULL) != 0) 
+	{
+    		free(self);
+    		return NULL;
+	}
+	
+  	self->refcount = 1;
+
+  return self;
+}
+
+THSemaphore* THSemaphore_newWithId(long id)
+{
+	THSemaphore *self = (THSemaphore*)id;
+  	__sync_fetch_and_add(&self->refcount, 1);
+	return self;
+}
+
+long    THSemaphore_id(THSemaphore *self)
+{
+	return (long)(self);
+}
+
+int     THSemaphore_wait(THSemaphore *self)
+{
+	int ret = 0;
+	ret |= pthread_mutex_lock(&self->mutex_);	
+	
+	while (self->counter_ <= 0)
+		ret |= pthread_cond_wait(&self->cond_, &self->mutex_);
+	
+	self->counter_--;	
+	ret |= pthread_mutex_unlock(&self->mutex_);
+
+	return ret;	
+	
+}
+
+int     THSemaphore_signal(THSemaphore *self)
+{
+	int ret = 0;
+	ret |= pthread_mutex_lock(&self->mutex_);
+	self->counter_++;
+	ret |= pthread_cond_signal(&self->cond_);
+	ret |= pthread_mutex_unlock(&self->mutex_);
+
+	return ret;
+}
+
+int     THSemaphore_trywait(THSemaphore *self)
+{
+	int ret = 0;
+	int try_wait_succeeded = 1;
+	ret |= pthread_mutex_lock(&self->mutex_);
+  	if (self->counter_ > 0) {
+    		self->counter_--;
+    		try_wait_succeeded = 0;
+  	}
+  	ret |= pthread_mutex_unlock(&self->mutex_);
+	return try_wait_succeeded;
+}
+
+void    THSemaphore_free(THSemaphore *self)
+{
+	if(self) 
+	{
+    		if(__sync_fetch_and_add(&self->refcount, -1) == 1) 
+		{
+			pthread_mutex_destroy(&self->mutex_);
+			pthread_cond_destroy(&self->cond_);
+			free(self);
+			self = NULL;
+    		}
+	}
+  }
+	
+
+
+#endif
diff --git a/fastnn/threads/lib/THThread.h b/fastnn/threads/lib/THThread.h
new file mode 100644
index 0000000..75ba417
--- /dev/null
+++ b/fastnn/threads/lib/THThread.h
@@ -0,0 +1,36 @@
+#ifndef TH_THREAD_INC
+#define TH_THREAD_INC
+
+typedef struct THThread_ THThread;
+typedef struct THMutex_ THMutex;
+typedef struct THCondition_ THCondition;
+typedef struct THSemaphore_ THSemaphore;
+
+THThread* THThread_new(int (*closure)(void*), void *data);
+long THThread_id(THThread *self);
+int THThread_free(THThread *self);
+
+THMutex* THMutex_new(void);
+THMutex* THMutex_newWithId(long id);
+long THMutex_id(THMutex *self);
+int THMutex_lock(THMutex *self);
+int THMutex_unlock(THMutex *self);
+int THMutex_trylock(THMutex *self);
+void THMutex_free(THMutex *self);
+
+THCondition* THCondition_new(void);
+THCondition* THCondition_newWithId(long id);
+long THCondition_id(THCondition *self);
+int THCondition_signal(THCondition *self);
+int THCondition_wait(THCondition *self, THMutex *mutex);
+void THCondition_free(THCondition *self);
+
+THSemaphore* THSemaphore_new(int initValue);
+THSemaphore* THSemaphore_newWithId(long id);
+long	THSemaphore_id(THSemaphore *self);
+int	THSemaphore_signal(THSemaphore *self);
+int	THSemaphore_wait(THSemaphore *self);
+int	THSemaphore_trywait(THSemaphore *self);
+void	THSemaphore_free(THSemaphore *self);
+
+#endif
diff --git a/fastnn/threads/lib/init.c b/fastnn/threads/lib/init.c
new file mode 100644
index 0000000..4042189
--- /dev/null
+++ b/fastnn/threads/lib/init.c
@@ -0,0 +1,27 @@
+#include <lua.h>
+#include <lauxlib.h>
+
+#if LUA_VERSION_NUM == 501
+static void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup)
+{
+  luaL_checkstack(L, nup+1, "too many upvalues");
+  for (; l->name != NULL; l++) {  /* fill the table with given functions */
+    int i;
+    lua_pushstring(L, l->name);
+    for (i = 0; i < nup; i++)  /* copy upvalues to the top */
+      lua_pushvalue(L, -(nup+1));
+    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
+    lua_settable(L, -(nup + 3));
+  }
+  lua_pop(L, nup);  /* remove upvalues */
+}
+#endif
+
+#include "threads.c"
+
+int luaopen_libthreads(lua_State *L)
+{
+  lua_newtable(L);
+  thread_init_pkg(L);
+  return 1;
+}
diff --git a/fastnn/threads/lib/luaTHRD.h b/fastnn/threads/lib/luaTHRD.h
new file mode 100644
index 0000000..3760bdb
--- /dev/null
+++ b/fastnn/threads/lib/luaTHRD.h
@@ -0,0 +1,84 @@
+#ifndef LUA_THRD_INC
+#define LUA_THRD_INC
+
+static int luaTHRD_pushudata(lua_State *L, void *ptr, const char* typename)
+{
+  void **udata = lua_newuserdata(L, sizeof(void*));
+  if(udata) {
+    *udata = ptr;
+    luaL_getmetatable(L, typename);
+    lua_setmetatable(L, -2);
+    return 1;
+  }
+  return 0;
+}
+
+static void *luaTHRD_checkudata(lua_State *L, int narg, const char *typename)
+{
+  void **udata = luaL_checkudata(L, narg, typename);
+  if(udata)
+    return *udata;
+  else
+    return NULL;
+}
+
+static void *luaTHRD_toudata(lua_State *L, int narg, const char *typename)
+{
+  void **udata = lua_touserdata(L, narg);
+  if(udata) {
+    if(lua_getmetatable(L, -1)) {
+      luaL_getmetatable(L, typename);
+      if(lua_equal(L, -1, -2)) {
+        lua_pop(L, 2);
+        return *udata;
+      }
+      else {
+        lua_pop(L, 2);
+        return NULL;
+      }
+    }
+    else
+      return NULL;
+  }
+  else
+    return NULL;
+}
+
+static int luaTHRD_ctor(lua_State *L)
+{
+  if(!lua_istable(L, 1)) /* dummy ctor table */
+    luaL_error(L, "ctor: table expected");
+  lua_getmetatable(L, 1);
+  lua_remove(L, 1); /* dummy ctor table */
+  if(!lua_istable(L, -1))
+    luaL_error(L, "ctor: no metatable found");
+  lua_pushstring(L, "__new");
+  lua_rawget(L, -2);
+  lua_remove(L, -2); /* forget about metatable */
+  if(!lua_isfunction(L, -1))
+    luaL_error(L, "ctor: __new appears to be not a function");
+  lua_insert(L, 1); /* ctor first, arguments follow */
+  lua_call(L, lua_gettop(L)-1, LUA_MULTRET);
+  return lua_gettop(L);
+}
+
+static void luaTHRD_pushctortable(lua_State *L, lua_CFunction ctor, const char* typename)
+{
+  lua_newtable(L); /* empty useless dude */
+  lua_newtable(L); /* metatable of the dude */
+  lua_pushstring(L, "__index");
+  luaL_getmetatable(L, typename);
+  lua_rawset(L, -3);
+  lua_pushstring(L, "__newindex");
+  luaL_getmetatable(L, typename);
+  lua_rawset(L, -3);
+  lua_pushstring(L, "__new"); /* __call will look into there */
+  lua_pushcfunction(L, ctor);
+  lua_rawset(L, -3);
+  lua_pushstring(L, "__call"); /* pop the table and calls __new */
+  lua_pushcfunction(L, luaTHRD_ctor);
+  lua_rawset(L, -3);
+  lua_setmetatable(L, -2);
+}
+
+#endif
diff --git a/fastnn/threads/lib/threads.c b/fastnn/threads/lib/threads.c
new file mode 100644
index 0000000..bf2a5ec
--- /dev/null
+++ b/fastnn/threads/lib/threads.c
@@ -0,0 +1,355 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <luaT.h>
+#include <string.h>
+
+#include "THThread.h"
+#include "luaTHRD.h"
+
+#include <lua.h>
+#include <lualib.h>
+
+static int newthread(void *code_)
+{
+  char *code = code_;
+  lua_State *L = luaL_newstate();
+
+  if(!L) {
+    printf("THREAD FATAL ERROR: could not create lua state\n");
+    return -1;
+  }
+  luaL_openlibs(L);
+
+  if(luaL_loadstring(L, code)) {
+    printf("FATAL THREAD PANIC: (loadstring) %s\n", lua_tolstring(L, -1, NULL));
+    free(code);
+    lua_close(L);
+    return -1;
+  }
+  free(code);
+  if(lua_pcall(L, 0, 0, 0)) {
+    printf("FATAL THREAD PANIC: (pcall) %s\n", lua_tolstring(L, -1, NULL));
+    lua_close(L);
+    return -1;
+  }
+
+  lua_close(L);
+  return 0;
+}
+
+static int thread_new(lua_State *L)
+{
+  THThread *thread = NULL;
+  size_t len = 0;
+  const char *code = luaL_checklstring(L, 1, &len);
+  char *code_dup = malloc(len+1);
+  if(!code_dup)
+    luaL_error(L, "threads: out of memory");
+  memcpy(code_dup, code, len+1);
+
+  thread = THThread_new(newthread, (void*)code_dup);
+  if(!thread)
+    luaL_error(L, "threads: thread new failed");
+  luaTHRD_pushudata(L, thread, "threads.Thread");
+
+  return 1;
+}
+
+static int thread_tostring(lua_State *L)
+{
+  char str[128];
+  THThread *thread = luaTHRD_checkudata(L, 1, "threads.Thread");
+  snprintf(str, 128, "threads.Thread <%lx>", THThread_id(thread));
+  lua_pushstring(L, str);
+  return 1;
+}
+
+static int thread_id(lua_State *L)
+{
+  THThread *thread = luaTHRD_checkudata(L, 1, "threads.Thread");
+  lua_pushinteger(L, THThread_id(thread));
+  return 1;
+}
+
+static int thread_free(lua_State *L)
+{
+  THThread *thread = luaTHRD_checkudata(L, 1, "threads.Thread");
+  THThread_free(thread);
+  return 0;
+}
+
+static int mutex_new(lua_State *L)
+{
+  THMutex *mutex = NULL;
+  if(lua_gettop(L) == 0) {
+    mutex = THMutex_new();
+  }
+  else if(lua_gettop(L) == 1) {
+    long id = luaL_checklong(L, 1);
+    mutex = THMutex_newWithId(id);
+  }
+  else
+    luaL_error(L, "threads: mutex new invalid arguments");
+  if(!mutex)
+    luaL_error(L, "threads: mutex new failed");
+  luaTHRD_pushudata(L, mutex, "threads.Mutex");
+  return 1;
+}
+
+static int mutex_tostring(lua_State *L)
+{
+  char str[128];
+  THMutex *mutex = luaTHRD_checkudata(L, 1, "threads.Mutex");
+  snprintf(str, 128, "threads.Mutex <%lx>", THMutex_id(mutex));
+  lua_pushstring(L, str);
+  return 1;
+}
+
+static int mutex_id(lua_State *L)
+{
+  THMutex *mutex = luaTHRD_checkudata(L, 1, "threads.Mutex");
+  lua_pushinteger(L, THMutex_id(mutex));
+  return 1;
+}
+
+static int mutex_lock(lua_State *L)
+{
+  THMutex *mutex = luaTHRD_checkudata(L, 1, "threads.Mutex");
+  if(THMutex_lock(mutex))
+    luaL_error(L, "threads: mutex lock failed");
+  return 0;
+}
+
+static int mutex_unlock(lua_State *L)
+{
+  THMutex *mutex = luaTHRD_checkudata(L, 1, "threads.Mutex");
+  if(THMutex_unlock(mutex))
+    luaL_error(L, "threads: mutex unlock failed");
+  return 0;
+}
+
+static int mutex_free(lua_State *L)
+{
+  THMutex *mutex = luaTHRD_checkudata(L, 1, "threads.Mutex");
+  THMutex_free(mutex);
+  return 0;
+}
+
+static int condition_new(lua_State *L)
+{
+  THCondition *condition = NULL;
+  if(lua_gettop(L) == 0) {
+    condition = THCondition_new();
+  }
+  else if(lua_gettop(L) == 1) {
+    long id = luaL_checklong(L, 1);
+    condition = THCondition_newWithId(id);
+  }
+  else
+    luaL_error(L, "threads: condition new invalid arguments");
+  if(!condition)
+    luaL_error(L, "threads: condition new failed");
+  luaTHRD_pushudata(L, condition, "threads.Condition");
+  return 1;
+}
+
+static int condition_tostring(lua_State *L)
+{
+  char str[128];
+  THCondition *condition = luaTHRD_checkudata(L, 1, "threads.Condition");
+  snprintf(str, 128, "threads.Condition <%lx>", THCondition_id(condition));
+  lua_pushstring(L, str);
+  return 1;
+}
+
+static int condition_id(lua_State *L)
+{
+  THCondition *condition = luaTHRD_checkudata(L, 1, "threads.Condition");
+  lua_pushinteger(L, THCondition_id(condition));
+  return 1;
+}
+
+static int condition_free(lua_State *L)
+{
+  THCondition *condition = luaTHRD_checkudata(L, 1, "threads.Condition");
+  if(!condition)
+    luaL_error(L, "threads: condition free failed");
+  THCondition_free(condition);
+  return 0;
+}
+
+static int condition_signal(lua_State *L)
+{
+  THCondition *condition = luaTHRD_checkudata(L, 1, "threads.Condition");
+  if(THCondition_signal(condition))
+    luaL_error(L, "threads: condition signal failed");
+  return 0;
+}
+
+static int condition_wait(lua_State *L)
+{
+  THCondition *condition = luaTHRD_checkudata(L, 1, "threads.Condition");
+  THMutex *mutex = luaTHRD_checkudata(L, 2, "threads.Mutex");
+  if(THCondition_wait(condition, mutex))
+    luaL_error(L, "threads: condition wait failed");
+  return 0;
+}
+
+static int semaphore_new(lua_State *L)
+{
+	THSemaphore* semaphore = NULL;
+        if(lua_gettop(L) == 1) {
+                int initValue = luaL_checkinteger(L, 1);
+                semaphore = THSemaphore_new(initValue);
+        }
+	else
+		luaL_error(L, "threads: semaphore new invalid arguments");	
+	if (!semaphore)
+		luaL_error(L, "threads: semaphore new failed");
+  	luaTHRD_pushudata(L, semaphore, "threads.Semaphore");
+  	return 1;
+}
+
+static int semaphore_newfromid(lua_State *L)
+{
+	THSemaphore* semaphore = NULL; 
+  	if(lua_gettop(L) == 1) {
+    		long id = luaL_checklong(L, 1); 
+    		semaphore = THSemaphore_newWithId(id);
+  	}
+  	else
+    		luaL_error(L, "threads: semaphore new invalid arguments");
+  	if(!semaphore)
+    		luaL_error(L, "threads: semaphore new failed");
+  	luaTHRD_pushudata(L, semaphore, "threads.Semaphore");
+  	return 1;
+}
+	
+static int semaphore_id(lua_State *L)
+{
+	THSemaphore *semaphore = luaTHRD_checkudata(L, 1, "threads.Semaphore");
+  	lua_pushinteger(L, THSemaphore_id(semaphore));
+  	return 1;	
+}
+
+static int semaphore_signal(lua_State *L)
+{
+	THSemaphore *semaphore = luaTHRD_checkudata(L, 1, "threads.Semaphore");
+	if(THSemaphore_signal(semaphore))
+    		luaL_error(L, "threads: semaphore signal failed");
+  	return 0;
+}
+
+static int semaphore_wait(lua_State *L)
+{
+	THSemaphore *semaphore = luaTHRD_checkudata(L, 1, "threads.Semaphore");
+        if(THSemaphore_wait(semaphore))
+                luaL_error(L, "threads: semaphore wait failed");
+        return 0;
+}
+
+static int semaphore_trywait(lua_State *L)
+{
+	THSemaphore *semaphore = luaTHRD_checkudata(L, 1, "threads.Semaphore");
+	int wait = THSemaphore_trywait(semaphore);
+	lua_pushinteger(L, wait);
+	return 1;
+}
+
+static void semaphore_free(lua_State *L)
+{
+	THSemaphore *semaphore = luaTHRD_checkudata(L, 1, "threads.Semaphore");
+	  if(!semaphore)
+    		luaL_error(L, "threads: semaphore free failed");
+	THSemaphore_free(semaphore);
+}
+
+static const struct luaL_Reg thread__ [] = {
+  {"new", thread_new},
+  {"__tostring", thread_tostring},
+  {"id", thread_id},
+  {"free", thread_free},
+  {NULL, NULL}
+};
+
+static const struct luaL_Reg mutex__ [] = {
+  {"new", mutex_new},
+  {"__tostring", mutex_tostring},
+  {"id", mutex_id},
+  {"lock", mutex_lock},
+  {"unlock", mutex_unlock},
+  {"free", mutex_free},
+  {NULL, NULL}
+};
+
+static const struct luaL_Reg condition__ [] = {
+  {"new", condition_new},
+  {"__tostring", condition_tostring},
+  {"id", condition_id},
+  {"signal", condition_signal},
+  {"wait", condition_wait},
+  {"free", condition_free},
+  {NULL, NULL}
+};
+
+static const struct luaL_Reg semaphore__ [] = {
+  {"new", semaphore_new},
+  {"newfromid", semaphore_newfromid},
+  {"id", semaphore_id},
+  {"signal", semaphore_signal},
+  {"wait", semaphore_wait},
+  {"trywait", semaphore_trywait},
+  {"free", semaphore_free},
+  {NULL, NULL}
+};
+
+static void thread_init_pkg(lua_State *L)
+{
+  if(!luaL_newmetatable(L, "threads.Thread"))
+    luaL_error(L, "threads: threads.Thread type already exists");
+  luaL_setfuncs(L, thread__, 0);
+  lua_pushstring(L, "__index");
+  lua_pushvalue(L, -2);
+  lua_rawset(L, -3);
+  lua_pop(L, 1);
+
+  if(!luaL_newmetatable(L, "threads.Mutex"))
+    luaL_error(L, "threads: threads.Mutex type already exists");
+  luaL_setfuncs(L, mutex__, 0);
+  lua_pushstring(L, "__index");
+  lua_pushvalue(L, -2);
+  lua_rawset(L, -3);
+  lua_pop(L, 1);
+
+  if(!luaL_newmetatable(L, "threads.Condition"))
+    luaL_error(L, "threads: threads.Condition type already exists");
+  luaL_setfuncs(L, condition__, 0);
+  lua_pushstring(L, "__index");
+  lua_pushvalue(L, -2);
+  lua_rawset(L, -3);
+  lua_pop(L, 1);
+
+  if(!luaL_newmetatable(L, "threads.Semaphore"))
+  luaL_error(L, "threads: threads.Semaphore type already exists");
+  luaL_setfuncs(L, semaphore__, 0);
+  lua_pushstring(L, "__index");
+  lua_pushvalue(L, -2);
+  lua_rawset(L, -3);
+  lua_pop(L, 1);
+
+  lua_pushstring(L, "Thread");
+  luaTHRD_pushctortable(L, thread_new, "threads.Thread");
+  lua_rawset(L, -3);
+
+  lua_pushstring(L, "Mutex");
+  luaTHRD_pushctortable(L, mutex_new, "threads.Mutex");
+  lua_rawset(L, -3);
+
+  lua_pushstring(L, "Condition");
+  luaTHRD_pushctortable(L, condition_new, "threads.Condition");
+  lua_rawset(L, -3);
+
+  lua_pushstring(L, "Semaphore");
+  luaTHRD_pushctortable(L, semaphore_new, "threads.Semaphore");
+  lua_rawset(L, -3);
+}