X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=threads-model.h;h=15dd151577e908027f002565cf2855e95c85d787;hp=30acd2deba1f50e27a15d1c2d74a649809cf004a;hb=25d73096cfc14c655f94b01bb235cc5efd1d5696;hpb=dc9c89654982c64264dfee7b1ea23e9a5e88e18e diff --git a/threads-model.h b/threads-model.h index 30acd2de..15dd1515 100644 --- a/threads-model.h +++ b/threads-model.h @@ -5,13 +5,14 @@ #ifndef __THREADS_MODEL_H__ #define __THREADS_MODEL_H__ -#include #include -#include - #include "mymemory.h" -#include +#include "threads.h" #include "modeltypes.h" +#include "stl-model.h" +#include "context.h" +#include "classlist.h" +#include "pthread.h" struct thread_params { thrd_start_t func; @@ -32,21 +33,25 @@ typedef enum thread_state { */ THREAD_BLOCKED, /** Thread has completed its execution */ - THREAD_COMPLETED + THREAD_COMPLETED, + THREAD_FREED } thread_state; -class ModelAction; /** @brief A Thread is created for each user-space thread */ class Thread { public: Thread(thread_id_t tid); - Thread(thrd_t *t, void (*func)(void *), void *a, Thread * parent_thrd = NULL); + Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread *parent); + Thread(thread_id_t tid, thrd_t *t, void *(*func)(void *), void *a, Thread *parent); + ~Thread(); void complete(); + void freeResources(); static int swap(ucontext_t *ctxt, Thread *t); static int swap(Thread *t, ucontext_t *ctxt); + static int swap(Thread *t, Thread *t2); thread_state get_state() const { return state; } void set_state(thread_state s); @@ -72,29 +77,19 @@ public: */ uint64_t get_return_value() const { return last_action_val; } + /** @set and get the return value from pthread functions */ + void set_pthread_return(void *ret) { pthread_return = ret; } + void * get_pthread_return() { return pthread_return; } + /** @return True if this thread is finished executing */ - bool is_complete() const { return state == THREAD_COMPLETED; } + bool is_complete() const { return state == THREAD_COMPLETED || state == THREAD_FREED; } + + /** @return True if this thread has finished and its resources have been freed */ + bool is_freed() const { return state == THREAD_FREED; } /** @return True if this thread is blocked */ bool is_blocked() const { return state == THREAD_BLOCKED; } - /** @return True if no threads are waiting on this Thread */ - bool wait_list_empty() const { return wait_list.empty(); } - - /** - * Add a ModelAction to the waiting list for this thread. - * @param t The ModelAction to add. Must be a JOIN. - */ - void push_wait_list(ModelAction *act) { wait_list.push_back(act); } - - unsigned int num_wait_list() const { - return wait_list.size(); - } - - ModelAction * get_waiter(unsigned int i) const { - return wait_list[i]; - } - /** @return The pending (next) ModelAction for this Thread * @see Thread::pending */ ModelAction * get_pending() const { return pending; } @@ -104,19 +99,23 @@ public: * @see Thread::pending */ void set_pending(ModelAction *act) { pending = act; } - /** - * Remove one ModelAction from the waiting list - * @return The ModelAction that was removed from the waiting list - */ - ModelAction * pop_wait_list() { - ModelAction *ret = wait_list.front(); - wait_list.pop_back(); - return ret; - } + bool just_woken_up() { return wakeup_state; } + void set_wakeup_state(bool state) { wakeup_state = state; } + + Thread * waiting_on() const; + bool is_waiting_on(const Thread *t) const; bool is_model_thread() const { return model_thread; } + void * get_stack_addr() { return stack; } + ClockVector * get_acq_fence_cv() { return acq_fence_cv; } + friend void thread_startup(); +#ifdef TLS + friend void setup_context(); + friend void * helper_thread(void *); + friend void finalize_helper_thread(); +#endif /** * Intentionally NOT allocated with MODELALLOC or SNAPSHOTALLOC. @@ -124,11 +123,29 @@ public: * to allow their allocation/deallocation to follow the same pattern as * the rest of the backtracked/replayed program. */ + void * operator new(size_t size) { + return Thread_malloc(size); + } + void operator delete(void *p, size_t size) { + Thread_free(p); + } + void * operator new[](size_t size) { + return Thread_malloc(size); + } + void operator delete[](void *p, size_t size) { + Thread_free(p); + } +#ifdef TLS + void setTLS(char *_tls) { tls = _tls;} +#endif private: int create_context(); /** @brief The parent Thread which created this Thread */ - Thread *parent; + Thread * const parent; + + /** @brief Acquire fence cv */ + ClockVector *acq_fence_cv; /** @brief The THREAD_CREATE ModelAction which created this Thread */ ModelAction *creation; @@ -142,21 +159,30 @@ private: */ ModelAction *pending; + /** @brief True if this thread was just woken up */ + bool wakeup_state; + void (*start_routine)(void *); + void *(*pstart_routine)(void *); + void *arg; ucontext_t context; void *stack; + uint32_t stack_size; +#ifdef TLS + void * helper_stack; +public: + char *tls; + ucontext_t helpercontext; + pthread_mutex_t mutex; + pthread_mutex_t mutex2; + pthread_t thread; +private: +#endif thrd_t *user_thread; thread_id_t id; thread_state state; - /** - * A list of ModelActions waiting on this Thread. Particularly, this - * list is used for thread joins, where another Thread waits for this - * Thread to complete - */ - std::vector< ModelAction *, SnapshotAlloc > wait_list; - /** * The value returned by the last action in this thread * @see Thread::set_return_value() @@ -164,11 +190,22 @@ private: */ uint64_t last_action_val; + /** the value return from pthread functions */ + void * pthread_return; + /** @brief Is this Thread a special model-checker thread? */ const bool model_thread; }; +#ifdef TLS +uintptr_t get_tls_addr(); +void tlsdestructor(void *v); +#endif + Thread * thread_current(); +thread_id_t thread_current_id(); +void thread_startup(); +void initMainThread(); static inline thread_id_t thrd_to_id(thrd_t t) { @@ -195,4 +232,12 @@ static inline int id_to_int(thread_id_t id) return id; } -#endif /* __THREADS_MODEL_H__ */ +int real_pthread_mutex_init(pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr); +int real_pthread_mutex_lock (pthread_mutex_t *__mutex); +int real_pthread_mutex_unlock (pthread_mutex_t *__mutex); +int real_pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void *(*__start_routine)(void *), void *__restrict __arg); +int real_pthread_join (pthread_t __th, void ** __thread_return); +void real_pthread_exit (void * value_ptr) __attribute__((noreturn)); +void real_init_all(); + +#endif /* __THREADS_MODEL_H__ */