X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=threads.cc;h=e22ffa3221f83ae1f95abb5b7b6c63da04c72183;hp=1a83283a680a8b071709b209db58fc12132756e7;hb=251ac4b4bf3a9f2d3cfacc1e6618200ca1c431ac;hpb=95ee0b6522a582a1a4501c12244d661905ba8a00 diff --git a/threads.cc b/threads.cc index 1a83283a..e22ffa32 100644 --- a/threads.cc +++ b/threads.cc @@ -5,13 +5,35 @@ #include #include -#include +#include "mutex.h" #include "common.h" #include "threads-model.h" #include "action.h" /* global "model" object */ #include "model.h" +#include "execution.h" +#include "schedule.h" +#include "clockvector.h" + +#ifdef TLS +#include +uintptr_t get_tls_addr() { + uintptr_t addr; + asm ("mov %%fs:0, %0" : "=r" (addr)); + return addr; +} + +#include +#include +extern "C" { +int arch_prctl(int code, unsigned long addr); +} +static void set_tls_addr(uintptr_t addr) { + arch_prctl(ARCH_SET_FS, addr); + asm ("mov %0, %%fs:0" : : "r" (addr) : "memory"); +} +#endif /** Allocate a stack for a new thread. */ static void * stack_allocate(size_t size) @@ -38,6 +60,29 @@ Thread * thread_current(void) return model->get_current_thread(); } +/** + * @brief Get the current Thread id + * + * Must be called from a user context + * + * @return The id of the currently executing thread + */ +thread_id_t thread_current_id(void) +{ + ASSERT(model); + return model->get_current_thread_id(); +} + +void modelexit() { + model->switch_thread(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, thread_current())); +} + +void initMainThread() { + atexit(modelexit); + Thread * curr_thread = thread_current(); + model->switch_thread(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread)); +} + /** * Provides a startup wrapper for each thread, allowing some initial * model-checking data to be recorded. This method also gets around makecontext @@ -46,9 +91,10 @@ Thread * thread_current(void) void thread_startup() { Thread * curr_thread = thread_current(); - +#ifndef TLS /* Add dummy "start" action, just to create a first clock vector */ - model->switch_to_master(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread)); + model->switch_thread(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread)); +#endif /* Call the actual thread function */ if (curr_thread->start_routine != NULL) { @@ -58,9 +104,181 @@ void thread_startup() void *retval = curr_thread->pstart_routine(curr_thread->arg); curr_thread->set_pthread_return(retval); } +#ifndef TLS + /* Finish thread properly */ + model->switch_thread(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread)); +#endif +} + +static int (*pthread_mutex_init_p)(pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) = NULL; + +int real_pthread_mutex_init(pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) { + return pthread_mutex_init_p(__mutex, __mutexattr); +} + +static int (*pthread_mutex_lock_p) (pthread_mutex_t *__mutex) = NULL; + +int real_pthread_mutex_lock (pthread_mutex_t *__mutex) { + return pthread_mutex_lock_p(__mutex); +} + +static int (*pthread_mutex_unlock_p) (pthread_mutex_t *__mutex) = NULL; + +int real_pthread_mutex_unlock (pthread_mutex_t *__mutex) { + return pthread_mutex_unlock_p(__mutex); +} + +static int (*pthread_create_p) (pthread_t *__restrict, const pthread_attr_t *__restrict, void *(*)(void *), void * __restrict) = NULL; + +int real_pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void *(*__start_routine)(void *), void *__restrict __arg) { + return pthread_create_p(__newthread, __attr, __start_routine, __arg); +} + +static int (*pthread_join_p) (pthread_t __th, void ** __thread_return) = NULL; + +int real_pthread_join (pthread_t __th, void ** __thread_return) { + return pthread_join_p(__th, __thread_return); +} + +static void (*pthread_exit_p)(void *) __attribute__((noreturn))= NULL; + +void real_pthread_exit (void * value_ptr) { + pthread_exit_p(value_ptr); +} + +void real_init_all() { + char * error; + if (!pthread_mutex_init_p) { + pthread_mutex_init_p = (int (*)(pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr))dlsym(RTLD_NEXT, "pthread_mutex_init"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + if (!pthread_mutex_lock_p) { + pthread_mutex_lock_p = (int (*)(pthread_mutex_t *__mutex))dlsym(RTLD_NEXT, "pthread_mutex_lock"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + if (!pthread_mutex_unlock_p) { + pthread_mutex_unlock_p = (int (*)(pthread_mutex_t *__mutex))dlsym(RTLD_NEXT, "pthread_mutex_unlock"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + if (!pthread_create_p) { + pthread_create_p = (int (*)(pthread_t *__restrict, const pthread_attr_t *__restrict, void *(*)(void *), void *__restrict))dlsym(RTLD_NEXT, "pthread_create"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + if (!pthread_join_p) { + pthread_join_p = (int (*)(pthread_t __th, void ** __thread_return))dlsym(RTLD_NEXT, "pthread_join"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + + if (!pthread_exit_p) { + *((void (**)(void *)) &pthread_exit_p) = (void (*)(void *))dlsym(RTLD_NEXT, "pthread_exit"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } +} + +#ifdef TLS +void finalize_helper_thread() { + Thread * curr_thread = thread_current(); + real_pthread_mutex_lock(&curr_thread->mutex); + curr_thread->tls = (char *) get_tls_addr(); + real_pthread_mutex_unlock(&curr_thread->mutex); + //Wait in the kernel until it is time for us to finish + real_pthread_mutex_lock(&curr_thread->mutex2); + real_pthread_mutex_unlock(&curr_thread->mutex2); + //return to helper thread function + setcontext(&curr_thread->context); +} + +void * helper_thread(void * ptr) { + Thread * curr_thread = thread_current(); + + //build a context for this real thread so we can take it's context + int ret = getcontext(&curr_thread->helpercontext); + ASSERT(!ret); + + //Setup destructor + if (pthread_setspecific(model->get_execution()->getPthreadKey(), (const void *)4)) { + printf("Destructor setup failed\n"); + exit(-1); + } + + + /* Initialize new managed context */ + curr_thread->helper_stack = stack_allocate(STACK_SIZE); + curr_thread->helpercontext.uc_stack.ss_sp = curr_thread->helper_stack; + curr_thread->helpercontext.uc_stack.ss_size = STACK_SIZE; + curr_thread->helpercontext.uc_stack.ss_flags = 0; + curr_thread->helpercontext.uc_link = NULL; + makecontext(&curr_thread->helpercontext, finalize_helper_thread, 0); + + model_swapcontext(&curr_thread->context, &curr_thread->helpercontext); + + + //start the real thread + thread_startup(); + + return NULL; +} + +#ifdef TLS +void tlsdestructor(void *v) { + uintptr_t count = (uintptr_t) v; + if (count > 1) { + if (pthread_setspecific(model->get_execution()->getPthreadKey(), (const void *)(count - 1))) { + printf("Destructor setup failed\n"); + exit(-1); + } + return; + } /* Finish thread properly */ - model->switch_to_master(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread)); + model->switch_thread(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, thread_current())); } +#endif + +void setup_context() { + Thread * curr_thread = thread_current(); + + /* Add dummy "start" action, just to create a first clock vector */ + model->switch_thread(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread)); + + real_init_all(); + + /* Initialize our lock */ + real_pthread_mutex_init(&curr_thread->mutex, NULL); + real_pthread_mutex_init(&curr_thread->mutex2, NULL); + real_pthread_mutex_lock(&curr_thread->mutex2); + + /* Create the real thread */ + real_pthread_create(&curr_thread->thread, NULL, helper_thread, NULL); + bool notdone = true; + while(notdone) { + real_pthread_mutex_lock(&curr_thread->mutex); + if (curr_thread->tls != NULL) + notdone = false; + real_pthread_mutex_unlock(&curr_thread->mutex); + } + + set_tls_addr((uintptr_t)curr_thread->tls); + setcontext(&curr_thread->context); +} +#endif /** * Create a thread context for a new thread so we can use @@ -80,8 +298,12 @@ int Thread::create_context() context.uc_stack.ss_sp = stack; context.uc_stack.ss_size = STACK_SIZE; context.uc_stack.ss_flags = 0; - context.uc_link = model->get_system_context(); + context.uc_link = NULL; +#ifdef TLS + makecontext(&context, setup_context, 0); +#else makecontext(&context, thread_startup, 0); +#endif return 0; } @@ -98,6 +320,9 @@ int Thread::create_context() int Thread::swap(Thread *t, ucontext_t *ctxt) { t->set_state(THREAD_READY); +#ifdef TLS + set_tls_addr((uintptr_t)model->getInitThread()->tls); +#endif return model_swapcontext(&t->context, ctxt); } @@ -112,18 +337,45 @@ int Thread::swap(Thread *t, ucontext_t *ctxt) int Thread::swap(ucontext_t *ctxt, Thread *t) { t->set_state(THREAD_RUNNING); +#ifdef TLS + if (t->tls != NULL) + set_tls_addr((uintptr_t)t->tls); +#endif return model_swapcontext(ctxt, &t->context); } +int Thread::swap(Thread *t, Thread *t2) +{ + t2->set_state(THREAD_RUNNING); + if (t == t2) + return 0; + +#ifdef TLS + if (t2->tls != NULL) + set_tls_addr((uintptr_t)t2->tls); +#endif + return model_swapcontext(&t->context, &t2->context); +} -/** Terminate a thread and free its stack. */ +/** Terminate a thread. */ void Thread::complete() { ASSERT(!is_complete()); DEBUG("completed thread %d\n", id_to_int(get_id())); state = THREAD_COMPLETED; +} + +void Thread::freeResources() { if (stack) stack_free(stack); +#ifdef TLS + if (this != model->getInitThread()) { + real_pthread_mutex_unlock(&mutex2); + real_pthread_join(thread, NULL); + stack_free(helper_stack); + } +#endif + state = THREAD_FREED; } /** @@ -136,14 +388,19 @@ void Thread::complete() */ Thread::Thread(thread_id_t tid) : parent(NULL), + acq_fence_cv(new ClockVector()), creation(NULL), pending(NULL), + wakeup_state(false), start_routine(NULL), arg(NULL), stack(NULL), +#ifdef TLS + tls(NULL), +#endif user_thread(NULL), id(tid), - state(THREAD_READY), /* Thread is always ready? */ + state(THREAD_READY), /* Thread is always ready? */ last_action_val(0), model_thread(true) { @@ -158,11 +415,16 @@ Thread::Thread(thread_id_t tid) : */ Thread::Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread *parent) : parent(parent), + acq_fence_cv(new ClockVector()), creation(NULL), pending(NULL), + wakeup_state(false), start_routine(func), pstart_routine(NULL), arg(a), +#ifdef TLS + tls(NULL), +#endif user_thread(t), id(tid), state(THREAD_CREATED), @@ -176,7 +438,7 @@ Thread::Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread if (ret) model_print("Error in create_context\n"); - user_thread->priv = this; // WL + user_thread->priv = this; // WL } /** @@ -187,11 +449,16 @@ Thread::Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread */ Thread::Thread(thread_id_t tid, thrd_t *t, void *(*func)(void *), void *a, Thread *parent) : parent(parent), + acq_fence_cv(new ClockVector()), creation(NULL), pending(NULL), + wakeup_state(false), start_routine(NULL), pstart_routine(func), arg(a), +#ifdef TLS + tls(NULL), +#endif user_thread(t), id(tid), state(THREAD_CREATED), @@ -212,6 +479,8 @@ Thread::~Thread() { if (!is_complete()) complete(); + + delete acq_fence_cv; } /** @return The thread_id_t corresponding to this Thread object. */ @@ -239,13 +508,15 @@ Thread * Thread::waiting_on() const if (!pending) return NULL; - if (pending->get_type() == THREAD_JOIN) - return pending->get_thread_operand(); - else if (pending->get_type() == PTHREAD_JOIN) - return pending->get_thread_operand(); - else if (pending->is_lock()) - return (Thread *)pending->get_mutex()->get_state()->locked; - return NULL; + switch (pending->get_type()) { + case THREAD_JOIN: + case PTHREAD_JOIN: + return pending->get_thread_operand(); + case ATOMIC_LOCK: + return (Thread *)pending->get_mutex()->get_state()->locked; + default: + return NULL; + } } /** @@ -258,7 +529,15 @@ Thread * Thread::waiting_on() const bool Thread::is_waiting_on(const Thread *t) const { Thread *wait; - for (wait = waiting_on(); wait != NULL; wait = wait->waiting_on()) + + // One thread relocks a recursive mutex + if (waiting_on() == t && pending->is_lock()) { + int mutex_type = pending->get_mutex()->get_state()->type; + if (mutex_type == PTHREAD_MUTEX_RECURSIVE) + return false; + } + + for (wait = waiting_on();wait != NULL;wait = wait->waiting_on()) if (wait == t) return true; return false;