From 93ad044bb1d9a346ebaae6a7b1fbbc5bc044d49b Mon Sep 17 00:00:00 2001 From: damien DELPY Date: Fri, 21 Mar 2025 15:19:28 +0100 Subject: [PATCH] fix(clang): format thread files. --- src/thread/thread.c | 273 +++++++++++++++++++++++--------------------- src/thread/thread.h | 30 ++--- 2 files changed, 158 insertions(+), 145 deletions(-) diff --git a/src/thread/thread.c b/src/thread/thread.c index 4c9f740..c1d25b6 100644 --- a/src/thread/thread.c +++ b/src/thread/thread.c @@ -1,176 +1,187 @@ #include #ifndef USE_PTHREAD -#include "thread.h" #include "debug.h" #include "pthread.h" -#include +#include "thread.h" #include #include +#include #include #include -#define FINISHED 0x1 +#define FINISHED 0x1 #define ALLOCATED 0x2 -#define WAITING 0x4 +#define WAITING 0x4 #ifndef STACK_SIZE #define STACK_SIZE 4096 #endif struct context_entry { - TAILQ_ENTRY(context_entry) link; - ucontext_t context; - thread_t id; - void *retvalue; - int valgrind_id; - char status; + TAILQ_ENTRY(context_entry) + link; + ucontext_t context; + thread_t id; + void* retvalue; + int valgrind_id; + char status; }; static TAILQ_HEAD(context_head, context_entry) head = TAILQ_HEAD_INITIALIZER(head); -static struct context_entry *running = 0; +static struct context_entry* running = 0; static unsigned long long counter = 0; -int thread_yield(void) { - TRACE("thread_yield"); - if (counter <= 1) { +int thread_yield(void) +{ + TRACE("thread_yield"); + if (counter <= 1) { + return 0; + } + struct context_entry* first = NULL; + int count = 0; + do { + if (count++ == counter) { + return 0; + } + first = TAILQ_FIRST(&head); + if (!first) { + return -1; + } + TAILQ_REMOVE(&head, first, link); + TAILQ_INSERT_TAIL(&head, first, link); + if (first->id == running->id) { + return 0; + } + } while ((first->status & FINISHED) || ((first->status & WAITING) && !(((struct context_entry*)first->retvalue)->status & FINISHED))); + TRACE("PICKING %p", first); + struct context_entry* old_runner = running; + running = first; + swapcontext(&old_runner->context, &running->context); return 0; - } - struct context_entry *first = NULL; - int count = 0; - do { - if (count++ == counter) { - return 0; - } - first = TAILQ_FIRST(&head); - if (!first) { - return -1; - } - TAILQ_REMOVE(&head, first, link); - TAILQ_INSERT_TAIL(&head, first, link); - if (first->id == running->id) { - return 0; - } - } while ((first->status & FINISHED) || - ((first->status & WAITING) && !(((struct context_entry *)first->retvalue)->status & FINISHED))); - TRACE("PICKING %p", first); - struct context_entry *old_runner = running; - running = first; - swapcontext(&old_runner->context, &running->context); - return 0; } -thread_t thread_self(void) { - if (running == NULL) { - return 0; - } - return running->id; +thread_t thread_self(void) +{ + if (running == NULL) { + return 0; + } + return running->id; } -void thread_function_wrapper(void *(*func)(void *), void *funcarg) { - TRACE("Wrapper for %p\n", func); - thread_exit(func(funcarg)); +void thread_function_wrapper(void* (*func)(void*), void* funcarg) +{ + TRACE("Wrapper for %p\n", func); + thread_exit(func(funcarg)); } -int thread_create(thread_t *newthread, void *(*func)(void *), void *funcarg) { - TRACE("Create a new thread that execute function %p", func); - struct context_entry *new_entry = malloc(sizeof(*new_entry)); - if (counter == 0) { +int thread_create(thread_t* newthread, void* (*func)(void*), void* funcarg) +{ + TRACE("Create a new thread that execute function %p", func); + struct context_entry* new_entry = malloc(sizeof(*new_entry)); + if (counter == 0) { + memset(new_entry, 0, sizeof(*new_entry)); + getcontext(&new_entry->context); + new_entry->id = 0; + new_entry->status = 0; + new_entry->retvalue = 0; + TAILQ_INSERT_HEAD(&head, new_entry, link); + running = new_entry; + counter++; + new_entry = malloc(sizeof(*new_entry)); + } memset(new_entry, 0, sizeof(*new_entry)); getcontext(&new_entry->context); - new_entry->id = 0; - new_entry->status = 0; + new_entry->context.uc_stack.ss_sp = malloc(STACK_SIZE); + new_entry->context.uc_stack.ss_size = STACK_SIZE; + new_entry->valgrind_id = VALGRIND_STACK_REGISTER( + new_entry->context.uc_stack.ss_sp, + new_entry->context.uc_stack.ss_sp + new_entry->context.uc_stack.ss_size); + new_entry->id = new_entry; + new_entry->status = ALLOCATED; new_entry->retvalue = 0; - TAILQ_INSERT_HEAD(&head, new_entry, link); - running = new_entry; + *newthread = new_entry; + makecontext(&new_entry->context, (void (*)(void))thread_function_wrapper, 2, func, funcarg); counter++; - new_entry = malloc(sizeof(*new_entry)); - } - memset(new_entry, 0, sizeof(*new_entry)); - getcontext(&new_entry->context); - new_entry->context.uc_stack.ss_sp = malloc(STACK_SIZE); - new_entry->context.uc_stack.ss_size = STACK_SIZE; - new_entry->valgrind_id = VALGRIND_STACK_REGISTER( - new_entry->context.uc_stack.ss_sp, - new_entry->context.uc_stack.ss_sp + new_entry->context.uc_stack.ss_size - ); - new_entry->id = new_entry; - new_entry->status = ALLOCATED; - new_entry->retvalue = 0; - *newthread = new_entry; - makecontext(&new_entry->context, (void (*)(void)) thread_function_wrapper, 2, func, funcarg); - counter++; - TAILQ_INSERT_HEAD(&head, new_entry, link); - return 0; -} - -void print_entry(struct context_entry *entry) { - TRACE("CONTEXT (%p, %p, %d);", entry, entry->id, (entry->status & FINISHED) > 0); -} - -int thread_join(thread_t thread, void **retval) { - TRACE("Join thread %p", thread); - struct context_entry *entry; - TAILQ_FOREACH(entry, &head, link) { - if (entry->id != thread) { - continue; - } - TRACE("FIND %d",entry->status); - running->status |= WAITING; - running->retvalue = entry; - while (!(entry->status & FINISHED)) { - TRACE("NOT FINISHED"); - thread_yield(); - } - running->status &= ~WAITING; - TRACE("AFTER"); - if (retval) - *retval = entry->retvalue; - TAILQ_REMOVE(&head, entry, link); - if (entry->status & ALLOCATED) { - TRACE("FREE\n"); - VALGRIND_STACK_DEREGISTER(entry->valgrind_id); - free(entry->context.uc_stack.ss_sp); - } else { - TRACE("NOT ALLOCATED\n"); - } - free(entry); - if (--counter == 1) { - TAILQ_REMOVE(&head, running, link); - if (running->status & ALLOCATED) { - VALGRIND_STACK_DEREGISTER(running->valgrind_id); - free(running->context.uc_stack.ss_sp); - } - free(running); - running = 0; - counter = 0; - } + TAILQ_INSERT_HEAD(&head, new_entry, link); return 0; - } - return -1; } -void thread_exit(void *retval) { - TRACE("Exit thread %p", running); - if (running == 0) +void print_entry(struct context_entry* entry) +{ + TRACE("CONTEXT (%p, %p, %d);", entry, entry->id, (entry->status & FINISHED) > 0); +} + +int thread_join(thread_t thread, void** retval) +{ + TRACE("Join thread %p", thread); + struct context_entry* entry; + TAILQ_FOREACH(entry, &head, link) + { + if (entry->id != thread) { + continue; + } + TRACE("FIND %d", entry->status); + running->status |= WAITING; + running->retvalue = entry; + while (!(entry->status & FINISHED)) { + TRACE("NOT FINISHED"); + thread_yield(); + } + running->status &= ~WAITING; + TRACE("AFTER"); + if (retval) + *retval = entry->retvalue; + TAILQ_REMOVE(&head, entry, link); + if (entry->status & ALLOCATED) { + TRACE("FREE\n"); + VALGRIND_STACK_DEREGISTER(entry->valgrind_id); + free(entry->context.uc_stack.ss_sp); + } else { + TRACE("NOT ALLOCATED\n"); + } + free(entry); + if (--counter == 1) { + TAILQ_REMOVE(&head, running, link); + if (running->status & ALLOCATED) { + VALGRIND_STACK_DEREGISTER(running->valgrind_id); + free(running->context.uc_stack.ss_sp); + } + free(running); + running = 0; + counter = 0; + } + return 0; + } + return -1; +} + +void thread_exit(void* retval) +{ + TRACE("Exit thread %p", running); + if (running == 0) + exit(0); + running->status |= FINISHED; + running->retvalue = retval; + thread_yield(); exit(0); - running->status |= FINISHED; - running->retvalue = retval; - thread_yield(); - exit(0); } -int thread_mutex_init(thread_mutex_t *mutex) { - return pthread_mutex_init((pthread_mutex_t *) mutex, NULL); +int thread_mutex_init(thread_mutex_t* mutex) +{ + return pthread_mutex_init((pthread_mutex_t*)mutex, NULL); } -int thread_mutex_destroy(thread_mutex_t *mutex) { - return pthread_mutex_destroy((pthread_mutex_t *) mutex); +int thread_mutex_destroy(thread_mutex_t* mutex) +{ + return pthread_mutex_destroy((pthread_mutex_t*)mutex); } -int thread_mutex_lock(thread_mutex_t *mutex) { - return pthread_mutex_lock((pthread_mutex_t * )mutex); +int thread_mutex_lock(thread_mutex_t* mutex) +{ + return pthread_mutex_lock((pthread_mutex_t*)mutex); } -int thread_mutex_unlock(thread_mutex_t *mutex) { - return pthread_mutex_unlock((pthread_mutex_t *)mutex); +int thread_mutex_unlock(thread_mutex_t* mutex) +{ + return pthread_mutex_unlock((pthread_mutex_t*)mutex); } #endif diff --git a/src/thread/thread.h b/src/thread/thread.h index 820c7d0..65ead23 100644 --- a/src/thread/thread.h +++ b/src/thread/thread.h @@ -8,7 +8,7 @@ * mais attention aux inconvénient des tableaux de threads * (consommation mémoire, cout d'allocation, ...). */ -typedef void * thread_t; +typedef void* thread_t; /* recuperer l'identifiant du thread courant. */ @@ -17,7 +17,7 @@ extern thread_t thread_self(void); /* creer un nouveau thread qui va exécuter la fonction func avec l'argument funcarg. * renvoie 0 en cas de succès, -1 en cas d'erreur. */ -extern int thread_create(thread_t *newthread, void *(*func)(void *), void *funcarg); +extern int thread_create(thread_t* newthread, void* (*func)(void*), void* funcarg); /* passer la main à un autre thread. */ @@ -27,7 +27,7 @@ extern int thread_yield(void); * la valeur renvoyée par le thread est placée dans *retval. * si retval est NULL, la valeur de retour est ignorée. */ -extern int thread_join(thread_t thread, void **retval); +extern int thread_join(thread_t thread, void** retval); /* terminer le thread courant en renvoyant la valeur de retour retval. * cette fonction ne retourne jamais. @@ -37,20 +37,22 @@ extern int thread_join(thread_t thread, void **retval); * cet attribut dans votre interface tant que votre thread_exit() * n'est pas correctement implémenté (il ne doit jamais retourner). */ -extern void thread_exit(void *retval) __attribute__ ((__noreturn__)); +extern void thread_exit(void* retval) __attribute__((__noreturn__)); /* Interface possible pour les mutex */ -typedef struct thread_mutex { int dummy; } thread_mutex_t; -int thread_mutex_init(thread_mutex_t *mutex); -int thread_mutex_destroy(thread_mutex_t *mutex); -int thread_mutex_lock(thread_mutex_t *mutex); -int thread_mutex_unlock(thread_mutex_t *mutex); +typedef struct thread_mutex { + int dummy; +} thread_mutex_t; +int thread_mutex_init(thread_mutex_t* mutex); +int thread_mutex_destroy(thread_mutex_t* mutex); +int thread_mutex_lock(thread_mutex_t* mutex); +int thread_mutex_unlock(thread_mutex_t* mutex); #else /* USE_PTHREAD */ /* Si on compile avec -DUSE_PTHREAD, ce sont les pthreads qui sont utilisés */ -#include #include +#include #define thread_t pthread_t #define thread_self pthread_self #define thread_create(th, func, arg) pthread_create(th, NULL, func, arg) @@ -59,11 +61,11 @@ int thread_mutex_unlock(thread_mutex_t *mutex); #define thread_exit pthread_exit /* Interface possible pour les mutex */ -#define thread_mutex_t pthread_mutex_t +#define thread_mutex_t pthread_mutex_t #define thread_mutex_init(_mutex) pthread_mutex_init(_mutex, NULL) -#define thread_mutex_destroy pthread_mutex_destroy -#define thread_mutex_lock pthread_mutex_lock -#define thread_mutex_unlock pthread_mutex_unlock +#define thread_mutex_destroy pthread_mutex_destroy +#define thread_mutex_lock pthread_mutex_lock +#define thread_mutex_unlock pthread_mutex_unlock #endif /* USE_PTHREAD */