next step making barrier self-sync'd destruction safe

i think this works, but it can be simplified. (next step)

diff --git a/src/thread/pthread_barrier_destroy.c b/src/thread/pthread_barrier_destroy.c
index 3ebc2b39a2c6af2ec58e09752aa0ef9464e8e9fc..e0da197a442d2f924fca76163ff13e57766152ce 100644 (file)
--- a/src/thread/pthread_barrier_destroy.c
+++ b/src/thread/pthread_barrier_destroy.c
@@ -5,8 +5,12 @@ void __vm_lock(int), __vm_unlock(void);
 int pthread_barrier_destroy(pthread_barrier_t *b)
 {
        if (b->_b_limit < 0) {
-               int seq = b->_b_seq;
-               if (seq & 1) __wait(&b->_b_seq, 0, seq, 0);
+               if (b->_b_lock) {
+                       int v;
+                       a_or(&b->_b_lock, INT_MIN);
+                       while ((v = b->_b_lock) & INT_MAX)
+                               __wait(&b->_b_lock, 0, v, 0);
+               }
                __vm_lock(-1);
                __vm_unlock();
        }

diff --git a/src/thread/pthread_barrier_wait.c b/src/thread/pthread_barrier_wait.c
index a97f6d56a0f3ba1eae0042cce194644557b8b763..9b1edbf94ad19a46a93fc9d68e497db662148ff4 100644 (file)
--- a/src/thread/pthread_barrier_wait.c
+++ b/src/thread/pthread_barrier_wait.c
@@ -23,11 +23,12 @@ static int pshared_barrier_wait(pthread_barrier_t *b)
        int limit = (b->_b_limit & INT_MAX) + 1;
        int seq;
        int ret = 0;
+       int v, w;
 
        if (limit==1) return PTHREAD_BARRIER_SERIAL_THREAD;
 
-       while (a_swap(&b->_b_lock, 1))
-               __wait(&b->_b_lock, &b->_b_waiters, 1, 0);
+       while ((v=a_cas(&b->_b_lock, 0, limit)))
+               __wait(&b->_b_lock, &b->_b_waiters, v, 0);
 
        seq = b->_b_seq;
 
@@ -46,12 +47,19 @@ static int pshared_barrier_wait(pthread_barrier_t *b)
        if (a_fetch_add(&b->_b_count, -1)==1) {
                b->_b_seq++;
                __wake(&b->_b_seq, -1, 0);
-               a_store(&b->_b_lock, 0);
-               if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
        } else {
                __wait(&b->_b_seq, 0, seq+1, 0);
        }
        
+       /* Perform a recursive unlock suitable for self-sync'd destruction */
+       do {
+               v = b->_b_lock;
+               w = b->_b_waiters;
+       } while (a_cas(&b->_b_lock, v, v-1 & INT_MAX) != v);
+
+       if (v==INT_MIN+1 || (v==1 && w))
+               __wake(&b->_b_lock, 1, 0);
+
        __vm_unlock();
 
        return ret;