parlib: Always use the default mutex/cv interface
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 5 Apr 2017 16:21:01 +0000 (12:21 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 3 May 2017 16:13:02 +0000 (12:13 -0400)
Previously, the 2LSs could override the mutex/CVs.  Now, the old default
implementation is the only implementation.  2LSs do their thing with the
sync objects.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/parlib/include/parlib/uthread.h
user/parlib/mutex.c
user/parlib/thread0_sched.c

index 9672a19..97811b4 100644 (file)
@@ -2,6 +2,7 @@
 
 #include <parlib/vcore.h>
 #include <parlib/signal.h>
+#include <parlib/spinlock.h>
 #include <ros/syscall.h>
 #include <sys/queue.h>
 
@@ -62,13 +63,6 @@ bool __uth_sync_get_uth(uth_sync_t sync, struct uthread *uth);
 /* 2LSs that use default sync objs will call this in their has_blocked op. */
 void __uth_default_sync_enqueue(struct uthread *uth, uth_sync_t sync);
 
-/* These structs are undefined.  We use them instead of void * so we can get
- * compiler warnings if someone passes the wrong pointer type.  Internally, we
- * use another struct type for mtx and cvs. */
-typedef struct __uth_mtx_opaque * uth_mutex_t;
-typedef struct __uth_recurse_mtx_opaque * uth_recurse_mutex_t;
-typedef struct __uth_cv_opaque * uth_cond_var_t;
-
 /* 2L-Scheduler operations.  Examples in pthread.c. */
 struct schedule_ops {
        /**** These functions must be defined ****/
@@ -80,17 +74,6 @@ struct schedule_ops {
        void (*thread_has_blocked)(struct uthread *, uth_sync_t, int);
        void (*thread_refl_fault)(struct uthread *, struct user_context *);
        /**** Defining these functions is optional. ****/
-       /* 2LSs can leave the mutex/cv funcs empty for a default implementation */
-       uth_mutex_t (*mutex_alloc)(void);
-       void (*mutex_free)(uth_mutex_t);
-       void (*mutex_lock)(uth_mutex_t);
-       bool (*mutex_trylock)(uth_mutex_t);
-       void (*mutex_unlock)(uth_mutex_t);
-       uth_cond_var_t (*cond_var_alloc)(void);
-       void (*cond_var_free)(uth_cond_var_t);
-       void (*cond_var_wait)(uth_cond_var_t, uth_mutex_t);
-       void (*cond_var_signal)(uth_cond_var_t);
-       void (*cond_var_broadcast)(uth_cond_var_t);
        uth_sync_t (*sync_alloc)(void);
        void (*sync_free)(uth_sync_t);
        struct uthread *(*sync_get_next)(uth_sync_t);
@@ -182,24 +165,42 @@ static inline struct user_context *get_cur_uth_ctx(void)
        val;                                                                       \
 })
 
-/* Generic Uthread Mutexes.  2LSs implement their own methods, but we need a
- * 2LS-independent interface and default implementation. */
+/* Uthread Mutexes / CVs / etc. */
+
+typedef struct uth_mutex * uth_mutex_t;
+typedef struct uth_recurse_mutex * uth_recurse_mutex_t;
+typedef struct uth_cond_var * uth_cond_var_t;
+
+struct uth_mutex {
+       struct spin_pdr_lock            lock;
+       uth_sync_t                                      sync_obj;
+       bool                                            locked;
+};
+
+struct uth_recurse_mutex {
+       uth_mutex_t                                     mtx;
+       struct uthread                          *lockholder;
+       unsigned int                            count;
+};
+
+struct uth_cond_var {
+       struct spin_pdr_lock            lock;
+       uth_sync_t                                      sync_obj;
+};
+
 uth_mutex_t uth_mutex_alloc(void);
 void uth_mutex_free(uth_mutex_t m);
 void uth_mutex_lock(uth_mutex_t m);
 bool uth_mutex_trylock(uth_mutex_t m);
 void uth_mutex_unlock(uth_mutex_t m);
 
-/* Recursive mutexes.  Internally, these are built on top of the regular
- * mutexes, and 2LSs do not have their own version. */
 uth_recurse_mutex_t uth_recurse_mutex_alloc(void);
 void uth_recurse_mutex_free(uth_recurse_mutex_t r_m);
 void uth_recurse_mutex_lock(uth_recurse_mutex_t r_m);
 bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_m);
 void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_m);
 
-/* Generic Uthread Condition Variables.  2LSs can implement their own methods.
- * Callers to cv_wait must hold the mutex, which it will atomically wait and
+/* Callers to cv_wait must hold the mutex, which it will atomically wait and
  * unlock, then relock when it returns.  Callers to signal and broadcast may
  * hold the mutex, if they choose. */
 uth_cond_var_t uth_cond_var_alloc(void);
