work on threads

4 files changed, 275 insertions, 123 deletions

diff --git a/src/thread.c b/src/thread.c
index 25ad500..441793b 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -1,114 +1,163 @@
-#include "thread.h"
-#include "lua5.4/lauxlib.h"
-#include "lua5.4/lua.h"
-#include "stdint.h"
-#include <stdlib.h>
-#include <unistd.h>
-#include <pthread.h>
-#include "types/str.h"
-#include "util.h"
-
-struct thread_info {
-    str* function;
-    lua_State* L;
-    int return_count;
-    pthread_t tid;
-    pthread_cond_t cond;
-    pthread_mutex_t lock;
-};
-
-#include "io.h"
-
-int l_res(lua_State* L){
-    int return_count = lua_gettop(L) - 1;
-    lua_pushstring(L, "_");
-    lua_gettable(L, 1);
-    struct thread_info* info = lua_touserdata(L, -1);
-    info->return_count = return_count;
-
-    for(int i = info->return_count - 1; i != -1; i--){
-        int ot = lua_gettop(L);
-
-        lua_pushvalue(L, 2 + i);
-        i_dcopy(L, info->L, NULL);
-
-        lua_settop(L, ot);
-    }
-
-    pthread_mutex_unlock(&info->lock);
-
-    pthread_exit(NULL);
-    p_error("thread did not exit");
-
-    return 1;
-}
-
-void* handle_thread(void* _args){
-  struct thread_info* args = (struct thread_info*)_args;
-  lua_State* L = args->L;
-
-  lua_newtable(L);
-  int res_idx = lua_gettop(L);
-  luaI_tsetcf(L, res_idx, "res", l_res);
-  luaI_tsetlud(L, res_idx, "_", args);
-
-  luaL_loadbuffer(L, args->function->c, args->function->len, "thread");
-  str_free(args->function);
-
-  lua_pushvalue(L, res_idx);
-  lua_call(L, 1, 0);
-
-  pthread_mutex_unlock(&args->lock);
-
-  return NULL;
-}
-
-int l_await(lua_State* L){
-    lua_pushstring(L, "_");
-    lua_gettable(L, 1);
-    struct thread_info* info = lua_touserdata(L, -1);
-
-    pthread_mutex_lock(&info->lock);
-
-    for(int i = 0; i != info->return_count; i++){
-        int ot = lua_gettop(info->L);
-
-        lua_pushvalue(info->L, ot - info->return_count + i);
-        i_dcopy(info->L, L, NULL);
-
-        lua_settop(info->L, ot);
-    }
-
-    return info->return_count;
-}
-
-int l_async(lua_State* oL){
-   lua_State* L = luaL_newstate(); 
-
-  luaL_openlibs(L);
-
-  lua_getglobal(oL, "_G");
-  i_dcopy(oL, L, NULL);
-  lua_set_global_table(L);
-
-  struct thread_info* args = calloc(1, sizeof * args);
-  args->L = L;
-  args->cond = (pthread_cond_t)PTHREAD_COND_INITIALIZER;
-  args->lock = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
-  pthread_mutex_lock(&args->lock);
-  args->return_count = 0;
-
-  args->function = str_init("");
-  lua_pushvalue(oL, 1);
-  lua_dump(oL, writer, (void*)args->function, 0);
- 
-  pthread_create(&args->tid, NULL, handle_thread, (void*)args);
-  pthread_detach(args->tid);
-
-  lua_newtable(oL);
-  int res_idx = lua_gettop(oL);
-  luaI_tsetcf(oL, res_idx, "await", l_await);
-  luaI_tsetlud(oL, res_idx, "_", args);
-  lua_pushvalue(oL, res_idx);
-  return 1;
-}
+#include "thread.h"

+#include "lua5.4/lauxlib.h"

+#include "lua5.4/lua.h"

+#include "stdint.h"

+#include <stdlib.h>

+#include <unistd.h>

+#include <pthread.h>

+#include "types/str.h"

+#include "util.h"

+

+#include "types/larray.h"

+

+struct thread_info {

+    str* function;

+    lua_State* L;

+    int return_count;

+    pthread_t tid;

+    pthread_cond_t cond;

+    pthread_mutex_t lock;

+};

+

+#include "io.h"

+

+pthread_mutex_t thread_lock_lock = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;

+larray_t* thread_locks = NULL;

