1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_THREADING_SUPPORT 12 #define _LIBCPP_THREADING_SUPPORT 13 14 #include <__config> 15 #include <chrono> 16 #include <errno.h> 17 18 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER 19 #pragma GCC system_header 20 #endif 21 22 #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) 23 # include <__external_threading> 24 #elif !defined(_LIBCPP_HAS_NO_THREADS) 25 26 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) 27 # include <pthread.h> 28 # include <sched.h> 29 #endif 30 31 _LIBCPP_PUSH_MACROS 32 #include <__undef_macros> 33 34 #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ 35 defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) || \ 36 defined(_LIBCPP_HAS_THREAD_API_WIN32) 37 #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS 38 #else 39 #define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY 40 #endif 41 42 #if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(no_thread_safety_analysis) 43 #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis)) 44 #else 45 #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 46 #endif 47 48 _LIBCPP_BEGIN_NAMESPACE_STD 49 50 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) 51 // Mutex 52 typedef pthread_mutex_t __libcpp_mutex_t; 53 #define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER 54 55 typedef pthread_mutex_t __libcpp_recursive_mutex_t; 56 57 // Condition Variable 58 typedef pthread_cond_t __libcpp_condvar_t; 59 #define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER 60 61 // Execute once 62 typedef pthread_once_t __libcpp_exec_once_flag; 63 #define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT 64 65 // Thread id 66 typedef pthread_t __libcpp_thread_id; 67 68 // Thread 69 #define _LIBCPP_NULL_THREAD 0U 70 71 typedef pthread_t __libcpp_thread_t; 72 73 // Thread Local Storage 74 typedef pthread_key_t __libcpp_tls_key; 75 76 #define _LIBCPP_TLS_DESTRUCTOR_CC 77 #else 78 // Mutex 79 typedef void* __libcpp_mutex_t; 80 #define _LIBCPP_MUTEX_INITIALIZER 0 81 82 #if defined(_M_IX86) || defined(__i386__) || defined(_M_ARM) || defined(__arm__) 83 typedef void* __libcpp_recursive_mutex_t[6]; 84 #elif defined(_M_AMD64) || defined(__x86_64__) || defined(_M_ARM64) || defined(__aarch64__) 85 typedef void* __libcpp_recursive_mutex_t[5]; 86 #else 87 # error Unsupported architecture 88 #endif 89 90 // Condition Variable 91 typedef void* __libcpp_condvar_t; 92 #define _LIBCPP_CONDVAR_INITIALIZER 0 93 94 // Execute Once 95 typedef void* __libcpp_exec_once_flag; 96 #define _LIBCPP_EXEC_ONCE_INITIALIZER 0 97 98 // Thread ID 99 typedef long __libcpp_thread_id; 100 101 // Thread 102 #define _LIBCPP_NULL_THREAD 0U 103 104 typedef void* __libcpp_thread_t; 105 106 // Thread Local Storage 107 typedef long __libcpp_tls_key; 108 109 #define _LIBCPP_TLS_DESTRUCTOR_CC __stdcall 110 #endif 111 112 // Mutex 113 _LIBCPP_THREAD_ABI_VISIBILITY 114 int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m); 115 116 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 117 int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m); 118 119 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 120 bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m); 121 122 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 123 int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m); 124 125 _LIBCPP_THREAD_ABI_VISIBILITY 126 int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m); 127 128 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 129 int __libcpp_mutex_lock(__libcpp_mutex_t *__m); 130 131 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 132 bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m); 133 134 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 135 int __libcpp_mutex_unlock(__libcpp_mutex_t *__m); 136 137 _LIBCPP_THREAD_ABI_VISIBILITY 138 int __libcpp_mutex_destroy(__libcpp_mutex_t *__m); 139 140 // Condition variable 141 _LIBCPP_THREAD_ABI_VISIBILITY 142 int __libcpp_condvar_signal(__libcpp_condvar_t* __cv); 143 144 _LIBCPP_THREAD_ABI_VISIBILITY 145 int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv); 146 147 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 148 int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m); 149 150 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS 151 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, 152 timespec *__ts); 153 154 _LIBCPP_THREAD_ABI_VISIBILITY 155 int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv); 156 157 // Execute once 158 _LIBCPP_THREAD_ABI_VISIBILITY 159 int __libcpp_execute_once(__libcpp_exec_once_flag *flag, 160 void (*init_routine)(void)); 161 162 // Thread id 163 _LIBCPP_THREAD_ABI_VISIBILITY 164 bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2); 165 166 _LIBCPP_THREAD_ABI_VISIBILITY 167 bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2); 168 169 // Thread 170 _LIBCPP_THREAD_ABI_VISIBILITY 171 bool __libcpp_thread_isnull(const __libcpp_thread_t *__t); 172 173 _LIBCPP_THREAD_ABI_VISIBILITY 174 int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), 175 void *__arg); 176 177 _LIBCPP_THREAD_ABI_VISIBILITY 178 __libcpp_thread_id __libcpp_thread_get_current_id(); 179 180 _LIBCPP_THREAD_ABI_VISIBILITY 181 __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t); 182 183 _LIBCPP_THREAD_ABI_VISIBILITY 184 int __libcpp_thread_join(__libcpp_thread_t *__t); 185 186 _LIBCPP_THREAD_ABI_VISIBILITY 187 int __libcpp_thread_detach(__libcpp_thread_t *__t); 188 189 _LIBCPP_THREAD_ABI_VISIBILITY 190 void __libcpp_thread_yield(); 191 192 _LIBCPP_THREAD_ABI_VISIBILITY 193 void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns); 194 195 // Thread local storage 196 _LIBCPP_THREAD_ABI_VISIBILITY 197 int __libcpp_tls_create(__libcpp_tls_key* __key, 198 void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)); 199 200 _LIBCPP_THREAD_ABI_VISIBILITY 201 void *__libcpp_tls_get(__libcpp_tls_key __key); 202 203 _LIBCPP_THREAD_ABI_VISIBILITY 204 int __libcpp_tls_set(__libcpp_tls_key __key, void *__p); 205 206 #if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ 207 defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)) && \ 208 defined(_LIBCPP_HAS_THREAD_API_PTHREAD) 209 210 int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) 211 { 212 pthread_mutexattr_t attr; 213 int __ec = pthread_mutexattr_init(&attr); 214 if (__ec) 215 return __ec; 216 __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); 217 if (__ec) { 218 pthread_mutexattr_destroy(&attr); 219 return __ec; 220 } 221 __ec = pthread_mutex_init(__m, &attr); 222 if (__ec) { 223 pthread_mutexattr_destroy(&attr); 224 return __ec; 225 } 226 __ec = pthread_mutexattr_destroy(&attr); 227 if (__ec) { 228 pthread_mutex_destroy(__m); 229 return __ec; 230 } 231 return 0; 232 } 233 234 int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) 235 { 236 return pthread_mutex_lock(__m); 237 } 238 239 bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) 240 { 241 return pthread_mutex_trylock(__m) == 0; 242 } 243 244 int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m) 245 { 246 return pthread_mutex_unlock(__m); 247 } 248 249 int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) 250 { 251 return pthread_mutex_destroy(__m); 252 } 253 254 int __libcpp_mutex_lock(__libcpp_mutex_t *__m) 255 { 256 return pthread_mutex_lock(__m); 257 } 258 259 bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) 260 { 261 return pthread_mutex_trylock(__m) == 0; 262 } 263 264 int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) 265 { 266 return pthread_mutex_unlock(__m); 267 } 268 269 int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) 270 { 271 return pthread_mutex_destroy(__m); 272 } 273 274 // Condition Variable 275 int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) 276 { 277 return pthread_cond_signal(__cv); 278 } 279 280 int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) 281 { 282 return pthread_cond_broadcast(__cv); 283 } 284 285 int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) 286 { 287 return pthread_cond_wait(__cv, __m); 288 } 289 290 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, 291 timespec *__ts) 292 { 293 return pthread_cond_timedwait(__cv, __m, __ts); 294 } 295 296 int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) 297 { 298 return pthread_cond_destroy(__cv); 299 } 300 301 // Execute once 302 int __libcpp_execute_once(__libcpp_exec_once_flag *flag, 303 void (*init_routine)(void)) { 304 return pthread_once(flag, init_routine); 305 } 306 307 // Thread id 308 // Returns non-zero if the thread ids are equal, otherwise 0 309 bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2) 310 { 311 return pthread_equal(t1, t2) != 0; 312 } 313 314 // Returns non-zero if t1 < t2, otherwise 0 315 bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2) 316 { 317 return t1 < t2; 318 } 319 320 // Thread 321 bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { 322 return *__t == 0; 323 } 324 325 int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), 326 void *__arg) 327 { 328 return pthread_create(__t, 0, __func, __arg); 329 } 330 331 __libcpp_thread_id __libcpp_thread_get_current_id() 332 { 333 return pthread_self(); 334 } 335 336 __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) 337 { 338 return *__t; 339 } 340 341 int __libcpp_thread_join(__libcpp_thread_t *__t) 342 { 343 return pthread_join(*__t, 0); 344 } 345 346 int __libcpp_thread_detach(__libcpp_thread_t *__t) 347 { 348 return pthread_detach(*__t); 349 } 350 351 void __libcpp_thread_yield() 352 { 353 sched_yield(); 354 } 355 356 void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) 357 { 358 using namespace chrono; 359 seconds __s = duration_cast<seconds>(__ns); 360 timespec __ts; 361 typedef decltype(__ts.tv_sec) ts_sec; 362 _LIBCPP_CONSTEXPR ts_sec __ts_sec_max = numeric_limits<ts_sec>::max(); 363 364 if (__s.count() < __ts_sec_max) 365 { 366 __ts.tv_sec = static_cast<ts_sec>(__s.count()); 367 __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count()); 368 } 369 else 370 { 371 __ts.tv_sec = __ts_sec_max; 372 __ts.tv_nsec = 999999999; // (10^9 - 1) 373 } 374 375 while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR); 376 } 377 378 // Thread local storage 379 int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *)) 380 { 381 return pthread_key_create(__key, __at_exit); 382 } 383 384 void *__libcpp_tls_get(__libcpp_tls_key __key) 385 { 386 return pthread_getspecific(__key); 387 } 388 389 int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) 390 { 391 return pthread_setspecific(__key, __p); 392 } 393 394 #endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL 395 396 _LIBCPP_END_NAMESPACE_STD 397 398 _LIBCPP_POP_MACROS 399 400 #endif // !_LIBCPP_HAS_NO_THREADS 401 402 #endif // _LIBCPP_THREADING_SUPPORT 403