index cbc4f57..5d512a9 100644 (file)
 #include <parlib/spinlock.h>
 #include <malloc.h>
 
-struct uth_default_mtx {
-       struct spin_pdr_lock            lock;
-       uth_sync_t                                      sync_obj;
-       bool                                            locked;
-};
-
-struct uth_default_cv {
-       struct spin_pdr_lock            lock;
-       uth_sync_t                                      sync_obj;
-};
 
+/************** Mutexes **************/
 
-/************** Default Mutex Implementation **************/
 
-
-static struct uth_default_mtx *uth_default_mtx_alloc(void)
+uth_mutex_t uth_mutex_alloc(void)
 {
-       struct uth_default_mtx *mtx;
+       struct uth_mutex *mtx;
 
-       mtx = malloc(sizeof(struct uth_default_mtx));
+       mtx = malloc(sizeof(struct uth_mutex));
        assert(mtx);
        spin_pdr_init(&mtx->lock);
        mtx->sync_obj = __uth_sync_alloc();
@@ -37,7 +26,7 @@ static struct uth_default_mtx *uth_default_mtx_alloc(void)
        return mtx;
 }
 
-static void uth_default_mtx_free(struct uth_default_mtx *mtx)
+void uth_mutex_free(uth_mutex_t mtx)
 {
        __uth_sync_free(mtx->sync_obj);
        free(mtx);
@@ -45,7 +34,7 @@ static void uth_default_mtx_free(struct uth_default_mtx *mtx)
 
 static void __mutex_cb(struct uthread *uth, void *arg)
 {
-       struct uth_default_mtx *mtx = (struct uth_default_mtx*)arg;
+       struct uth_mutex *mtx = (struct uth_mutex*)arg;
 
        /* We need to tell the 2LS that its thread blocked.  We need to do this
         * before unlocking the mtx, since as soon as we unlock, the mtx could be
@@ -57,7 +46,7 @@ static void __mutex_cb(struct uthread *uth, void *arg)
        spin_pdr_unlock(&mtx->lock);
 }
 
-static void uth_default_mtx_lock(struct uth_default_mtx *mtx)
+void uth_mutex_lock(uth_mutex_t mtx)
 {
        spin_pdr_lock(&mtx->lock);
        if (!mtx->locked) {
@@ -71,7 +60,7 @@ static void uth_default_mtx_lock(struct uth_default_mtx *mtx)
        uthread_yield(TRUE, __mutex_cb, mtx);
 }
 
-static bool uth_default_mtx_trylock(struct uth_default_mtx *mtx)
+bool uth_mutex_trylock(uth_mutex_t mtx)
 {
        bool ret = FALSE;
 
@@ -84,7 +73,7 @@ static bool uth_default_mtx_trylock(struct uth_default_mtx *mtx)
        return ret;
 }
 
-static void uth_default_mtx_unlock(struct uth_default_mtx *mtx)
+void uth_mutex_unlock(uth_mutex_t mtx)
 {
        struct uthread *uth;
 
@@ -98,83 +87,28 @@ static void uth_default_mtx_unlock(struct uth_default_mtx *mtx)
 }
 
 
-/************** Wrappers for the uthread mutex interface **************/
-
-
-uth_mutex_t uth_mutex_alloc(void)
-{
-       if (sched_ops->mutex_alloc)
-               return sched_ops->mutex_alloc();
-       return (uth_mutex_t)uth_default_mtx_alloc();
-}
-
-void uth_mutex_free(uth_mutex_t m)
-{
-       if (sched_ops->mutex_free) {
-               sched_ops->mutex_free(m);
-               return;
-       }
-       uth_default_mtx_free((struct uth_default_mtx*)m);
-}
-
-void uth_mutex_lock(uth_mutex_t m)
-{
-       if (sched_ops->mutex_lock) {
-               sched_ops->mutex_lock(m);
-               return;
-       }
-       uth_default_mtx_lock((struct uth_default_mtx*)m);
-}
-
-bool uth_mutex_trylock(uth_mutex_t m)
-{
-       if (sched_ops->mutex_trylock)
-               return sched_ops->mutex_trylock(m);
-       return uth_default_mtx_trylock((struct uth_default_mtx*)m);
-}
-
-void uth_mutex_unlock(uth_mutex_t m)
-{
-       if (sched_ops->mutex_unlock) {
-               sched_ops->mutex_unlock(m);
-               return;
-       }
-       uth_default_mtx_unlock((struct uth_default_mtx*)m);
-}
-
-
 /************** Recursive mutexes **************/
 
-/* Note the interface type uth_recurse_mtx_t is a pointer to this struct. */
-struct uth_recurse_mtx {
-       uth_mutex_t                                     mtx;
-       struct uthread                          *lockholder;
-       unsigned int                            count;
-};
 
 uth_recurse_mutex_t uth_recurse_mutex_alloc(void)
 {
-       struct uth_recurse_mtx *r_mtx = malloc(sizeof(struct uth_recurse_mtx));
+       struct uth_recurse_mutex *r_mtx = malloc(sizeof(struct uth_recurse_mutex));
 
        assert(r_mtx);
        r_mtx->mtx = uth_mutex_alloc();
        r_mtx->lockholder = NULL;
        r_mtx->count = 0;
-       return (uth_recurse_mutex_t)r_mtx;
+       return r_mtx;
 }
 
-void uth_recurse_mutex_free(uth_recurse_mutex_t r_m)
+void uth_recurse_mutex_free(uth_recurse_mutex_t r_mtx)
 {
-       struct uth_recurse_mtx *r_mtx = (struct uth_recurse_mtx*)r_m;
-
        uth_mutex_free(r_mtx->mtx);
        free(r_mtx);
 }
 
-void uth_recurse_mutex_lock(uth_recurse_mutex_t r_m)
+void uth_recurse_mutex_lock(uth_recurse_mutex_t r_mtx)
 {
-       struct uth_recurse_mtx *r_mtx = (struct uth_recurse_mtx*)r_m;
-
        assert(!in_vcore_context());
        assert(current_uthread);
        /* We don't have to worry about races on current_uthread or count.  They are
@@ -194,9 +128,8 @@ void uth_recurse_mutex_lock(uth_recurse_mutex_t r_m)
        r_mtx->count = 1;
 }
 
-bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_m)
+bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_mtx)
 {
-       struct uth_recurse_mtx *r_mtx = (struct uth_recurse_mtx*)r_m;
        bool ret;
 
        assert(!in_vcore_context());
@@ -213,10 +146,8 @@ bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_m)
        return ret;
 }
 
-void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_m)
+void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_mtx)
 {
-       struct uth_recurse_mtx *r_mtx = (struct uth_recurse_mtx*)r_m;
-
        r_mtx->count--;
        if (!r_mtx->count) {
                r_mtx->lockholder = NULL;
@@ -225,36 +156,36 @@ void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_m)
 }
 
 
-/************** Default Condition Variable Implementation **************/
+/************** Condition Variables **************/
 
 
-static struct uth_default_cv *uth_default_cv_alloc(void)
+uth_cond_var_t uth_cond_var_alloc(void)
 {
-       struct uth_default_cv *cv;
+       struct uth_cond_var *cv;
 
-       cv = malloc(sizeof(struct uth_default_cv));
+       cv = malloc(sizeof(struct uth_cond_var));
        assert(cv);
        spin_pdr_init(&cv->lock);
        cv->sync_obj = __uth_sync_alloc();
        return cv;
 }
 
-static void uth_default_cv_free(struct uth_default_cv *cv)
+void uth_cond_var_free(uth_cond_var_t cv)
 {
        __uth_sync_free(cv->sync_obj);
        free(cv);
 }
 
 struct uth_cv_link {
-       struct uth_default_cv           *cv;
-       struct uth_default_mtx          *mtx;
+       struct uth_cond_var                     *cv;
+       struct uth_mutex                        *mtx;
 };
 
 static void __cv_wait_cb(struct uthread *uth, void *arg)
 {
        struct uth_cv_link *link = (struct uth_cv_link*)arg;
-       struct uth_default_cv *cv = link->cv;
-       struct uth_default_mtx *mtx = link->mtx;
+       struct uth_cond_var *cv = link->cv;
+       struct uth_mutex *mtx = link->mtx;
 
        /* We need to tell the 2LS that its thread blocked.  We need to do this
         * before unlocking the cv, since as soon as we unlock, the cv could be
@@ -330,8 +261,7 @@ static void __cv_wait_cb(struct uthread *uth, void *arg)
  *
  * Also note that we use the external API for the mutex operations.  A 2LS could
  * have their own mutex ops but still use the generic cv ops. */
-static void uth_default_cv_wait(struct uth_default_cv *cv,
-                                struct uth_default_mtx *mtx)
+void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t mtx)
 {
        struct uth_cv_link link;
 
@@ -342,7 +272,7 @@ static void uth_default_cv_wait(struct uth_default_cv *cv,
        uth_mutex_lock((uth_mutex_t)mtx);
 }
 
-static void uth_default_cv_signal(struct uth_default_cv *cv)
+void uth_cond_var_signal(uth_cond_var_t cv)
 {
        struct uthread *uth;
 
@@ -353,7 +283,7 @@ static void uth_default_cv_signal(struct uth_default_cv *cv)
                uthread_runnable(uth);
 }
 
-static void uth_default_cv_broadcast(struct uth_default_cv *cv)
+void uth_cond_var_broadcast(uth_cond_var_t cv)
 {
        struct uth_tailq restartees = TAILQ_HEAD_INITIALIZER(restartees);
        struct uthread *i, *safe;
@@ -372,53 +302,6 @@ static void uth_default_cv_broadcast(struct uth_default_cv *cv)
 }
 
 
-/************** Wrappers for the uthread CV interface **************/
-
-
-uth_cond_var_t uth_cond_var_alloc(void)
-{
-       if (sched_ops->cond_var_alloc)
-               return sched_ops->cond_var_alloc();
-       return (uth_cond_var_t)uth_default_cv_alloc();
-}
-
-void uth_cond_var_free(uth_cond_var_t cv)
-{
-       if (sched_ops->cond_var_free) {
-               sched_ops->cond_var_free(cv);
-               return;
-       }
-       uth_default_cv_free((struct uth_default_cv*)cv);
-}
-
-void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t m)
-{
-       if (sched_ops->cond_var_wait) {
-               sched_ops->cond_var_wait(cv, m);
-               return;
-       }
-       uth_default_cv_wait((struct uth_default_cv*)cv, (struct uth_default_mtx*)m);
-}
-
-void uth_cond_var_signal(uth_cond_var_t cv)
-{
-       if (sched_ops->cond_var_signal) {
-               sched_ops->cond_var_signal(cv);
-               return;
-       }
-       uth_default_cv_signal((struct uth_default_cv*)cv);
-}
-
-void uth_cond_var_broadcast(uth_cond_var_t cv)
-{
-       if (sched_ops->cond_var_broadcast) {
-               sched_ops->cond_var_broadcast(cv);
-               return;
-       }
-       uth_default_cv_broadcast((struct uth_default_cv*)cv);
-}
-
-
 /************** Default Sync Obj Implementation **************/
 
 static uth_sync_t uth_default_sync_alloc(void)
index f85abe0..39b4a2a 100644 (file)
@@ -23,11 +23,6 @@ static void thread0_thread_refl_fault(struct uthread *uth,
 static void thread0_thread_runnable(struct uthread *uth);
 static void thread0_thread_has_blocked(struct uthread *uth, uth_sync_t sync,
                                        int flags);
-static uth_mutex_t thread0_mtx_alloc(void);
-static void thread0_mtx_free(uth_mutex_t m);
-static void thread0_mtx_lock(uth_mutex_t m);
-static bool thread0_mtx_trylock(uth_mutex_t m);
-static void thread0_mtx_unlock(uth_mutex_t m);
 static uth_sync_t thread0_sync_alloc(void);
 static void thread0_sync_free(uth_sync_t);
 static struct uthread *thread0_sync_get_next(uth_sync_t);
@@ -41,11 +36,6 @@ struct schedule_ops thread0_2ls_ops = {
        .thread_runnable = thread0_thread_runnable,
        .thread_paused = thread0_thread_runnable,
        .thread_has_blocked = thread0_thread_has_blocked,
-       .mutex_alloc = thread0_mtx_alloc,
-       .mutex_free = thread0_mtx_free,
-       .mutex_lock = thread0_mtx_lock,
-       .mutex_trylock = thread0_mtx_trylock,
-       .mutex_unlock = thread0_mtx_unlock,
        .sync_alloc = thread0_sync_alloc,
        .sync_free = thread0_sync_free,
        .sync_get_next = thread0_sync_get_next,
@@ -158,51 +148,6 @@ static void thread0_thread_has_blocked(struct uthread *uth, uth_sync_t sync,
        thread0_info.is_blocked = TRUE;
 }
 
-/* We only have one thread, so we don't *need* mutexes.  But we'll use a bool to
- * catch code that could deadlock itself. */
-static uth_mutex_t thread0_mtx_alloc(void)
-{
-       bool *mtx = malloc(sizeof(bool));
-
-       assert(mtx);
-       *mtx = FALSE;
-       return (uth_mutex_t)mtx;
-}
-
-static void thread0_mtx_free(uth_mutex_t m)
-{
-       bool *mtx = (bool*)m;
-
-       assert(*mtx == FALSE);
-       free((void*)m);
-}
-
-static void thread0_mtx_lock(uth_mutex_t m)
-{
-       bool *mtx = (bool*)m;
-
-       assert(*mtx == FALSE);
-       *mtx = TRUE;
-}
-
-static bool thread0_mtx_trylock(uth_mutex_t m)
-{
-       bool *mtx = (bool*)m;
-
-       if (*mtx)
-               return FALSE;
-       *mtx = TRUE;
-       return TRUE;
-}
-
-static void thread0_mtx_unlock(uth_mutex_t m)
-{
-       bool *mtx = (bool*)m;
-
-       assert(*mtx == TRUE);
-       *mtx = FALSE;
-}
-
 static uth_sync_t thread0_sync_alloc(void)
 {
        return (void*)0xf00baa;