X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=threads.cc;h=dc2db2d9bfefcab57458035f3f4bc815b75b5fc5;hp=397c7894b70291b10016d1d3774ea74f7c840c73;hb=dfb6b1724a592f7a5376336d653b93d9010833c4;hpb=e1430f3d41e01fca5b878fc5909cf1c871c12f0e diff --git a/threads.cc b/threads.cc index 397c7894..dc2db2d9 100644 --- a/threads.cc +++ b/threads.cc @@ -1,30 +1,61 @@ -#include +/** @file threads.cc + * @brief Thread functions. + */ + +#include -#include "libthreads.h" -#include "schedule.h" +#include #include "common.h" -#include "threads_internal.h" +#include "threads-model.h" /* global "model" object */ #include "model.h" -#define STACK_SIZE (1024 * 1024) - -static void *stack_allocate(size_t size) +/** Allocate a stack for a new thread. */ +static void * stack_allocate(size_t size) { - return malloc(size); + return snapshot_malloc(size); } +/** Free a stack for a terminated thread. */ static void stack_free(void *stack) { - free(stack); + snapshot_free(stack); } -Thread *thread_current(void) +/** Return the currently executing thread. */ +Thread * thread_current(void) { - return model->scheduler->get_current_thread(); + ASSERT(model); + return model->get_current_thread(); } +/** + * 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() +{ + Thread * curr_thread = thread_current(); + + /* 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)); + + /* Call the actual thread function */ + curr_thread->start_routine(curr_thread->arg); + + /* Finish thread properly */ + model->switch_to_master(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread)); +} + +/** + * Create a thread context for a new thread so we can use + * setcontext/getcontext/swapcontext to swap it out. + * @return 0 on success; otherwise, non-zero error condition + */ int Thread::create_context() { int ret; @@ -33,121 +64,119 @@ int Thread::create_context() if (ret) return ret; - /* start_routine == NULL means this is our initial context */ - if (!start_routine) - return 0; - /* Initialize new managed context */ stack = stack_allocate(STACK_SIZE); context.uc_stack.ss_sp = stack; context.uc_stack.ss_size = STACK_SIZE; context.uc_stack.ss_flags = 0; - context.uc_link = &model->system_thread->context; - makecontext(&context, start_routine, 1, arg); + context.uc_link = model->get_system_context(); + makecontext(&context, thread_startup, 0); return 0; } -int Thread::swap(Thread *t) +/** + * Swaps the current context to another thread of execution. This form switches + * from a user Thread to a system context. + * @param t Thread representing the currently-running thread. The current + * context is saved here. + * @param ctxt Context to which we will swap. Must hold a valid system context. + * @return Does not return, unless we return to Thread t's context. See + * swapcontext(3) (returns 0 for success, -1 for failure). + */ +int Thread::swap(Thread *t, ucontext_t *ctxt) { - return swapcontext(&this->context, &t->context); + return swapcontext(&t->context, ctxt); } -void Thread::dispose() +/** + * Swaps the current context to another thread of execution. This form switches + * from a system context to a user Thread. + * @param ctxt System context variable to which to save the current context. + * @param t Thread to which we will swap. Must hold a valid user context. + * @return Does not return, unless we return to the system context (ctxt). See + * swapcontext(3) (returns 0 for success, -1 for failure). + */ +int Thread::swap(ucontext_t *ctxt, Thread *t) { - DEBUG("completed thread %d\n", thread_current()->get_id()); - state = THREAD_COMPLETED; - stack_free(stack); -} - -Thread::Thread(thrd_t *t, void (*func)(), void *a) { - int ret; - - user_thread = t; - start_routine = func; - arg = a; - - /* Initialize state */ - ret = create_context(); - if (ret) - printf("Error in create_context\n"); - - state = THREAD_CREATED; - model->assign_id(this); - model->scheduler->add_thread(this); + return swapcontext(ctxt, &t->context); } -Thread::Thread(thrd_t *t) { - /* system thread */ - user_thread = t; - state = THREAD_CREATED; - model->assign_id(this); - create_context(); - model->add_system_thread(this); -} -thread_id_t Thread::get_id() +/** Terminate a thread and free its stack. */ +void Thread::complete() { - return thrd_to_id(*user_thread); + if (!is_complete()) { + DEBUG("completed thread %d\n", id_to_int(get_id())); + state = THREAD_COMPLETED; + if (stack) + stack_free(stack); + } } -/* - * Return 1 if found next thread, 0 otherwise +/** + * @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 */ -static int thread_system_next(void) +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? */ + wait_list(), + last_action_val(0), + model_thread(true) { - Thread *curr, *next; - - curr = thread_current(); - model->check_current_action(); - if (curr) { - if (curr->get_state() == THREAD_READY) - model->scheduler->add_thread(curr); - else if (curr->get_state() == THREAD_RUNNING) - /* Stopped while running; i.e., completed */ - curr->dispose(); - else - DEBUG("ERROR: current thread in unexpected state??\n"); - } - next = model->scheduler->next_thread(); - if (next) - next->set_state(THREAD_RUNNING); - DEBUG("(%d, %d)\n", curr ? curr->get_id() : -1, next ? next->get_id() : -1); - if (!next) - return 1; - return model->system_thread->swap(next); + memset(&context, 0, sizeof(context)); } -static void thread_wait_finish(void) +/** + * Construct a new thread. + * @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(thrd_t *t, void (*func)(void *), void *a) : + creation(NULL), + pending(NULL), + start_routine(func), + arg(a), + user_thread(t), + state(THREAD_CREATED), + wait_list(), + last_action_val(VALUE_NONE), + model_thread(false) { + int ret; - DBG(); + /* Initialize state */ + ret = create_context(); + if (ret) + printf("Error in create_context\n"); - while (!thread_system_next()); + id = model->get_next_id(); + *user_thread = id; + parent = thread_current(); } -/* - * Main system function - */ -int main() +/** Destructor */ +Thread::~Thread() { - thrd_t user_thread, main_thread; - Thread *th; - - model = new ModelChecker(); - - th = new Thread(&main_thread); - - /* Start user program */ - thrd_create(&user_thread, &user_main, NULL); - - /* Wait for all threads to complete */ - thread_wait_finish(); - - model->print_trace(); - delete th; - delete model; + complete(); + model->remove_thread(this); +} - DEBUG("Exiting\n"); - return 0; +/** @return The thread_id_t corresponding to this Thread object. */ +thread_id_t Thread::get_id() +{ + return id; }