| // -*- C++ -*- |
| //===----------------------------------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is dual licensed under the MIT and the University of Illinois Open |
| // Source Licenses. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _LIBCPP_THREADING_SUPPORT |
| #define _LIBCPP_THREADING_SUPPORT |
| |
| #include <__config> |
| #include <chrono> |
| #include <errno.h> |
| |
| #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER |
| #pragma GCC system_header |
| #endif |
| |
| #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) |
| # include <__external_threading> |
| #elif !defined(_LIBCPP_HAS_NO_THREADS) |
| |
| #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) |
| # include <pthread.h> |
| # include <sched.h> |
| #elif defined(_LIBCPP_HAS_THREAD_API_WIN32) |
| #include <Windows.h> |
| #include <process.h> |
| #include <fibersapi.h> |
| #endif |
| |
| #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ |
| defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) |
| #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS |
| #else |
| #define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY |
| #endif |
| |
| #if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(no_thread_safety_analysis) |
| #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis)) |
| #else |
| #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| #endif |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| |
| #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) |
| // Mutex |
| typedef pthread_mutex_t __libcpp_mutex_t; |
| #define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER |
| |
| typedef pthread_mutex_t __libcpp_recursive_mutex_t; |
| |
| // Condition Variable |
| typedef pthread_cond_t __libcpp_condvar_t; |
| #define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER |
| |
| // Execute once |
| typedef pthread_once_t __libcpp_exec_once_flag; |
| #define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT |
| |
| // Thread id |
| typedef pthread_t __libcpp_thread_id; |
| |
| // Thread |
| #define _LIBCPP_NULL_THREAD 0U |
| |
| typedef pthread_t __libcpp_thread_t; |
| |
| // Thrad Local Storage |
| typedef pthread_key_t __libcpp_tls_key; |
| |
| #define _LIBCPP_TLS_DESTRUCTOR_CC |
| #else |
| // Mutex |
| typedef SRWLOCK __libcpp_mutex_t; |
| #define _LIBCPP_MUTEX_INITIALIZER SRWLOCK_INIT |
| |
| typedef CRITICAL_SECTION __libcpp_recursive_mutex_t; |
| |
| // Condition Variable |
| typedef CONDITION_VARIABLE __libcpp_condvar_t; |
| #define _LIBCPP_CONDVAR_INITIALIZER CONDITION_VARIABLE_INIT |
| |
| // Execute Once |
| typedef INIT_ONCE __libcpp_exec_once_flag; |
| #define _LIBCPP_EXEC_ONCE_INITIALIZER INIT_ONCE_STATIC_INIT |
| |
| // Thread ID |
| typedef DWORD __libcpp_thread_id; |
| |
| // Thread |
| #define _LIBCPP_NULL_THREAD 0U |
| |
| typedef HANDLE __libcpp_thread_t; |
| |
| // Thread Local Storage |
| typedef DWORD __libcpp_tls_key; |
| |
| #define _LIBCPP_TLS_DESTRUCTOR_CC WINAPI |
| #endif |
| |
| // Mutex |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_mutex_lock(__libcpp_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_mutex_unlock(__libcpp_mutex_t *__m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_mutex_destroy(__libcpp_mutex_t *__m); |
| |
| // Condition variable |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_condvar_signal(__libcpp_condvar_t* __cv); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| timespec *__ts); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv); |
| |
| // Execute once |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_execute_once(__libcpp_exec_once_flag *flag, |
| void (*init_routine)(void)); |
| |
| // Thread id |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2); |
| |
| // Thread |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| bool __libcpp_thread_isnull(const __libcpp_thread_t *__t); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| void *__arg); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| __libcpp_thread_id __libcpp_thread_get_current_id(); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_thread_join(__libcpp_thread_t *__t); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_thread_detach(__libcpp_thread_t *__t); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| void __libcpp_thread_yield(); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns); |
| |
| // Thread local storage |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_tls_create(__libcpp_tls_key* __key, |
| void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| void *__libcpp_tls_get(__libcpp_tls_key __key); |
| |
| _LIBCPP_THREAD_ABI_VISIBILITY |
| int __libcpp_tls_set(__libcpp_tls_key __key, void *__p); |
| |
| #if !defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ |
| defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) |
| |
| #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) |
| |
| int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) |
| { |
| pthread_mutexattr_t attr; |
| int __ec = pthread_mutexattr_init(&attr); |
| if (__ec) |
| return __ec; |
| __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); |
| if (__ec) { |
| pthread_mutexattr_destroy(&attr); |
| return __ec; |
| } |
| __ec = pthread_mutex_init(__m, &attr); |
| if (__ec) { |
| pthread_mutexattr_destroy(&attr); |
| return __ec; |
| } |
| __ec = pthread_mutexattr_destroy(&attr); |
| if (__ec) { |
| pthread_mutex_destroy(__m); |
| return __ec; |
| } |
| return 0; |
| } |
| |
| int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) |
| { |
| return pthread_mutex_lock(__m); |
| } |
| |
| bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) |
| { |
| return pthread_mutex_trylock(__m) == 0; |
| } |
| |
| int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m) |
| { |
| return pthread_mutex_unlock(__m); |
| } |
| |
| int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) |
| { |
| return pthread_mutex_destroy(__m); |
| } |
| |
| int __libcpp_mutex_lock(__libcpp_mutex_t *__m) |
| { |
| return pthread_mutex_lock(__m); |
| } |
| |
| bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) |
| { |
| return pthread_mutex_trylock(__m) == 0; |
| } |
| |
| int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) |
| { |
| return pthread_mutex_unlock(__m); |
| } |
| |
| int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) |
| { |
| return pthread_mutex_destroy(__m); |
| } |
| |
| // Condition Variable |
| int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) |
| { |
| return pthread_cond_signal(__cv); |
| } |
| |
| int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) |
| { |
| return pthread_cond_broadcast(__cv); |
| } |
| |
| int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) |
| { |
| return pthread_cond_wait(__cv, __m); |
| } |
| |
| int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| timespec *__ts) |
| { |
| return pthread_cond_timedwait(__cv, __m, __ts); |
| } |
| |
| int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) |
| { |
| return pthread_cond_destroy(__cv); |
| } |
| |
| // Execute once |
| int __libcpp_execute_once(__libcpp_exec_once_flag *flag, |
| void (*init_routine)(void)) { |
| return pthread_once(flag, init_routine); |
| } |
| |
| // Thread id |
| // Returns non-zero if the thread ids are equal, otherwise 0 |
| bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2) |
| { |
| return pthread_equal(t1, t2) != 0; |
| } |
| |
| // Returns non-zero if t1 < t2, otherwise 0 |
| bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2) |
| { |
| return t1 < t2; |
| } |
| |
| // Thread |
| bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { |
| return *__t == 0; |
| } |
| |
| int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| void *__arg) |
| { |
| return pthread_create(__t, 0, __func, __arg); |
| } |
| |
| __libcpp_thread_id __libcpp_thread_get_current_id() |
| { |
| return pthread_self(); |
| } |
| |
| __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) |
| { |
| return *__t; |
| } |
| |
| int __libcpp_thread_join(__libcpp_thread_t *__t) |
| { |
| return pthread_join(*__t, 0); |
| } |
| |
| int __libcpp_thread_detach(__libcpp_thread_t *__t) |
| { |
| return pthread_detach(*__t); |
| } |
| |
| void __libcpp_thread_yield() |
| { |
| sched_yield(); |
| } |
| |
| void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) |
| { |
| using namespace chrono; |
| seconds __s = duration_cast<seconds>(__ns); |
| timespec __ts; |
| typedef decltype(__ts.tv_sec) ts_sec; |
| _LIBCPP_CONSTEXPR ts_sec __ts_sec_max = numeric_limits<ts_sec>::max(); |
| |
| if (__s.count() < __ts_sec_max) |
| { |
| __ts.tv_sec = static_cast<ts_sec>(__s.count()); |
| __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count()); |
| } |
| else |
| { |
| __ts.tv_sec = __ts_sec_max; |
| __ts.tv_nsec = 999999999; // (10^9 - 1) |
| } |
| |
| while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR); |
| } |
| |
| // Thread local storage |
| int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *)) |
| { |
| return pthread_key_create(__key, __at_exit); |
| } |
| |
| void *__libcpp_tls_get(__libcpp_tls_key __key) |
| { |
| return pthread_getspecific(__key); |
| } |
| |
| int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) |
| { |
| return pthread_setspecific(__key, __p); |
| } |
| |
| #elif defined(_LIBCPP_HAS_THREAD_API_WIN32) |
| |
| // Mutex |
| int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) |
| { |
| InitializeCriticalSection(__m); |
| return 0; |
| } |
| |
| int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) |
| { |
| EnterCriticalSection(__m); |
| return 0; |
| } |
| |
| bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) |
| { |
| return TryEnterCriticalSection(__m) != 0; |
| } |
| |
| int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m) |
| { |
| LeaveCriticalSection(__m); |
| return 0; |
| } |
| |
| int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) |
| { |
| DeleteCriticalSection(__m); |
| return 0; |
| } |
| |
| int __libcpp_mutex_lock(__libcpp_mutex_t *__m) |
| { |
| AcquireSRWLockExclusive(__m); |
| return 0; |
| } |
| |
| bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) |
| { |
| return TryAcquireSRWLockExclusive(__m) != 0; |
| } |
| |
| int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) |
| { |
| ReleaseSRWLockExclusive(__m); |
| return 0; |
| } |
| |
| int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) |
| { |
| static_cast<void>(__m); |
| return 0; |
| } |
| |
| // Condition Variable |
| int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) |
| { |
| WakeConditionVariable(__cv); |
| return 0; |
| } |
| |
| int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) |
| { |
| WakeAllConditionVariable(__cv); |
| return 0; |
| } |
| |
| int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) |
| { |
| SleepConditionVariableSRW(__cv, __m, INFINITE, 0); |
| return 0; |
| } |
| |
| int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| timespec *__ts) |
| { |
| using namespace _VSTD::chrono; |
| |
| auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec); |
| auto abstime = |
| system_clock::time_point(duration_cast<system_clock::duration>(duration)); |
| auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now()); |
| |
| if (!SleepConditionVariableSRW(__cv, __m, |
| timeout_ms.count() > 0 ? timeout_ms.count() |
| : 0, |
| 0)) |
| return GetLastError(); |
| return 0; |
| } |
| |
| int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) |
| { |
| static_cast<void>(__cv); |
| return 0; |
| } |
| |
| // Execute Once |
| static inline _LIBCPP_ALWAYS_INLINE BOOL CALLBACK |
| __libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter, |
| PVOID *__context) |
| { |
| static_cast<void>(__init_once); |
| static_cast<void>(__context); |
| |
| void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter); |
| init_routine(); |
| return TRUE; |
| } |
| |
| int __libcpp_execute_once(__libcpp_exec_once_flag *__flag, |
| void (*__init_routine)(void)) |
| { |
| if (!InitOnceExecuteOnce(__flag, __libcpp_init_once_execute_once_thunk, |
| reinterpret_cast<void *>(__init_routine), NULL)) |
| return GetLastError(); |
| return 0; |
| } |
| |
| // Thread ID |
| bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs, |
| __libcpp_thread_id __rhs) |
| { |
| return __lhs == __rhs; |
| } |
| |
| bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs) |
| { |
| return __lhs < __rhs; |
| } |
| |
| // Thread |
| struct __libcpp_beginthreadex_thunk_data |
| { |
| void *(*__func)(void *); |
| void *__arg; |
| }; |
| |
| static inline _LIBCPP_ALWAYS_INLINE unsigned WINAPI |
| __libcpp_beginthreadex_thunk(void *__raw_data) |
| { |
| auto *__data = |
| static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data); |
| auto *__func = __data->__func; |
| void *__arg = __data->__arg; |
| delete __data; |
| return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg))); |
| } |
| |
| bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { |
| return *__t == 0; |
| } |
| |
| int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| void *__arg) |
| { |
| auto *__data = new __libcpp_beginthreadex_thunk_data; |
| __data->__func = __func; |
| __data->__arg = __arg; |
| |
| *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, |
| __libcpp_beginthreadex_thunk, |
| __data, 0, nullptr)); |
| |
| if (*__t) |
| return 0; |
| return GetLastError(); |
| } |
| |
| __libcpp_thread_id __libcpp_thread_get_current_id() |
| { |
| return GetCurrentThreadId(); |
| } |
| |
| __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) |
| { |
| return GetThreadId(*__t); |
| } |
| |
| int __libcpp_thread_join(__libcpp_thread_t *__t) |
| { |
| if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED) |
| return GetLastError(); |
| if (!CloseHandle(*__t)) |
| return GetLastError(); |
| return 0; |
| } |
| |
| int __libcpp_thread_detach(__libcpp_thread_t *__t) |
| { |
| if (!CloseHandle(*__t)) |
| return GetLastError(); |
| return 0; |
| } |
| |
| void __libcpp_thread_yield() |
| { |
| SwitchToThread(); |
| } |
| |
| void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) |
| { |
| using namespace chrono; |
| // round-up to the nearest milisecond |
| milliseconds __ms = |
| duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999)); |
| // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx) |
| Sleep(__ms.count()); |
| } |
| |
| // Thread Local Storage |
| int __libcpp_tls_create(__libcpp_tls_key* __key, |
| void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)) |
| { |
| *__key = FlsAlloc(__at_exit); |
| if (*__key == FLS_OUT_OF_INDEXES) |
| return GetLastError(); |
| return 0; |
| } |
| |
| void *__libcpp_tls_get(__libcpp_tls_key __key) |
| { |
| return FlsGetValue(__key); |
| } |
| |
| int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) |
| { |
| if (!FlsSetValue(__key, __p)) |
| return GetLastError(); |
| return 0; |
| } |
| |
| #endif // _LIBCPP_HAS_THREAD_API_PTHREAD |
| |
| #endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| #endif // !_LIBCPP_HAS_NO_THREADS |
| |
| #endif // _LIBCPP_THREADING_SUPPORT |