codekingpro/portable-devtools

1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCUDACXX_THREADING_SUPPORT11#define _LIBCUDACXX_THREADING_SUPPORT12 13#ifndef __cuda_std__14#include <__config>15#include <errno.h>16#else17#include "__cuda/atomic_prelude.h"18#endif // __cuda_std__19 20#include "__assert" // all public C++ headers provide the assertion handler21#include "__functional/hash.h"22#include "chrono"23#include "climits"24#include "iosfwd"25 26#ifndef __cuda_std__27#include <__pragma_push>28#endif // __cuda_std__29 30#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)31#  pragma GCC system_header32#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)33#  pragma clang system_header34#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)35#  pragma system_header36#endif // no system header37 38#if defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)39# ifndef __cuda_std__40#  include <__external_threading>41# else42#  define _LIBCUDACXX_THREAD_ABI_VISIBILITY inline _LIBCUDACXX_INLINE_VISIBILITY43# endif44#elif !defined(_LIBCUDACXX_HAS_NO_THREADS)45 46#if defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)47# include <pthread.h>48# include <sched.h>49# include <semaphore.h>50# if defined(__APPLE__)51#  include <dispatch/dispatch.h>52# endif53# if defined(__linux__)54#  include <unistd.h>55#  include <linux/futex.h>56#  include <sys/syscall.h>57# endif58#endif59 60#if defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)61# include <process.h>62# include <windows.h>63#endif64 65#if defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || \66    defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)67#define _LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_FUNC_VIS68#else69#define _LIBCUDACXX_THREAD_ABI_VISIBILITY inline _LIBCUDACXX_INLINE_VISIBILITY70#endif71 72#if defined(__FreeBSD__) && defined(_LIBCUDACXX_COMPILER_CLANG) && __has_attribute(no_thread_safety_analysis)73#define _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))74#else75#define _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS76#endif77 78typedef ::timespec __libcpp_timespec_t;79#endif // !defined(_LIBCUDACXX_HAS_NO_THREADS)80 81_LIBCUDACXX_BEGIN_NAMESPACE_STD82 83#if !defined(_LIBCUDACXX_HAS_NO_THREADS)84 85#define _LIBCUDACXX_POLLING_COUNT 1686 87_LIBCUDACXX_INLINE_VISIBILITY88inline void __libcpp_thread_yield_processor()89{90#if defined(__aarch64__)91# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("yield" :::);)92#elif defined(__x86_64__)93# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("pause" :::);)94#elif defined (__powerpc__)95# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("or 27,27,27":::);)96#else97# define __LIBCUDACXX_ASM_THREAD_YIELD (;)98#endif99    NV_IF_TARGET(100        NV_IS_HOST,101            __LIBCUDACXX_ASM_THREAD_YIELD102    )103}104 105_LIBCUDACXX_THREAD_ABI_VISIBILITY106void __libcpp_thread_yield();107 108_LIBCUDACXX_THREAD_ABI_VISIBILITY109void __libcpp_thread_sleep_for(chrono::nanoseconds __ns);110 111template<class _Fn>112_LIBCUDACXX_THREAD_ABI_VISIBILITY113bool __libcpp_thread_poll_with_backoff(_Fn && __f, chrono::nanoseconds __max = chrono::nanoseconds::zero());114 115#if defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)116// Mutex117typedef pthread_mutex_t __libcpp_mutex_t;118#define _LIBCUDACXX_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER119 120typedef pthread_mutex_t __libcpp_recursive_mutex_t;121 122// Condition Variable123typedef pthread_cond_t __libcpp_condvar_t;124#define _LIBCUDACXX_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER125 126// Semaphore127#if defined(__APPLE__)128typedef dispatch_semaphore_t __libcpp_semaphore_t;129# define _LIBCUDACXX_SEMAPHORE_MAX numeric_limits<long>::max()130#else131typedef sem_t __libcpp_semaphore_t;132# define _LIBCUDACXX_SEMAPHORE_MAX SEM_VALUE_MAX133#endif134 135// Execute once136typedef pthread_once_t __libcpp_exec_once_flag;137#define _LIBCUDACXX_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT138 139// Thread id140typedef pthread_t __libcpp_thread_id;141 142// Thread143#define _LIBCUDACXX_NULL_THREAD 0U144 145typedef pthread_t __libcpp_thread_t;146 147// Thread Local Storage148typedef pthread_key_t __libcpp_tls_key;149 150#define _LIBCUDACXX_TLS_DESTRUCTOR_CC151#elif !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)152// Mutex153typedef void* __libcpp_mutex_t;154#define _LIBCUDACXX_MUTEX_INITIALIZER 0155 156#if defined(_M_IX86) || defined(__i386__) || defined(_M_ARM) || defined(__arm__)157typedef void* __libcpp_recursive_mutex_t[6];158#elif defined(_M_AMD64) || defined(__x86_64__) || defined(_M_ARM64) || defined(__aarch64__)159typedef void* __libcpp_recursive_mutex_t[5];160#else161# error Unsupported architecture162#endif163 164// Condition Variable165typedef void* __libcpp_condvar_t;166#define _LIBCUDACXX_CONDVAR_INITIALIZER 0167 168// Semaphore169typedef void* __libcpp_semaphore_t;170 171// Execute Once172typedef void* __libcpp_exec_once_flag;173#define _LIBCUDACXX_EXEC_ONCE_INITIALIZER 0174 175// Thread ID176typedef long __libcpp_thread_id;177 178// Thread179#define _LIBCUDACXX_NULL_THREAD 0U180 181typedef void* __libcpp_thread_t;182 183// Thread Local Storage184typedef long __libcpp_tls_key;185 186#define _LIBCUDACXX_TLS_DESTRUCTOR_CC __stdcall187#endif // !defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD) && !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)188 189#if !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)190 191_LIBCUDACXX_THREAD_ABI_VISIBILITY192__libcpp_timespec_t __libcpp_to_timespec(const chrono::nanoseconds& __ns);193 194// Mutex195_LIBCUDACXX_THREAD_ABI_VISIBILITY196int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);197 198_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS199int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m);200 201_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS202bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m);203 204_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS205int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m);206 207_LIBCUDACXX_THREAD_ABI_VISIBILITY208int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m);209 210_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS211int __libcpp_mutex_lock(__libcpp_mutex_t *__m);212 213_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS214bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m);215 216_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS217int __libcpp_mutex_unlock(__libcpp_mutex_t *__m);218 219_LIBCUDACXX_THREAD_ABI_VISIBILITY220int __libcpp_mutex_destroy(__libcpp_mutex_t *__m);221 222// Condition variable223_LIBCUDACXX_THREAD_ABI_VISIBILITY224int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);225 226_LIBCUDACXX_THREAD_ABI_VISIBILITY227int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);228 229_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS230int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);231 232_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS233int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,234                               __libcpp_timespec_t *__ts);235 236_LIBCUDACXX_THREAD_ABI_VISIBILITY237int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);238 239// Semaphore240_LIBCUDACXX_THREAD_ABI_VISIBILITY241bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init);242 243_LIBCUDACXX_THREAD_ABI_VISIBILITY244bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem);245 246_LIBCUDACXX_THREAD_ABI_VISIBILITY247bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem);248 249_LIBCUDACXX_THREAD_ABI_VISIBILITY250bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem);251 252_LIBCUDACXX_THREAD_ABI_VISIBILITY253bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns);254 255// Execute once256_LIBCUDACXX_THREAD_ABI_VISIBILITY257int __libcpp_execute_once(__libcpp_exec_once_flag *flag,258                          void (*init_routine)());259 260// Thread id261_LIBCUDACXX_THREAD_ABI_VISIBILITY262bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);263 264_LIBCUDACXX_THREAD_ABI_VISIBILITY265bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2);266 267// Thread268_LIBCUDACXX_THREAD_ABI_VISIBILITY269bool __libcpp_thread_isnull(const __libcpp_thread_t *__t);270 271_LIBCUDACXX_THREAD_ABI_VISIBILITY272int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),273                           void *__arg);274 275_LIBCUDACXX_THREAD_ABI_VISIBILITY276__libcpp_thread_id __libcpp_thread_get_current_id();277 278_LIBCUDACXX_THREAD_ABI_VISIBILITY279__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t);280 281_LIBCUDACXX_THREAD_ABI_VISIBILITY282int __libcpp_thread_join(__libcpp_thread_t *__t);283 284_LIBCUDACXX_THREAD_ABI_VISIBILITY285int __libcpp_thread_detach(__libcpp_thread_t *__t);286 287// Thread local storage288_LIBCUDACXX_THREAD_ABI_VISIBILITY289int __libcpp_tls_create(__libcpp_tls_key* __key,290                        void(_LIBCUDACXX_TLS_DESTRUCTOR_CC* __at_exit)(void*));291 292_LIBCUDACXX_THREAD_ABI_VISIBILITY293void *__libcpp_tls_get(__libcpp_tls_key __key);294 295_LIBCUDACXX_THREAD_ABI_VISIBILITY296int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);297 298#endif // !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)299 300#if !defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)301 302#if defined(_LIBCUDACXX_HAS_THREAD_API_CUDA)303 304_LIBCUDACXX_THREAD_ABI_VISIBILITY305void __libcpp_thread_yield() {}306 307_LIBCUDACXX_THREAD_ABI_VISIBILITY308void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)309{310    NV_IF_TARGET(311        NV_IS_DEVICE, (312            auto const __step = __ns.count();313            assert(__step < numeric_limits<unsigned>::max());314            asm volatile("nanosleep.u32 %0;"::"r"((unsigned)__step):);315        )316    )317}318 319#elif defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)320 321_LIBCUDACXX_THREAD_ABI_VISIBILITY322__libcpp_timespec_t __libcpp_to_timespec(const chrono::nanoseconds& __ns)323{324     using namespace chrono;325     seconds __s = duration_cast<seconds>(__ns);326     __libcpp_timespec_t __ts;327     typedef decltype(__ts.tv_sec) ts_sec;328     constexpr ts_sec __ts_sec_max = numeric_limits<ts_sec>::max();329 330     if (__s.count() < __ts_sec_max)331     {332         __ts.tv_sec = static_cast<ts_sec>(__s.count());333         __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());334     }335     else336     {337         __ts.tv_sec = __ts_sec_max;338         __ts.tv_nsec = 999999999; // (10^9 - 1)339     }340     return __ts;341}342 343_LIBCUDACXX_THREAD_ABI_VISIBILITY344int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)345{346    pthread_mutexattr_t attr;347    int __ec = pthread_mutexattr_init(&attr);348    if (__ec)349        return __ec;350    __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);351    if (__ec) {352        pthread_mutexattr_destroy(&attr);353        return __ec;354    }355    __ec = pthread_mutex_init(__m, &attr);356    if (__ec) {357        pthread_mutexattr_destroy(&attr);358        return __ec;359    }360    __ec = pthread_mutexattr_destroy(&attr);361    if (__ec) {362        pthread_mutex_destroy(__m);363        return __ec;364    }365    return 0;366}367 368_LIBCUDACXX_THREAD_ABI_VISIBILITY369int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)370{371    return pthread_mutex_lock(__m);372}373 374_LIBCUDACXX_THREAD_ABI_VISIBILITY375bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)376{377    return pthread_mutex_trylock(__m) == 0;378}379 380_LIBCUDACXX_THREAD_ABI_VISIBILITY381int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m)382{383    return pthread_mutex_unlock(__m);384}385 386_LIBCUDACXX_THREAD_ABI_VISIBILITY387int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)388{389    return pthread_mutex_destroy(__m);390}391 392_LIBCUDACXX_THREAD_ABI_VISIBILITY393int __libcpp_mutex_lock(__libcpp_mutex_t *__m)394{395    return pthread_mutex_lock(__m);396}397 398_LIBCUDACXX_THREAD_ABI_VISIBILITY399bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)400{401    return pthread_mutex_trylock(__m) == 0;402}403 404_LIBCUDACXX_THREAD_ABI_VISIBILITY405int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)406{407    return pthread_mutex_unlock(__m);408}409 410_LIBCUDACXX_THREAD_ABI_VISIBILITY411int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)412{413  return pthread_mutex_destroy(__m);414}415 416// Condition Variable417_LIBCUDACXX_THREAD_ABI_VISIBILITY418int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)419{420    return pthread_cond_signal(__cv);421}422 423_LIBCUDACXX_THREAD_ABI_VISIBILITY424int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)425{426    return pthread_cond_broadcast(__cv);427}428 429_LIBCUDACXX_THREAD_ABI_VISIBILITY430int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)431{432    return pthread_cond_wait(__cv, __m);433}434 435_LIBCUDACXX_THREAD_ABI_VISIBILITY436int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,437                               __libcpp_timespec_t *__ts)438{439    return pthread_cond_timedwait(__cv, __m, __ts);440}441 442_LIBCUDACXX_THREAD_ABI_VISIBILITY443int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)444{445    return pthread_cond_destroy(__cv);446}447 448// Semaphore449#if defined(__APPLE__)450 451bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)452{453    return (*__sem = dispatch_semaphore_create(__init)) != NULL;454}455 456bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)457{458    dispatch_release(*__sem);459    return true;460}461 462bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)463{464    dispatch_semaphore_signal(*__sem);465    return true;466}467 468bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)469{470    return dispatch_semaphore_wait(*__sem, DISPATCH_TIME_FOREVER) == 0;471}472 473bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns)474{475    return dispatch_semaphore_wait(*__sem, dispatch_time(DISPATCH_TIME_NOW, __ns.count())) == 0;476}477 478#else479 480_LIBCUDACXX_THREAD_ABI_VISIBILITY481bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)482{483    return sem_init(__sem, 0, __init) == 0;484}485 486_LIBCUDACXX_THREAD_ABI_VISIBILITY487bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)488{489    return sem_destroy(__sem) == 0;490}491 492_LIBCUDACXX_THREAD_ABI_VISIBILITY493bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)494{495    return sem_post(__sem) == 0;496}497 498_LIBCUDACXX_THREAD_ABI_VISIBILITY499bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)500{501    return sem_wait(__sem) == 0;502}503 504_LIBCUDACXX_THREAD_ABI_VISIBILITY505bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns)506{507    __libcpp_timespec_t __ts = __libcpp_to_timespec(__ns);508    return sem_timedwait(__sem, &__ts) == 0;509}510 511#endif //__APPLE__512 513// Execute once514_LIBCUDACXX_THREAD_ABI_VISIBILITY515int __libcpp_execute_once(__libcpp_exec_once_flag *flag, void (*init_routine)())516{517    return pthread_once(flag, init_routine);518}519 520// Thread id521// Returns non-zero if the thread ids are equal, otherwise 0522_LIBCUDACXX_THREAD_ABI_VISIBILITY523bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)524{525    return pthread_equal(t1, t2) != 0;526}527 528// Returns non-zero if t1 < t2, otherwise 0529_LIBCUDACXX_THREAD_ABI_VISIBILITY530bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)531{532    return t1 < t2;533}534 535// Thread536_LIBCUDACXX_THREAD_ABI_VISIBILITY537bool __libcpp_thread_isnull(const __libcpp_thread_t *__t)538{539    return *__t == 0;540}541 542_LIBCUDACXX_THREAD_ABI_VISIBILITY543int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),544                           void *__arg)545{546    return pthread_create(__t, 0, __func, __arg);547}548 549_LIBCUDACXX_THREAD_ABI_VISIBILITY550__libcpp_thread_id __libcpp_thread_get_current_id()551{552    return pthread_self();553}554 555_LIBCUDACXX_THREAD_ABI_VISIBILITY556__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)557{558    return *__t;559}560 561_LIBCUDACXX_THREAD_ABI_VISIBILITY562int __libcpp_thread_join(__libcpp_thread_t *__t)563{564    return pthread_join(*__t, 0);565}566 567_LIBCUDACXX_THREAD_ABI_VISIBILITY568int __libcpp_thread_detach(__libcpp_thread_t *__t)569{570    return pthread_detach(*__t);571}572 573// Thread local storage574_LIBCUDACXX_THREAD_ABI_VISIBILITY575int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *))576{577    return pthread_key_create(__key, __at_exit);578}579 580_LIBCUDACXX_THREAD_ABI_VISIBILITY581void *__libcpp_tls_get(__libcpp_tls_key __key)582{583    return pthread_getspecific(__key);584}585 586_LIBCUDACXX_THREAD_ABI_VISIBILITY587int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)588{589    return pthread_setspecific(__key, __p);590}591 592_LIBCUDACXX_THREAD_ABI_VISIBILITY593void __libcpp_thread_yield()594{595    sched_yield();596}597 598_LIBCUDACXX_THREAD_ABI_VISIBILITY599void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)600{601    __libcpp_timespec_t __ts = __libcpp_to_timespec(__ns);602    while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);603}604 605#if defined(__linux__) && !defined(_LIBCUDACXX_HAS_NO_PLATFORM_WAIT)606 607#define _LIBCUDACXX_HAS_PLATFORM_WAIT608 609typedef int __libcpp_platform_wait_t;610 611template<typename _Tp>612struct __libcpp_platform_wait_uses_type {613    enum { __value = is_same<__remove_cv_t<_Tp>, __libcpp_platform_wait_t>::value };614};615 616template <class _Tp, typename enable_if<__libcpp_platform_wait_uses_type<_Tp>::__value, int>::type = 1>617void __libcpp_platform_wait(_Tp const* ptr, _Tp val, void const* timeout) {618    syscall(SYS_futex, ptr, FUTEX_WAIT_PRIVATE, val, timeout, 0, 0);619}620 621template <class _Tp, typename enable_if<__libcpp_platform_wait_uses_type<_Tp>::__value, int>::type = 1>622void __libcpp_platform_wake(_Tp const* ptr, bool all) {623    syscall(SYS_futex, ptr, FUTEX_WAKE_PRIVATE, all ? INT_MAX : 1, 0, 0, 0);624}625 626#endif // defined(__linux__) && !defined(_LIBCUDACXX_HAS_NO_PLATFORM_WAIT)627 628#elif defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)629 630void __libcpp_thread_yield()631{632    SwitchToThread();633}634 635void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)636{637    using namespace chrono;638    // round-up to the nearest milisecond639    milliseconds __ms =640        duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999));641    Sleep(static_cast<DWORD>(__ms.count()));642}643 644#endif // defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)645 646#endif // !defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)647 648template<class _Fn>649_LIBCUDACXX_THREAD_ABI_VISIBILITY650bool __libcpp_thread_poll_with_backoff(_Fn && __f, chrono::nanoseconds __max)651{652    chrono::high_resolution_clock::time_point const __start = chrono::high_resolution_clock::now();653    for(int __count = 0;;) {654      if(__f())655        return true;656      if(__count < _LIBCUDACXX_POLLING_COUNT) {657        if(__count > (_LIBCUDACXX_POLLING_COUNT >> 1))658          __libcpp_thread_yield_processor();659        __count += 1;660        continue;661      }662      chrono::high_resolution_clock::duration const __elapsed = chrono::high_resolution_clock::now() - __start;663      if(__max != chrono::nanoseconds::zero() &&664         __max < __elapsed)665         return false;666      chrono::nanoseconds const __step = __elapsed / 4;667      if(__step >= chrono::milliseconds(1))668        __libcpp_thread_sleep_for(chrono::milliseconds(1));669      else if(__step >= chrono::microseconds(10))670        __libcpp_thread_sleep_for(__step);671      else672        __libcpp_thread_yield();673    }674}675 676#ifndef _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE677 678struct alignas(64) __libcpp_contention_t {679#if defined(_LIBCUDACXX_HAS_PLATFORM_WAIT)680    ptrdiff_t                __waiters = 0;681    __libcpp_platform_wait_t __version = 0;682#else683    ptrdiff_t                __credit = 0;684    __libcpp_mutex_t         __mutex = _LIBCUDACXX_MUTEX_INITIALIZER;685    __libcpp_condvar_t       __condvar = _LIBCUDACXX_CONDVAR_INITIALIZER;686#endif687};688 689_LIBCUDACXX_FUNC_VIS690__libcpp_contention_t * __libcpp_contention_state(void const volatile * p) noexcept;691 692#endif // _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE693 694#if !defined(_LIBCUDACXX_HAS_NO_TREE_BARRIER) && !defined(_LIBCUDACXX_HAS_NO_THREAD_FAVORITE_BARRIER_INDEX)695 696_LIBCUDACXX_EXPORTED_FROM_ABI697extern thread_local ptrdiff_t __libcpp_thread_favorite_barrier_index;698 699#endif700 701#ifndef __cuda_std__702 703class _LIBCUDACXX_TYPE_VIS thread;704class _LIBCUDACXX_TYPE_VIS __thread_id;705 706namespace this_thread707{708 709_LIBCUDACXX_INLINE_VISIBILITY __thread_id get_id() noexcept;710 711}  // this_thread712 713template<> struct hash<__thread_id>;714 715class _LIBCUDACXX_TEMPLATE_VIS __thread_id716{717    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.718    // NULL is the no-thread value on Darwin.  Someone needs to check719    // on other platforms.  We assume 0 works everywhere for now.720    __libcpp_thread_id __id_;721 722public:723    _LIBCUDACXX_INLINE_VISIBILITY724    __thread_id() noexcept : __id_(0) {}725 726    friend _LIBCUDACXX_INLINE_VISIBILITY727        bool operator==(__thread_id __x, __thread_id __y) noexcept728        { // don't pass id==0 to underlying routines729        if (__x.__id_ == 0) return __y.__id_ == 0;730        if (__y.__id_ == 0) return false;731        return __libcpp_thread_id_equal(__x.__id_, __y.__id_);732        }733    friend _LIBCUDACXX_INLINE_VISIBILITY734        bool operator!=(__thread_id __x, __thread_id __y) noexcept735        {return !(__x == __y);}736    friend _LIBCUDACXX_INLINE_VISIBILITY737        bool operator< (__thread_id __x, __thread_id __y) noexcept738        { // id==0 is always less than any other thread_id739        if (__x.__id_ == 0) return __y.__id_ != 0;740        if (__y.__id_ == 0) return false;741        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);742        }743    friend _LIBCUDACXX_INLINE_VISIBILITY744        bool operator<=(__thread_id __x, __thread_id __y) noexcept745        {return !(__y < __x);}746    friend _LIBCUDACXX_INLINE_VISIBILITY747        bool operator> (__thread_id __x, __thread_id __y) noexcept748        {return   __y < __x ;}749    friend _LIBCUDACXX_INLINE_VISIBILITY750        bool operator>=(__thread_id __x, __thread_id __y) noexcept751        {return !(__x < __y);}752 753    _LIBCUDACXX_INLINE_VISIBILITY754    void __reset() { __id_ = 0; }755 756#ifndef __cuda_std__757    template<class _CharT, class _Traits>758    friend759    _LIBCUDACXX_INLINE_VISIBILITY760    basic_ostream<_CharT, _Traits>&761    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);762#endif763 764private:765    _LIBCUDACXX_INLINE_VISIBILITY766    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}767 768    friend __thread_id this_thread::get_id() noexcept;769    friend class _LIBCUDACXX_TYPE_VIS thread;770    friend struct _LIBCUDACXX_TEMPLATE_VIS hash<__thread_id>;771};772 773namespace this_thread774{775 776inline _LIBCUDACXX_INLINE_VISIBILITY777__thread_id778get_id() noexcept779{780    return __libcpp_thread_get_current_id();781}782 783}  // this_thread784 785#endif // __cuda_std__786 787#endif // !_LIBCUDACXX_HAS_NO_THREADS788 789_LIBCUDACXX_END_NAMESPACE_STD790 791#ifndef __cuda_std__792#include <__pragma_pop>793#endif794 795#endif // _LIBCUDACXX_THREADING_SUPPORT796