mirror of git://git.musl-libc.org/musl
process-shared barrier support, based on discussion with bdonlan
this implementation is rather heavy-weight, but it's the first solution i've found that's actually correct. all waiters actually wait twice at the barrier so that they can synchronize exit, and they hold a "vm lock" that prevents changes to virtual memory mappings (and blocks pthread_barrier_destroy) until all waiters are finished inspecting the barrier. thus, it is safe for any thread to destroy and/or unmap the barrier's memory as soon as pthread_barrier_wait returns, without further synchronization.
This commit is contained in:
parent
3f39c9b313
commit
6016457011
|
@ -73,10 +73,12 @@ struct __timer {
|
|||
#define _c_waiters2 __u.__i[7]
|
||||
#define _rw_lock __u.__i[0]
|
||||
#define _rw_waiters __u.__i[1]
|
||||
#define _b_inst __u.__p[0]
|
||||
#define _b_lock __u.__i[0]
|
||||
#define _b_waiters __u.__i[1]
|
||||
#define _b_limit __u.__i[2]
|
||||
#define _b_lock __u.__i[3]
|
||||
#define _b_waiters __u.__i[4]
|
||||
#define _b_count __u.__i[3]
|
||||
#define _b_seq __u.__i[4]
|
||||
#define _b_inst __u.__p[4]
|
||||
|
||||
#include "pthread_arch.h"
|
||||
|
||||
|
|
|
@ -5,16 +5,25 @@
|
|||
#include "syscall.h"
|
||||
#include "libc.h"
|
||||
|
||||
static void dummy1(int x) { }
|
||||
static void dummy0(void) { }
|
||||
weak_alias(dummy1, __vm_lock);
|
||||
weak_alias(dummy0, __vm_unlock);
|
||||
|
||||
void *__mmap(void *start, size_t len, int prot, int flags, int fd, off_t off)
|
||||
{
|
||||
void *ret;
|
||||
if (sizeof(off_t) > sizeof(long))
|
||||
if (((long)off & 0xfff) | ((long)((unsigned long long)off>>(12 + 8*(sizeof(off_t)-sizeof(long))))))
|
||||
start = (void *)-1;
|
||||
if (flags & MAP_FIXED) __vm_lock(-1);
|
||||
#ifdef SYS_mmap2
|
||||
return (void *)syscall(SYS_mmap2, start, len, prot, flags, fd, off>>12);
|
||||
ret = (void *)syscall(SYS_mmap2, start, len, prot, flags, fd, off>>12);
|
||||
#else
|
||||
return (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
|
||||
ret = (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
|
||||
#endif
|
||||
if (flags & MAP_FIXED) __vm_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
weak_alias(__mmap, mmap);
|
||||
|
|
|
@ -3,9 +3,18 @@
|
|||
#include "syscall.h"
|
||||
#include "libc.h"
|
||||
|
||||
static void dummy1(int x) { }
|
||||
static void dummy0(void) { }
|
||||
weak_alias(dummy1, __vm_lock);
|
||||
weak_alias(dummy0, __vm_unlock);
|
||||
|
||||
int __munmap(void *start, size_t len)
|
||||
{
|
||||
return syscall(SYS_munmap, start, len);
|
||||
int ret;
|
||||
__vm_lock(-1);
|
||||
ret = syscall(SYS_munmap, start, len);
|
||||
__vm_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
weak_alias(__munmap, munmap);
|
||||
|
|
|
@ -1,6 +1,12 @@
|
|||
#include "pthread_impl.h"
|
||||
|
||||
void __vm_lock(int), __vm_unlock(void);
|
||||
|
||||
int pthread_barrier_destroy(pthread_barrier_t *b)
|
||||
{
|
||||
if (b->_b_limit < 0) {
|
||||
__vm_lock(-1);
|
||||
__vm_unlock();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
int pthread_barrier_init(pthread_barrier_t *b, const pthread_barrierattr_t *a, unsigned count)
|
||||
{
|
||||
if (!count) return EINVAL;
|
||||
*b = (pthread_barrier_t){ ._b_limit = count-1 };
|
||||
if (count-1 > INT_MAX-1) return EINVAL;
|
||||
*b = (pthread_barrier_t){ ._b_limit = count-1 | (a?*a:0) };
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -1,5 +1,62 @@
|
|||
#include "pthread_impl.h"
|
||||
|
||||
static int vmlock[2];
|
||||
|
||||
void __vm_lock(int inc)
|
||||
{
|
||||
for (;;) {
|
||||
int v = vmlock[0];
|
||||
if (inc*v < 0) __wait(vmlock, vmlock+1, v, 1);
|
||||
else if (a_cas(vmlock, v, v+inc)==v) break;
|
||||
}
|
||||
}
|
||||
|
||||
void __vm_unlock(void)
|
||||
{
|
||||
if (vmlock[0]>0) a_dec(vmlock);
|
||||
else a_inc(vmlock);
|
||||
if (vmlock[1]) __wake(vmlock, 1, 1);
|
||||
}
|
||||
|
||||
static int pshared_barrier_wait(pthread_barrier_t *b)
|
||||
{
|
||||
int limit = (b->_b_limit & INT_MAX) + 1;
|
||||
int seq;
|
||||
int ret = 0;
|
||||
|
||||
if (!limit) return PTHREAD_BARRIER_SERIAL_THREAD;
|
||||
|
||||
while (a_swap(&b->_b_lock, 1))
|
||||
__wait(&b->_b_lock, &b->_b_waiters, 1, 0);
|
||||
|
||||
seq = b->_b_seq;
|
||||
|
||||
if (++b->_b_count == limit) {
|
||||
ret = PTHREAD_BARRIER_SERIAL_THREAD;
|
||||
b->_b_seq++;
|
||||
__wake(&b->_b_seq, -1, 0);
|
||||
} else {
|
||||
a_store(&b->_b_lock, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
|
||||
__wait(&b->_b_seq, 0, seq, 0);
|
||||
}
|
||||
|
||||
__vm_lock(+1);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
__vm_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct instance
|
||||
{
|
||||
int count;
|
||||
|
@ -16,9 +73,12 @@ int pthread_barrier_wait(pthread_barrier_t *b)
|
|||
/* Trivial case: count was set at 1 */
|
||||
if (!limit) return PTHREAD_BARRIER_SERIAL_THREAD;
|
||||
|
||||
/* Process-shared barriers require a separate, inefficient wait */
|
||||
if (limit < 0) return pshared_barrier_wait(b);
|
||||
|
||||
/* Otherwise we need a lock on the barrier object */
|
||||
while (a_swap(&b->_b_lock, 1))
|
||||
__wait(&b->_b_lock, &b->_b_waiters, 1, 0);
|
||||
__wait(&b->_b_lock, &b->_b_waiters, 1, 1);
|
||||
inst = b->_b_inst;
|
||||
|
||||
/* First thread to enter the barrier becomes the "instance owner" */
|
||||
|
@ -27,7 +87,7 @@ int pthread_barrier_wait(pthread_barrier_t *b)
|
|||
int spins = 10000;
|
||||
b->_b_inst = inst = &new_inst;
|
||||
a_store(&b->_b_lock, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
|
||||
while (spins-- && !inst->finished)
|
||||
a_spin();
|
||||
a_inc(&inst->finished);
|
||||
|
@ -40,19 +100,19 @@ int pthread_barrier_wait(pthread_barrier_t *b)
|
|||
if (++inst->count == limit) {
|
||||
b->_b_inst = 0;
|
||||
a_store(&b->_b_lock, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
|
||||
a_store(&inst->last, 1);
|
||||
if (inst->waiters)
|
||||
__wake(&inst->last, -1, 0);
|
||||
__wake(&inst->last, -1, 1);
|
||||
} else {
|
||||
a_store(&b->_b_lock, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 0);
|
||||
__wait(&inst->last, &inst->waiters, 0, 0);
|
||||
if (b->_b_waiters) __wake(&b->_b_lock, 1, 1);
|
||||
__wait(&inst->last, &inst->waiters, 0, 1);
|
||||
}
|
||||
|
||||
/* Last thread to exit the barrier wakes the instance owner */
|
||||
if (a_fetch_add(&inst->count,-1)==1 && a_fetch_add(&inst->finished,1))
|
||||
__wake(&inst->finished, 1, 0);
|
||||
__wake(&inst->finished, 1, 1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -2,6 +2,6 @@
|
|||
|
||||
int pthread_barrierattr_setpshared(pthread_barrierattr_t *a, int pshared)
|
||||
{
|
||||
*a = !!pshared;
|
||||
*a = pshared ? INT_MIN : 0;
|
||||
return 0;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue