14 #include "kmp_affinity.h"
18 #include "kmp_wait_release.h"
28 #pragma comment(lib, "psapi.lib")
31 enum SYSTEM_INFORMATION_CLASS {
32 SystemProcessInformation = 5
52 SIZE_T PeakVirtualSize;
55 SIZE_T PeakWorkingSetSize;
56 SIZE_T WorkingSetSize;
57 SIZE_T QuotaPeakPagedPoolUsage;
58 SIZE_T QuotaPagedPoolUsage;
59 SIZE_T QuotaPeakNonPagedPoolUsage;
60 SIZE_T QuotaNonPagedPoolUsage;
62 SIZE_T PeakPagefileUsage;
63 SIZE_T PrivatePageCount;
66 struct SYSTEM_THREAD {
67 LARGE_INTEGER KernelTime;
68 LARGE_INTEGER UserTime;
69 LARGE_INTEGER CreateTime;
75 ULONG ContextSwitchCount;
80 KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, KernelTime) == 0);
82 KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, StartAddress) == 28);
83 KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, State) == 52);
85 KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, StartAddress) == 32);
86 KMP_BUILD_ASSERT(offsetof(SYSTEM_THREAD, State) == 68);
89 struct 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;
99 HANDLE ParentProcessId;
102 VM_COUNTERS VMCounters;
103 IO_COUNTERS IOCounters;
104 SYSTEM_THREAD Threads[1];
106 typedef SYSTEM_PROCESS_INFORMATION *PSYSTEM_PROCESS_INFORMATION;
108 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, NextEntryOffset) == 0);
109 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, CreateTime) == 32);
110 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ImageName) == 56);
112 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ProcessId) == 68);
113 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, HandleCount) == 76);
114 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, VMCounters) == 88);
115 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, IOCounters) == 136);
116 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, Threads) == 184);
118 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, ProcessId) == 80);
119 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, HandleCount) == 96);
120 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, VMCounters) == 112);
121 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, IOCounters) == 208);
122 KMP_BUILD_ASSERT(offsetof(SYSTEM_PROCESS_INFORMATION, Threads) == 256);
125 typedef NTSTATUS(NTAPI *NtQuerySystemInformation_t)(SYSTEM_INFORMATION_CLASS,
126 PVOID, ULONG, PULONG);
127 NtQuerySystemInformation_t NtQuerySystemInformation = NULL;
129 HMODULE ntdll = NULL;
133 static HMODULE kernel32 = NULL;
135 #if KMP_HANDLE_SIGNALS
136 typedef void (*sig_func_t)(int);
137 static sig_func_t __kmp_sighldrs[NSIG];
138 static int __kmp_siginstalled[NSIG];
142 static HANDLE __kmp_monitor_ev;
144 static kmp_int64 __kmp_win32_time;
145 double __kmp_win32_tick;
147 int __kmp_init_runtime = FALSE;
148 CRITICAL_SECTION __kmp_win32_section;
150 void __kmp_win32_mutex_init(kmp_win32_mutex_t *mx) {
151 InitializeCriticalSection(&mx->cs);
153 __kmp_itt_system_object_created(&mx->cs,
"Critical Section");
157 void __kmp_win32_mutex_destroy(kmp_win32_mutex_t *mx) {
158 DeleteCriticalSection(&mx->cs);
161 void __kmp_win32_mutex_lock(kmp_win32_mutex_t *mx) {
162 EnterCriticalSection(&mx->cs);
165 int __kmp_win32_mutex_trylock(kmp_win32_mutex_t *mx) {
166 return TryEnterCriticalSection(&mx->cs);
169 void __kmp_win32_mutex_unlock(kmp_win32_mutex_t *mx) {
170 LeaveCriticalSection(&mx->cs);
173 void __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;
179 __kmp_win32_mutex_init(&cv->waiters_count_lock_);
182 cv->event_ = CreateEvent(NULL,
187 __kmp_itt_system_object_created(cv->event_,
"Event");
191 void __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));
201 static void __kmp_win32_cond_wait(kmp_win32_cond_t *cv, kmp_win32_mutex_t *mx,
202 kmp_info_t *th, C *flag) {
207 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
210 cv->waiters_count_++;
213 my_generation = cv->wait_generation_count_;
215 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
216 __kmp_win32_mutex_unlock(mx);
220 DWORD res, timeout = 5000;
222 res = WaitForSingleObject(cv->event_, timeout);
224 if (res == WAIT_OBJECT_0) {
226 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
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) {
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);
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()));
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_++;
255 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
257 __kmp_win32_mutex_unlock(mx);
265 __kmp_win32_mutex_lock(mx);
266 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
268 cv->waiters_count_--;
269 cv->release_count_--;
271 last_waiter = (cv->release_count_ == 0);
273 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
277 ResetEvent(cv->event_);
281 void __kmp_win32_cond_broadcast(kmp_win32_cond_t *cv) {
282 __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
284 if (cv->waiters_count_ > 0) {
285 SetEvent(cv->event_);
288 cv->release_count_ = cv->waiters_count_;
291 cv->wait_generation_count_++;
294 __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
297 void __kmp_win32_cond_signal(kmp_win32_cond_t *cv) {
298 __kmp_win32_cond_broadcast(cv);
301 void __kmp_enable(
int new_state) {
302 if (__kmp_init_runtime)
303 LeaveCriticalSection(&__kmp_win32_section);
306 void __kmp_disable(
int *old_state) {
309 if (__kmp_init_runtime)
310 EnterCriticalSection(&__kmp_win32_section);
313 void __kmp_suspend_initialize(
void) {
316 void __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;
320 if (old_value == new_value)
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) {
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);
336 void __kmp_suspend_uninitialize_thread(kmp_info_t *th) {
337 if (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init)) {
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);
346 int __kmp_try_suspend_mx(kmp_info_t *th) {
347 return __kmp_win32_mutex_trylock(&th->th.th_suspend_mx);
350 void __kmp_lock_suspend_mx(kmp_info_t *th) {
351 __kmp_win32_mutex_lock(&th->th.th_suspend_mx);
354 void __kmp_unlock_suspend_mx(kmp_info_t *th) {
355 __kmp_win32_mutex_unlock(&th->th.th_suspend_mx);
361 static 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;
365 KF_TRACE(30, (
"__kmp_suspend_template: T#%d enter for flag's loc(%p)\n",
366 th_gtid, flag->get()));
368 __kmp_suspend_initialize_thread(th);
369 __kmp_lock_suspend_mx(th);
371 KF_TRACE(10, (
"__kmp_suspend_template: T#%d setting sleep bit for flag's"
373 th_gtid, flag->get()));
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);
389 KF_TRACE(5, (
"__kmp_suspend_template: T#%d set sleep bit for flag's"
391 th_gtid, flag->get(), (
unsigned int)flag->load()));
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()));
402 __kmp_suspend_count++;
407 int deactivated = FALSE;
409 while (flag->is_sleeping()) {
410 KF_TRACE(15, (
"__kmp_suspend_template: T#%d about to perform "
411 "kmp_win32_cond_wait()\n",
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);
425 KMP_DEBUG_ASSERT(th->th.th_sleep_loc);
426 KMP_DEBUG_ASSERT(th->th.th_sleep_loc_type == flag->get_type());
428 __kmp_win32_cond_wait(&th->th.th_suspend_cv, &th->th.th_suspend_mx, th,
432 if (flag->is_sleeping()) {
434 (
"__kmp_suspend_template: T#%d spurious wakeup\n", th_gtid));
442 TCW_PTR(th->th.th_sleep_loc, NULL);
443 th->th.th_sleep_loc_type = flag_unset;
445 KMP_DEBUG_ASSERT(!flag->is_sleeping());
446 KMP_DEBUG_ASSERT(!th->th.th_sleep_loc);
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;
458 __kmp_unlock_suspend_mx(th);
459 KF_TRACE(30, (
"__kmp_suspend_template: T#%d exit\n", th_gtid));
462 template <
bool C,
bool S>
463 void __kmp_suspend_32(
int th_gtid, kmp_flag_32<C, S> *flag) {
464 __kmp_suspend_template(th_gtid, flag);
466 template <
bool C,
bool S>
467 void __kmp_suspend_64(
int th_gtid, kmp_flag_64<C, S> *flag) {
468 __kmp_suspend_template(th_gtid, flag);
470 template <
bool C,
bool S>
471 void __kmp_atomic_suspend_64(
int th_gtid, kmp_atomic_flag_64<C, S> *flag) {
472 __kmp_suspend_template(th_gtid, flag);
474 void __kmp_suspend_oncore(
int th_gtid, kmp_flag_oncore *flag) {
475 __kmp_suspend_template(th_gtid, flag);
478 template void __kmp_suspend_32<false, false>(
int, kmp_flag_32<false, false> *);
479 template void __kmp_suspend_64<false, true>(
int, kmp_flag_64<false, true> *);
480 template void __kmp_suspend_64<true, false>(
int, kmp_flag_64<true, false> *);
482 __kmp_atomic_suspend_64<false, true>(
int, kmp_atomic_flag_64<false, true> *);
484 __kmp_atomic_suspend_64<true, false>(
int, kmp_atomic_flag_64<true, false> *);
489 static inline void __kmp_resume_template(
int target_gtid, C *flag) {
490 kmp_info_t *th = __kmp_threads[target_gtid];
493 int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
496 KF_TRACE(30, (
"__kmp_resume_template: T#%d wants to wakeup T#%d enter\n",
499 __kmp_suspend_initialize_thread(th);
500 __kmp_lock_suspend_mx(th);
502 if (!flag || flag != th->th.th_sleep_loc) {
505 flag = (C *)th->th.th_sleep_loc;
510 if (!flag || flag->get_type() != th->th.th_sleep_loc_type) {
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);
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);
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;
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()));
535 __kmp_win32_cond_signal(&th->th.th_suspend_cv);
536 __kmp_unlock_suspend_mx(th);
538 KF_TRACE(30, (
"__kmp_resume_template: T#%d exiting after signaling wake up"
543 template <
bool C,
bool S>
544 void __kmp_resume_32(
int target_gtid, kmp_flag_32<C, S> *flag) {
545 __kmp_resume_template(target_gtid, flag);
547 template <
bool C,
bool S>
548 void __kmp_resume_64(
int target_gtid, kmp_flag_64<C, S> *flag) {
549 __kmp_resume_template(target_gtid, flag);
551 template <
bool C,
bool S>
552 void __kmp_atomic_resume_64(
int target_gtid, kmp_atomic_flag_64<C, S> *flag) {
553 __kmp_resume_template(target_gtid, flag);
555 void __kmp_resume_oncore(
int target_gtid, kmp_flag_oncore *flag) {
556 __kmp_resume_template(target_gtid, flag);
559 template void __kmp_resume_32<false, true>(
int, kmp_flag_32<false, true> *);
560 template void __kmp_resume_32<false, false>(
int, kmp_flag_32<false, false> *);
561 template void __kmp_resume_64<false, true>(
int, kmp_flag_64<false, true> *);
563 __kmp_atomic_resume_64<false, true>(
int, kmp_atomic_flag_64<false, true> *);
565 void __kmp_yield() { Sleep(0); }
567 void __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 if (!TlsSetValue(__kmp_gtid_threadprivate_key, (LPVOID)(gtid + 1)))
572 KMP_FATAL(TLSSetValueFailed);
574 KA_TRACE(50, (
"__kmp_gtid_set_specific: runtime shutdown, returning\n"));
578 int __kmp_gtid_get_specific() {
580 if (!__kmp_init_gtid) {
581 KA_TRACE(50, (
"__kmp_gtid_get_specific: runtime shutdown, returning "
582 "KMP_GTID_SHUTDOWN\n"));
583 return KMP_GTID_SHUTDOWN;
585 gtid = (int)(kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key);
591 KA_TRACE(50, (
"__kmp_gtid_get_specific: key:%d gtid:%d\n",
592 __kmp_gtid_threadprivate_key, gtid));
596 void __kmp_affinity_bind_thread(
int proc) {
597 if (__kmp_num_proc_groups > 1) {
601 KMP_DEBUG_ASSERT((proc >= 0) && (proc < (__kmp_num_proc_groups * CHAR_BIT *
602 sizeof(DWORD_PTR))));
603 ga.Group = proc / (CHAR_BIT *
sizeof(DWORD_PTR));
604 ga.Mask = (
unsigned long long)1 << (proc % (CHAR_BIT *
sizeof(DWORD_PTR)));
605 ga.Reserved[0] = ga.Reserved[1] = ga.Reserved[2] = 0;
607 KMP_DEBUG_ASSERT(__kmp_SetThreadGroupAffinity != NULL);
608 if (__kmp_SetThreadGroupAffinity(GetCurrentThread(), &ga, NULL) == 0) {
609 DWORD error = GetLastError();
610 if (__kmp_affinity_verbose) {
611 kmp_msg_t err_code = KMP_ERR(error);
612 __kmp_msg(kmp_ms_warning, KMP_MSG(CantSetThreadAffMask), err_code,
614 if (__kmp_generate_warnings == kmp_warnings_off) {
615 __kmp_str_free(&err_code.str);
620 kmp_affin_mask_t *mask;
621 KMP_CPU_ALLOC_ON_STACK(mask);
623 KMP_CPU_SET(proc, mask);
624 __kmp_set_system_affinity(mask, TRUE);
625 KMP_CPU_FREE_FROM_STACK(mask);
629 void __kmp_affinity_determine_capable(
const char *env_var) {
633 #if KMP_GROUP_AFFINITY
634 KMP_AFFINITY_ENABLE(__kmp_num_proc_groups *
sizeof(DWORD_PTR));
636 KMP_AFFINITY_ENABLE(
sizeof(DWORD_PTR));
639 KA_TRACE(10, (
"__kmp_affinity_determine_capable: "
640 "Windows* OS affinity interface functional (mask size = "
641 "%" KMP_SIZE_T_SPEC
").\n",
642 __kmp_affin_mask_size));
645 double __kmp_read_cpu_time(
void) {
646 FILETIME CreationTime, ExitTime, KernelTime, UserTime;
652 status = GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime,
653 &KernelTime, &UserTime);
658 sec += KernelTime.dwHighDateTime;
659 sec += UserTime.dwHighDateTime;
662 sec *= (double)(1 << 16) * (double)(1 << 16);
664 sec += KernelTime.dwLowDateTime;
665 sec += UserTime.dwLowDateTime;
667 cpu_time += (sec * 100.0) / KMP_NSEC_PER_SEC;
673 int __kmp_read_system_info(
struct kmp_sys_info *info) {
686 void __kmp_runtime_initialize(
void) {
691 if (__kmp_init_runtime) {
699 UINT err_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
701 BOOL ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
702 GET_MODULE_HANDLE_EX_FLAG_PIN,
703 (LPCTSTR)&__kmp_serial_initialize, &h);
705 KMP_DEBUG_ASSERT2(h && ret,
"OpenMP RTL cannot find itself loaded");
706 SetErrorMode(err_mode);
707 KA_TRACE(10, (
"__kmp_runtime_initialize: dynamic library pinned\n"));
711 InitializeCriticalSection(&__kmp_win32_section);
713 __kmp_itt_system_object_created(&__kmp_win32_section,
"Critical Section");
715 __kmp_initialize_system_tick();
717 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
718 if (!__kmp_cpuinfo.initialized) {
719 __kmp_query_cpuid(&__kmp_cpuinfo);
724 #if KMP_OS_WINDOWS && !KMP_DYNAMIC_LIB
739 __kmp_tls_gtid_min = 0;
741 __kmp_tls_gtid_min = KMP_TLS_GTID_MIN;
745 if (!__kmp_gtid_threadprivate_key) {
746 __kmp_gtid_threadprivate_key = TlsAlloc();
747 if (__kmp_gtid_threadprivate_key == TLS_OUT_OF_INDEXES) {
748 KMP_FATAL(TLSOutOfIndexes);
756 __kmp_str_buf_init(&path);
757 path_size = GetSystemDirectory(path.str, path.size);
758 KMP_DEBUG_ASSERT(path_size > 0);
759 if (path_size >= path.size) {
761 __kmp_str_buf_reserve(&path, path_size);
762 path_size = GetSystemDirectory(path.str, path.size);
763 KMP_DEBUG_ASSERT(path_size > 0);
765 if (path_size > 0 && path_size < path.size) {
768 path.used = path_size;
769 __kmp_str_buf_print(&path,
"\\%s",
"ntdll.dll");
772 ntdll = GetModuleHandle(path.str);
775 KMP_DEBUG_ASSERT(ntdll != NULL);
777 NtQuerySystemInformation = (NtQuerySystemInformation_t)GetProcAddress(
778 ntdll,
"NtQuerySystemInformation");
780 KMP_DEBUG_ASSERT(NtQuerySystemInformation != NULL);
782 #if KMP_GROUP_AFFINITY
785 if (path_size > 0 && path_size < path.size) {
788 path.used = path_size;
789 __kmp_str_buf_print(&path,
"\\%s",
"kernel32.dll");
792 kernel32 = GetModuleHandle(path.str);
793 KA_TRACE(10, (
"__kmp_runtime_initialize: kernel32.dll = %s\n", path.str));
797 if (kernel32 != NULL) {
798 __kmp_GetActiveProcessorCount =
799 (kmp_GetActiveProcessorCount_t)GetProcAddress(
800 kernel32,
"GetActiveProcessorCount");
801 __kmp_GetActiveProcessorGroupCount =
802 (kmp_GetActiveProcessorGroupCount_t)GetProcAddress(
803 kernel32,
"GetActiveProcessorGroupCount");
804 __kmp_GetThreadGroupAffinity =
805 (kmp_GetThreadGroupAffinity_t)GetProcAddress(
806 kernel32,
"GetThreadGroupAffinity");
807 __kmp_SetThreadGroupAffinity =
808 (kmp_SetThreadGroupAffinity_t)GetProcAddress(
809 kernel32,
"SetThreadGroupAffinity");
811 KA_TRACE(10, (
"__kmp_runtime_initialize: __kmp_GetActiveProcessorCount"
813 __kmp_GetActiveProcessorCount));
814 KA_TRACE(10, (
"__kmp_runtime_initialize: "
815 "__kmp_GetActiveProcessorGroupCount = %p\n",
816 __kmp_GetActiveProcessorGroupCount));
817 KA_TRACE(10, (
"__kmp_runtime_initialize:__kmp_GetThreadGroupAffinity"
819 __kmp_GetThreadGroupAffinity));
820 KA_TRACE(10, (
"__kmp_runtime_initialize: __kmp_SetThreadGroupAffinity"
822 __kmp_SetThreadGroupAffinity));
823 KA_TRACE(10, (
"__kmp_runtime_initialize: sizeof(kmp_affin_mask_t) = %d\n",
824 sizeof(kmp_affin_mask_t)));
831 if ((__kmp_GetActiveProcessorCount != NULL) &&
832 (__kmp_GetActiveProcessorGroupCount != NULL) &&
833 (__kmp_GetThreadGroupAffinity != NULL) &&
834 (__kmp_SetThreadGroupAffinity != NULL) &&
835 ((__kmp_num_proc_groups = __kmp_GetActiveProcessorGroupCount()) >
840 KA_TRACE(10, (
"__kmp_runtime_initialize: %d processor groups"
842 __kmp_num_proc_groups));
846 for (i = 0; i < __kmp_num_proc_groups; i++) {
847 DWORD size = __kmp_GetActiveProcessorCount(i);
849 KA_TRACE(10, (
"__kmp_runtime_initialize: proc group %d size = %d\n",
853 KA_TRACE(10, (
"__kmp_runtime_initialize: %d processor groups"
855 __kmp_num_proc_groups));
859 if (__kmp_num_proc_groups <= 1) {
860 GetSystemInfo(&info);
861 __kmp_xproc = info.dwNumberOfProcessors;
865 GetSystemInfo(&info);
866 __kmp_xproc = info.dwNumberOfProcessors;
871 if (__kmp_xproc <= 0) {
876 (
"__kmp_runtime_initialize: total processors = %d\n", __kmp_xproc));
878 __kmp_str_buf_free(&path);
881 __kmp_itt_initialize();
884 __kmp_init_runtime = TRUE;
887 void __kmp_runtime_destroy(
void) {
888 if (!__kmp_init_runtime) {
898 KA_TRACE(40, (
"__kmp_runtime_destroy\n"));
900 if (__kmp_gtid_threadprivate_key) {
901 TlsFree(__kmp_gtid_threadprivate_key);
902 __kmp_gtid_threadprivate_key = 0;
905 __kmp_affinity_uninitialize();
906 DeleteCriticalSection(&__kmp_win32_section);
909 NtQuerySystemInformation = NULL;
913 __kmp_GetActiveProcessorCount = NULL;
914 __kmp_GetActiveProcessorGroupCount = NULL;
915 __kmp_GetThreadGroupAffinity = NULL;
916 __kmp_SetThreadGroupAffinity = NULL;
919 __kmp_init_runtime = FALSE;
922 void __kmp_terminate_thread(
int gtid) {
923 kmp_info_t *th = __kmp_threads[gtid];
928 KA_TRACE(10, (
"__kmp_terminate_thread: kill (%d)\n", gtid));
930 if (TerminateThread(th->th.th_info.ds.ds_thread, (DWORD)-1) == FALSE) {
933 __kmp_free_handle(th->th.th_info.ds.ds_thread);
936 void __kmp_clear_system_time(
void) {
939 status = QueryPerformanceCounter(&time);
940 __kmp_win32_time = (kmp_int64)time.QuadPart;
943 void __kmp_initialize_system_tick(
void) {
948 status = QueryPerformanceFrequency(&freq);
950 DWORD error = GetLastError();
951 __kmp_fatal(KMP_MSG(FunctionError,
"QueryPerformanceFrequency()"),
952 KMP_ERR(error), __kmp_msg_null);
955 __kmp_win32_tick = ((double)1.0) / (double)freq.QuadPart;
962 void __kmp_elapsed(
double *t) {
965 status = QueryPerformanceCounter(&now);
966 *t = ((double)now.QuadPart) * __kmp_win32_tick;
971 void __kmp_elapsed_tick(
double *t) { *t = __kmp_win32_tick; }
973 void __kmp_read_system_time(
double *delta) {
978 status = QueryPerformanceCounter(&now);
980 *delta = ((double)(((kmp_int64)now.QuadPart) - __kmp_win32_time)) *
986 kmp_uint64 __kmp_now_nsec() {
988 QueryPerformanceCounter(&now);
989 return 1e9 * __kmp_win32_tick * now.QuadPart;
992 extern "C" void *__stdcall __kmp_launch_worker(
void *arg) {
993 volatile void *stack_data;
996 kmp_info_t *this_thr = (kmp_info_t *)arg;
999 gtid = this_thr->th.th_info.ds.ds_gtid;
1000 __kmp_gtid_set_specific(gtid);
1001 #ifdef KMP_TDATA_GTID
1002 #error "This define causes problems with LoadLibrary() + declspec(thread) " \
1003 "on Windows* OS. See CQ50564, tests kmp_load_library*.c and this MSDN " \
1004 "reference: http://support.microsoft.com/kb/118816"
1009 __kmp_itt_thread_name(gtid);
1012 __kmp_affinity_set_init_mask(gtid, FALSE);
1014 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
1016 __kmp_clear_x87_fpu_status_word();
1017 __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
1018 __kmp_load_mxcsr(&__kmp_init_mxcsr);
1021 if (__kmp_stkoffset > 0 && gtid > 0) {
1022 padding = KMP_ALLOCA(gtid * __kmp_stkoffset);
1025 KMP_FSYNC_RELEASING(&this_thr->th.th_info.ds.ds_alive);
1026 this_thr->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1027 TCW_4(this_thr->th.th_info.ds.ds_alive, TRUE);
1029 if (TCR_4(__kmp_gtid_mode) <
1031 TCW_PTR(this_thr->th.th_info.ds.ds_stackbase, &stack_data);
1032 KMP_ASSERT(this_thr->th.th_info.ds.ds_stackgrow == FALSE);
1033 __kmp_check_stack_overlap(this_thr);
1036 exit_val = __kmp_launch_thread(this_thr);
1037 KMP_FSYNC_RELEASING(&this_thr->th.th_info.ds.ds_alive);
1038 TCW_4(this_thr->th.th_info.ds.ds_alive, FALSE);
1046 void *__stdcall __kmp_launch_monitor(
void *arg) {
1048 kmp_thread_t monitor;
1051 kmp_info_t *this_thr = (kmp_info_t *)arg;
1053 KMP_DEBUG_ASSERT(__kmp_init_monitor);
1054 TCW_4(__kmp_init_monitor, 2);
1056 this_thr->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1057 TCW_4(this_thr->th.th_info.ds.ds_alive, TRUE);
1060 KA_TRACE(10, (
"__kmp_launch_monitor: launched\n"));
1062 monitor = GetCurrentThread();
1065 status = SetThreadPriority(monitor, THREAD_PRIORITY_HIGHEST);
1067 DWORD error = GetLastError();
1068 __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
1072 __kmp_gtid_set_specific(KMP_GTID_MONITOR);
1073 #ifdef KMP_TDATA_GTID
1074 #error "This define causes problems with LoadLibrary() + declspec(thread) " \
1075 "on Windows* OS. See CQ50564, tests kmp_load_library*.c and this MSDN " \
1076 "reference: http://support.microsoft.com/kb/118816"
1081 __kmp_itt_thread_ignore();
1087 interval = (1000 / __kmp_monitor_wakeups);
1089 while (!TCR_4(__kmp_global.g.g_done)) {
1092 KA_TRACE(15, (
"__kmp_launch_monitor: update\n"));
1094 wait_status = WaitForSingleObject(__kmp_monitor_ev, interval);
1096 if (wait_status == WAIT_TIMEOUT) {
1097 TCW_4(__kmp_global.g.g_time.dt.t_value,
1098 TCR_4(__kmp_global.g.g_time.dt.t_value) + 1);
1104 KA_TRACE(10, (
"__kmp_launch_monitor: finished\n"));
1106 status = SetThreadPriority(monitor, THREAD_PRIORITY_NORMAL);
1108 DWORD error = GetLastError();
1109 __kmp_fatal(KMP_MSG(CantSetThreadPriority), KMP_ERR(error), __kmp_msg_null);
1112 if (__kmp_global.g.g_abort != 0) {
1117 KA_TRACE(10, (
"__kmp_launch_monitor: terminate sig=%d\n",
1118 (__kmp_global.g.g_abort)));
1123 for (gtid = 1; gtid < __kmp_threads_capacity; ++gtid)
1124 __kmp_terminate_thread(gtid);
1131 (
"__kmp_launch_monitor: raise sig=%d\n", __kmp_global.g.g_abort));
1133 if (__kmp_global.g.g_abort > 0) {
1134 raise(__kmp_global.g.g_abort);
1138 TCW_4(this_thr->th.th_info.ds.ds_alive, FALSE);
1145 void __kmp_create_worker(
int gtid, kmp_info_t *th,
size_t stack_size) {
1146 kmp_thread_t handle;
1149 KA_TRACE(10, (
"__kmp_create_worker: try to create thread (%d)\n", gtid));
1151 th->th.th_info.ds.ds_gtid = gtid;
1153 if (KMP_UBER_GTID(gtid)) {
1161 rc = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
1162 GetCurrentProcess(), &th->th.th_info.ds.ds_thread, 0,
1163 FALSE, DUPLICATE_SAME_ACCESS);
1165 KA_TRACE(10, (
" __kmp_create_worker: ROOT Handle duplicated, th = %p, "
1166 "handle = %" KMP_UINTPTR_SPEC
"\n",
1167 (LPVOID)th, th->th.th_info.ds.ds_thread));
1168 th->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
1170 if (TCR_4(__kmp_gtid_mode) < 2) {
1172 TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data);
1173 TCW_PTR(th->th.th_info.ds.ds_stacksize, 0);
1174 TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE);
1175 __kmp_check_stack_overlap(th);
1182 (
"__kmp_create_worker: stack_size = %" KMP_SIZE_T_SPEC
" bytes\n",
1185 stack_size += gtid * __kmp_stkoffset;
1187 TCW_PTR(th->th.th_info.ds.ds_stacksize, stack_size);
1188 TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE);
1191 (
"__kmp_create_worker: (before) stack_size = %" KMP_SIZE_T_SPEC
1192 " bytes, &__kmp_launch_worker = %p, th = %p, &idThread = %p\n",
1193 (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)&__kmp_launch_worker,
1194 (LPVOID)th, &idThread));
1196 handle = CreateThread(
1197 NULL, (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)__kmp_launch_worker,
1198 (LPVOID)th, STACK_SIZE_PARAM_IS_A_RESERVATION, &idThread);
1201 (
"__kmp_create_worker: (after) stack_size = %" KMP_SIZE_T_SPEC
1202 " bytes, &__kmp_launch_worker = %p, th = %p, "
1203 "idThread = %u, handle = %" KMP_UINTPTR_SPEC
"\n",
1204 (SIZE_T)stack_size, (LPTHREAD_START_ROUTINE)&__kmp_launch_worker,
1205 (LPVOID)th, idThread, handle));
1208 DWORD error = GetLastError();
1209 __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
1211 th->th.th_info.ds.ds_thread = handle;
1217 KA_TRACE(10, (
"__kmp_create_worker: done creating thread (%d)\n", gtid));
1220 int __kmp_still_running(kmp_info_t *th) {
1221 return (WAIT_TIMEOUT == WaitForSingleObject(th->th.th_info.ds.ds_thread, 0));
1225 void __kmp_create_monitor(kmp_info_t *th) {
1226 kmp_thread_t handle;
1228 int ideal, new_ideal;
1230 if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
1232 KA_TRACE(10, (
"__kmp_create_monitor: skipping monitor thread because of "
1233 "MAX blocktime\n"));
1234 th->th.th_info.ds.ds_tid = 0;
1235 th->th.th_info.ds.ds_gtid = 0;
1236 TCW_4(__kmp_init_monitor, 2);
1239 KA_TRACE(10, (
"__kmp_create_monitor: try to create monitor\n"));
1243 __kmp_monitor_ev = CreateEvent(NULL, TRUE, FALSE, NULL);
1244 if (__kmp_monitor_ev == NULL) {
1245 DWORD error = GetLastError();
1246 __kmp_fatal(KMP_MSG(CantCreateEvent), KMP_ERR(error), __kmp_msg_null);
1249 __kmp_itt_system_object_created(__kmp_monitor_ev,
"Event");
1252 th->th.th_info.ds.ds_tid = KMP_GTID_MONITOR;
1253 th->th.th_info.ds.ds_gtid = KMP_GTID_MONITOR;
1257 if (__kmp_monitor_stksize == 0) {
1258 __kmp_monitor_stksize = KMP_DEFAULT_MONITOR_STKSIZE;
1260 if (__kmp_monitor_stksize < __kmp_sys_min_stksize) {
1261 __kmp_monitor_stksize = __kmp_sys_min_stksize;
1264 KA_TRACE(10, (
"__kmp_create_monitor: requested stacksize = %d bytes\n",
1265 (
int)__kmp_monitor_stksize));
1267 TCW_4(__kmp_global.g.g_time.dt.t_value, 0);
1270 CreateThread(NULL, (SIZE_T)__kmp_monitor_stksize,
1271 (LPTHREAD_START_ROUTINE)__kmp_launch_monitor, (LPVOID)th,
1272 STACK_SIZE_PARAM_IS_A_RESERVATION, &idThread);
1274 DWORD error = GetLastError();
1275 __kmp_fatal(KMP_MSG(CantCreateThread), KMP_ERR(error), __kmp_msg_null);
1277 th->th.th_info.ds.ds_thread = handle;
1281 KA_TRACE(10, (
"__kmp_create_monitor: monitor created %p\n",
1282 (
void *)th->th.th_info.ds.ds_thread));
1292 int __kmp_is_thread_alive(kmp_info_t *th, DWORD *exit_val) {
1294 rc = GetExitCodeThread(th->th.th_info.ds.ds_thread, exit_val);
1296 DWORD error = GetLastError();
1297 __kmp_fatal(KMP_MSG(FunctionError,
"GetExitCodeThread()"), KMP_ERR(error),
1300 return (*exit_val == STILL_ACTIVE);
1303 void __kmp_exit_thread(
int exit_status) {
1304 ExitThread(exit_status);
1308 static void __kmp_reap_common(kmp_info_t *th) {
1314 10, (
"__kmp_reap_common: try to reap (%d)\n", th->th.th_info.ds.ds_gtid));
1332 KMP_FSYNC_SPIN_INIT(obj, (
void *)&th->th.th_info.ds.ds_alive);
1334 KMP_INIT_YIELD(spins);
1335 KMP_INIT_BACKOFF(time);
1338 KMP_FSYNC_SPIN_PREPARE(obj);
1340 __kmp_is_thread_alive(th, &exit_val);
1341 KMP_YIELD_OVERSUB_ELSE_SPIN(spins, time);
1342 }
while (exit_val == STILL_ACTIVE && TCR_4(th->th.th_info.ds.ds_alive));
1344 if (exit_val == STILL_ACTIVE) {
1345 KMP_FSYNC_CANCEL(obj);
1347 KMP_FSYNC_SPIN_ACQUIRED(obj);
1352 __kmp_free_handle(th->th.th_info.ds.ds_thread);
1357 if (exit_val == STILL_ACTIVE) {
1358 KA_TRACE(1, (
"__kmp_reap_common: thread still active.\n"));
1359 }
else if ((
void *)exit_val != (
void *)th) {
1360 KA_TRACE(1, (
"__kmp_reap_common: ExitProcess / TerminateThread used?\n"));
1364 (
"__kmp_reap_common: done reaping (%d), handle = %" KMP_UINTPTR_SPEC
1366 th->th.th_info.ds.ds_gtid, th->th.th_info.ds.ds_thread));
1368 th->th.th_info.ds.ds_thread = 0;
1369 th->th.th_info.ds.ds_tid = KMP_GTID_DNE;
1370 th->th.th_info.ds.ds_gtid = KMP_GTID_DNE;
1371 th->th.th_info.ds.ds_thread_id = 0;
1377 void __kmp_reap_monitor(kmp_info_t *th) {
1380 KA_TRACE(10, (
"__kmp_reap_monitor: try to reap %p\n",
1381 (
void *)th->th.th_info.ds.ds_thread));
1386 KMP_DEBUG_ASSERT(th->th.th_info.ds.ds_tid == th->th.th_info.ds.ds_gtid);
1387 if (th->th.th_info.ds.ds_gtid != KMP_GTID_MONITOR) {
1388 KA_TRACE(10, (
"__kmp_reap_monitor: monitor did not start, returning\n"));
1394 status = SetEvent(__kmp_monitor_ev);
1395 if (status == FALSE) {
1396 DWORD error = GetLastError();
1397 __kmp_fatal(KMP_MSG(CantSetEvent), KMP_ERR(error), __kmp_msg_null);
1399 KA_TRACE(10, (
"__kmp_reap_monitor: reaping thread (%d)\n",
1400 th->th.th_info.ds.ds_gtid));
1401 __kmp_reap_common(th);
1403 __kmp_free_handle(__kmp_monitor_ev);
1409 void __kmp_reap_worker(kmp_info_t *th) {
1410 KA_TRACE(10, (
"__kmp_reap_worker: reaping thread (%d)\n",
1411 th->th.th_info.ds.ds_gtid));
1412 __kmp_reap_common(th);
1415 #if KMP_HANDLE_SIGNALS
1417 static void __kmp_team_handler(
int signo) {
1418 if (__kmp_global.g.g_abort == 0) {
1420 if (__kmp_debug_buf) {
1421 __kmp_dump_debug_buffer();
1424 TCW_4(__kmp_global.g.g_abort, signo);
1426 TCW_4(__kmp_global.g.g_done, TRUE);
1431 static sig_func_t __kmp_signal(
int signum, sig_func_t handler) {
1432 sig_func_t old = signal(signum, handler);
1433 if (old == SIG_ERR) {
1435 __kmp_fatal(KMP_MSG(FunctionError,
"signal"), KMP_ERR(error),
1441 static void __kmp_install_one_handler(
int sig, sig_func_t handler,
1442 int parallel_init) {
1445 KB_TRACE(60, (
"__kmp_install_one_handler: called: sig=%d\n", sig));
1446 if (parallel_init) {
1447 old = __kmp_signal(sig, handler);
1449 if (old == __kmp_sighldrs[sig]) {
1450 __kmp_siginstalled[sig] = 1;
1452 old = __kmp_signal(sig, old);
1458 old = __kmp_signal(sig, SIG_DFL);
1459 __kmp_sighldrs[sig] = old;
1460 __kmp_signal(sig, old);
1465 static void __kmp_remove_one_handler(
int sig) {
1466 if (__kmp_siginstalled[sig]) {
1469 KB_TRACE(60, (
"__kmp_remove_one_handler: called: sig=%d\n", sig));
1470 old = __kmp_signal(sig, __kmp_sighldrs[sig]);
1471 if (old != __kmp_team_handler) {
1472 KB_TRACE(10, (
"__kmp_remove_one_handler: oops, not our handler, "
1473 "restoring: sig=%d\n",
1475 old = __kmp_signal(sig, old);
1477 __kmp_sighldrs[sig] = NULL;
1478 __kmp_siginstalled[sig] = 0;
1483 void __kmp_install_signals(
int parallel_init) {
1484 KB_TRACE(10, (
"__kmp_install_signals: called\n"));
1485 if (!__kmp_handle_signals) {
1486 KB_TRACE(10, (
"__kmp_install_signals: KMP_HANDLE_SIGNALS is false - "
1487 "handlers not installed\n"));
1490 __kmp_install_one_handler(SIGINT, __kmp_team_handler, parallel_init);
1491 __kmp_install_one_handler(SIGILL, __kmp_team_handler, parallel_init);
1492 __kmp_install_one_handler(SIGABRT, __kmp_team_handler, parallel_init);
1493 __kmp_install_one_handler(SIGFPE, __kmp_team_handler, parallel_init);
1494 __kmp_install_one_handler(SIGSEGV, __kmp_team_handler, parallel_init);
1495 __kmp_install_one_handler(SIGTERM, __kmp_team_handler, parallel_init);
1498 void __kmp_remove_signals(
void) {
1500 KB_TRACE(10, (
"__kmp_remove_signals: called\n"));
1501 for (sig = 1; sig < NSIG; ++sig) {
1502 __kmp_remove_one_handler(sig);
1509 void __kmp_thread_sleep(
int millis) {
1512 status = SleepEx((DWORD)millis, FALSE);
1514 DWORD error = GetLastError();
1515 __kmp_fatal(KMP_MSG(FunctionError,
"SleepEx()"), KMP_ERR(error),
1521 int __kmp_is_address_mapped(
void *addr) {
1523 MEMORY_BASIC_INFORMATION lpBuffer;
1526 dwLength =
sizeof(MEMORY_BASIC_INFORMATION);
1528 status = VirtualQuery(addr, &lpBuffer, dwLength);
1530 return !(((lpBuffer.State == MEM_RESERVE) || (lpBuffer.State == MEM_FREE)) ||
1531 ((lpBuffer.Protect == PAGE_NOACCESS) ||
1532 (lpBuffer.Protect == PAGE_EXECUTE)));
1535 kmp_uint64 __kmp_hardware_timestamp(
void) {
1538 QueryPerformanceCounter((LARGE_INTEGER *)&r);
1543 void __kmp_free_handle(kmp_thread_t tHandle) {
1547 rc = CloseHandle(tHandle);
1549 DWORD error = GetLastError();
1550 __kmp_fatal(KMP_MSG(CantCloseHandle), KMP_ERR(error), __kmp_msg_null);
1554 int __kmp_get_load_balance(
int max) {
1555 static ULONG glb_buff_size = 100 * 1024;
1558 static int glb_running_threads = 0;
1559 static double glb_call_time = 0;
1561 int running_threads = 0;
1562 NTSTATUS status = 0;
1563 ULONG buff_size = 0;
1564 ULONG info_size = 0;
1565 void *buffer = NULL;
1566 PSYSTEM_PROCESS_INFORMATION spi = NULL;
1569 double call_time = 0.0;
1571 __kmp_elapsed(&call_time);
1573 if (glb_call_time &&
1574 (call_time - glb_call_time < __kmp_load_balance_interval)) {
1575 running_threads = glb_running_threads;
1578 glb_call_time = call_time;
1581 if (NtQuerySystemInformation == NULL) {
1582 running_threads = -1;
1593 buff_size = glb_buff_size;
1595 buff_size = 2 * buff_size;
1598 buffer = KMP_INTERNAL_REALLOC(buffer, buff_size);
1599 if (buffer == NULL) {
1600 running_threads = -1;
1603 status = NtQuerySystemInformation(SystemProcessInformation, buffer,
1604 buff_size, &info_size);
1607 }
while (status == STATUS_INFO_LENGTH_MISMATCH);
1608 glb_buff_size = buff_size;
1610 #define CHECK(cond) \
1612 KMP_DEBUG_ASSERT(cond); \
1614 running_threads = -1; \
1619 CHECK(buff_size >= info_size);
1620 spi = PSYSTEM_PROCESS_INFORMATION(buffer);
1622 ptrdiff_t offset = uintptr_t(spi) - uintptr_t(buffer);
1623 CHECK(0 <= offset &&
1624 offset +
sizeof(SYSTEM_PROCESS_INFORMATION) < info_size);
1625 HANDLE pid = spi->ProcessId;
1626 ULONG num = spi->NumberOfThreads;
1629 sizeof(SYSTEM_PROCESS_INFORMATION) +
sizeof(SYSTEM_THREAD) * (num - 1);
1630 CHECK(offset + spi_size <
1632 if (spi->NextEntryOffset != 0) {
1634 spi->NextEntryOffset);
1640 for (
int i = 0; i < num; ++i) {
1641 THREAD_STATE state = spi->Threads[i].State;
1644 if (state == StateRunning) {
1648 if (running_threads >= max) {
1654 if (spi->NextEntryOffset == 0) {
1657 spi = PSYSTEM_PROCESS_INFORMATION(uintptr_t(spi) + spi->NextEntryOffset);
1664 if (buffer != NULL) {
1665 KMP_INTERNAL_FREE(buffer);
1668 glb_running_threads = running_threads;
1670 return running_threads;
1674 void *__kmp_lookup_symbol(
const char *name) {
1675 HANDLE process = GetCurrentProcess();
1677 HMODULE *modules =
nullptr;
1678 if (!EnumProcessModules(process, modules, 0, &needed))
1680 DWORD num_modules = needed /
sizeof(HMODULE);
1681 modules = (HMODULE *)malloc(num_modules *
sizeof(HMODULE));
1682 if (!EnumProcessModules(process, modules, needed, &needed)) {
1686 void *proc =
nullptr;
1687 for (uint32_t i = 0; i < num_modules; i++) {
1688 proc = (
void *)GetProcAddress(modules[i], name);
1697 void __kmp_hidden_helper_worker_thread_wait() {
1698 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1701 void __kmp_do_initialize_hidden_helper_threads() {
1702 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1705 void __kmp_hidden_helper_threads_initz_wait() {
1706 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1709 void __kmp_hidden_helper_initz_release() {
1710 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1713 void __kmp_hidden_helper_main_thread_wait() {
1714 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1717 void __kmp_hidden_helper_main_thread_release() {
1718 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1721 void __kmp_hidden_helper_worker_thread_signal() {
1722 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1725 void __kmp_hidden_helper_threads_deinitz_wait() {
1726 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");
1729 void __kmp_hidden_helper_threads_deinitz_release() {
1730 KMP_ASSERT(0 &&
"Hidden helper task is not supported on Windows");