Add default memory allocation and free functions for HSIterator and some other tiny...

[c11tester.git] / threads.cc

diff --git a/threads.cc b/threads.cc
index 35929be6e79ced5ec9a1e1add478d22380a9b122..0da9282aa942bd2966bf939d6409636fa99049e5 100644 (file)
--- a/threads.cc
+++ b/threads.cc
@@ -13,6 +13,7 @@
 /* global "model" object */
 #include "model.h"
 #include "execution.h"
+#include "schedule.h"
 
 #ifdef TLS
 #include <dlfcn.h>
@@ -92,9 +93,43 @@ void thread_startup()
        model->switch_to_master(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread));
 }
 
-#ifdef TLS
+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) {
-       static int (*pthread_mutex_init_p) (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) = NULL;
+       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");
@@ -103,12 +138,6 @@ int real_pthread_mutex_init(pthread_mutex_t *__mutex, const pthread_mutexattr_t
                        exit(EXIT_FAILURE);
                }
        }
-       return pthread_mutex_init_p(__mutex, __mutexattr);
-}
-
-int real_pthread_mutex_lock (pthread_mutex_t *__mutex) {
-       static int (*pthread_mutex_lock_p) (pthread_mutex_t *__mutex) = NULL;
-       char * error;
        if (!pthread_mutex_lock_p) {
                pthread_mutex_lock_p = (int (*)(pthread_mutex_t *__mutex))dlsym(RTLD_NEXT, "pthread_mutex_lock");
                if ((error = dlerror()) != NULL) {
@@ -116,12 +145,6 @@ int real_pthread_mutex_lock (pthread_mutex_t *__mutex) {
                        exit(EXIT_FAILURE);
                }
        }
-       return pthread_mutex_lock_p(__mutex);
-}
-
-int real_pthread_mutex_unlock (pthread_mutex_t *__mutex) {
-       static int (*pthread_mutex_unlock_p) (pthread_mutex_t *__mutex) = NULL;
-       char * error;
        if (!pthread_mutex_unlock_p) {
                pthread_mutex_unlock_p = (int (*)(pthread_mutex_t *__mutex))dlsym(RTLD_NEXT, "pthread_mutex_unlock");
                if ((error = dlerror()) != NULL) {
@@ -129,12 +152,6 @@ int real_pthread_mutex_unlock (pthread_mutex_t *__mutex) {
                        exit(EXIT_FAILURE);
                }
        }
-       return pthread_mutex_unlock_p(__mutex);
-}
-
-int real_pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void *(*__start_routine)(void *), void *__restrict __arg) {
-       static int (*pthread_create_p) (pthread_t *__restrict, const pthread_attr_t *__restrict, void *(*)(void *), void * __restrict) = NULL;
-       char * error;
        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) {
@@ -142,12 +159,6 @@ int real_pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t
                        exit(EXIT_FAILURE);
                }
        }
-       return pthread_create_p(__newthread, __attr, __start_routine, __arg);
-}
-
-int real_pthread_join (pthread_t __th, void ** __thread_return) {
-       static int (*pthread_join_p) (pthread_t __th, void ** __thread_return) = NULL;
-       char * error;
        if (!pthread_join_p) {
                pthread_join_p = (int (*)(pthread_t __th, void ** __thread_return))dlsym(RTLD_NEXT, "pthread_join");
                if ((error = dlerror()) != NULL) {
@@ -155,12 +166,19 @@ int real_pthread_join (pthread_t __th, void ** __thread_return) {
                        exit(EXIT_FAILURE);
                }
        }
-       return pthread_join_p(__th, __thread_return);
+
+       if (!pthread_exit_p) {
+               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();
-       model_print("finalize_helper_thread\n");
        real_pthread_mutex_lock(&curr_thread->mutex);
        curr_thread->tls = (char *) get_tls_addr();
        real_pthread_mutex_unlock(&curr_thread->mutex);
@@ -173,7 +191,6 @@ void finalize_helper_thread() {
 
 void * helper_thread(void * ptr) {
        Thread * curr_thread = thread_current();
-       model_print("helper_thread\n");
 
        //build a context for this real thread so we can take it's context
        int ret = getcontext(&curr_thread->helpercontext);
@@ -200,11 +217,12 @@ void * helper_thread(void * ptr) {
 
 void setup_context() {
        Thread * curr_thread = thread_current();
-       model_print("setup_context\n");
 
        /* 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));
 
+       real_init_all();
+
        /* Initialize our lock */
        real_pthread_mutex_init(&curr_thread->mutex, NULL);
        real_pthread_mutex_init(&curr_thread->mutex2, NULL);
@@ -212,7 +230,6 @@ void setup_context() {
 
        /* Create the real thread */
        real_pthread_create(&curr_thread->thread, NULL, helper_thread, NULL);
-       model_print("thread_created\n");
        bool notdone = true;
        while(notdone) {
                real_pthread_mutex_lock(&curr_thread->mutex);
@@ -222,7 +239,6 @@ void setup_context() {
        }
 
        set_tls_addr((uintptr_t)curr_thread->tls);
-       model_print("tls taken\n");
        setcontext(&curr_thread->context);
 }
 #endif
@@ -250,7 +266,7 @@ int Thread::create_context()
        if (model != NULL)
                makecontext(&context, setup_context, 0);
        else
-               makecontext(&context, thread_startup, 0);
+               makecontext(&context, main_thread_startup, 0);
 #else
        makecontext(&context, thread_startup, 0);
 #endif
@@ -304,9 +320,16 @@ void Thread::complete()
        if (stack)
                stack_free(stack);
 #ifdef TLS
-       if (this != model->getInitThread()) {
+       if (this != model->getInitThread() && !model->getParams()->threadsnocleanup) {
+               modellock = 1;
+               ASSERT(thread_current()==NULL);
+               Thread * curr_thread = model->getScheduler()->get_current_thread();
+               //Make any current_thread calls work in code to free
+               model->getScheduler()->set_current_thread(this);
                real_pthread_mutex_unlock(&mutex2);
                real_pthread_join(thread, NULL);
+               model->getScheduler()->set_current_thread(curr_thread);
+               modellock = 0;
        }
 #endif
 }