From c562d0f9e336251f9ff599a840310835820b0461 Mon Sep 17 00:00:00 2001 From: ame Date: Wed, 8 May 2024 10:55:05 -0500 Subject: work on threads --- src/thread.c | 277 +++++++++++++++++++++++++++++++---------------------- src/thread.h | 21 ++-- src/types/larray.c | 79 +++++++++++++++ src/types/larray.h | 21 ++++ 4 files changed, 275 insertions(+), 123 deletions(-) create mode 100644 src/types/larray.c create mode 100644 src/types/larray.h (limited to 'src') 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 -#include -#include -#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 +#include +#include +#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 +#include +#include + +#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 + +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); + -- cgit v1.2.3