+

+int l_tlock(lua_State* L){

+    int idx = luaL_checkinteger(L, 1);

+

+    pthread_mutex_lock(&thread_lock_lock);

+    pthread_mutex_t mutex;

+    if(thread_locks == NULL) thread_locks = larray_init();

+    int i = 0;

+    if((i = larray_geti(thread_locks, idx)) == -1){

+        pthread_mutex_init(&mutex, NULL);

+        pthread_mutex_lock(&mutex);

+        larray_set(&thread_locks, idx, (void*)mutex);

+    } else {

+        pthread_mutex_t m = (pthread_mutex_t)thread_locks->arr[i].value;

+        pthread_mutex_unlock(&thread_lock_lock);

+        pthread_mutex_lock(&m);

+        pthread_mutex_lock(&thread_lock_lock);

+        thread_locks->arr[i].value = (void*)m;

+

+    }

+    

+    pthread_mutex_unlock(&thread_lock_lock);

+    return 0;

+}

+

+int l_tunlock(lua_State* L){

+    int idx = luaL_checkinteger(L, 1);

+

+    pthread_mutex_lock(&thread_lock_lock);

+    int i = 0;

+    if(thread_locks != NULL && (i = larray_geti(thread_locks, idx)) != -1){

+        pthread_mutex_t m = (pthread_mutex_t)thread_locks->arr[i].value;

+        pthread_mutex_unlock(&m);

+        thread_locks->arr[i].value = (void*)m;

+    }

+

+    pthread_mutex_unlock(&thread_lock_lock);

+    return 0;

+}

+

+int l_res(lua_State* L){

+    int return_count = lua_gettop(L) - 1;

+    lua_pushstring(L, "_");

+    lua_gettable(L, 1);

+    struct thread_info* info = lua_touserdata(L, -1);

+    info->return_count = return_count;

+

+    for(int i = info->return_count - 1; i != -1; i--){

+        int ot = lua_gettop(L);

+

+        lua_pushvalue(L, 2 + i);

+        i_dcopy(L, info->L, NULL);

+

+        lua_settop(L, ot);

+    }

+

+    pthread_mutex_unlock(&info->lock);

+

+    pthread_exit(NULL);

+    p_error("thread did not exit");

+

+    return 1;

+}

+

+void* handle_thread(void* _args){

+  struct thread_info* args = (struct thread_info*)_args;

+  lua_State* L = args->L;

+

+  lua_newtable(L);

+  int res_idx = lua_gettop(L);

+  luaI_tsetlud(L, res_idx, "_", args);

+

+  lua_newtable(L);

+  int meta_idx = lua_gettop(L);

+  luaI_tsetcf(L, meta_idx, "__call", l_res);

+  lua_pushvalue(L, meta_idx);

+  lua_setmetatable(L, res_idx);

+

+  luaL_loadbuffer(L, args->function->c, args->function->len, "thread");

+  str_free(args->function);

+

+  lua_pushvalue(L, res_idx);

+  lua_call(L, 1, 0);

+

+  pthread_mutex_unlock(&args->lock);

+

+  return NULL;

+}

+

+int l_await(lua_State* L){

+    lua_pushstring(L, "_");

+    lua_gettable(L, 1);

+    struct thread_info* info = lua_touserdata(L, -1);

+

+    pthread_mutex_lock(&info->lock);

+

+    for(int i = 0; i != info->return_count; i++){

+        int ot = lua_gettop(info->L);

+

+        lua_pushvalue(info->L, ot - info->return_count + i);

+        i_dcopy(info->L, L, NULL);

+

+        lua_settop(info->L, ot);

+    }

+

+    return info->return_count;

+}

+

+int l_async(lua_State* oL){

+   lua_State* L = luaL_newstate(); 

+

+  luaL_openlibs(L);

+

+  lua_getglobal(oL, "_G");

+  i_dcopy(oL, L, NULL);

+  lua_set_global_table(L);

+

+  struct thread_info* args = calloc(1, sizeof * args);

+  args->L = L;

+  args->cond = (pthread_cond_t)PTHREAD_COND_INITIALIZER;

+  args->lock = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;

+  pthread_mutex_lock(&args->lock);

+  args->return_count = 0;

+

+  args->function = str_init("");

+  lua_pushvalue(oL, 1);

+  lua_dump(oL, writer, (void*)args->function, 0);

+ 

+  pthread_create(&args->tid, NULL, handle_thread, (void*)args);

+  pthread_detach(args->tid);

+

+  lua_newtable(oL);

+  int res_idx = lua_gettop(oL);

+  luaI_tsetcf(oL, res_idx, "await", l_await);

+  luaI_tsetlud(oL, res_idx, "_", args);

+  lua_pushvalue(oL, res_idx);

+  return 1;

+}

