ndacremont/uthread
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: fix the most annoying bug of the world

Browse Source
This commit is contained in:
Nemo D'ACREMONT 2025-04-24 12:31:20 +02:00
parent 9c256a26ea
commit 81abd5113a
No known key found for this signature in database
GPG Key ID: 85F245EC3BB1E022
1 changed files with 37 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
src/thread/thread.c
View File

@ -15,8 +15,7 @@
#define UNSET_STATUS(entry, value) ((entry->status) &= ~(value)) #define UNSET_STATUS(entry, value) ((entry->status) &= ~(value))
#define FINISHED (1 << 0) #define FINISHED (1 << 0)
#define IS_FINISHED(entry) (HAS_STATUS(entry, FINISHED)) #define IS_FINISHED(entry) (HAS_STATUS(entry, FINISHED))
#define ALLOCATED (1 << 1) #define IS_MAIN(entry) (entry == main)
#define WAS_ALLOCATED(entry) (HAS_STATUS(entry, ALLOCATED))
#define WAITING (1 << 2) #define WAITING (1 << 2)
#define IS_WAITING(entry) (HAS_STATUS(entry, WAITING)) #define IS_WAITING(entry) (HAS_STATUS(entry, WAITING))
#define WAITED (1 << 3) #define WAITED (1 << 3)
@ -41,6 +40,7 @@
static char stack_for_freeing[STACK_SIZE] = {0}; static char stack_for_freeing[STACK_SIZE] = {0};
static int stack_valgrind_id = 0; static int stack_valgrind_id = 0;
static ucontext_t context_for_freeing; static ucontext_t context_for_freeing;
static struct context_entry_t* main = NULL;
struct mutex_fifo_entry_t; struct mutex_fifo_entry_t;
@ -64,15 +64,14 @@ TAILQ_HEAD(scheduler_fifo_t, context_entry_t);
static struct scheduler_fifo_t scheduler_fifo = TAILQ_HEAD_INITIALIZER(scheduler_fifo); static struct scheduler_fifo_t scheduler_fifo = TAILQ_HEAD_INITIALIZER(scheduler_fifo);
// Linked list used to store what's needed to be freed at the very end // Linked list used to store what's needed to be freed at the very end
TAILQ_HEAD(ctx_to_free_fifo_t, context_entry_t); TAILQ_HEAD(available_threads_fifo, context_entry_t);
static struct ctx_to_free_fifo_t context_to_freed = TAILQ_HEAD_INITIALIZER(context_to_freed); static struct available_threads_fifo available_threads = TAILQ_HEAD_INITIALIZER(available_threads);
int thread_yield(void) int thread_yield(void)
{ {
//TRACE("thread_yield"); //TRACE("thread_yield");
if (TAILQ_EMPTY(&scheduler_fifo)) { if (TAILQ_EMPTY(&scheduler_fifo))
return 0; return 0;
}
if (HAS_STATUS(running, MUTEX_LOCKING)) { if (HAS_STATUS(running, MUTEX_LOCKING)) {
if (running->mutex_prio > 0) { if (running->mutex_prio > 0) {
@ -94,9 +93,8 @@ int thread_yield(void)
struct context_entry_t* first = TAILQ_FIRST(&scheduler_fifo); struct context_entry_t* first = TAILQ_FIRST(&scheduler_fifo);
TAILQ_REMOVE(&scheduler_fifo, first, link); TAILQ_REMOVE(&scheduler_fifo, first, link);
if (!IS_FINISHED(running) && !IS_WAITING(running) && !IS_MUTEX_WAITING(running)) { if (!IS_FINISHED(running) && !IS_WAITING(running) && !IS_MUTEX_WAITING(running))
TAILQ_INSERT_TAIL(&scheduler_fifo, running, link); TAILQ_INSERT_TAIL(&scheduler_fifo, running, link);
}
TRACE("PICKING %p (previous was %p)", first, running); TRACE("PICKING %p (previous was %p)", first, running);
// Switch to the new thread. // Switch to the new thread.
@ -129,9 +127,10 @@ int thread_create(thread_t* newthread, void* (*func)(void*), void* funcarg)
DBG("Create a new thread that execute function %p", func); DBG("Create a new thread that execute function %p", func);
struct context_entry_t* new_entry; struct context_entry_t* new_entry;
TRACE("Checking for previous allocated entry"); TRACE("Checking for previous allocated entry");
if (!TAILQ_EMPTY(&context_to_freed)) { if (!TAILQ_EMPTY(&available_threads)) {
new_entry = TAILQ_FIRST(&context_to_freed); TRACE("TAKE THREAD AVAILABLE");
TAILQ_REMOVE(&context_to_freed, new_entry, link); new_entry = TAILQ_FIRST(&available_threads);
TAILQ_REMOVE(&available_threads, new_entry, link);
} else { } else {
TRACE("Allocating new entry"); TRACE("Allocating new entry");
new_entry = malloc(sizeof(*new_entry)); new_entry = malloc(sizeof(*new_entry));
@ -151,7 +150,7 @@ int thread_create(thread_t* newthread, void* (*func)(void*), void* funcarg)
// Use the entry's memory address as an id. // Use the entry's memory address as an id.
TRACE("ALLOCATED %p", new_entry); TRACE("ALLOCATED %p", new_entry);
new_entry->status = ALLOCATED; new_entry->status = 0;
new_entry->retvalue = NULL; new_entry->retvalue = NULL;
ufd__init(&new_entry->waited_threads, new_entry); ufd__init(&new_entry->waited_threads, new_entry);
new_entry->mutex_prio = MUTEX_MAXPRIO; new_entry->mutex_prio = MUTEX_MAXPRIO;
@ -170,7 +169,7 @@ int thread_create(thread_t* newthread, void* (*func)(void*), void* funcarg)
void print_entry(struct context_entry_t* entry) void print_entry(struct context_entry_t* entry)
{ {
TRACE("CONTEXT (%p, %p, %d);", entry, entry, WAS_ALLOCATED(entry)); TRACE("CONTEXT (%p, %p, %d);", entry, entry, IS_MAIN(entry));
} }
int thread_join(thread_t thread, void** retval) int thread_join(thread_t thread, void** retval)
@ -188,32 +187,30 @@ int thread_join(thread_t thread, void** retval)
} }
if (!IS_FINISHED(entry)) { if (!IS_FINISHED(entry)) {
DBG("%p is waiting for %p", running, entry);
// Use status to be in waiting state // Use status to be in waiting state
SET_STATUS(running, WAITING); SET_STATUS(running, WAITING);
// Mark the waited thread as waited to not be waited by any other thread.
SET_STATUS(entry, WAITED); SET_STATUS(entry, WAITED);
// Use retvalue to share which thread is currently waiting for this thread // Use retvalue to share which thread is currently waiting for this thread
entry->retvalue = running; entry->retvalue = running;
ufd__join(&running->waited_threads, &entry->waited_threads); ufd__join(&running->waited_threads, &entry->waited_threads);
struct context_entry_t* running_last_waited = ufd__find(&running->waited_threads)->thread;
DBG("%p is waiting for %p", running, entry);
DBG("MUTEX WAITING %d %p", IS_MUTEX_WAITING(running_last_waited));
#ifdef FIBO_STRAT #ifdef FIBO_STRAT
#else #else
if (!IS_MUTEX_WAITING(running_last_waited)) { // Opti: prioritize the scheduling of the most waited thread
struct context_entry_t* running_last_waited = ufd__find(&running->waited_threads)->thread;
// theorically, this thread can be finished and on the way of being joined
if (!IS_FINISHED(running_last_waited) && !IS_MUTEX_WAITING(running_last_waited)) {
TAILQ_REMOVE(&scheduler_fifo, running_last_waited, link); TAILQ_REMOVE(&scheduler_fifo, running_last_waited, link);
TAILQ_INSERT_HEAD(&scheduler_fifo, running_last_waited, link); TAILQ_INSERT_HEAD(&scheduler_fifo, running_last_waited, link);
} }
#endif #endif
do { do {
thread_yield(); thread_yield();
} while (!IS_FINISHED(entry)); } while (!IS_FINISHED(entry));
ufd__delete(&entry->waited_threads); ufd__delete(&entry->waited_threads);
} }
@ -221,18 +218,12 @@ int thread_join(thread_t thread, void** retval)
TRACE("RETURNING %p IN %p", entry->retvalue, retval); TRACE("RETURNING %p IN %p", entry->retvalue, retval);
if (retval) if (retval)
*retval = entry->retvalue; *retval = entry->retvalue;
UNSET_STATUS(entry, WAITED);
// Exit from waiting state
UNSET_STATUS(running, WAITING);
// Clean up DBG("(entry, was_alloacted) : %p,%d", entry, IS_MAIN(entry));
DBG("(entry, was_alloacted) : %p,%d", entry, WAS_ALLOCATED(entry)); if (!IS_MAIN(entry))
if (WAS_ALLOCATED(entry)) { TAILQ_INSERT_TAIL(&available_threads, entry, link);
DBG("ADDING (%p) TO FREED TAIL", entry);
TAILQ_INSERT_TAIL(&context_to_freed, entry, link);
} else {
free(entry);
}
return 0; return 0;
} }
@ -245,12 +236,13 @@ void thread_exit(void* retval)
if (IS_WAITED(running)) { if (IS_WAITED(running)) {
// If the thread was waited by another thread, we need to wake it up. // If the thread was waited by another thread, we need to wake it up.
struct context_entry_t* waiting = running->retvalue; struct context_entry_t* waiting = running->retvalue;
UNSET_STATUS(running, WAITED); UNSET_STATUS(waiting, WAITING);
TRACE("WAS WAITED BY %p", waiting);
#ifdef FIBO_STRAT #ifdef FIBO_STRAT
TAILQ_INSERT_HEAD(&scheduler_fifo, waiting, link); TAILQ_INSERT_HEAD(&scheduler_fifo, waiting, link);
#else #else
TAILQ_INSERT_TAIL(&scheduler_fifo, waiting, link); TAILQ_INSERT_HEAD(&scheduler_fifo, waiting, link);
#endif #endif
} }
running->retvalue = retval; running->retvalue = retval;
@ -272,7 +264,7 @@ void clear_context(void)
last = TAILQ_FIRST(&scheduler_fifo); last = TAILQ_FIRST(&scheduler_fifo);
TAILQ_REMOVE(&scheduler_fifo, last, link); TAILQ_REMOVE(&scheduler_fifo, last, link);
if (WAS_ALLOCATED(last)) if (!IS_MAIN(last))
VALGRIND_STACK_DEREGISTER(last->valgrind_id); VALGRIND_STACK_DEREGISTER(last->valgrind_id);
if (IS_WAITED(last)) { if (IS_WAITED(last)) {
@ -283,13 +275,14 @@ void clear_context(void)
free(last); free(last);
} }
while (!TAILQ_EMPTY(&context_to_freed)) { while (!TAILQ_EMPTY(&available_threads)) {
last = TAILQ_FIRST(&context_to_freed); last = TAILQ_FIRST(&available_threads);
TAILQ_REMOVE(&context_to_freed, last, link); TAILQ_REMOVE(&available_threads, last, link);
if (WAS_ALLOCATED(last)) if (IS_MAIN(last))
VALGRIND_STACK_DEREGISTER(last->valgrind_id); continue;
VALGRIND_STACK_DEREGISTER(last->valgrind_id);
free(last); free(last);
} }
@ -319,10 +312,10 @@ void __attribute__((constructor)) setup_main_thread()
ufd__init(&new_entry->waited_threads, new_entry); ufd__init(&new_entry->waited_threads, new_entry);
new_entry->retvalue = NULL; new_entry->retvalue = NULL;
new_entry->status = 0; new_entry->status = 0;
TAILQ_INSERT_TAIL(&context_to_freed, new_entry, link); TAILQ_INSERT_TAIL(&available_threads, new_entry, link);
} }
struct context_entry_t* main = malloc(sizeof(*main)); main = malloc(sizeof(*main));
// memset(main, 0, sizeof(*main)); // memset(main, 0, sizeof(*main));
getcontext(&main->context); getcontext(&main->context);
main->status = 0; main->status = 0;
@ -344,11 +337,12 @@ void __attribute__((destructor)) clear_last_thread()
TRACE("POST"); TRACE("POST");
// Running is the initial main thread. No need to switch to a static stack. // Running is the initial main thread. No need to switch to a static stack.
TAILQ_INSERT_HEAD(&scheduler_fifo, running, link); TAILQ_INSERT_HEAD(&scheduler_fifo, running, link);
if (!WAS_ALLOCATED(running)) { if (IS_MAIN(running)) {
clear_context(); clear_context();
exit(0); exit(0);
} }
free(main);
// Running's stack was allocated by us, lets switch to a static stack first. // Running's stack was allocated by us, lets switch to a static stack first.
swapcontext(&running->context, &context_for_freeing); swapcontext(&running->context, &context_for_freeing);
exit(0); exit(0);