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 _c_waiters2 __u.__i[7]
|
||||||
#define _rw_lock __u.__i[0]
|
#define _rw_lock __u.__i[0]
|
||||||
#define _rw_waiters __u.__i[1]
|
#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_limit __u.__i[2]
|
||||||
#define _b_lock __u.__i[3]
|
#define _b_count __u.__i[3]
|
||||||
#define _b_waiters __u.__i[4]
|
#define _b_seq __u.__i[4]
|
||||||
|
#define _b_inst __u.__p[4]
|
||||||
|
|
||||||
#include "pthread_arch.h"
|
#include "pthread_arch.h"
|
||||||
|
|
||||||
|
|
|
@ -5,16 +5,25 @@
|
||||||
#include "syscall.h"
|
#include "syscall.h"
|
||||||
#include "libc.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 *__mmap(void *start, size_t len, int prot, int flags, int fd, off_t off)
|
||||||
{
|
{
|
||||||
|
void *ret;
|
||||||
if (sizeof(off_t) > sizeof(long))
|
if (sizeof(off_t) > sizeof(long))
|
||||||
if (((long)off & 0xfff) | ((long)((unsigned long long)off>>(12 + 8*(sizeof(off_t)-sizeof(long))))))
|
if (((long)off & 0xfff) | ((long)((unsigned long long)off>>(12 + 8*(sizeof(off_t)-sizeof(long))))))
|
||||||
start = (void *)-1;
|
start = (void *)-1;
|
||||||
|
if (flags & MAP_FIXED) __vm_lock(-1);
|
||||||
#ifdef SYS_mmap2
|
#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
|
#else
|
||||||
return (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
|
ret = (void *)syscall(SYS_mmap, start, len, prot, flags, fd, off);
|
||||||
#endif
|
#endif
|
||||||
|
if (flags & MAP_FIXED) __vm_unlock();
|
||||||
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
weak_alias(__mmap, mmap);
|
weak_alias(__mmap, mmap);
|
||||||
|
|
|
@ -3,9 +3,18 @@
|
||||||
#include "syscall.h"
|
#include "syscall.h"
|
||||||
#include "libc.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)
|
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);
|
weak_alias(__munmap, munmap);
|
||||||
|
|
|
@ -1,6 +1,12 @@
|
||||||
#include "pthread_impl.h"
|
#include "pthread_impl.h"
|
||||||
|
|
||||||
|
void __vm_lock(int), __vm_unlock(void);
|
||||||
|
|
||||||
int pthread_barrier_destroy(pthread_barrier_t *b)
|
int pthread_barrier_destroy(pthread_barrier_t *b)
|
||||||
{
|
{
|
||||||
|
if (b->_b_limit < 0) {
|
||||||
|
__vm_lock(-1);
|
||||||
|
__vm_unlock();
|
||||||
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -2,7 +2,7 @@
|
||||||
|
|
||||||
int pthread_barrier_init(pthread_barrier_t *b, const pthread_barrierattr_t *a, unsigned count)
|
int pthread_barrier_init(pthread_barrier_t *b, const pthread_barrierattr_t *a, unsigned count)
|
||||||
{
|
{
|
||||||
if (!count) return EINVAL;
|
if (count-1 > INT_MAX-1) return EINVAL;
|
||||||
*b = (pthread_barrier_t){ ._b_limit = count-1 };
|
*b = (pthread_barrier_t){ ._b_limit = count-1 | (a?*a:0) };
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,62 @@
|
||||||
#include "pthread_impl.h"
|
#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
|
struct instance
|
||||||
{
|
{
|
||||||
int count;
|
int count;
|
||||||
|
@ -16,9 +73,12 @@ int pthread_barrier_wait(pthread_barrier_t *b)
|
||||||
/* Trivial case: count was set at 1 */
|
/* Trivial case: count was set at 1 */
|
||||||
if (!limit) return PTHREAD_BARRIER_SERIAL_THREAD;
|
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 */
|
/* Otherwise we need a lock on the barrier object */
|
||||||
while (a_swap(&b->_b_lock, 1))
|
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;
|
inst = b->_b_inst;
|
||||||
|
|
||||||
/* First thread to enter the barrier becomes the "instance owner" */
|
/* 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;
|
int spins = 10000;
|
||||||
b->_b_inst = inst = &new_inst;
|
b->_b_inst = inst = &new_inst;
|
||||||
a_store(&b->_b_lock, 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);
|
||||||
while (spins-- && !inst->finished)
|
while (spins-- && !inst->finished)
|
||||||
a_spin();
|
a_spin();
|
||||||
a_inc(&inst->finished);
|
a_inc(&inst->finished);
|
||||||
|
@ -40,19 +100,19 @@ int pthread_barrier_wait(pthread_barrier_t *b)
|
||||||
if (++inst->count == limit) {
|
if (++inst->count == limit) {
|
||||||
b->_b_inst = 0;
|
b->_b_inst = 0;
|
||||||
a_store(&b->_b_lock, 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);
|
a_store(&inst->last, 1);
|
||||||
if (inst->waiters)
|
if (inst->waiters)
|
||||||
__wake(&inst->last, -1, 0);
|
__wake(&inst->last, -1, 1);
|
||||||
} else {
|
} else {
|
||||||
a_store(&b->_b_lock, 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);
|
||||||
__wait(&inst->last, &inst->waiters, 0, 0);
|
__wait(&inst->last, &inst->waiters, 0, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Last thread to exit the barrier wakes the instance owner */
|
/* Last thread to exit the barrier wakes the instance owner */
|
||||||
if (a_fetch_add(&inst->count,-1)==1 && a_fetch_add(&inst->finished,1))
|
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;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -2,6 +2,6 @@
|
||||||
|
|
||||||
int pthread_barrierattr_setpshared(pthread_barrierattr_t *a, int pshared)
|
int pthread_barrierattr_setpshared(pthread_barrierattr_t *a, int pshared)
|
||||||
{
|
{
|
||||||
*a = !!pshared;
|
*a = pshared ? INT_MIN : 0;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue