Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 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> |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 15 | #include <chrono> |
| 16 | #include <errno.h> |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 17 | |
| 18 | #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER |
| 19 | #pragma GCC system_header |
| 20 | #endif |
| 21 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 22 | #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL) |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 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> |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 29 | #elif defined(_LIBCPP_HAS_THREAD_API_WIN32) |
Martell Malone | fa3bd28 | 2017-05-25 22:37:15 +0000 | [diff] [blame] | 30 | #include <windows.h> |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 31 | #include <process.h> |
| 32 | #include <fibersapi.h> |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 33 | #endif |
| 34 | |
Eric Fiselier | 018a3d5 | 2017-05-31 22:07:49 +0000 | [diff] [blame] | 35 | _LIBCPP_PUSH_MACROS |
| 36 | #include <__undef_macros> |
| 37 | |
| 38 | |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 39 | #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ |
| 40 | defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 41 | #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS |
| 42 | #else |
| 43 | #define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY |
| 44 | #endif |
| 45 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 46 | #if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(no_thread_safety_analysis) |
| 47 | #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis)) |
| 48 | #else |
| 49 | #define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
| 50 | #endif |
| 51 | |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 52 | _LIBCPP_BEGIN_NAMESPACE_STD |
| 53 | |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 54 | #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 55 | // Mutex |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 56 | typedef pthread_mutex_t __libcpp_mutex_t; |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 57 | #define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 58 | |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 59 | typedef pthread_mutex_t __libcpp_recursive_mutex_t; |
| 60 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 61 | // Condition Variable |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 62 | typedef pthread_cond_t __libcpp_condvar_t; |
| 63 | #define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 64 | |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 65 | // Execute once |
| 66 | typedef pthread_once_t __libcpp_exec_once_flag; |
| 67 | #define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT |
| 68 | |
| 69 | // Thread id |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 70 | typedef pthread_t __libcpp_thread_id; |
| 71 | |
| 72 | // Thread |
Asiri Rathnayake | a1d7d2f | 2017-01-16 12:19:54 +0000 | [diff] [blame] | 73 | #define _LIBCPP_NULL_THREAD 0U |
| 74 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 75 | typedef pthread_t __libcpp_thread_t; |
| 76 | |
| 77 | // Thrad Local Storage |
| 78 | typedef pthread_key_t __libcpp_tls_key; |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 79 | |
| 80 | #define _LIBCPP_TLS_DESTRUCTOR_CC |
| 81 | #else |
| 82 | // Mutex |
| 83 | typedef SRWLOCK __libcpp_mutex_t; |
| 84 | #define _LIBCPP_MUTEX_INITIALIZER SRWLOCK_INIT |
| 85 | |
| 86 | typedef CRITICAL_SECTION __libcpp_recursive_mutex_t; |
| 87 | |
| 88 | // Condition Variable |
| 89 | typedef CONDITION_VARIABLE __libcpp_condvar_t; |
| 90 | #define _LIBCPP_CONDVAR_INITIALIZER CONDITION_VARIABLE_INIT |
| 91 | |
| 92 | // Execute Once |
| 93 | typedef INIT_ONCE __libcpp_exec_once_flag; |
| 94 | #define _LIBCPP_EXEC_ONCE_INITIALIZER INIT_ONCE_STATIC_INIT |
| 95 | |
| 96 | // Thread ID |
| 97 | typedef DWORD __libcpp_thread_id; |
| 98 | |
| 99 | // Thread |
Asiri Rathnayake | a1d7d2f | 2017-01-16 12:19:54 +0000 | [diff] [blame] | 100 | #define _LIBCPP_NULL_THREAD 0U |
| 101 | |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 102 | typedef HANDLE __libcpp_thread_t; |
| 103 | |
| 104 | // Thread Local Storage |
| 105 | typedef DWORD __libcpp_tls_key; |
| 106 | |
| 107 | #define _LIBCPP_TLS_DESTRUCTOR_CC WINAPI |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 108 | #endif |
| 109 | |
| 110 | // Mutex |
| 111 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 112 | int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m); |
| 113 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 114 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 115 | int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m); |
| 116 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 117 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 118 | bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m); |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 119 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 120 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 121 | int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m); |
| 122 | |
| 123 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 124 | int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 125 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 126 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 127 | int __libcpp_mutex_lock(__libcpp_mutex_t *__m); |
| 128 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 129 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 130 | bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 131 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 132 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 133 | int __libcpp_mutex_unlock(__libcpp_mutex_t *__m); |
| 134 | |
| 135 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 136 | int __libcpp_mutex_destroy(__libcpp_mutex_t *__m); |
| 137 | |
| 138 | // Condition variable |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 139 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 140 | int __libcpp_condvar_signal(__libcpp_condvar_t* __cv); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 141 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 142 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 143 | int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 144 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 145 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 146 | int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 147 | |
Dimitry Andric | 362353a | 2017-01-26 18:37:18 +0000 | [diff] [blame] | 148 | _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 149 | int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| 150 | timespec *__ts); |
| 151 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 152 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 153 | int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv); |
| 154 | |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 155 | // Execute once |
| 156 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 157 | int __libcpp_execute_once(__libcpp_exec_once_flag *flag, |
| 158 | void (*init_routine)(void)); |
| 159 | |
| 160 | // Thread id |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 161 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 162 | bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 163 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 164 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 165 | bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2); |
| 166 | |
| 167 | // Thread |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 168 | _LIBCPP_THREAD_ABI_VISIBILITY |
Asiri Rathnayake | a1d7d2f | 2017-01-16 12:19:54 +0000 | [diff] [blame] | 169 | bool __libcpp_thread_isnull(const __libcpp_thread_t *__t); |
| 170 | |
| 171 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 172 | int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| 173 | void *__arg); |
| 174 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 175 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 176 | __libcpp_thread_id __libcpp_thread_get_current_id(); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 177 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 178 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 179 | __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t); |
| 180 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 181 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 182 | int __libcpp_thread_join(__libcpp_thread_t *__t); |
| 183 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 184 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 185 | int __libcpp_thread_detach(__libcpp_thread_t *__t); |
| 186 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 187 | _LIBCPP_THREAD_ABI_VISIBILITY |
| 188 | void __libcpp_thread_yield(); |
| 189 | |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 190 | _LIBCPP_THREAD_ABI_VISIBILITY |
Joerg Sonnenberger | 5a0c9c3 | 2017-02-09 14:12:29 +0000 | [diff] [blame] | 191 | void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns); |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 192 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 193 | // Thread local storage |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 194 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 195 | int __libcpp_tls_create(__libcpp_tls_key* __key, |
| 196 | void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)); |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 197 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 198 | _LIBCPP_THREAD_ABI_VISIBILITY |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 199 | void *__libcpp_tls_get(__libcpp_tls_key __key); |
| 200 | |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 201 | _LIBCPP_THREAD_ABI_VISIBILITY |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 202 | int __libcpp_tls_set(__libcpp_tls_key __key, void *__p); |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 203 | |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 204 | #if !defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \ |
| 205 | defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) |
| 206 | |
| 207 | #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD) |
Asiri Rathnayake | 040945b | 2016-09-11 21:46:40 +0000 | [diff] [blame] | 208 | |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 209 | int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 210 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 211 | pthread_mutexattr_t attr; |
| 212 | int __ec = pthread_mutexattr_init(&attr); |
| 213 | if (__ec) |
| 214 | return __ec; |
| 215 | __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); |
| 216 | if (__ec) { |
| 217 | pthread_mutexattr_destroy(&attr); |
| 218 | return __ec; |
| 219 | } |
| 220 | __ec = pthread_mutex_init(__m, &attr); |
| 221 | if (__ec) { |
| 222 | pthread_mutexattr_destroy(&attr); |
| 223 | return __ec; |
| 224 | } |
| 225 | __ec = pthread_mutexattr_destroy(&attr); |
| 226 | if (__ec) { |
| 227 | pthread_mutex_destroy(__m); |
| 228 | return __ec; |
| 229 | } |
| 230 | return 0; |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 231 | } |
| 232 | |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 233 | int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) |
| 234 | { |
| 235 | return pthread_mutex_lock(__m); |
| 236 | } |
| 237 | |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 238 | bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 239 | { |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 240 | return pthread_mutex_trylock(__m) == 0; |
Saleem Abdulrasool | 3451a65 | 2017-01-05 17:54:45 +0000 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m) |
| 244 | { |
| 245 | return pthread_mutex_unlock(__m); |
| 246 | } |
| 247 | |
| 248 | int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) |
| 249 | { |
| 250 | return pthread_mutex_destroy(__m); |
| 251 | } |
| 252 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 253 | int __libcpp_mutex_lock(__libcpp_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 254 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 255 | return pthread_mutex_lock(__m); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 256 | } |
| 257 | |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 258 | bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 259 | { |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 260 | return pthread_mutex_trylock(__m) == 0; |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 261 | } |
| 262 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 263 | int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 264 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 265 | return pthread_mutex_unlock(__m); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 266 | } |
| 267 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 268 | int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 269 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 270 | return pthread_mutex_destroy(__m); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 271 | } |
| 272 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 273 | // Condition Variable |
| 274 | int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 275 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 276 | return pthread_cond_signal(__cv); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 277 | } |
| 278 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 279 | int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 280 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 281 | return pthread_cond_broadcast(__cv); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 282 | } |
| 283 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 284 | int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 285 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 286 | return pthread_cond_wait(__cv, __m); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 287 | } |
| 288 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 289 | int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| 290 | timespec *__ts) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 291 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 292 | return pthread_cond_timedwait(__cv, __m, __ts); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 293 | } |
| 294 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 295 | int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 296 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 297 | return pthread_cond_destroy(__cv); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 298 | } |
| 299 | |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 300 | // Execute once |
| 301 | int __libcpp_execute_once(__libcpp_exec_once_flag *flag, |
| 302 | void (*init_routine)(void)) { |
| 303 | return pthread_once(flag, init_routine); |
| 304 | } |
| 305 | |
| 306 | // Thread id |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 307 | // Returns non-zero if the thread ids are equal, otherwise 0 |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 308 | bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2) |
| 309 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 310 | return pthread_equal(t1, t2) != 0; |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | // Returns non-zero if t1 < t2, otherwise 0 |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 314 | bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2) |
| 315 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 316 | return t1 < t2; |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | // Thread |
Asiri Rathnayake | a1d7d2f | 2017-01-16 12:19:54 +0000 | [diff] [blame] | 320 | bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { |
| 321 | return *__t == 0; |
| 322 | } |
| 323 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 324 | int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| 325 | void *__arg) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 326 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 327 | return pthread_create(__t, 0, __func, __arg); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 328 | } |
| 329 | |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 330 | __libcpp_thread_id __libcpp_thread_get_current_id() |
| 331 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 332 | return pthread_self(); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 333 | } |
| 334 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 335 | __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 336 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 337 | return *__t; |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 338 | } |
| 339 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 340 | int __libcpp_thread_join(__libcpp_thread_t *__t) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 341 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 342 | return pthread_join(*__t, 0); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 343 | } |
| 344 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 345 | int __libcpp_thread_detach(__libcpp_thread_t *__t) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 346 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 347 | return pthread_detach(*__t); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 350 | void __libcpp_thread_yield() |
| 351 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 352 | sched_yield(); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 353 | } |
| 354 | |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 355 | void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) |
| 356 | { |
| 357 | using namespace chrono; |
| 358 | seconds __s = duration_cast<seconds>(__ns); |
| 359 | timespec __ts; |
| 360 | typedef decltype(__ts.tv_sec) ts_sec; |
| 361 | _LIBCPP_CONSTEXPR ts_sec __ts_sec_max = numeric_limits<ts_sec>::max(); |
| 362 | |
| 363 | if (__s.count() < __ts_sec_max) |
| 364 | { |
| 365 | __ts.tv_sec = static_cast<ts_sec>(__s.count()); |
| 366 | __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count()); |
| 367 | } |
| 368 | else |
| 369 | { |
| 370 | __ts.tv_sec = __ts_sec_max; |
| 371 | __ts.tv_nsec = 999999999; // (10^9 - 1) |
| 372 | } |
| 373 | |
| 374 | while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR); |
| 375 | } |
| 376 | |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 377 | // Thread local storage |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 378 | int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *)) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 379 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 380 | return pthread_key_create(__key, __at_exit); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 381 | } |
| 382 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 383 | void *__libcpp_tls_get(__libcpp_tls_key __key) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 384 | { |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 385 | return pthread_getspecific(__key); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 386 | } |
| 387 | |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 388 | int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 389 | { |
Asiri Rathnayake | e262e7b | 2017-01-03 12:59:50 +0000 | [diff] [blame] | 390 | return pthread_setspecific(__key, __p); |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 391 | } |
| 392 | |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 393 | #elif defined(_LIBCPP_HAS_THREAD_API_WIN32) |
| 394 | |
| 395 | // Mutex |
| 396 | int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m) |
| 397 | { |
| 398 | InitializeCriticalSection(__m); |
| 399 | return 0; |
| 400 | } |
| 401 | |
| 402 | int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m) |
| 403 | { |
| 404 | EnterCriticalSection(__m); |
| 405 | return 0; |
| 406 | } |
| 407 | |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 408 | bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m) |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 409 | { |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 410 | return TryEnterCriticalSection(__m) != 0; |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 411 | } |
| 412 | |
| 413 | int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m) |
| 414 | { |
| 415 | LeaveCriticalSection(__m); |
| 416 | return 0; |
| 417 | } |
| 418 | |
| 419 | int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m) |
| 420 | { |
Saleem Abdulrasool | 1d32408 | 2017-01-10 04:18:47 +0000 | [diff] [blame] | 421 | DeleteCriticalSection(__m); |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 422 | return 0; |
| 423 | } |
| 424 | |
| 425 | int __libcpp_mutex_lock(__libcpp_mutex_t *__m) |
| 426 | { |
| 427 | AcquireSRWLockExclusive(__m); |
| 428 | return 0; |
| 429 | } |
| 430 | |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 431 | bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m) |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 432 | { |
Eric Fiselier | 30d12e3 | 2017-01-14 10:27:12 +0000 | [diff] [blame] | 433 | return TryAcquireSRWLockExclusive(__m) != 0; |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | int __libcpp_mutex_unlock(__libcpp_mutex_t *__m) |
| 437 | { |
| 438 | ReleaseSRWLockExclusive(__m); |
| 439 | return 0; |
| 440 | } |
| 441 | |
| 442 | int __libcpp_mutex_destroy(__libcpp_mutex_t *__m) |
| 443 | { |
| 444 | static_cast<void>(__m); |
| 445 | return 0; |
| 446 | } |
| 447 | |
| 448 | // Condition Variable |
| 449 | int __libcpp_condvar_signal(__libcpp_condvar_t *__cv) |
| 450 | { |
| 451 | WakeConditionVariable(__cv); |
| 452 | return 0; |
| 453 | } |
| 454 | |
| 455 | int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv) |
| 456 | { |
| 457 | WakeAllConditionVariable(__cv); |
| 458 | return 0; |
| 459 | } |
| 460 | |
| 461 | int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m) |
| 462 | { |
| 463 | SleepConditionVariableSRW(__cv, __m, INFINITE, 0); |
| 464 | return 0; |
| 465 | } |
| 466 | |
| 467 | int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, |
| 468 | timespec *__ts) |
| 469 | { |
| 470 | using namespace _VSTD::chrono; |
| 471 | |
| 472 | auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec); |
| 473 | auto abstime = |
| 474 | system_clock::time_point(duration_cast<system_clock::duration>(duration)); |
| 475 | auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now()); |
| 476 | |
| 477 | if (!SleepConditionVariableSRW(__cv, __m, |
| 478 | timeout_ms.count() > 0 ? timeout_ms.count() |
| 479 | : 0, |
| 480 | 0)) |
Eric Fiselier | 08fd336 | 2017-05-05 21:31:22 +0000 | [diff] [blame] | 481 | { |
| 482 | auto __ec = GetLastError(); |
| 483 | return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec; |
| 484 | } |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 485 | return 0; |
| 486 | } |
| 487 | |
| 488 | int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv) |
| 489 | { |
| 490 | static_cast<void>(__cv); |
| 491 | return 0; |
| 492 | } |
| 493 | |
| 494 | // Execute Once |
| 495 | static inline _LIBCPP_ALWAYS_INLINE BOOL CALLBACK |
| 496 | __libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter, |
| 497 | PVOID *__context) |
| 498 | { |
| 499 | static_cast<void>(__init_once); |
| 500 | static_cast<void>(__context); |
| 501 | |
| 502 | void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter); |
| 503 | init_routine(); |
| 504 | return TRUE; |
| 505 | } |
| 506 | |
| 507 | int __libcpp_execute_once(__libcpp_exec_once_flag *__flag, |
| 508 | void (*__init_routine)(void)) |
| 509 | { |
| 510 | if (!InitOnceExecuteOnce(__flag, __libcpp_init_once_execute_once_thunk, |
| 511 | reinterpret_cast<void *>(__init_routine), NULL)) |
| 512 | return GetLastError(); |
| 513 | return 0; |
| 514 | } |
| 515 | |
| 516 | // Thread ID |
| 517 | bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs, |
| 518 | __libcpp_thread_id __rhs) |
| 519 | { |
| 520 | return __lhs == __rhs; |
| 521 | } |
| 522 | |
| 523 | bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs) |
| 524 | { |
| 525 | return __lhs < __rhs; |
| 526 | } |
| 527 | |
| 528 | // Thread |
| 529 | struct __libcpp_beginthreadex_thunk_data |
| 530 | { |
| 531 | void *(*__func)(void *); |
| 532 | void *__arg; |
| 533 | }; |
| 534 | |
Eric Fiselier | 543e83b | 2017-01-14 20:19:00 +0000 | [diff] [blame] | 535 | static inline _LIBCPP_ALWAYS_INLINE unsigned WINAPI |
Eric Fiselier | 433a397 | 2017-01-14 19:11:07 +0000 | [diff] [blame] | 536 | __libcpp_beginthreadex_thunk(void *__raw_data) |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 537 | { |
Eric Fiselier | 433a397 | 2017-01-14 19:11:07 +0000 | [diff] [blame] | 538 | auto *__data = |
| 539 | static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data); |
| 540 | auto *__func = __data->__func; |
| 541 | void *__arg = __data->__arg; |
| 542 | delete __data; |
Eric Fiselier | 543e83b | 2017-01-14 20:19:00 +0000 | [diff] [blame] | 543 | return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg))); |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 544 | } |
| 545 | |
Asiri Rathnayake | a1d7d2f | 2017-01-16 12:19:54 +0000 | [diff] [blame] | 546 | bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) { |
| 547 | return *__t == 0; |
| 548 | } |
| 549 | |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 550 | int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *), |
| 551 | void *__arg) |
| 552 | { |
Eric Fiselier | 433a397 | 2017-01-14 19:11:07 +0000 | [diff] [blame] | 553 | auto *__data = new __libcpp_beginthreadex_thunk_data; |
| 554 | __data->__func = __func; |
| 555 | __data->__arg = __arg; |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 556 | |
Eric Fiselier | 543e83b | 2017-01-14 20:19:00 +0000 | [diff] [blame] | 557 | *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, |
| 558 | __libcpp_beginthreadex_thunk, |
| 559 | __data, 0, nullptr)); |
| 560 | |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 561 | if (*__t) |
| 562 | return 0; |
| 563 | return GetLastError(); |
| 564 | } |
| 565 | |
| 566 | __libcpp_thread_id __libcpp_thread_get_current_id() |
| 567 | { |
| 568 | return GetCurrentThreadId(); |
| 569 | } |
| 570 | |
| 571 | __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t) |
| 572 | { |
| 573 | return GetThreadId(*__t); |
| 574 | } |
| 575 | |
| 576 | int __libcpp_thread_join(__libcpp_thread_t *__t) |
| 577 | { |
| 578 | if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED) |
| 579 | return GetLastError(); |
| 580 | if (!CloseHandle(*__t)) |
| 581 | return GetLastError(); |
| 582 | return 0; |
| 583 | } |
| 584 | |
| 585 | int __libcpp_thread_detach(__libcpp_thread_t *__t) |
| 586 | { |
| 587 | if (!CloseHandle(*__t)) |
| 588 | return GetLastError(); |
| 589 | return 0; |
| 590 | } |
| 591 | |
| 592 | void __libcpp_thread_yield() |
| 593 | { |
| 594 | SwitchToThread(); |
| 595 | } |
| 596 | |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 597 | void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) |
| 598 | { |
Saleem Abdulrasool | e891cc8 | 2017-02-18 19:28:43 +0000 | [diff] [blame] | 599 | using namespace chrono; |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 600 | // round-up to the nearest milisecond |
Saleem Abdulrasool | 29e1142 | 2017-02-10 02:49:52 +0000 | [diff] [blame] | 601 | milliseconds __ms = |
| 602 | duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999)); |
Saleem Abdulrasool | e891cc8 | 2017-02-18 19:28:43 +0000 | [diff] [blame] | 603 | // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx) |
| 604 | Sleep(__ms.count()); |
Asiri Rathnayake | 1b93961 | 2017-02-09 09:31:41 +0000 | [diff] [blame] | 605 | } |
| 606 | |
Saleem Abdulrasool | 678eadd | 2017-01-07 03:07:45 +0000 | [diff] [blame] | 607 | // Thread Local Storage |
| 608 | int __libcpp_tls_create(__libcpp_tls_key* __key, |
| 609 | void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*)) |
| 610 | { |
| 611 | *__key = FlsAlloc(__at_exit); |
| 612 | if (*__key == FLS_OUT_OF_INDEXES) |
| 613 | return GetLastError(); |
| 614 | return 0; |
| 615 | } |
| 616 | |
| 617 | void *__libcpp_tls_get(__libcpp_tls_key __key) |
| 618 | { |
| 619 | return FlsGetValue(__key); |
| 620 | } |
| 621 | |
| 622 | int __libcpp_tls_set(__libcpp_tls_key __key, void *__p) |
| 623 | { |
| 624 | if (!FlsSetValue(__key, __p)) |
| 625 | return GetLastError(); |
| 626 | return 0; |
| 627 | } |
| 628 | |
Saleem Abdulrasool | 1d19237 | 2017-01-03 02:00:31 +0000 | [diff] [blame] | 629 | #endif // _LIBCPP_HAS_THREAD_API_PTHREAD |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 630 | |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 631 | #endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL |
| 632 | |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 633 | _LIBCPP_END_NAMESPACE_STD |
| 634 | |
Eric Fiselier | 018a3d5 | 2017-05-31 22:07:49 +0000 | [diff] [blame] | 635 | _LIBCPP_POP_MACROS |
| 636 | |
Eric Fiselier | 66134e8 | 2017-01-06 20:05:40 +0000 | [diff] [blame] | 637 | #endif // !_LIBCPP_HAS_NO_THREADS |
Asiri Rathnayake | 35ff03b | 2016-05-06 14:06:29 +0000 | [diff] [blame] | 638 | |
| 639 | #endif // _LIBCPP_THREADING_SUPPORT |