libcxx/src/support/win32/thread_win32.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <__threading_support>
  10 #include <chrono>
  11
  12 #define NOMINMAX
  13 #define WIN32_LEAN_AND_MEAN
  14 #include <windows.h>
  15 #include <process.h>
  16 #include <fibersapi.h>
  17
  18 _LIBCPP_BEGIN_NAMESPACE_STD
  19
  20 static_assert(sizeof(__libcpp_mutex_t) == sizeof(SRWLOCK), "");
  21 static_assert(alignof(__libcpp_mutex_t) == alignof(SRWLOCK), "");
  22
  23 static_assert(sizeof(__libcpp_recursive_mutex_t) == sizeof(CRITICAL_SECTION),
  24               "");
  25 static_assert(alignof(__libcpp_recursive_mutex_t) == alignof(CRITICAL_SECTION),
  26               "");
  27
  28 static_assert(sizeof(__libcpp_condvar_t) == sizeof(CONDITION_VARIABLE), "");
  29 static_assert(alignof(__libcpp_condvar_t) == alignof(CONDITION_VARIABLE), "");
  30
  31 static_assert(sizeof(__libcpp_exec_once_flag) == sizeof(INIT_ONCE), "");
  32 static_assert(alignof(__libcpp_exec_once_flag) == alignof(INIT_ONCE), "");
  33
  34 static_assert(sizeof(__libcpp_thread_id) == sizeof(DWORD), "");
  35 static_assert(alignof(__libcpp_thread_id) == alignof(DWORD), "");
  36
  37 static_assert(sizeof(__libcpp_thread_t) == sizeof(HANDLE), "");
  38 static_assert(alignof(__libcpp_thread_t) == alignof(HANDLE), "");
  39
  40 static_assert(sizeof(__libcpp_tls_key) == sizeof(DWORD), "");
  41 static_assert(alignof(__libcpp_tls_key) == alignof(DWORD), "");
  42
  43 // Mutex
  44 int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
  45 {
  46   InitializeCriticalSection((LPCRITICAL_SECTION)__m);
  47   return 0;
  48 }
  49
  50 int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
  51 {
  52   EnterCriticalSection((LPCRITICAL_SECTION)__m);
  53   return 0;
  54 }
  55
  56 bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
  57 {
  58   return TryEnterCriticalSection((LPCRITICAL_SECTION)__m) != 0;
  59 }
  60
  61 int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
  62 {
  63   LeaveCriticalSection((LPCRITICAL_SECTION)__m);
  64   return 0;
  65 }
  66
  67 int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
  68 {
  69   DeleteCriticalSection((LPCRITICAL_SECTION)__m);
  70   return 0;
  71 }
  72
  73 int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
  74 {
  75   AcquireSRWLockExclusive((PSRWLOCK)__m);
  76   return 0;
  77 }
  78
  79 bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
  80 {
  81   return TryAcquireSRWLockExclusive((PSRWLOCK)__m) != 0;
  82 }
  83
  84 int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
  85 {
  86   ReleaseSRWLockExclusive((PSRWLOCK)__m);
  87   return 0;
  88 }
  89
  90 int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
  91 {
  92   static_cast<void>(__m);
  93   return 0;
  94 }
  95
  96 // Condition Variable
  97 int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
  98 {
  99   WakeConditionVariable((PCONDITION_VARIABLE)__cv);
 100   return 0;
 101 }
 102
 103 int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
 104 {
 105   WakeAllConditionVariable((PCONDITION_VARIABLE)__cv);
 106   return 0;
 107 }
 108
 109 int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
 110 {
 111   SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m, INFINITE, 0);
 112   return 0;
 113 }
 114
 115 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
 116                                __libcpp_timespec_t *__ts)
 117 {
 118   using namespace _VSTD::chrono;
 119
 120   auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec);
 121   auto abstime =
 122       system_clock::time_point(duration_cast<system_clock::duration>(duration));
 123   auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now());
 124
 125   if (!SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m,
 126                                  timeout_ms.count() > 0 ? timeout_ms.count()
 127                                                         : 0,
 128                                  0))
 129     {
 130       auto __ec = GetLastError();
 131       return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec;
 132     }
 133   return 0;
 134 }
 135
 136 int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
 137 {
 138   static_cast<void>(__cv);
 139   return 0;
 140 }
 141
 142 // Execute Once
 143 static inline _LIBCPP_INLINE_VISIBILITY BOOL CALLBACK
 144 __libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter,
 145                                       PVOID *__context)
 146 {
 147   static_cast<void>(__init_once);
 148   static_cast<void>(__context);
 149
 150   void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter);
 151   init_routine();
 152   return TRUE;
 153 }
 154
 155 int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
 156                           void (*__init_routine)(void))
 157 {
 158   if (!InitOnceExecuteOnce((PINIT_ONCE)__flag, __libcpp_init_once_execute_once_thunk,
 159                            reinterpret_cast<void *>(__init_routine), NULL))
 160     return GetLastError();
 161   return 0;
 162 }
 163
 164 // Thread ID
 165 bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs,
 166                               __libcpp_thread_id __rhs)
 167 {
 168   return __lhs == __rhs;
 169 }
 170
 171 bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs)
 172 {
 173   return __lhs < __rhs;
 174 }
 175
 176 // Thread
 177 struct __libcpp_beginthreadex_thunk_data
 178 {
 179   void *(*__func)(void *);
 180   void *__arg;
 181 };
 182
 183 static inline _LIBCPP_INLINE_VISIBILITY unsigned WINAPI
 184 __libcpp_beginthreadex_thunk(void *__raw_data)
 185 {
 186   auto *__data =
 187       static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data);
 188   auto *__func = __data->__func;
 189   void *__arg = __data->__arg;
 190   delete __data;
 191   return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg)));
 192 }
 193
 194 bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
 195   return *__t == 0;
 196 }
 197
 198 int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
 199                            void *__arg)
 200 {
 201   auto *__data = new __libcpp_beginthreadex_thunk_data;
 202   __data->__func = __func;
 203   __data->__arg = __arg;
 204
 205   *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0,
 206                                                  __libcpp_beginthreadex_thunk,
 207                                                  __data, 0, nullptr));
 208
 209   if (*__t)
 210     return 0;
 211   return GetLastError();
 212 }
 213
 214 __libcpp_thread_id __libcpp_thread_get_current_id()
 215 {
 216   return GetCurrentThreadId();
 217 }
 218
 219 __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
 220 {
 221   return GetThreadId(*__t);
 222 }
 223
 224 int __libcpp_thread_join(__libcpp_thread_t *__t)
 225 {
 226   if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED)
 227     return GetLastError();
 228   if (!CloseHandle(*__t))
 229     return GetLastError();
 230   return 0;
 231 }
 232
 233 int __libcpp_thread_detach(__libcpp_thread_t *__t)
 234 {
 235   if (!CloseHandle(*__t))
 236     return GetLastError();
 237   return 0;
 238 }
 239
 240 void __libcpp_thread_yield()
 241 {
 242   SwitchToThread();
 243 }
 244
 245 void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
 246 {
 247   // round-up to the nearest millisecond
 248   chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns);
 249   // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx)
 250   Sleep(__ms.count());
 251 }
 252
 253 // Thread Local Storage
 254 int __libcpp_tls_create(__libcpp_tls_key* __key,
 255                         void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*))
 256 {
 257   DWORD index = FlsAlloc(__at_exit);
 258   if (index == FLS_OUT_OF_INDEXES)
 259     return GetLastError();
 260   *__key = index;
 261   return 0;
 262 }
 263
 264 void *__libcpp_tls_get(__libcpp_tls_key __key)
 265 {
 266   return FlsGetValue(__key);
 267 }
 268
 269 int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
 270 {
 271   if (!FlsSetValue(__key, __p))
 272     return GetLastError();
 273   return 0;
 274 }
 275
 276 _LIBCPP_END_NAMESPACE_STD