X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=threads.cc;h=67f681ca7052538afb794ff87bb9708ff3655daa;hp=39f049541d69184cc012bcd042f2400208863a3a;hb=fa4c0d65d9c72d08d28e604a3eaa2fd82a9c6b20;hpb=15190694fd79202132be5f6e056fa5c00893664e diff --git a/threads.cc b/threads.cc index 39f04954..67f681ca 100644 --- a/threads.cc +++ b/threads.cc @@ -2,9 +2,13 @@ * @brief Thread functions. */ -#include "libthreads.h" +#include + +#include +#include "mutex.h" #include "common.h" -#include "threads.h" +#include "threads-model.h" +#include "action.h" /* global "model" object */ #include "model.h" @@ -12,16 +16,22 @@ /** Allocate a stack for a new thread. */ static void * stack_allocate(size_t size) { - return malloc(size); + return Thread_malloc(size); } /** Free a stack for a terminated thread. */ static void stack_free(void *stack) { - free(stack); + Thread_free(stack); } -/** Return the currently executing thread. */ +/** + * @brief Get the current Thread + * + * Must be called from a user context + * + * @return The currently executing thread + */ Thread * thread_current(void) { ASSERT(model); @@ -32,8 +42,6 @@ Thread * thread_current(void) * Provides a startup wrapper for each thread, allowing some initial * model-checking data to be recorded. This method also gets around makecontext * not being 64-bit clean - * @todo We should make the START event always immediately follow the - * CREATE event, so we don't get redundant traces... */ void thread_startup() { @@ -43,8 +51,13 @@ void thread_startup() model->switch_to_master(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread)); /* Call the actual thread function */ - curr_thread->start_routine(curr_thread->arg); - + if (curr_thread->start_routine != NULL) { + curr_thread->start_routine(curr_thread->arg); + } else if (curr_thread->pstart_routine != NULL) { + // set pthread return value + void *retval = curr_thread->pstart_routine(curr_thread->arg); + curr_thread->set_pthread_return(retval); + } /* Finish thread properly */ model->switch_to_master(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread)); } @@ -84,7 +97,8 @@ int Thread::create_context() */ int Thread::swap(Thread *t, ucontext_t *ctxt) { - return swapcontext(&t->context, ctxt); + t->set_state(THREAD_READY); + return model_swapcontext(&t->context, ctxt); } /** @@ -97,19 +111,43 @@ int Thread::swap(Thread *t, ucontext_t *ctxt) */ int Thread::swap(ucontext_t *ctxt, Thread *t) { - return swapcontext(ctxt, &t->context); + t->set_state(THREAD_RUNNING); + return model_swapcontext(ctxt, &t->context); } /** Terminate a thread and free its stack. */ void Thread::complete() { - if (!is_complete()) { - DEBUG("completed thread %d\n", get_id()); - state = THREAD_COMPLETED; - if (stack) - stack_free(stack); - } + ASSERT(!is_complete()); + DEBUG("completed thread %d\n", id_to_int(get_id())); + state = THREAD_COMPLETED; + if (stack) + stack_free(stack); +} + +/** + * @brief Construct a new model-checker Thread + * + * A model-checker Thread is used for accounting purposes only. It will never + * have its own stack, and it should never be inserted into the Scheduler. + * + * @param tid The thread ID to assign + */ +Thread::Thread(thread_id_t tid) : + parent(NULL), + creation(NULL), + pending(NULL), + start_routine(NULL), + arg(NULL), + stack(NULL), + user_thread(NULL), + id(tid), + state(THREAD_READY), /* Thread is always ready? */ + last_action_val(0), + model_thread(true) +{ + memset(&context, 0, sizeof(context)); } /** @@ -118,36 +156,110 @@ void Thread::complete() * @param func The function that the thread will call. * @param a The parameter to pass to this function. */ -Thread::Thread(thrd_t *t, void (*func)(void *), void *a) : +Thread::Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread *parent) : + parent(parent), + creation(NULL), pending(NULL), start_routine(func), + pstart_routine(NULL), arg(a), user_thread(t), + id(tid), state(THREAD_CREATED), - wait_list(), - last_action_val(VALUE_NONE) + last_action_val(VALUE_NONE), + model_thread(false) { int ret; /* Initialize state */ ret = create_context(); if (ret) - printf("Error in create_context\n"); + model_print("Error in create_context\n"); + + user_thread->priv = this; // WL +} + +/** + * Construct a new thread for pthread. + * @param t The thread identifier of the newly created thread. + * @param func The function that the thread will call. + * @param a The parameter to pass to this function. + */ +Thread::Thread(thread_id_t tid, thrd_t *t, void *(*func)(void *), void *a, Thread *parent) : + parent(parent), + creation(NULL), + pending(NULL), + start_routine(NULL), + pstart_routine(func), + arg(a), + user_thread(t), + id(tid), + state(THREAD_CREATED), + last_action_val(VALUE_NONE), + model_thread(false) +{ + int ret; - id = model->get_next_id(); - *user_thread = id; - parent = thread_current(); + /* Initialize state */ + ret = create_context(); + if (ret) + model_print("Error in create_context\n"); } + /** Destructor */ Thread::~Thread() { - complete(); - model->remove_thread(this); + if (!is_complete()) + complete(); } /** @return The thread_id_t corresponding to this Thread object. */ -thread_id_t Thread::get_id() +thread_id_t Thread::get_id() const { return id; } + +/** + * Set a thread's THREAD_* state (@see thread_state) + * @param s The state to enter + */ +void Thread::set_state(thread_state s) +{ + ASSERT(s == THREAD_COMPLETED || state != THREAD_COMPLETED); + state = s; +} + +/** + * Get the Thread that this Thread is immediately waiting on + * @return The thread we are waiting on, if any; otherwise NULL + */ +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; +} + +/** + * Check if this Thread is waiting (blocking) on a given Thread, directly or + * indirectly (via a chain of waiting threads) + * + * @param t The Thread on which we may be waiting + * @return True if we are waiting on Thread t; false otherwise + */ +bool Thread::is_waiting_on(const Thread *t) const +{ + Thread *wait; + for (wait = waiting_on();wait != NULL;wait = wait->waiting_on()) + if (wait == t) + return true; + return false; +}