mirror of
https://github.com/fluencelabs/musl
synced 2025-06-02 01:21:34 +00:00
bc09d58c04
private-futex uses the virtual address of the futex int directly as the hash key rather than requiring the kernel to resolve the address to an underlying backing for the mapping in which it lies. for certain usage patterns it improves performance significantly. in many places, the code using futex __wake and __wait operations was already passing a correct fixed zero or nonzero flag for the priv argument, so no change was needed at the site of the call, only in the __wake and __wait functions themselves. in other places, especially where the process-shared attribute for a synchronization object was not previously tracked, additional new code is needed. for mutexes, the only place to store the flag is in the type field, so additional bit masking logic is needed for accessing the type. for non-process-shared condition variable broadcasts, the futex requeue operation is unable to requeue from a private futex to a process-shared one in the mutex structure, so requeue is simply disabled in this case by waking all waiters. for robust mutexes, the kernel always performs a non-private wake when the owner dies. in order not to introduce a behavioral regression in non-process-shared robust mutexes (when the owning thread dies), they are simply forced to be treated as process-shared for now, giving correct behavior at the expense of performance. this can be fixed by adding explicit code to pthread_exit to do the right thing for non-shared robust mutexes in userspace rather than relying on the kernel to do it, and will be fixed in this way later. since not all supported kernels have private futex support, the new code detects EINVAL from the futex syscall and falls back to making the call without the private flag. no attempt to cache the result is made; caching it and using the cached value efficiently is somewhat difficult, and not worth the complexity when the benefits would be seen only on ancient kernels which have numerous other limitations and bugs anyway.
99 lines
2.3 KiB
C
99 lines
2.3 KiB
C
#include "pthread_impl.h"
|
|
|
|
int pthread_attr_getdetachstate(const pthread_attr_t *a, int *state)
|
|
{
|
|
*state = a->_a_detach;
|
|
return 0;
|
|
}
|
|
int pthread_attr_getguardsize(const pthread_attr_t *restrict a, size_t *restrict size)
|
|
{
|
|
*size = a->_a_guardsize + DEFAULT_GUARD_SIZE;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getinheritsched(const pthread_attr_t *restrict a, int *restrict inherit)
|
|
{
|
|
*inherit = a->_a_sched;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getschedparam(const pthread_attr_t *restrict a, struct sched_param *restrict param)
|
|
{
|
|
param->sched_priority = a->_a_prio;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getschedpolicy(const pthread_attr_t *restrict a, int *restrict policy)
|
|
{
|
|
*policy = a->_a_policy;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getscope(const pthread_attr_t *restrict a, int *restrict scope)
|
|
{
|
|
*scope = PTHREAD_SCOPE_SYSTEM;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getstack(const pthread_attr_t *restrict a, void **restrict addr, size_t *restrict size)
|
|
{
|
|
if (!a->_a_stackaddr)
|
|
return EINVAL;
|
|
*size = a->_a_stacksize + DEFAULT_STACK_SIZE;
|
|
*addr = (void *)(a->_a_stackaddr - *size);
|
|
return 0;
|
|
}
|
|
|
|
int pthread_attr_getstacksize(const pthread_attr_t *restrict a, size_t *restrict size)
|
|
{
|
|
*size = a->_a_stacksize + DEFAULT_STACK_SIZE;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_barrierattr_getpshared(const pthread_barrierattr_t *restrict a, int *restrict pshared)
|
|
{
|
|
*pshared = !!a->__attr;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_condattr_getclock(const pthread_condattr_t *restrict a, clockid_t *restrict clk)
|
|
{
|
|
*clk = a->__attr & 0x7fffffff;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_condattr_getpshared(const pthread_condattr_t *restrict a, int *restrict pshared)
|
|
{
|
|
*pshared = a->__attr>>31;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *restrict a, int *restrict protocol)
|
|
{
|
|
*protocol = PTHREAD_PRIO_NONE;
|
|
return 0;
|
|
}
|
|
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict a, int *restrict pshared)
|
|
{
|
|
*pshared = a->__attr / 128U % 2;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict a, int *restrict robust)
|
|
{
|
|
*robust = a->__attr / 4U % 2;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict a, int *restrict type)
|
|
{
|
|
*type = a->__attr & 3;
|
|
return 0;
|
|
}
|
|
|
|
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *restrict a, int *restrict pshared)
|
|
{
|
|
*pshared = a->__attr[0];
|
|
return 0;
|
|
}
|