diff --git a/src/thread.h b/src/thread.h
index d25b448..e9ead6d 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -1,9 +1,12 @@
-#include "lua.h"
-
-int l_async(lua_State*);
-
-static const luaL_Reg thread_function_list [] = {
-  {"async",l_async},
-  
-  {NULL,NULL}
-};
+#include "lua.h"

+

+int l_async(lua_State*);

+int l_tlock(lua_State*);

+int l_tunlock(lua_State*);

+

+static const luaL_Reg thread_function_list [] = {

+  {"async",l_async},

+  {"lock",l_tlock},

+  {"unlock",l_tunlock},

+  {NULL,NULL}

+};

diff --git a/src/types/larray.c b/src/types/larray.c
new file mode 100644
index 0000000..7a5afbc
--- /dev/null
+++ b/src/types/larray.c
@@ -0,0 +1,79 @@
+#include <stdio.h>

+#include <stdint.h>

+#include <stdlib.h>

+

+#include "larray.h"

+

+#define inc 4

+

+larray_t* larray_initl(int len){

+    larray_t* l = calloc(1, sizeof * l);

+    l->size = len;

+    l->arr = calloc(len, sizeof * l->arr);

+    return l;

+}

+

+larray_t* larray_init(){

+    return larray_initl(inc);

+}

+

+void larray_expand(larray_t** _l){

+    larray_t* l = *_l;

+    larray_t* remade = larray_initl(l->size * 4);

+    for(int i = 0; i != l->size; i++){

+        //what happens if the map_set calls map_regraph??? idk

+        if(l->arr[i].used)

+            larray_set(&remade, l->arr[i].idx, l->arr[i].value);

+    }

+

+    *_l = remade;

+}

+

+void larray_set(larray_t** _l, uint64_t idx, void* value){

+    larray_t* l = *_l;

+

+    if(l->len + 1 >= l->size){

+        expand:

+        larray_expand(&l);

+    }

+

+    uint64_t oind, ind = oind = idx % l->size;

+

+    for(int count = 0; l->arr[ind].used && l->arr[ind].idx != idx; count++){

+        ind++;

+        if(ind >= l->size) ind = 0;

+        if(ind == oind || count > 10) goto expand;

+    }

+

+    l->arr[ind].idx = idx;

+    l->arr[ind].value = value;

+    l->arr[ind].used = 1;

+    l->len++;

+

+    *_l = l;

+}

+

+int larray_geti(larray_t* l, uint64_t idx){

+    uint64_t ind = idx % l->size;

+

+    for(uint64_t initial = ind; ind != initial - 1;){

+        if(!l->arr[ind].used) return -1;

+        //printf("%s\n",M->M[ind].key->c);

+        if(l->arr[ind].idx == idx) return ind;

+        ind++;

+        if(ind >= l->size) ind = 0;

+    }

+    return -1;

+}

+

+void* larray_get(larray_t* l, uint64_t idx){

+    int r = larray_geti(l, idx);

+

+    return r == -1 ? NULL : l->arr[r].value;

+}

+

+void larray_clear(larray_t* l){

+    free(l->arr);

+    free(l);

+}

+

diff --git a/src/types/larray.h b/src/types/larray.h
new file mode 100644
index 0000000..ff67857
--- /dev/null
+++ b/src/types/larray.h
@@ -0,0 +1,21 @@
+#include <stdint.h>

+

+struct larray_item {

+    uint64_t idx;

+    void* value;

+    int used;

+};

+

+typedef struct {

+    struct larray_item* arr;

+    size_t len, size;

+} larray_t;

+

+larray_t* larray_initl(int len);

+larray_t* larray_init();

+void larray_expand(larray_t** _l);

+void larray_set(larray_t** _l, uint64_t idx, void* value);

+int larray_geti(larray_t* l, uint64_t idx);

+void* larray_get(larray_t* l, uint64_t idx);

+void larray_clear(larray_t* l);

+