LLVM OpenMP* Runtime Library
z_Windows_NT_util.cpp
1/*
2 * z_Windows_NT_util.cpp -- platform specific routines.
3 */
4
5//===----------------------------------------------------------------------===//
6//
7// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8// See https://llvm.org/LICENSE.txt for license information.
9// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10//
11//===----------------------------------------------------------------------===//
12
13#include "kmp.h"
14#include "kmp_affinity.h"
15#include "kmp_i18n.h"
16#include "kmp_io.h"
17#include "kmp_itt.h"
18#include "kmp_wait_release.h"
19
20/* This code is related to NtQuerySystemInformation() function. This function
21 is used in the Load balance algorithm for OMP_DYNAMIC=true to find the
22 number of running threads in the system. */
23
24#include <ntsecapi.h> // UNICODE_STRING
25#include <ntstatus.h>
26#include <psapi.h>
27#ifdef _MSC_VER
28#pragma comment(lib, "psapi.lib")
29#endif
30
31enum SYSTEM_INFORMATION_CLASS {
32 SystemProcessInformation = 5
33}; // SYSTEM_INFORMATION_CLASS
34
35struct CLIENT_ID {
36 HANDLE UniqueProcess;
37 HANDLE UniqueThread;
38}; // struct CLIENT_ID
39
40enum THREAD_STATE {
41 StateInitialized,
42 StateReady,
43 StateRunning,
44 StateStandby,
45 StateTerminated,
46 StateWait,
47 StateTransition,
48 StateUnknown
49}; // enum THREAD_STATE
50
51struct VM_COUNTERS {
52 SIZE_T PeakVirtualSize;
53 SIZE_T VirtualSize;
54 ULONG PageFaultCount;
55 SIZE_T PeakWorkingSetSize;
56 SIZE_T WorkingSetSize;
57 SIZE_T QuotaPeakPagedPoolUsage;
58 SIZE_T QuotaPagedPoolUsage;
59 SIZE_T QuotaPeakNonPagedPoolUsage;
60 SIZE_T QuotaNonPagedPoolUsage;
61 SIZE_T PagefileUsage;
62 SIZE_T PeakPagefileUsage;
63 SIZE_T PrivatePageCount;
64}; // struct VM_COUNTERS
65
66struct SYSTEM_THREAD {
67 LARGE_INTEGER KernelTime;
68 LARGE_INTEGER UserTime;
69 LARGE_INTEGER CreateTime;
70 ULONG WaitTime;
71 LPVOID StartAddress;
72 CLIENT_ID ClientId;
73 DWORD Priority;
74 LONG BasePriority;
75 ULONG ContextSwitchCount;
76 THREAD_STATE State;
77 ULONG WaitReason;
78}; // SYSTEM_THREAD
79
80KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, KernelTime) == 0);
81#if KMP_ARCH_X86
82KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, StartAddress) == 28);
83KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, State) == 52);
84#else
85KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, StartAddress) == 32);
86KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, State) == 68);
87#endif
88
89struct SYSTEM_PROCESS_INFORMATION {
90 ULONG NextEntryOffset;
91 ULONG NumberOfThreads;
92 LARGE_INTEGER Reserved[3];
93 LARGE_INTEGER CreateTime;
94 LARGE_INTEGER UserTime;
95 LARGE_INTEGER KernelTime;
96 UNICODE_STRING ImageName;
97 DWORD BasePriority;
98 HANDLE ProcessId;
99 HANDLE ParentProcessId;
100 ULONG HandleCount;
101 ULONG Reserved2[2];
102 VM_COUNTERS VMCounters;
103 IO_COUNTERS IOCounters;
104 SYSTEM_THREAD Threads[1];
105}; // SYSTEM_PROCESS_INFORMATION
106typedef SYSTEM_PROCESS_INFORMATION *PSYSTEM_PROCESS_INFORMATION;
107
108KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, NextEntryOffset) == 0);
109KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, CreateTime) == 32);
110KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ImageName) == 56);
111#if KMP_ARCH_X86
112KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ProcessId) == 68);
113KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, HandleCount) == 76);
114KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, VMCounters) == 88);
115KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, IOCounters) == 136);
116KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, Threads) == 184);
117#else
118KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ProcessId) == 80);
119KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, HandleCount) == 96);
120KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, VMCounters) == 112);
121KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, IOCounters) == 208);
122KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, Threads) == 256);
123#endif
124
125typedef NTSTATUS(NTAPI *NtQuerySystemInformation_t)(SYSTEM_INFORMATION_CLASS,
126 PVOID, ULONG, PULONG);
127NtQuerySystemInformation_t NtQuerySystemInformation = NULL;
128
129HMODULE ntdll = NULL;
130
131/* End of NtQuerySystemInformation()-related code */
132
133static HMODULE kernel32 = NULL;
134
135#if KMP_HANDLE_SIGNALS
136typedef void (*sig_func_t)(int);
137static sig_func_t __kmp_sighldrs[NSIG];
138static int __kmp_siginstalled[NSIG];
139#endif
140
141#if KMP_USE_MONITOR
142static HANDLE __kmp_monitor_ev;
143#endif
144static kmp_int64 __kmp_win32_time;
145double __kmp_win32_tick;
146
147int __kmp_init_runtime = FALSE;
148CRITICAL_SECTION __kmp_win32_section;
149
150void __kmp_win32_mutex_init(kmp_win32_mutex_t *mx) {
151 InitializeCriticalSection(&mx->cs);
152#if USE_ITT_BUILD
153 __kmp_itt_system_object_created(&mx->cs, "Critical Section");
154#endif /* USE_ITT_BUILD */
155}
156
157void __kmp_win32_mutex_destroy(kmp_win32_mutex_t *mx) {
158 DeleteCriticalSection(&mx->cs);
159}
160
161void __kmp_win32_mutex_lock(kmp_win32_mutex_t *mx) {
162 EnterCriticalSection(&mx->cs);
163}
164
165int __kmp_win32_mutex_trylock(kmp_win32_mutex_t *mx) {
166 return TryEnterCriticalSection(&mx->cs);
167}
168
169void __kmp_win32_mutex_unlock(kmp_win32_mutex_t *mx) {
170 LeaveCriticalSection(&mx->cs);
171}
172
173void __kmp_win32_cond_init(kmp_win32_cond_t *cv) {
174 cv->waiters_count_ = 0;
175 cv->wait_generation_count_ = 0;
176 cv->release_count_ = 0;
177
178 /* Initialize the critical section */
179 __kmp_win32_mutex_init(&cv->waiters_count_lock_);
180
181 /* Create a manual-reset event. */
182 cv->event_ = CreateEvent(NULL, // no security
183 TRUE, // manual-reset
184 FALSE, // non-signaled initially
185 NULL); // unnamed
186#if USE_ITT_BUILD
187 __kmp_itt_system_object_created(cv->event_, "Event");
188#endif /* USE_ITT_BUILD */
189}
190
191void __kmp_win32_cond_destroy(kmp_win32_cond_t *cv) {
192 __kmp_win32_mutex_destroy(&cv->waiters_count_lock_);
193 __kmp_free_handle(cv->event_);
194 memset(cv, '\0', sizeof(*cv));
195}
196
197/* TODO associate cv with a team instead of a thread so as to optimize
198 the case where we wake up a whole team */
199
200template <class C>
201static void __kmp_win32_cond_wait(kmp_win32_cond_t *cv, kmp_win32_mutex_t *mx,
202 kmp_info_t *th, C *flag) {
203 int my_generation;
204 int last_waiter;
205
206 /* Avoid race conditions */
207 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
208
209 /* Increment count of waiters */
210 cv->waiters_count_++;
211
212 /* Store current generation in our activation record. */
213 my_generation = cv->wait_generation_count_;
214
215 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
216 __kmp_win32_mutex_unlock(mx);
217
218 for (;;) {
219 int wait_done = 0;
220 DWORD res, timeout = 5000; // just tried to quess an appropriate number
221 /* Wait until the event is signaled */
222 res = WaitForSingleObject(cv->event_, timeout);
223
224 if (res == WAIT_OBJECT_0) {
225 // event signaled
226 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
227 /* Exit the loop when the <cv->event_> is signaled and there are still
228 waiting threads from this <wait_generation> that haven't been released
229 from this wait yet. */
230 wait_done = (cv->release_count_ > 0) &&
231 (cv->wait_generation_count_ != my_generation);
232 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
233 } else if (res == WAIT_TIMEOUT || res == WAIT_FAILED) {
234 // check if the flag and cv counters are in consistent state
235 // as MS sent us debug dump whith inconsistent state of data
236 __kmp_win32_mutex_lock(mx);
237 typename C::flag_t old_f = flag->set_sleeping();
238 if (!flag->done_check_val(old_f & ~KMP_BARRIER_SLEEP_STATE)) {
239 __kmp_win32_mutex_unlock(mx);
240 continue;
241 }
242 // condition fulfilled, exiting
243 flag->unset_sleeping();
244 TCW_PTR(th->th.th_sleep_loc, NULL);
245 th->th.th_sleep_loc_type = flag_unset;
246 KF_TRACE(50, ("__kmp_win32_cond_wait: exiting, condition "
247 "fulfilled: flag's loc(%p): %u\n",
248 flag->get(), (unsigned int)flag->load()));
249
250 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
251 KMP_DEBUG_ASSERT(cv->waiters_count_ > 0);
252 cv->release_count_ = cv->waiters_count_;
253 cv->wait_generation_count_++;
254 wait_done = 1;
255 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
256
257 __kmp_win32_mutex_unlock(mx);
258 }
259 /* there used to be a semicolon after the if statement, it looked like a
260 bug, so i removed it */
261 if (wait_done)
262 break;
263 }
264
265 __kmp_win32_mutex_lock(mx);
266 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
267
268 cv->waiters_count_--;
269 cv->release_count_--;
270
271 last_waiter = (cv->release_count_ == 0);
272
273 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
274
275 if (last_waiter) {
276 /* We're the last waiter to be notified, so reset the manual event. */
277 ResetEvent(cv->event_);
278 }
279}
280
281void __kmp_win32_cond_broadcast(kmp_win32_cond_t *cv) {
282 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
283
284 if (cv->waiters_count_ > 0) {
285 SetEvent(cv->event_);
286 /* Release all the threads in this generation. */
287
288 cv->release_count_ = cv->waiters_count_;
289
290 /* Start a new generation. */
291 cv->wait_generation_count_++;
292 }
293
294 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
295}
296
297void __kmp_win32_cond_signal(kmp_win32_cond_t *cv) {
298 __kmp_win32_cond_broadcast(cv);
299}
300
301void __kmp_enable(int new_state) {
302 if (__kmp_init_runtime)
303 LeaveCriticalSection(&__kmp_win32_section);
304}
305
306void __kmp_disable(int *old_state) {
307 *old_state = 0;
308
309 if (__kmp_init_runtime)
310 EnterCriticalSection(&__kmp_win32_section);
311}
312
313void __kmp_suspend_initialize(void) { /* do nothing */
314}
315
316void __kmp_suspend_initialize_thread(kmp_info_t *th) {
317 int old_value = KMP_ATOMIC_LD_RLX(&th->th.th_suspend_init);
318 int new_value = TRUE;
319 // Return if already initialized
320 if (old_value == new_value)
321 return;
322 // Wait, then return if being initialized
323 if (old_value == -1 ||
324 !__kmp_atomic_compare_store(&th->th.th_suspend_init, old_value, -1)) {
325 while (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init) != new_value) {
326 KMP_CPU_PAUSE();
327 }
328 } else {
329 // Claim to be the initializer and do initializations
330 __kmp_win32_cond_init(&th->th.th_suspend_cv);
331 __kmp_win32_mutex_init(&th->th.th_suspend_mx);
332 KMP_ATOMIC_ST_REL(&th->th.th_suspend_init, new_value);
333 }
334}
335
336void __kmp_suspend_uninitialize_thread(kmp_info_t *th) {
337 if (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init)) {
338 /* this means we have initialize the suspension pthread objects for this
339 thread in this instance of the process */
340 __kmp_win32_cond_destroy(&th->th.th_suspend_cv);
341 __kmp_win32_mutex_destroy(&th->th.th_suspend_mx);
342 KMP_ATOMIC_ST_REL(&th->th.th_suspend_init, FALSE);
343 }
344}
345
346int __kmp_try_suspend_mx(kmp_info_t *th) {
347 return __kmp_win32_mutex_trylock(&th->th.th_suspend_mx);
348}
349
350void __kmp_lock_suspend_mx(kmp_info_t *th) {
351 __kmp_win32_mutex_lock(&th->th.th_suspend_mx);
352}
353
354void __kmp_unlock_suspend_mx(kmp_info_t *th) {
355 __kmp_win32_mutex_unlock(&th->th.th_suspend_mx);
356}
357
358/* This routine puts the calling thread to sleep after setting the
359 sleep bit for the indicated flag variable to true. */
360template <class C>
361static inline void __kmp_suspend_template(int th_gtid, C *flag) {
362 kmp_info_t *th = __kmp_threads[th_gtid];
363 typename C::flag_t old_spin;
364
365 KF_TRACE(30, ("__kmp_suspend_template: T#%d enter for flag's loc(%p)\n",
366 th_gtid, flag->get()));
367
368 __kmp_suspend_initialize_thread(th);
369 __kmp_lock_suspend_mx(th);
370
371 KF_TRACE(10, ("__kmp_suspend_template: T#%d setting sleep bit for flag's"
372 " loc(%p)\n",
373 th_gtid, flag->get()));
374
375 /* TODO: shouldn't this use release semantics to ensure that
376 __kmp_suspend_initialize_thread gets called first? */
377 old_spin = flag->set_sleeping();
378 TCW_PTR(th->th.th_sleep_loc, (void *)flag);
379 th->th.th_sleep_loc_type = flag->get_type();
380 if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
381 __kmp_pause_status != kmp_soft_paused) {
382 flag->unset_sleeping();
383 TCW_PTR(th->th.th_sleep_loc, NULL);
384 th->th.th_sleep_loc_type = flag_unset;
385 __kmp_unlock_suspend_mx(th);
386 return;
387 }
388
389 KF_TRACE(5, ("__kmp_suspend_template: T#%d set sleep bit for flag's"
390 " loc(%p)==%u\n",
391 th_gtid, flag->get(), (unsigned int)flag->load()));
392
393 if (flag->done_check_val(old_spin) || flag->done_check()) {
394 flag->unset_sleeping();
395 TCW_PTR(th->th.th_sleep_loc, NULL);
396 th->th.th_sleep_loc_type = flag_unset;
397 KF_TRACE(5, ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "
398 "for flag's loc(%p)\n",
399 th_gtid, flag->get()));
400 } else {
401#ifdef DEBUG_SUSPEND
402 __kmp_suspend_count++;
403#endif
404 /* Encapsulate in a loop as the documentation states that this may "with
405 low probability" return when the condition variable has not been signaled
406 or broadcast */
407 int deactivated = FALSE;
408
409 while (flag->is_sleeping()) {
410 KF_TRACE(15, ("__kmp_suspend_template: T#%d about to perform "
411 "kmp_win32_cond_wait()\n",
412 th_gtid));
413 // Mark the thread as no longer active (only in the first iteration of the
414 // loop).
415 if (!deactivated) {
416 th->th.th_active = FALSE;
417 if (th->th.th_active_in_pool) {
418 th->th.th_active_in_pool = FALSE;
419 KMP_ATOMIC_DEC(&__kmp_thread_pool_active_nth);
420 KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);
421 }
422 deactivated = TRUE;
423 }
424
425 KMP_DEBUG_ASSERT(th->th.th_sleep_loc);
426 KMP_DEBUG_ASSERT(th->th.th_sleep_loc_type == flag->get_type());
427
428 __kmp_win32_cond_wait(&th->th.th_suspend_cv, &th->th.th_suspend_mx, th,
429 flag);
430
431#ifdef KMP_DEBUG
432 if (flag->is_sleeping()) {
433 KF_TRACE(100,
434 ("__kmp_suspend_template: T#%d spurious wakeup\n", th_gtid));
435 }
436#endif /* KMP_DEBUG */
437
438 } // while
439
440 // We may have had the loop variable set before entering the loop body;
441 // so we need to reset sleep_loc.
442 TCW_PTR(th->th.th_sleep_loc, NULL);
443 th->th.th_sleep_loc_type = flag_unset;
444
445 KMP_DEBUG_ASSERT(!flag->is_sleeping());
446 KMP_DEBUG_ASSERT(!th->th.th_sleep_loc);
447
448 // Mark the thread as active again (if it was previous marked as inactive)
449 if (deactivated) {
450 th->th.th_active = TRUE;
451 if (TCR_4(th->th.th_in_pool)) {
452 KMP_ATOMIC_INC(&__kmp_thread_pool_active_nth);
453 th->th.th_active_in_pool = TRUE;
454 }
455 }
456 }
457
458 __kmp_unlock_suspend_mx(th);
459 KF_TRACE(30, ("__kmp_suspend_template: T#%d exit\n", th_gtid));
460}
461
462template <bool C, bool S>
463void __kmp_suspend_32(int th_gtid, kmp_flag_32<C, S> *flag) {
464 __kmp_suspend_template(th_gtid, flag);
465}
466template <bool C, bool S>
467void __kmp_suspend_64(int th_gtid, kmp_flag_64<C, S> *flag) {
468 __kmp_suspend_template(th_gtid, flag);
469}
470template <bool C, bool S>
471void __kmp_atomic_suspend_64(int th_gtid, kmp_atomic_flag_64<C, S> *flag) {
472 __kmp_suspend_template(th_gtid, flag);
473}
474void __kmp_suspend_oncore(int th_gtid, kmp_flag_oncore *flag) {
475 __kmp_suspend_template(th_gtid, flag);
476}
477
478template void __kmp_suspend_32<false, false>(int, kmp_flag_32<false, false> *);
479template void __kmp_suspend_64<false, true>(int, kmp_flag_64<false, true> *);
480template void __kmp_suspend_64<true, false>(int, kmp_flag_64<true, false> *);
481template void
482__kmp_atomic_suspend_64<false, true>(int, kmp_atomic_flag_64<false, true> *);
483template void
484__kmp_atomic_suspend_64<true, false>(int, kmp_atomic_flag_64<true, false> *);
485
486/* This routine signals the thread specified by target_gtid to wake up
487 after setting the sleep bit indicated by the flag argument to FALSE */
488template <class C>
489static inline void __kmp_resume_template(int target_gtid, C *flag) {
490 kmp_info_t *th = __kmp_threads[target_gtid];
491
492#ifdef KMP_DEBUG
493 int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
494#endif
495
496 KF_TRACE(30, ("__kmp_resume_template: T#%d wants to wakeup T#%d enter\n",
497 gtid, target_gtid));
498
499 __kmp_suspend_initialize_thread(th);
500 __kmp_lock_suspend_mx(th);
501
502 if (!flag || flag != th->th.th_sleep_loc) {
503 // coming from __kmp_null_resume_wrapper, or thread is now sleeping on a
504 // different location; wake up at new location
505 flag = (C *)th->th.th_sleep_loc;
506 }
507
508 // First, check if the flag is null or its type has changed. If so, someone
509 // else woke it up.
510 if (!flag || flag->get_type() != th->th.th_sleep_loc_type) {
511 // simply shows what flag was cast to
512 KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "
513 "awake: flag's loc(%p)\n",
514 gtid, target_gtid, NULL));
515 __kmp_unlock_suspend_mx(th);
516 return;
517 } else {
518 if (!flag->is_sleeping()) {
519 KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "
520 "awake: flag's loc(%p): %u\n",
521 gtid, target_gtid, flag->get(), (unsigned int)flag->load()));
522 __kmp_unlock_suspend_mx(th);
523 return;
524 }
525 }
526 KMP_DEBUG_ASSERT(flag);
527 flag->unset_sleeping();
528 TCW_PTR(th->th.th_sleep_loc, NULL);
529 th->th.th_sleep_loc_type = flag_unset;
530
531 KF_TRACE(5, ("__kmp_resume_template: T#%d about to wakeup T#%d, reset sleep "
532 "bit for flag's loc(%p)\n",
533 gtid, target_gtid, flag->get()));
534
535 __kmp_win32_cond_signal(&th->th.th_suspend_cv);
536 __kmp_unlock_suspend_mx(th);
537
538 KF_TRACE(30, ("__kmp_resume_template: T#%d exiting after signaling wake up"
539 " for T#%d\n",
540 gtid, target_gtid));
541}
542
543template <bool C, bool S>
544void __kmp_resume_32(int target_gtid, kmp_flag_32<C, S> *flag) {
545 __kmp_resume_template(target_gtid, flag);
546}
547template <bool C, bool S>
548void __kmp_resume_64(int target_gtid, kmp_flag_64<C, S> *flag) {
549 __kmp_resume_template(target_gtid, flag);
550}
551template <bool C, bool S>
552void __kmp_atomic_resume_64(int target_gtid, kmp_atomic_flag_64<C, S> *flag) {
553 __kmp_resume_template(target_gtid, flag);
554}
555void __kmp_resume_oncore(int target_gtid, kmp_flag_oncore *flag) {
556 __kmp_resume_template(target_gtid, flag);
557}
558
559template void __kmp_resume_32<false, true>(int, kmp_flag_32<false, true> *);
560template void __kmp_resume_32<false, false>(int, kmp_flag_32<false, false> *);
561template void __kmp_resume_64<false, true>(int, kmp_flag_64<false, true> *);
562template void
563__kmp_atomic_resume_64<false, true>(int, kmp_atomic_flag_64<false, true> *);
564
565void __kmp_yield() { Sleep(0); }
566
567void __kmp_gtid_set_specific(int gtid) {
568 if (__kmp_init_gtid) {
569 KA_TRACE(50, ("__kmp_gtid_set_specific: T#%d key:%d\n", gtid,
570 __kmp_gtid_threadprivate_key));
571 kmp_intptr_t g = (kmp_intptr_t)gtid;
572 if (!TlsSetValue(__kmp_gtid_threadprivate_key, (LPVOID)(g + 1)))
573 KMP_FATAL(TLSSetValueFailed);
574 } else {
575 KA_TRACE(50, ("__kmp_gtid_set_specific: runtime shutdown, returning\n"));
576 }
577}
578
579int __kmp_gtid_get_specific() {
580 int gtid;
581 if (!__kmp_init_gtid) {
582 KA_TRACE(50, ("__kmp_gtid_get_specific: runtime shutdown, returning "
583 "KMP_GTID_SHUTDOWN\n"));
584 return KMP_GTID_SHUTDOWN;
585 }
586 gtid = (int)(kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key);
587 if (gtid == 0) {
588 gtid = KMP_GTID_DNE;
589 } else {
590 gtid--;
591 }
592 KA_TRACE(50, ("__kmp_gtid_get_specific: key:%d gtid:%d\n",
593 __kmp_gtid_threadprivate_key, gtid));
594 return gtid;
595}
596
597void __kmp_affinity_bind_thread(int proc) {
598 if (__kmp_num_proc_groups > 1) {
599 // Form the GROUP_AFFINITY struct directly, rather than filling
600 // out a bit vector and calling __kmp_set_system_affinity().
601 GROUP_AFFINITY ga;
602 KMP_DEBUG_ASSERT((proc >= 0) && (proc < (__kmp_num_proc_groups * CHAR_BIT *
603 sizeof(DWORD_PTR))));
604 ga.Group = proc / (CHAR_BIT * sizeof(DWORD_PTR));
605 ga.Mask = (unsigned long long)1 << (proc % (CHAR_BIT * sizeof(DWORD_PTR)));
606 ga.Reserved[0] = ga.Reserved[1] = ga.Reserved[2] = 0;
607
608 KMP_DEBUG_ASSERT(__kmp_SetThreadGroupAffinity != NULL);
609 if (__kmp_SetThreadGroupAffinity(GetCurrentThread(), &ga, NULL) == 0) {
610 DWORD error = GetLastError();
611 if (__kmp_affinity_verbose) { // AC: continue silently if not verbose
612 kmp_msg_t err_code = KMP_ERR(error);
613 __kmp_msg(kmp_ms_warning, KMP_MSG(CantSetThreadAffMask), err_code,
614 __kmp_msg_null);
615 if (__kmp_generate_warnings == kmp_warnings_off) {
616 __kmp_str_free(&err_code.str);
617 }
618 }
619 }
620 } else {
621 kmp_affin_mask_t *mask;
622 KMP_CPU_ALLOC_ON_STACK(mask);
623 KMP_CPU_ZERO(mask);
624 KMP_CPU_SET(proc, mask);
625 __kmp_set_system_affinity(mask, TRUE);
626 KMP_CPU_FREE_FROM_STACK(mask);
627 }
628}
629
630void __kmp_affinity_determine_capable(const char *env_var) {
631 // All versions of Windows* OS (since Win '95) support
632 // SetThreadAffinityMask().
633
634#if KMP_GROUP_AFFINITY
635 KMP_AFFINITY_ENABLE(__kmp_num_proc_groups * sizeof(DWORD_PTR));
636#else
637 KMP_AFFINITY_ENABLE(sizeof(DWORD_PTR));
638#endif
639
640 KA_TRACE(10, ("__kmp_affinity_determine_capable: "
641 "Windows* OS affinity interface functional (mask size = "
642 "%" KMP_SIZE_T_SPEC ").\n",
643 __kmp_affin_mask_size));
644}
645
646double __kmp_read_cpu_time(void) {
647 FILETIME CreationTime, ExitTime, KernelTime, UserTime;
648 int status;
649 double cpu_time;
650
651 cpu_time = 0;
652
653 status = GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime,
654 &KernelTime, &UserTime);
655
656 if (status) {
657 double sec = 0;
658
659 sec += KernelTime.dwHighDateTime;
660 sec += UserTime.dwHighDateTime;
661
662 /* Shift left by 32 bits */
663 sec *= (double)(1 << 16) * (double)(1 << 16);
664
665 sec += KernelTime.dwLowDateTime;
666 sec += UserTime.dwLowDateTime;
667
668 cpu_time += (sec * 100.0) / KMP_NSEC_PER_SEC;
669 }
670
671 return cpu_time;
672}
673
674int __kmp_read_system_info(struct kmp_sys_info *info) {
675 info->maxrss = 0; /* the maximum resident set size utilized (in kilobytes) */
676 info->minflt = 0; /* the number of page faults serviced without any I/O */
677 info->majflt = 0; /* the number of page faults serviced that required I/O */
678 info->nswap = 0; // the number of times a process was "swapped" out of memory
679 info->inblock = 0; // the number of times the file system had to perform input
680 info->oublock = 0; // number of times the file system had to perform output
681 info->nvcsw = 0; /* the number of times a context switch was voluntarily */
682 info->nivcsw = 0; /* the number of times a context switch was forced */
683
684 return 1;
685}
686
687void __kmp_runtime_initialize(void) {
688 SYSTEM_INFO info;
689 kmp_str_buf_t path;
690 UINT path_size;
691
692 if (__kmp_init_runtime) {
693 return;
694 }
695
696#if KMP_DYNAMIC_LIB
697 /* Pin dynamic library for the lifetime of application */
698 {
699 // First, turn off error message boxes
700 UINT err_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
701 HMODULE h;
702 BOOL ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
703 GET_MODULE_HANDLE_EX_FLAG_PIN,
704 (LPCTSTR)&__kmp_serial_initialize, &h);
705 (void)ret;
706 KMP_DEBUG_ASSERT2(h && ret, "OpenMP RTL cannot find itself loaded");
707 SetErrorMode(err_mode); // Restore error mode
708 KA_TRACE(10, ("__kmp_runtime_initialize: dynamic library pinned\n"));
709 }
710#endif
711
712 InitializeCriticalSection(&__kmp_win32_section);
713#if USE_ITT_BUILD
714 __kmp_itt_system_object_created(&__kmp_win32_section, "Critical Section");
715#endif /* USE_ITT_BUILD */
716 __kmp_initialize_system_tick();
717
718#if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
719 if (!__kmp_cpuinfo.initialized) {
720 __kmp_query_cpuid(&__kmp_cpuinfo);
721 }
722#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
723
724/* Set up minimum number of threads to switch to TLS gtid */
725#if KMP_OS_WINDOWS && !KMP_DYNAMIC_LIB
726 // Windows* OS, static library.
727 /* New thread may use stack space previously used by another thread,
728 currently terminated. On Windows* OS, in case of static linking, we do not
729 know the moment of thread termination, and our structures (__kmp_threads
730 and __kmp_root arrays) are still keep info about dead threads. This leads
731 to problem in __kmp_get_global_thread_id() function: it wrongly finds gtid
732 (by searching through stack addresses of all known threads) for
733 unregistered foreign tread.
734
735 Setting __kmp_tls_gtid_min to 0 workarounds this problem:
736 __kmp_get_global_thread_id() does not search through stacks, but get gtid
737 from TLS immediately.
738 --ln
739 */
740 __kmp_tls_gtid_min = 0;
741#else
742 __kmp_tls_gtid_min = KMP_TLS_GTID_MIN;
743#endif
744
745 /* for the static library */
746 if (!__kmp_gtid_threadprivate_key) {
747 __kmp_gtid_threadprivate_key = TlsAlloc();
748 if (__kmp_gtid_threadprivate_key == TLS_OUT_OF_INDEXES) {
749 KMP_FATAL(TLSOutOfIndexes);
750 }
751 }
752
753 // Load ntdll.dll.
754 /* Simple GetModuleHandle( "ntdll.dl" ) is not suitable due to security issue
755 (see http://www.microsoft.com/technet/security/advisory/2269637.mspx). We
756 have to specify full path to the library. */
757 __kmp_str_buf_init(&path);
758 path_size = GetSystemDirectory(path.str, path.size);
759 KMP_DEBUG_ASSERT(path_size > 0);
760 if (path_size >= path.size) {
761 // Buffer is too short. Expand the buffer and try again.
762 __kmp_str_buf_reserve(&path, path_size);
763 path_size = GetSystemDirectory(path.str, path.size);
764 KMP_DEBUG_ASSERT(path_size > 0);
765 }
766 if (path_size > 0 && path_size < path.size) {
767 // Now we have system directory name in the buffer.
768 // Append backslash and name of dll to form full path,
769 path.used = path_size;
770 __kmp_str_buf_print(&path, "\\%s", "ntdll.dll");
771
772 // Now load ntdll using full path.
773 ntdll = GetModuleHandle(path.str);
774 }
775
776 KMP_DEBUG_ASSERT(ntdll != NULL);
777 if (ntdll != NULL) {
778 NtQuerySystemInformation = (NtQuerySystemInformation_t)GetProcAddress(
779 ntdll, "NtQuerySystemInformation");
780 }
781 KMP_DEBUG_ASSERT(NtQuerySystemInformation != NULL);
782
783#if KMP_GROUP_AFFINITY
784 // Load kernel32.dll.
785 // Same caveat - must use full system path name.
786 if (path_size > 0 && path_size < path.size) {
787 // Truncate the buffer back to just the system path length,
788 // discarding "\\ntdll.dll", and replacing it with "kernel32.dll".
789 path.used = path_size;
790 __kmp_str_buf_print(&path, "\\%s", "kernel32.dll");
791
792 // Load kernel32.dll using full path.
793 kernel32 = GetModuleHandle(path.str);
794 KA_TRACE(10, ("__kmp_runtime_initialize: kernel32.dll = %s\n", path.str));
795
796 // Load the function pointers to kernel32.dll routines
797 // that may or may not exist on this system.
798 if (kernel32 != NULL) {
799 __kmp_GetActiveProcessorCount =
800 (kmp_GetActiveProcessorCount_t)GetProcAddress(
801 kernel32, "GetActiveProcessorCount");
802 __kmp_GetActiveProcessorGroupCount =
803 (kmp_GetActiveProcessorGroupCount_t)GetProcAddress(
804 kernel32, "GetActiveProcessorGroupCount");
805 __kmp_GetThreadGroupAffinity =
806 (kmp_GetThreadGroupAffinity_t)GetProcAddress(
807 kernel32, "GetThreadGroupAffinity");
808 __kmp_SetThreadGroupAffinity =
809 (kmp_SetThreadGroupAffinity_t)GetProcAddress(
810 kernel32, "SetThreadGroupAffinity");
811
812 KA_TRACE(10, ("__kmp_runtime_initialize: __kmp_GetActiveProcessorCount"
813 " = %p\n",
814 __kmp_GetActiveProcessorCount));
815 KA_TRACE(10, ("__kmp_runtime_initialize: "
816 "__kmp_GetActiveProcessorGroupCount = %p\n",
817 __kmp_GetActiveProcessorGroupCount));
818 KA_TRACE(10, ("__kmp_runtime_initialize:__kmp_GetThreadGroupAffinity"
819 " = %p\n",
820 __kmp_GetThreadGroupAffinity));
821 KA_TRACE(10, ("__kmp_runtime_initialize: __kmp_SetThreadGroupAffinity"
822 " = %p\n",
823 __kmp_SetThreadGroupAffinity));
824 KA_TRACE(10, ("__kmp_runtime_initialize: sizeof(kmp_affin_mask_t) = %d\n",
825 sizeof(kmp_affin_mask_t)));
826
827 // See if group affinity is supported on this system.
828 // If so, calculate the #groups and #procs.
829 //
830 // Group affinity was introduced with Windows* 7 OS and
831 // Windows* Server 2008 R2 OS.
832 if ((__kmp_GetActiveProcessorCount != NULL) &&
833 (__kmp_GetActiveProcessorGroupCount != NULL) &&
834 (__kmp_GetThreadGroupAffinity != NULL) &&
835 (__kmp_SetThreadGroupAffinity != NULL) &&
836 ((__kmp_num_proc_groups = __kmp_GetActiveProcessorGroupCount()) >
837 1)) {
838 // Calculate the total number of active OS procs.
839 int i;
840
841 KA_TRACE(10, ("__kmp_runtime_initialize: %d processor groups"
842 " detected\n",
843 __kmp_num_proc_groups));
844
845 __kmp_xproc = 0;
846
847 for (i = 0; i < __kmp_num_proc_groups; i++) {
848 DWORD size = __kmp_GetActiveProcessorCount(i);
849 __kmp_xproc += size;
850 KA_TRACE(10, ("__kmp_runtime_initialize: proc group %d size = %d\n",
851 i, size));
852 }
853 } else {
854 KA_TRACE(10, ("__kmp_runtime_initialize: %d processor groups"
855 " detected\n",
856 __kmp_num_proc_groups));
857 }
858 }
859 }
860 if (__kmp_num_proc_groups <= 1) {
861 GetSystemInfo(&info);
862 __kmp_xproc = info.dwNumberOfProcessors;
863 }
864#else
865 (void)kernel32;
866 GetSystemInfo(&info);
867 __kmp_xproc = info.dwNumberOfProcessors;
868#endif /* KMP_GROUP_AFFINITY */
869
870 // If the OS said there were 0 procs, take a guess and use a value of 2.
871 // This is done for Linux* OS, also. Do we need error / warning?
872 if (__kmp_xproc <= 0) {
873 __kmp_xproc = 2;
874 }
875
876 KA_TRACE(5,
877 ("__kmp_runtime_initialize: total processors = %d\n", __kmp_xproc));
878
879 __kmp_str_buf_free(&path);
880
881#if USE_ITT_BUILD
882 __kmp_itt_initialize();
883#endif /* USE_ITT_BUILD */
884
885 __kmp_init_runtime = TRUE;
886} // __kmp_runtime_initialize
887
888void __kmp_runtime_destroy(void) {
889 if (!__kmp_init_runtime) {
890 return;
891 }
892
893#if USE_ITT_BUILD
894 __kmp_itt_destroy();
895#endif /* USE_ITT_BUILD */
896
897 /* we can't DeleteCriticalsection( & __kmp_win32_section ); */
898 /* due to the KX_TRACE() commands */
899 KA_TRACE(40, ("__kmp_runtime_destroy\n"));
900
901 if (__kmp_gtid_threadprivate_key) {
902 TlsFree(__kmp_gtid_threadprivate_key);
903 __kmp_gtid_threadprivate_key = 0;
904 }
905
906 __kmp_affinity_uninitialize();
907 DeleteCriticalSection(&__kmp_win32_section);
908
909 ntdll = NULL;
910 NtQuerySystemInformation = NULL;
911
912#if KMP_ARCH_X86_64
913 kernel32 = NULL;
914 __kmp_GetActiveProcessorCount = NULL;
915 __kmp_GetActiveProcessorGroupCount = NULL;
916 __kmp_GetThreadGroupAffinity = NULL;
917 __kmp_SetThreadGroupAffinity = NULL;
918#endif // KMP_ARCH_X86_64
919
920 __kmp_init_runtime = FALSE;
921}
922
923void __kmp_terminate_thread(int gtid) {
924 kmp_info_t *th = __kmp_threads[gtid];
925
926 if (!th)
927 return;
928
929 KA_TRACE(10, ("__kmp_terminate_thread: kill (%d)\n", gtid));
930
931 if (TerminateThread(th->th.th_info.ds.ds_thread, (DWORD)-1) == FALSE) {
932 /* It's OK, the thread may have exited already */
933 }
934 __kmp_free_handle(th->th.th_info.ds.ds_thread);
935}
936
937void __kmp_clear_system_time(void) {
938 LARGE_INTEGER time;
939 QueryPerformanceCounter(&time);
940 __kmp_win32_time = (kmp_int64)time.QuadPart;
941}
942
943void __kmp_initialize_system_tick(void) {
944 {
945 BOOL status;
946 LARGE_INTEGER freq;
947
948 status = QueryPerformanceFrequency(&freq);
949 if (!status) {
950 DWORD error = GetLastError();
951 __kmp_fatal(KMP_MSG(FunctionError, "QueryPerformanceFrequency()"),
952 KMP_ERR(error), __kmp_msg_null);
953
954 } else {
955 __kmp_win32_tick = ((double)1.0) / (double)freq.QuadPart;
956 }
957 }
958}
959
960/* Calculate the elapsed wall clock time for the user */
961
962void __kmp_elapsed(double *t) {
963 LARGE_INTEGER now;
964 QueryPerformanceCounter(&now);
965 *t = ((double)now.QuadPart) * __kmp_win32_tick;
966}
967
968/* Calculate the elapsed wall clock tick for the user */
969
970void __kmp_elapsed_tick(double *t) { *t = __kmp_win32_tick; }
971
972void __kmp_read_system_time(double *delta) {
973 if (delta != NULL) {
974 LARGE_INTEGER now;
975 QueryPerformanceCounter(&now);
976 *delta = ((double)(((kmp_int64)now.QuadPart) - __kmp_win32_time)) *
977 __kmp_win32_tick;
978 }
979}
980
981/* Return the current time stamp in nsec */
982kmp_uint64 __kmp_now_nsec() {
983 LARGE_INTEGER now;
984 QueryPerformanceCounter(&now);
985 return 1e9 * __kmp_win32_tick * now.QuadPart;
986}
987
988extern "C" void *__stdcall __kmp_launch_worker(void *arg) {
989 volatile void *stack_data;
990 void *exit_val;
991 void *padding = 0;
992 kmp_info_t *this_thr = (kmp_info_t *)arg;
993 int gtid;
994
995 gtid = this_thr->th.th_info.ds.ds_gtid;
996 __kmp_gtid_set_specific(gtid);
997#ifdef KMP_TDATA_GTID
998#error "This define causes problems with LoadLibrary() + declspec(thread) " \
999 "on Windows* OS. See CQ50564, tests kmp_load_library*.c and this MSDN " \
1000 "reference: http://support.microsoft.com/kb/118816"
1001//__kmp_gtid = gtid;
1002#endif
1003
1004#if USE_ITT_BUILD
1005 __kmp_itt_thread_name(gtid);
1006#endif /* USE_ITT_BUILD */
1007
1008 __kmp_affinity_set_init_mask(gtid, FALSE);
1009
1010#if KMP_ARCH_X86 || KMP_ARCH_X86_64
1011 // Set FP control regs to be a copy of the parallel initialization thread's.
1012 __kmp_clear_x87_fpu_status_word();
1013 __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
1014 __kmp_load_mxcsr(&__kmp_init_mxcsr);
1015#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
1016
1017 if (__kmp_stkoffset > 0 && gtid > 0) {
1018 padding = KMP_ALLOCA(gtid * __kmp_stkoffset);
1019 (void)padding;
1020 }
1021
1022 KMP_FSYNC_RELEASING(&this_thr->th.th_info.ds.ds_alive);
1023 this_thr->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1024 TCW_4(this_thr->th.th_info.ds.ds_alive, TRUE);
1025
1026 if (TCR_4(__kmp_gtid_mode) <
1027 2) { // check stack only if it is used to get gtid
1028 TCW_PTR(this_thr->th.th_info.ds.ds_stackbase, &stack_data);
1029 KMP_ASSERT(this_thr->th.th_info.ds.ds_stackgrow == FALSE);
1030 __kmp_check_stack_overlap(this_thr);
1031 }
1032 KMP_MB();
1033 exit_val = __kmp_launch_thread(this_thr);
1034 KMP_FSYNC_RELEASING(&this_thr->th.th_info.ds.ds_alive);
1035 TCW_4(this_thr->th.th_info.ds.ds_alive, FALSE);
1036 KMP_MB();
1037 return exit_val;
1038}
1039
1040#if KMP_USE_MONITOR
1041/* The monitor thread controls all of the threads in the complex */
1042
1043void *__stdcall __kmp_launch_monitor(void *arg) {
1044 DWORD wait_status;
1045 kmp_thread_t monitor;
1046 int status;
1047 int interval;
1048 kmp_info_t *this_thr = (kmp_info_t *)arg;
1049
1050 KMP_DEBUG_ASSERT(__kmp_init_monitor);
1051 TCW_4(__kmp_init_monitor, 2); // AC: Signal library that monitor has started
1052 // TODO: hide "2" in enum (like {true,false,started})
1053 this_thr->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1054 TCW_4(this_thr->th.th_info.ds.ds_alive, TRUE);
1055
1056 KMP_MB(); /* Flush all pending memory write invalidates. */
1057 KA_TRACE(10, ("__kmp_launch_monitor: launched\n"));
1058
1059 monitor = GetCurrentThread();
1060
1061 /* set thread priority */
1062 status = SetThreadPriority(monitor, THREAD_PRIORITY_HIGHEST);
1063 if (!status) {
1064 DWORD error = GetLastError();
1065 __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
1066 }
1067
1068 /* register us as monitor */
1069 __kmp_gtid_set_specific(KMP_GTID_MONITOR);
1070#ifdef KMP_TDATA_GTID
1071#error "This define causes problems with LoadLibrary() + declspec(thread) " \
1072 "on Windows* OS. See CQ50564, tests kmp_load_library*.c and this MSDN " \
1073 "reference: http://support.microsoft.com/kb/118816"
1074//__kmp_gtid = KMP_GTID_MONITOR;
1075#endif
1076
1077#if USE_ITT_BUILD
1078 __kmp_itt_thread_ignore(); // Instruct Intel(R) Threading Tools to ignore
1079// monitor thread.
1080#endif /* USE_ITT_BUILD */
1081
1082 KMP_MB(); /* Flush all pending memory write invalidates. */
1083
1084 interval = (1000 / __kmp_monitor_wakeups); /* in milliseconds */
1085
1086 while (!TCR_4(__kmp_global.g.g_done)) {
1087 /* This thread monitors the state of the system */
1088
1089 KA_TRACE(15, ("__kmp_launch_monitor: update\n"));
1090
1091 wait_status = WaitForSingleObject(__kmp_monitor_ev, interval);
1092
1093 if (wait_status == WAIT_TIMEOUT) {
1094 TCW_4(__kmp_global.g.g_time.dt.t_value,
1095 TCR_4(__kmp_global.g.g_time.dt.t_value) + 1);
1096 }
1097
1098 KMP_MB(); /* Flush all pending memory write invalidates. */
1099 }
1100
1101 KA_TRACE(10, ("__kmp_launch_monitor: finished\n"));
1102
1103 status = SetThreadPriority(monitor, THREAD_PRIORITY_NORMAL);
1104 if (!status) {
1105 DWORD error = GetLastError();
1106 __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
1107 }
1108
1109 if (__kmp_global.g.g_abort != 0) {
1110 /* now we need to terminate the worker threads */
1111 /* the value of t_abort is the signal we caught */
1112 int gtid;
1113
1114 KA_TRACE(10, ("__kmp_launch_monitor: terminate sig=%d\n",
1115 (__kmp_global.g.g_abort)));
1116
1117 /* terminate the OpenMP worker threads */
1118 /* TODO this is not valid for sibling threads!!
1119 * the uber master might not be 0 anymore.. */
1120 for (gtid = 1; gtid < __kmp_threads_capacity; ++gtid)
1121 __kmp_terminate_thread(gtid);
1122
1123 __kmp_cleanup();
1124
1125 Sleep(0);
1126
1127 KA_TRACE(10,
1128 ("__kmp_launch_monitor: raise sig=%d\n", __kmp_global.g.g_abort));
1129
1130 if (__kmp_global.g.g_abort > 0) {
1131 raise(__kmp_global.g.g_abort);
1132 }
1133 }
1134
1135 TCW_4(this_thr->th.th_info.ds.ds_alive, FALSE);
1136
1137 KMP_MB();
1138 return arg;
1139}
1140#endif
1141
1142void __kmp_create_worker(int gtid, kmp_info_t *th, size_t stack_size) {
1143 kmp_thread_t handle;
1144 DWORD idThread;
1145
1146 KA_TRACE(10, ("__kmp_create_worker: try to create thread (%d)\n", gtid));
1147
1148 th->th.th_info.ds.ds_gtid = gtid;
1149
1150 if (KMP_UBER_GTID(gtid)) {
1151 int stack_data;
1152
1153 /* TODO: GetCurrentThread() returns a pseudo-handle that is unsuitable for
1154 other threads to use. Is it appropriate to just use GetCurrentThread?
1155 When should we close this handle? When unregistering the root? */
1156 {
1157 BOOL rc;
1158 rc = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
1159 GetCurrentProcess(), &th->th.th_info.ds.ds_thread, 0,
1160 FALSE, DUPLICATE_SAME_ACCESS);
1161 KMP_ASSERT(rc);
1162 KA_TRACE(10, (" __kmp_create_worker: ROOT Handle duplicated, th = %p, "
1163 "handle = %" KMP_UINTPTR_SPEC "\n",
1164 (LPVOID)th, th->th.th_info.ds.ds_thread));
1165 th->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1166 }
1167 if (TCR_4(__kmp_gtid_mode) < 2) { // check stack only if used to get gtid
1168 /* we will dynamically update the stack range if gtid_mode == 1 */
1169 TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data);
1170 TCW_PTR(th->th.th_info.ds.ds_stacksize, 0);
1171 TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE);
1172 __kmp_check_stack_overlap(th);
1173 }
1174 } else {
1175 KMP_MB(); /* Flush all pending memory write invalidates. */
1176
1177 /* Set stack size for this thread now. */
1178 KA_TRACE(10,
1179 ("__kmp_create_worker: stack_size = %" KMP_SIZE_T_SPEC " bytes\n",
1180 stack_size));
1181
1182 stack_size += gtid * __kmp_stkoffset;
1183
1184 TCW_PTR(th->th.th_info.ds.ds_stacksize, stack_size);
1185 TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE);
1186
1187 KA_TRACE(10,
1188 ("__kmp_create_worker: (before) stack_size = %" KMP_SIZE_T_SPEC
1189 " bytes, &__kmp_launch_worker = %p, th = %p, &idThread = %p\n",
1190 (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)&__kmp_launch_worker,
1191 (LPVOID)th, &idThread));
1192
1193 handle = CreateThread(
1194 NULL, (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)__kmp_launch_worker,
1195 (LPVOID)th, STACK_SIZE_PARAM_IS_A_RESERVATION, &idThread);
1196
1197 KA_TRACE(10,
1198 ("__kmp_create_worker: (after) stack_size = %" KMP_SIZE_T_SPEC
1199 " bytes, &__kmp_launch_worker = %p, th = %p, "
1200 "idThread = %u, handle = %" KMP_UINTPTR_SPEC "\n",
1201 (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)&__kmp_launch_worker,
1202 (LPVOID)th, idThread, handle));
1203
1204 if (handle == 0) {
1205 DWORD error = GetLastError();
1206 __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
1207 } else {
1208 th->th.th_info.ds.ds_thread = handle;
1209 }
1210
1211 KMP_MB(); /* Flush all pending memory write invalidates. */
1212 }
1213
1214 KA_TRACE(10, ("__kmp_create_worker: done creating thread (%d)\n", gtid));
1215}
1216
1217int __kmp_still_running(kmp_info_t *th) {
1218 return (WAIT_TIMEOUT == WaitForSingleObject(th->th.th_info.ds.ds_thread, 0));
1219}
1220
1221#if KMP_USE_MONITOR
1222void __kmp_create_monitor(kmp_info_t *th) {
1223 kmp_thread_t handle;
1224 DWORD idThread;
1225 int ideal, new_ideal;
1226
1227 if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
1228 // We don't need monitor thread in case of MAX_BLOCKTIME
1229 KA_TRACE(10, ("__kmp_create_monitor: skipping monitor thread because of "
1230 "MAX blocktime\n"));
1231 th->th.th_info.ds.ds_tid = 0; // this makes reap_monitor no-op
1232 th->th.th_info.ds.ds_gtid = 0;
1233 TCW_4(__kmp_init_monitor, 2); // Signal to stop waiting for monitor creation
1234 return;
1235 }
1236 KA_TRACE(10, ("__kmp_create_monitor: try to create monitor\n"));
1237
1238 KMP_MB(); /* Flush all pending memory write invalidates. */
1239
1240 __kmp_monitor_ev = CreateEvent(NULL, TRUE, FALSE, NULL);
1241 if (__kmp_monitor_ev == NULL) {
1242 DWORD error = GetLastError();
1243 __kmp_fatal(KMP_MSG(CantCreateEvent), KMP_ERR(error), __kmp_msg_null);
1244 }
1245#if USE_ITT_BUILD
1246 __kmp_itt_system_object_created(__kmp_monitor_ev, "Event");
1247#endif /* USE_ITT_BUILD */
1248
1249 th->th.th_info.ds.ds_tid = KMP_GTID_MONITOR;
1250 th->th.th_info.ds.ds_gtid = KMP_GTID_MONITOR;
1251
1252 // FIXME - on Windows* OS, if __kmp_monitor_stksize = 0, figure out how
1253 // to automatically expand stacksize based on CreateThread error code.
1254 if (__kmp_monitor_stksize == 0) {
1255 __kmp_monitor_stksize = KMP_DEFAULT_MONITOR_STKSIZE;
1256 }
1257 if (__kmp_monitor_stksize < __kmp_sys_min_stksize) {
1258 __kmp_monitor_stksize = __kmp_sys_min_stksize;
1259 }
1260
1261 KA_TRACE(10, ("__kmp_create_monitor: requested stacksize = %d bytes\n",
1262 (int)__kmp_monitor_stksize));
1263
1264 TCW_4(__kmp_global.g.g_time.dt.t_value, 0);
1265
1266 handle =
1267 CreateThread(NULL, (SIZE_T)__kmp_monitor_stksize,
1268 (LPTHREAD_START_ROUTINE)__kmp_launch_monitor, (LPVOID)th,
1269 STACK_SIZE_PARAM_IS_A_RESERVATION, &idThread);
1270 if (handle == 0) {
1271 DWORD error = GetLastError();
1272 __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
1273 } else
1274 th->th.th_info.ds.ds_thread = handle;
1275
1276 KMP_MB(); /* Flush all pending memory write invalidates. */
1277
1278 KA_TRACE(10, ("__kmp_create_monitor: monitor created %p\n",
1279 (void *)th->th.th_info.ds.ds_thread));
1280}
1281#endif
1282
1283/* Check to see if thread is still alive.
1284 NOTE: The ExitProcess(code) system call causes all threads to Terminate
1285 with a exit_val = code. Because of this we can not rely on exit_val having
1286 any particular value. So this routine may return STILL_ALIVE in exit_val
1287 even after the thread is dead. */
1288
1289int __kmp_is_thread_alive(kmp_info_t *th, DWORD *exit_val) {
1290 DWORD rc;
1291 rc = GetExitCodeThread(th->th.th_info.ds.ds_thread, exit_val);
1292 if (rc == 0) {
1293 DWORD error = GetLastError();
1294 __kmp_fatal(KMP_MSG(FunctionError, "GetExitCodeThread()"), KMP_ERR(error),
1295 __kmp_msg_null);
1296 }
1297 return (*exit_val == STILL_ACTIVE);
1298}
1299
1300void __kmp_exit_thread(int exit_status) {
1301 ExitThread(exit_status);
1302} // __kmp_exit_thread
1303
1304// This is a common part for both __kmp_reap_worker() and __kmp_reap_monitor().
1305static void __kmp_reap_common(kmp_info_t *th) {
1306 DWORD exit_val;
1307
1308 KMP_MB(); /* Flush all pending memory write invalidates. */
1309
1310 KA_TRACE(
1311 10, ("__kmp_reap_common: try to reap (%d)\n", th->th.th_info.ds.ds_gtid));
1312
1313 /* 2006-10-19:
1314 There are two opposite situations:
1315 1. Windows* OS keep thread alive after it resets ds_alive flag and
1316 exits from thread function. (For example, see C70770/Q394281 "unloading of
1317 dll based on OMP is very slow".)
1318 2. Windows* OS may kill thread before it resets ds_alive flag.
1319
1320 Right solution seems to be waiting for *either* thread termination *or*
1321 ds_alive resetting. */
1322 {
1323 // TODO: This code is very similar to KMP_WAIT. Need to generalize
1324 // KMP_WAIT to cover this usage also.
1325 void *obj = NULL;
1326 kmp_uint32 spins;
1327 kmp_uint64 time;
1328#if USE_ITT_BUILD
1329 KMP_FSYNC_SPIN_INIT(obj, (void *)&th->th.th_info.ds.ds_alive);
1330#endif /* USE_ITT_BUILD */
1331 KMP_INIT_YIELD(spins);
1332 KMP_INIT_BACKOFF(time);
1333 do {
1334#if USE_ITT_BUILD
1335 KMP_FSYNC_SPIN_PREPARE(obj);
1336#endif /* USE_ITT_BUILD */
1337 __kmp_is_thread_alive(th, &exit_val);
1338 KMP_YIELD_OVERSUB_ELSE_SPIN(spins, time);
1339 } while (exit_val == STILL_ACTIVE && TCR_4(th->th.th_info.ds.ds_alive));
1340#if USE_ITT_BUILD
1341 if (exit_val == STILL_ACTIVE) {
1342 KMP_FSYNC_CANCEL(obj);
1343 } else {
1344 KMP_FSYNC_SPIN_ACQUIRED(obj);
1345 }
1346#endif /* USE_ITT_BUILD */
1347 }
1348
1349 __kmp_free_handle(th->th.th_info.ds.ds_thread);
1350
1351 /* NOTE: The ExitProcess(code) system call causes all threads to Terminate
1352 with a exit_val = code. Because of this we can not rely on exit_val having
1353 any particular value. */
1354 kmp_intptr_t e = (kmp_intptr_t)exit_val;
1355 if (exit_val == STILL_ACTIVE) {
1356 KA_TRACE(1, ("__kmp_reap_common: thread still active.\n"));
1357 } else if ((void *)e != (void *)th) {
1358 KA_TRACE(1, ("__kmp_reap_common: ExitProcess / TerminateThread used?\n"));
1359 }
1360
1361 KA_TRACE(10,
1362 ("__kmp_reap_common: done reaping (%d), handle = %" KMP_UINTPTR_SPEC
1363 "\n",
1364 th->th.th_info.ds.ds_gtid, th->th.th_info.ds.ds_thread));
1365
1366 th->th.th_info.ds.ds_thread = 0;
1367 th->th.th_info.ds.ds_tid = KMP_GTID_DNE;
1368 th->th.th_info.ds.ds_gtid = KMP_GTID_DNE;
1369 th->th.th_info.ds.ds_thread_id = 0;
1370
1371 KMP_MB(); /* Flush all pending memory write invalidates. */
1372}
1373
1374#if KMP_USE_MONITOR
1375void __kmp_reap_monitor(kmp_info_t *th) {
1376 int status;
1377
1378 KA_TRACE(10, ("__kmp_reap_monitor: try to reap %p\n",
1379 (void *)th->th.th_info.ds.ds_thread));
1380
1381 // If monitor has been created, its tid and gtid should be KMP_GTID_MONITOR.
1382 // If both tid and gtid are 0, it means the monitor did not ever start.
1383 // If both tid and gtid are KMP_GTID_DNE, the monitor has been shut down.
1384 KMP_DEBUG_ASSERT(th->th.th_info.ds.ds_tid == th->th.th_info.ds.ds_gtid);
1385 if (th->th.th_info.ds.ds_gtid != KMP_GTID_MONITOR) {
1386 KA_TRACE(10, ("__kmp_reap_monitor: monitor did not start, returning\n"));
1387 return;
1388 }
1389
1390 KMP_MB(); /* Flush all pending memory write invalidates. */
1391
1392 status = SetEvent(__kmp_monitor_ev);
1393 if (status == FALSE) {
1394 DWORD error = GetLastError();
1395 __kmp_fatal(KMP_MSG(CantSetEvent), KMP_ERR(error), __kmp_msg_null);
1396 }
1397 KA_TRACE(10, ("__kmp_reap_monitor: reaping thread (%d)\n",
1398 th->th.th_info.ds.ds_gtid));
1399 __kmp_reap_common(th);
1400
1401 __kmp_free_handle(__kmp_monitor_ev);
1402
1403 KMP_MB(); /* Flush all pending memory write invalidates. */
1404}
1405#endif
1406
1407void __kmp_reap_worker(kmp_info_t *th) {
1408 KA_TRACE(10, ("__kmp_reap_worker: reaping thread (%d)\n",
1409 th->th.th_info.ds.ds_gtid));
1410 __kmp_reap_common(th);
1411}
1412
1413#if KMP_HANDLE_SIGNALS
1414
1415static void __kmp_team_handler(int signo) {
1416 if (__kmp_global.g.g_abort == 0) {
1417 // Stage 1 signal handler, let's shut down all of the threads.
1418 if (__kmp_debug_buf) {
1419 __kmp_dump_debug_buffer();
1420 }
1421 KMP_MB(); // Flush all pending memory write invalidates.
1422 TCW_4(__kmp_global.g.g_abort, signo);
1423 KMP_MB(); // Flush all pending memory write invalidates.
1424 TCW_4(__kmp_global.g.g_done, TRUE);
1425 KMP_MB(); // Flush all pending memory write invalidates.
1426 }
1427} // __kmp_team_handler
1428
1429static sig_func_t __kmp_signal(int signum, sig_func_t handler) {
1430 sig_func_t old = signal(signum, handler);
1431 if (old == SIG_ERR) {
1432 int error = errno;
1433 __kmp_fatal(KMP_MSG(FunctionError, "signal"), KMP_ERR(error),
1434 __kmp_msg_null);
1435 }
1436 return old;
1437}
1438
1439static void __kmp_install_one_handler(int sig, sig_func_t handler,
1440 int parallel_init) {
1441 sig_func_t old;
1442 KMP_MB(); /* Flush all pending memory write invalidates. */
1443 KB_TRACE(60, ("__kmp_install_one_handler: called: sig=%d\n", sig));
1444 if (parallel_init) {
1445 old = __kmp_signal(sig, handler);
1446 // SIG_DFL on Windows* OS in NULL or 0.
1447 if (old == __kmp_sighldrs[sig]) {
1448 __kmp_siginstalled[sig] = 1;
1449 } else { // Restore/keep user's handler if one previously installed.
1450 old = __kmp_signal(sig, old);
1451 }
1452 } else {
1453 // Save initial/system signal handlers to see if user handlers installed.
1454 // 2009-09-23: It is a dead code. On Windows* OS __kmp_install_signals
1455 // called once with parallel_init == TRUE.
1456 old = __kmp_signal(sig, SIG_DFL);
1457 __kmp_sighldrs[sig] = old;
1458 __kmp_signal(sig, old);
1459 }
1460 KMP_MB(); /* Flush all pending memory write invalidates. */
1461} // __kmp_install_one_handler
1462
1463static void __kmp_remove_one_handler(int sig) {
1464 if (__kmp_siginstalled[sig]) {
1465 sig_func_t old;
1466 KMP_MB(); // Flush all pending memory write invalidates.
1467 KB_TRACE(60, ("__kmp_remove_one_handler: called: sig=%d\n", sig));
1468 old = __kmp_signal(sig, __kmp_sighldrs[sig]);
1469 if (old != __kmp_team_handler) {
1470 KB_TRACE(10, ("__kmp_remove_one_handler: oops, not our handler, "
1471 "restoring: sig=%d\n",
1472 sig));
1473 old = __kmp_signal(sig, old);
1474 }
1475 __kmp_sighldrs[sig] = NULL;
1476 __kmp_siginstalled[sig] = 0;
1477 KMP_MB(); // Flush all pending memory write invalidates.
1478 }
1479} // __kmp_remove_one_handler
1480
1481void __kmp_install_signals(int parallel_init) {
1482 KB_TRACE(10, ("__kmp_install_signals: called\n"));
1483 if (!__kmp_handle_signals) {
1484 KB_TRACE(10, ("__kmp_install_signals: KMP_HANDLE_SIGNALS is false - "
1485 "handlers not installed\n"));
1486 return;
1487 }
1488 __kmp_install_one_handler(SIGINT, __kmp_team_handler, parallel_init);
1489 __kmp_install_one_handler(SIGILL, __kmp_team_handler, parallel_init);
1490 __kmp_install_one_handler(SIGABRT, __kmp_team_handler, parallel_init);
1491 __kmp_install_one_handler(SIGFPE, __kmp_team_handler, parallel_init);
1492 __kmp_install_one_handler(SIGSEGV, __kmp_team_handler, parallel_init);
1493 __kmp_install_one_handler(SIGTERM, __kmp_team_handler, parallel_init);
1494} // __kmp_install_signals
1495
1496void __kmp_remove_signals(void) {
1497 int sig;
1498 KB_TRACE(10, ("__kmp_remove_signals: called\n"));
1499 for (sig = 1; sig < NSIG; ++sig) {
1500 __kmp_remove_one_handler(sig);
1501 }
1502} // __kmp_remove_signals
1503
1504#endif // KMP_HANDLE_SIGNALS
1505
1506/* Put the thread to sleep for a time period */
1507void __kmp_thread_sleep(int millis) {
1508 DWORD status;
1509
1510 status = SleepEx((DWORD)millis, FALSE);
1511 if (status) {
1512 DWORD error = GetLastError();
1513 __kmp_fatal(KMP_MSG(FunctionError, "SleepEx()"), KMP_ERR(error),
1514 __kmp_msg_null);
1515 }
1516}
1517
1518// Determine whether the given address is mapped into the current address space.
1519int __kmp_is_address_mapped(void *addr) {
1520 MEMORY_BASIC_INFORMATION lpBuffer;
1521 SIZE_T dwLength;
1522
1523 dwLength = sizeof(MEMORY_BASIC_INFORMATION);
1524
1525 VirtualQuery(addr, &lpBuffer, dwLength);
1526
1527 return !(((lpBuffer.State == MEM_RESERVE) || (lpBuffer.State == MEM_FREE)) ||
1528 ((lpBuffer.Protect == PAGE_NOACCESS) ||
1529 (lpBuffer.Protect == PAGE_EXECUTE)));
1530}
1531
1532kmp_uint64 __kmp_hardware_timestamp(void) {
1533 kmp_uint64 r = 0;
1534
1535 QueryPerformanceCounter((LARGE_INTEGER *)&r);
1536 return r;
1537}
1538
1539/* Free handle and check the error code */
1540void __kmp_free_handle(kmp_thread_t tHandle) {
1541 /* called with parameter type HANDLE also, thus suppose kmp_thread_t defined
1542 * as HANDLE */
1543 BOOL rc;
1544 rc = CloseHandle(tHandle);
1545 if (!rc) {
1546 DWORD error = GetLastError();
1547 __kmp_fatal(KMP_MSG(CantCloseHandle), KMP_ERR(error), __kmp_msg_null);
1548 }
1549}
1550
1551int __kmp_get_load_balance(int max) {
1552 static ULONG glb_buff_size = 100 * 1024;
1553
1554 // Saved count of the running threads for the thread balance algorithm
1555 static int glb_running_threads = 0;
1556 static double glb_call_time = 0; /* Thread balance algorithm call time */
1557
1558 int running_threads = 0; // Number of running threads in the system.
1559 NTSTATUS status = 0;
1560 ULONG buff_size = 0;
1561 ULONG info_size = 0;
1562 void *buffer = NULL;
1563 PSYSTEM_PROCESS_INFORMATION spi = NULL;
1564 int first_time = 1;
1565
1566 double call_time = 0.0; // start, finish;
1567
1568 __kmp_elapsed(&call_time);
1569
1570 if (glb_call_time &&
1571 (call_time - glb_call_time < __kmp_load_balance_interval)) {
1572 running_threads = glb_running_threads;
1573 goto finish;
1574 }
1575 glb_call_time = call_time;
1576
1577 // Do not spend time on running algorithm if we have a permanent error.
1578 if (NtQuerySystemInformation == NULL) {
1579 running_threads = -1;
1580 goto finish;
1581 }
1582
1583 if (max <= 0) {
1584 max = INT_MAX;
1585 }
1586
1587 do {
1588
1589 if (first_time) {
1590 buff_size = glb_buff_size;
1591 } else {
1592 buff_size = 2 * buff_size;
1593 }
1594
1595 buffer = KMP_INTERNAL_REALLOC(buffer, buff_size);
1596 if (buffer == NULL) {
1597 running_threads = -1;
1598 goto finish;
1599 }
1600 status = NtQuerySystemInformation(SystemProcessInformation, buffer,
1601 buff_size, &info_size);
1602 first_time = 0;
1603
1604 } while (status == STATUS_INFO_LENGTH_MISMATCH);
1605 glb_buff_size = buff_size;
1606
1607#define CHECK(cond) \
1608 { \
1609 KMP_DEBUG_ASSERT(cond); \
1610 if (!(cond)) { \
1611 running_threads = -1; \
1612 goto finish; \
1613 } \
1614 }
1615
1616 CHECK(buff_size >= info_size);
1617 spi = PSYSTEM_PROCESS_INFORMATION(buffer);
1618 for (;;) {
1619 ptrdiff_t offset = uintptr_t(spi) - uintptr_t(buffer);
1620 CHECK(0 <= offset &&
1621 offset + sizeof(SYSTEM_PROCESS_INFORMATION) < info_size);
1622 HANDLE pid = spi->ProcessId;
1623 ULONG num = spi->NumberOfThreads;
1624 CHECK(num >= 1);
1625 size_t spi_size =
1626 sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD) * (num - 1);
1627 CHECK(offset + spi_size <
1628 info_size); // Make sure process info record fits the buffer.
1629 if (spi->NextEntryOffset != 0) {
1630 CHECK(spi_size <=
1631 spi->NextEntryOffset); // And do not overlap with the next record.
1632 }
1633 // pid == 0 corresponds to the System Idle Process. It always has running
1634 // threads on all cores. So, we don't consider the running threads of this
1635 // process.
1636 if (pid != 0) {
1637 for (int i = 0; i < num; ++i) {
1638 THREAD_STATE state = spi->Threads[i].State;
1639 // Count threads that have Ready or Running state.
1640 // !!! TODO: Why comment does not match the code???
1641 if (state == StateRunning) {
1642 ++running_threads;
1643 // Stop counting running threads if the number is already greater than
1644 // the number of available cores
1645 if (running_threads >= max) {
1646 goto finish;
1647 }
1648 }
1649 }
1650 }
1651 if (spi->NextEntryOffset == 0) {
1652 break;
1653 }
1654 spi = PSYSTEM_PROCESS_INFORMATION(uintptr_t(spi) + spi->NextEntryOffset);
1655 }
1656
1657#undef CHECK
1658
1659finish: // Clean up and exit.
1660
1661 if (buffer != NULL) {
1662 KMP_INTERNAL_FREE(buffer);
1663 }
1664
1665 glb_running_threads = running_threads;
1666
1667 return running_threads;
1668} //__kmp_get_load_balance()
1669
1670// Find symbol from the loaded modules
1671void *__kmp_lookup_symbol(const char *name) {
1672 HANDLE process = GetCurrentProcess();
1673 DWORD needed;
1674 HMODULE *modules = nullptr;
1675 if (!EnumProcessModules(process, modules, 0, &needed))
1676 return nullptr;
1677 DWORD num_modules = needed / sizeof(HMODULE);
1678 modules = (HMODULE *)malloc(num_modules * sizeof(HMODULE));
1679 if (!EnumProcessModules(process, modules, needed, &needed)) {
1680 free(modules);
1681 return nullptr;
1682 }
1683 void *proc = nullptr;
1684 for (uint32_t i = 0; i < num_modules; i++) {
1685 proc = (void *)GetProcAddress(modules[i], name);
1686 if (proc)
1687 break;
1688 }
1689 free(modules);
1690 return proc;
1691}
1692
1693// Functions for hidden helper task
1694void __kmp_hidden_helper_worker_thread_wait() {
1695 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1696}
1697
1698void __kmp_do_initialize_hidden_helper_threads() {
1699 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1700}
1701
1702void __kmp_hidden_helper_threads_initz_wait() {
1703 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1704}
1705
1706void __kmp_hidden_helper_initz_release() {
1707 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1708}
1709
1710void __kmp_hidden_helper_main_thread_wait() {
1711 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1712}
1713
1714void __kmp_hidden_helper_main_thread_release() {
1715 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1716}
1717
1718void __kmp_hidden_helper_worker_thread_signal() {
1719 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1720}
1721
1722void __kmp_hidden_helper_threads_deinitz_wait() {
1723 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1724}
1725
1726void __kmp_hidden_helper_threads_deinitz_release() {
1727 KMP_ASSERT(0 && "Hidden helper task is not supported on Windows");
1728}