/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux

Bug Summary

File:	projects/openmp/runtime/src/z_Linux_util.cpp
Warning:	line 186, column 9 Attempt to free released memory
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name z_Linux_util.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D omp_EXPORTS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/projects/openmp/runtime/src -I /build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/i18n -I /build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/include/50 -I /build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/thirdparty/ittnotify -U NDEBUG -D _GNU_SOURCE -D _REENTRANT -D _FORTIFY_SOURCE=2 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-switch -Wno-missing-field-initializers -Wno-missing-braces -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/projects/openmp/runtime/src -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fno-rtti -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp -faddrsig
1/*
* z_Linux_util.cpp -- platform specific routines.
*/

5//===----------------------------------------------------------------------===//
6//
7//                     The LLVM Compiler Infrastructure
8//
9// This file is dual licensed under the MIT and the University of Illinois Open
10// Source Licenses. See LICENSE.txt for details.
11//
12//===----------------------------------------------------------------------===//

14#include "kmp.h"
15#include "kmp_affinity.h"
16#include "kmp_i18n.h"
17#include "kmp_io.h"
18#include "kmp_itt.h"
19#include "kmp_lock.h"
20#include "kmp_stats.h"
21#include "kmp_str.h"
22#include "kmp_wait_release.h"
23#include "kmp_wrapper_getpid.h"

25#if !KMP_OS_FREEBSD0 && !KMP_OS_NETBSD0
26#include <alloca.h>
27#endif
28#include <math.h> // HUGE_VAL.
29#include <sys/resource.h>
30#include <sys/syscall.h>
31#include <sys/time.h>
32#include <sys/times.h>
33#include <unistd.h>

35#if KMP_OS_LINUX1 && !KMP_OS_CNK0
36#include <sys/sysinfo.h>
37#if KMP_USE_FUTEX(1 && !0 && (0 || 1 || KMP_ARCH_ARM || 0))
38// We should really include <futex.h>, but that causes compatibility problems on
39// different Linux* OS distributions that either require that you include (or
40// break when you try to include) <pci/types.h>. Since all we need is the two
41// macros below (which are part of the kernel ABI, so can't change) we just
42// define the constants here and don't include <futex.h>
43#ifndef FUTEX_WAIT0
44#define FUTEX_WAIT0 0
45#endif
46#ifndef FUTEX_WAKE1
47#define FUTEX_WAKE1 1
48#endif
49#endif
50#elif KMP_OS_DARWIN0
51#include <mach/mach.h>
52#include <sys/sysctl.h>
53#elif KMP_OS_FREEBSD0
54#include <pthread_np.h>
55#endif

57#include <ctype.h>
58#include <dirent.h>
59#include <fcntl.h>

61#include "tsan_annotations.h"

63struct kmp_sys_timer {
struct timespec start;
65};

67// Convert timespec to nanoseconds.
68#define TS2NS(timespec)(((timespec).tv_sec * 1e9) + (timespec).tv_nsec) (((timespec).tv_sec * 1e9) + (timespec).tv_nsec)

70static struct kmp_sys_timer __kmp_sys_timer_data;

72#if KMP_HANDLE_SIGNALS(1 || 0)
73typedef void (*sig_func_t)(int);
74STATIC_EFI2_WORKAROUND struct sigaction __kmp_sighldrs[NSIG65];
75static sigset_t __kmp_sigset;
76#endif

78static int __kmp_init_runtime = FALSE0;

80static int __kmp_fork_count = 0;

82static pthread_condattr_t __kmp_suspend_cond_attr;
83static pthread_mutexattr_t __kmp_suspend_mutex_attr;

85static kmp_cond_align_t __kmp_wait_cv;
86static kmp_mutex_align_t __kmp_wait_mx;

88kmp_uint64 __kmp_ticks_per_msec = 1000000;

90#ifdef DEBUG_SUSPEND
91static void __kmp_print_cond(char *buffer, kmp_cond_align_t *cond) {
KMP_SNPRINTFsnprintf(buffer, 128, "(cond (lock (%ld, %d)), (descr (%p)))",
             cond->c_cond.__c_lock.__status, cond->c_cond.__c_lock.__spinlock,
             cond->c_cond.__c_waiting);
95}
96#endif

98#if (KMP_OS_LINUX1 && KMP_AFFINITY_SUPPORTED1)

100/* Affinity support */

102void __kmp_affinity_bind_thread(int which) {
KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),if (!((__kmp_affin_mask_size > 0))) { __kmp_debug_assert((
"Illegal set affinity operation when not capable"), "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 104); }
            "Illegal set affinity operation when not capable")if (!((__kmp_affin_mask_size > 0))) { __kmp_debug_assert((
"Illegal set affinity operation when not capable"), "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 104); };

kmp_affin_mask_t *mask;
KMP_CPU_ALLOC_ON_STACK(mask)(mask = __kmp_affinity_dispatch->allocate_mask());
KMP_CPU_ZERO(mask)(mask)->zero();
KMP_CPU_SET(which, mask)(mask)->set(which);
__kmp_set_system_affinity(mask, TRUE)(mask)->set_system_affinity((!0));
KMP_CPU_FREE_FROM_STACK(mask)__kmp_affinity_dispatch->deallocate_mask(mask);
112}

114/* Determine if we can access affinity functionality on this version of
* Linux* OS by checking __NR_sched_{get,set}affinity system calls, and set
* __kmp_affin_mask_size to the appropriate value (0 means not capable). */
117void __kmp_affinity_determine_capable(const char *env_var) {
118// Check and see if the OS supports thread affinity.

120#define KMP_CPU_SET_SIZE_LIMIT(1024 * 1024) (1024 * 1024)

int gCode;
int sCode;
unsigned char *buf;
buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT)malloc((1024 * 1024));
1
Within the expansion of the macro 'KMP_INTERNAL_MALLOC':
→
a
Memory is allocated

// If Linux* OS:
// If the syscall fails or returns a suggestion for the size,
// then we don't have to search for an appropriate size.
gCode = syscall(__NR_sched_getaffinity204, 0, KMP_CPU_SET_SIZE_LIMIT(1024 * 1024), buf);
KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "initial getaffinity call returned %d errno = %d\n", gCode, (
*__errno_location ())); }
              "initial getaffinity call returned %d errno = %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "initial getaffinity call returned %d errno = %d\n", gCode, (
*__errno_location ())); }
              gCode, errno))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "initial getaffinity call returned %d errno = %d\n", gCode, (
*__errno_location ())); };

// if ((gCode < 0) && (errno == ENOSYS))
if (gCode < 0) {
2
←
Assuming 'gCode' is >= 0→
3
←
Taking false branch→
  // System call not supported
  if (__kmp_affinity_verbose ||
      (__kmp_affinity_warnings && (__kmp_affinity_type != affinity_none) &&
       (__kmp_affinity_type != affinity_default) &&
       (__kmp_affinity_type != affinity_disabled))) {
    int error = errno(*__errno_location ());
    kmp_msg_t err_code = KMP_ERR(error)__kmp_msg_error_code(error);
    __kmp_msg(kmp_ms_warning, KMP_MSG(GetAffSysCallNotSupported, env_var)__kmp_msg_format(kmp_i18n_msg_GetAffSysCallNotSupported, env_var
),
              err_code, __kmp_msg_null);
    if (__kmp_generate_warnings == kmp_warnings_off) {
      __kmp_str_free(&err_code.str);
    }
  }
  KMP_AFFINITY_DISABLE()(__kmp_affin_mask_size = 0);
  KMP_INTERNAL_FREE(buf)free(buf);
  return;
}
if (gCode > 0) { // Linux* OS only
4
←
Assuming 'gCode' is > 0→
5
←
Taking true branch→
  // The optimal situation: the OS returns the size of the buffer it expects.
  //
  // A verification of correct behavior is that Isetaffinity on a NULL
  // buffer with the same size fails with errno set to EFAULT.
  sCode = syscall(__NR_sched_setaffinity203, 0, gCode, NULL__null);
  KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); }
                "setaffinity for mask size %d returned %d errno = %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); }
                gCode, sCode, errno))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); };
  if (sCode < 0) {
6
←
Assuming 'sCode' is < 0→
7
←
Taking true branch→
    if (errno(*__errno_location ()) == ENOSYS38) {
8
←
Taking true branch→
      if (__kmp_affinity_verbose ||
9
←
Assuming '__kmp_affinity_verbose' is 0→
          (__kmp_affinity_warnings &&
10
←
Assuming '__kmp_affinity_warnings' is 0→
           (__kmp_affinity_type != affinity_none) &&
           (__kmp_affinity_type != affinity_default) &&
           (__kmp_affinity_type != affinity_disabled))) {
        int error = errno(*__errno_location ());
        kmp_msg_t err_code = KMP_ERR(error)__kmp_msg_error_code(error);
        __kmp_msg(kmp_ms_warning, KMP_MSG(SetAffSysCallNotSupported, env_var)__kmp_msg_format(kmp_i18n_msg_SetAffSysCallNotSupported, env_var
),
                  err_code, __kmp_msg_null);
        if (__kmp_generate_warnings == kmp_warnings_off) {
          __kmp_str_free(&err_code.str);
        }
      }
      KMP_AFFINITY_DISABLE()(__kmp_affin_mask_size = 0);
      KMP_INTERNAL_FREE(buf)free(buf);
11
←
Within the expansion of the macro 'KMP_INTERNAL_FREE':
→
a
Memory is released
    }
    if (errno(*__errno_location ()) == EFAULT14) {
12
←
Taking true branch→
      KMP_AFFINITY_ENABLE(gCode)(__kmp_affin_mask_size = gCode);
      KA_TRACE(10, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); }
                    "affinity supported (mask size %d)\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); }
                    (int)__kmp_affin_mask_size))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); };
      KMP_INTERNAL_FREE(buf)free(buf);
13
←
Within the expansion of the macro 'KMP_INTERNAL_FREE':
a
Attempt to free released memory
      return;
    }
  }
}

// Call the getaffinity system call repeatedly with increasing set sizes
// until we succeed, or reach an upper bound on the search.
KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "searching for proper set size\n"); }
              "searching for proper set size\n"))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "searching for proper set size\n"); };
int size;
for (size = 1; size <= KMP_CPU_SET_SIZE_LIMIT(1024 * 1024); size *= 2) {
  gCode = syscall(__NR_sched_getaffinity204, 0, size, buf);
  KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "getaffinity for mask size %d returned %d errno = %d\n", size
, gCode, (*__errno_location ())); }
                "getaffinity for mask size %d returned %d errno = %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "getaffinity for mask size %d returned %d errno = %d\n", size
, gCode, (*__errno_location ())); }
                size, gCode, errno))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "getaffinity for mask size %d returned %d errno = %d\n", size
, gCode, (*__errno_location ())); };

  if (gCode < 0) {
    if (errno(*__errno_location ()) == ENOSYS38) {
      // We shouldn't get here
      KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    "inconsistent OS call behavior: errno == ENOSYS for mask "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    "size %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    size))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); };
      if (__kmp_affinity_verbose ||
          (__kmp_affinity_warnings &&
           (__kmp_affinity_type != affinity_none) &&
           (__kmp_affinity_type != affinity_default) &&
           (__kmp_affinity_type != affinity_disabled))) {
        int error = errno(*__errno_location ());
        kmp_msg_t err_code = KMP_ERR(error)__kmp_msg_error_code(error);
        __kmp_msg(kmp_ms_warning, KMP_MSG(GetAffSysCallNotSupported, env_var)__kmp_msg_format(kmp_i18n_msg_GetAffSysCallNotSupported, env_var
),
                  err_code, __kmp_msg_null);
        if (__kmp_generate_warnings == kmp_warnings_off) {
          __kmp_str_free(&err_code.str);
        }
      }
      KMP_AFFINITY_DISABLE()(__kmp_affin_mask_size = 0);
      KMP_INTERNAL_FREE(buf)free(buf);
      return;
    }
    continue;
  }

  sCode = syscall(__NR_sched_setaffinity203, 0, gCode, NULL__null);
  KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); }
                "setaffinity for mask size %d returned %d errno = %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); }
                gCode, sCode, errno))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "setaffinity for mask size %d returned %d errno = %d\n", gCode
, sCode, (*__errno_location ())); };
  if (sCode < 0) {
    if (errno(*__errno_location ()) == ENOSYS38) { // Linux* OS only
      // We shouldn't get here
      KA_TRACE(30, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    "inconsistent OS call behavior: errno == ENOSYS for mask "if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    "size %d\n",if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); }
                    size))if (kmp_a_debug >= 30) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "inconsistent OS call behavior: errno == ENOSYS for mask " "size %d\n"
, size); };
      if (__kmp_affinity_verbose ||
          (__kmp_affinity_warnings &&
           (__kmp_affinity_type != affinity_none) &&
           (__kmp_affinity_type != affinity_default) &&
           (__kmp_affinity_type != affinity_disabled))) {
        int error = errno(*__errno_location ());
        kmp_msg_t err_code = KMP_ERR(error)__kmp_msg_error_code(error);
        __kmp_msg(kmp_ms_warning, KMP_MSG(SetAffSysCallNotSupported, env_var)__kmp_msg_format(kmp_i18n_msg_SetAffSysCallNotSupported, env_var
),
                  err_code, __kmp_msg_null);
        if (__kmp_generate_warnings == kmp_warnings_off) {
          __kmp_str_free(&err_code.str);
        }
      }
      KMP_AFFINITY_DISABLE()(__kmp_affin_mask_size = 0);
      KMP_INTERNAL_FREE(buf)free(buf);
      return;
    }
    if (errno(*__errno_location ()) == EFAULT14) {
      KMP_AFFINITY_ENABLE(gCode)(__kmp_affin_mask_size = gCode);
      KA_TRACE(10, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); }
                    "affinity supported (mask size %d)\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); }
                    (int)__kmp_affin_mask_size))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "affinity supported (mask size %d)\n", (int)__kmp_affin_mask_size
); };
      KMP_INTERNAL_FREE(buf)free(buf);
      return;
    }
  }
}
// save uncaught error code
// int error = errno;
KMP_INTERNAL_FREE(buf)free(buf);
// restore uncaught error code, will be printed at the next KMP_WARNING below
// errno = error;

// Affinity is not supported
KMP_AFFINITY_DISABLE()(__kmp_affin_mask_size = 0);
KA_TRACE(10, ("__kmp_affinity_determine_capable: "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "cannot determine mask size - affinity not supported\n"); }
              "cannot determine mask size - affinity not supported\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_affinity_determine_capable: "
 "cannot determine mask size - affinity not supported\n"); };
if (__kmp_affinity_verbose ||
    (__kmp_affinity_warnings && (__kmp_affinity_type != affinity_none) &&
     (__kmp_affinity_type != affinity_default) &&
     (__kmp_affinity_type != affinity_disabled))) {
  KMP_WARNING(AffCantGetMaskSize, env_var)__kmp_msg(kmp_ms_warning, __kmp_msg_format(kmp_i18n_msg_AffCantGetMaskSize
, env_var), __kmp_msg_null);
}
284}

286#endif // KMP_OS_LINUX && KMP_AFFINITY_SUPPORTED

288#if KMP_USE_FUTEX(1 && !0 && (0 || 1 || KMP_ARCH_ARM || 0))

290int __kmp_futex_determine_capable() {
int loc = 0;
int rc = syscall(__NR_futex202, &loc, FUTEX_WAKE1, 1, NULL__null, NULL__null, 0);
int retval = (rc == 0) || (errno(*__errno_location ()) != ENOSYS38);

KA_TRACE(10,if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_futex_determine_capable: rc = %d errno = %d\n"
, rc, (*__errno_location ())); }
         ("__kmp_futex_determine_capable: rc = %d errno = %d\n", rc, errno))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_futex_determine_capable: rc = %d errno = %d\n"
, rc, (*__errno_location ())); };
KA_TRACE(10, ("__kmp_futex_determine_capable: futex syscall%s supported\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_futex_determine_capable: futex syscall%s supported\n"
, retval ? "" : " not"); }
              retval ? "" : " not"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_futex_determine_capable: futex syscall%s supported\n"
, retval ? "" : " not"); };

return retval;
301}

303#endif // KMP_USE_FUTEX

305#if (KMP_ARCH_X860 || KMP_ARCH_X86_641) && (!KMP_ASM_INTRINS1)
306/* Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to
 use compare_and_store for these routines */

309kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 d) {
kmp_int8 old_value, new_value;

old_value = TCR_1(*p)(*p);
new_value = old_value | d;

while (!KMP_COMPARE_AND_STORE_REL8(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8
)(old_value), (kmp_uint8)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_1(*p)(*p);
  new_value = old_value | d;
}
return old_value;
321}

323kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 d) {
kmp_int8 old_value, new_value;

old_value = TCR_1(*p)(*p);
new_value = old_value & d;

while (!KMP_COMPARE_AND_STORE_REL8(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8
)(old_value), (kmp_uint8)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_1(*p)(*p);
  new_value = old_value & d;
}
return old_value;
335}

337kmp_uint32 __kmp_test_then_or32(volatile kmp_uint32 *p, kmp_uint32 d) {
kmp_uint32 old_value, new_value;

old_value = TCR_4(*p)(*p);
new_value = old_value | d;

while (!KMP_COMPARE_AND_STORE_REL32(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32
)(old_value), (kmp_uint32)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_4(*p)(*p);
  new_value = old_value | d;
}
return old_value;
349}

351kmp_uint32 __kmp_test_then_and32(volatile kmp_uint32 *p, kmp_uint32 d) {
kmp_uint32 old_value, new_value;

old_value = TCR_4(*p)(*p);
new_value = old_value & d;

while (!KMP_COMPARE_AND_STORE_REL32(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32
)(old_value), (kmp_uint32)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_4(*p)(*p);
  new_value = old_value & d;
}
return old_value;
363}

365#if KMP_ARCH_X860
366kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 d) {
kmp_int8 old_value, new_value;

old_value = TCR_1(*p)(*p);
new_value = old_value + d;

while (!KMP_COMPARE_AND_STORE_REL8(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8
)(old_value), (kmp_uint8)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_1(*p)(*p);
  new_value = old_value + d;
}
return old_value;
378}

380kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 d) {
kmp_int64 old_value, new_value;

old_value = TCR_8(*p)(*p);
new_value = old_value + d;

while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64
)(old_value), (kmp_uint64)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_8(*p)(*p);
  new_value = old_value + d;
}
return old_value;
392}
393#endif /* KMP_ARCH_X86 */

395kmp_uint64 __kmp_test_then_or64(volatile kmp_uint64 *p, kmp_uint64 d) {
kmp_uint64 old_value, new_value;

old_value = TCR_8(*p)(*p);
new_value = old_value | d;
while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64
)(old_value), (kmp_uint64)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_8(*p)(*p);
  new_value = old_value | d;
}
return old_value;
406}

408kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 d) {
kmp_uint64 old_value, new_value;

old_value = TCR_8(*p)(*p);
new_value = old_value & d;
while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)__sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64
)(old_value), (kmp_uint64)(new_value))) {
  KMP_CPU_PAUSE()__kmp_x86_pause();
  old_value = TCR_8(*p)(*p);
  new_value = old_value & d;
}
return old_value;
419}

421#endif /* (KMP_ARCH_X86 || KMP_ARCH_X86_64) && (! KMP_ASM_INTRINS) */

423void __kmp_terminate_thread(int gtid) {
int status;
kmp_info_t *th = __kmp_threads[gtid];

if (!th)
  return;

430#ifdef KMP_CANCEL_THREADS
KA_TRACE(10, ("__kmp_terminate_thread: kill (%d)\n", gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_terminate_thread: kill (%d)\n"
, gtid); };
status = pthread_cancel(th->th.th_info.ds.ds_thread);
if (status != 0 && status != ESRCH3) {
  __kmp_fatal(KMP_MSG(CantTerminateWorkerThread)__kmp_msg_format(kmp_i18n_msg_CantTerminateWorkerThread), KMP_ERR(status)__kmp_msg_error_code(status),
              __kmp_msg_null);
}
437#endif
__kmp_yield(TRUE(!0));
439} //

441/* Set thread stack info according to values returned by pthread_getattr_np().
 If values are unreasonable, assume call failed and use incremental stack
 refinement method instead. Returns TRUE if the stack parameters could be
 determined exactly, FALSE if incremental refinement is necessary. */
445static kmp_int32 __kmp_set_stack_info(int gtid, kmp_info_t *th) {
int stack_data;
447#if KMP_OS_LINUX1 || KMP_OS_FREEBSD0 || KMP_OS_NETBSD0
/* Linux* OS only -- no pthread_getattr_np support on OS X* */
pthread_attr_t attr;
int status;
size_t size = 0;
void *addr = 0;

/* Always do incremental stack refinement for ubermaster threads since the
   initial thread stack range can be reduced by sibling thread creation so
   pthread_attr_getstack may cause thread gtid aliasing */
if (!KMP_UBER_GTID(gtid)) {

  /* Fetch the real thread attributes */
  status = pthread_attr_init(&attr);
  KMP_CHECK_SYSFAIL("pthread_attr_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_attr_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
462#if KMP_OS_FREEBSD0 || KMP_OS_NETBSD0
  status = pthread_attr_get_np(pthread_self(), &attr);
  KMP_CHECK_SYSFAIL("pthread_attr_get_np", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_attr_get_np"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
465#else
  status = pthread_getattr_np(pthread_self(), &attr);
  KMP_CHECK_SYSFAIL("pthread_getattr_np", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_getattr_np"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
468#endif
  status = pthread_attr_getstack(&attr, &addr, &size);
  KMP_CHECK_SYSFAIL("pthread_attr_getstack", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_attr_getstack"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  KA_TRACE(60,if (kmp_a_debug >= 60) { __kmp_debug_printf ("__kmp_set_stack_info: T#%d pthread_attr_getstack returned size:"
 " %lu, low addr: %p\n", gtid, size, addr); }
           ("__kmp_set_stack_info: T#%d pthread_attr_getstack returned size:"if (kmp_a_debug >= 60) { __kmp_debug_printf ("__kmp_set_stack_info: T#%d pthread_attr_getstack returned size:"
 " %lu, low addr: %p\n", gtid, size, addr); }
            " %lu, low addr: %p\n",if (kmp_a_debug >= 60) { __kmp_debug_printf ("__kmp_set_stack_info: T#%d pthread_attr_getstack returned size:"
 " %lu, low addr: %p\n", gtid, size, addr); }
            gtid, size, addr))if (kmp_a_debug >= 60) { __kmp_debug_printf ("__kmp_set_stack_info: T#%d pthread_attr_getstack returned size:"
 " %lu, low addr: %p\n", gtid, size, addr); };
  status = pthread_attr_destroy(&attr);
  KMP_CHECK_SYSFAIL("pthread_attr_destroy", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_attr_destroy"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
}

if (size != 0 && addr != 0) { // was stack parameter determination successful?
  /* Store the correct base and size */
  TCW_PTR(th->th.th_info.ds.ds_stackbase, (((char *)addr) + size))((th->th.th_info.ds.ds_stackbase)) = (((((char *)addr) + size
)));
  TCW_PTR(th->th.th_info.ds.ds_stacksize, size)((th->th.th_info.ds.ds_stacksize)) = ((size));
  TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE)(th->th.th_info.ds.ds_stackgrow) = (0);
  return TRUE(!0);
}
486#endif /* KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD */
/* Use incremental refinement starting from initial conservative estimate */
TCW_PTR(th->th.th_info.ds.ds_stacksize, 0)((th->th.th_info.ds.ds_stacksize)) = ((0));
TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data)((th->th.th_info.ds.ds_stackbase)) = ((&stack_data));
TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE)(th->th.th_info.ds.ds_stackgrow) = ((!0));
return FALSE0;
492}

494static void *__kmp_launch_worker(void *thr) {
int status, old_type, old_state;
496#ifdef KMP_BLOCK_SIGNALS
sigset_t new_set, old_set;
498#endif /* KMP_BLOCK_SIGNALS */
void *exit_val;
500#if KMP_OS_LINUX1 || KMP_OS_FREEBSD0 || KMP_OS_NETBSD0
void *volatile padding = 0;
502#endif
int gtid;

gtid = ((kmp_info_t *)thr)->th.th_info.ds.ds_gtid;
__kmp_gtid_set_specific(gtid);
507#ifdef KMP_TDATA_GTID1
__kmp_gtid = gtid;
509#endif
510#if KMP_STATS_ENABLED0
// set thread local index to point to thread-specific stats
__kmp_stats_thread_ptr = ((kmp_info_t *)thr)->th.th_stats;
__kmp_stats_thread_ptr->startLife();
KMP_SET_THREAD_STATE(IDLE)((void)0);
KMP_INIT_PARTITIONED_TIMERS(OMP_idle)((void)0);
516#endif

518#if USE_ITT_BUILD1
__kmp_itt_thread_name(gtid);
520#endif /* USE_ITT_BUILD */

522#if KMP_AFFINITY_SUPPORTED1
__kmp_affinity_set_init_mask(gtid, FALSE0);
524#endif

526#ifdef KMP_CANCEL_THREADS
status = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUSPTHREAD_CANCEL_ASYNCHRONOUS, &old_type);
KMP_CHECK_SYSFAIL("pthread_setcanceltype", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcanceltype"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
// josh todo: isn't PTHREAD_CANCEL_ENABLE default for newly-created threads?
status = pthread_setcancelstate(PTHREAD_CANCEL_ENABLEPTHREAD_CANCEL_ENABLE, &old_state);
KMP_CHECK_SYSFAIL("pthread_setcancelstate", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcancelstate"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
532#endif

534#if KMP_ARCH_X860 || KMP_ARCH_X86_641
// Set FP control regs to be a copy of the parallel initialization thread's.
__kmp_clear_x87_fpu_status_word();
__kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
__kmp_load_mxcsr(&__kmp_init_mxcsr)_mm_setcsr(*(&__kmp_init_mxcsr));
539#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */

541#ifdef KMP_BLOCK_SIGNALS
status = sigfillset(&new_set);
KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "sigfillset"), __kmp_msg_error_code
(error), __kmp_msg_null); } };
status = pthread_sigmask(SIG_BLOCK0, &new_set, &old_set);
KMP_CHECK_SYSFAIL("pthread_sigmask", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_sigmask"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
546#endif /* KMP_BLOCK_SIGNALS */

548#if KMP_OS_LINUX1 || KMP_OS_FREEBSD0 || KMP_OS_NETBSD0
if (__kmp_stkoffset > 0 && gtid > 0) {
  padding = KMP_ALLOCA(gtid * __kmp_stkoffset)__builtin_alloca (gtid * __kmp_stkoffset);
}
552#endif

KMP_MB();
__kmp_set_stack_info(gtid, (kmp_info_t *)thr);

__kmp_check_stack_overlap((kmp_info_t *)thr);

exit_val = __kmp_launch_thread((kmp_info_t *)thr);

561#ifdef KMP_BLOCK_SIGNALS
status = pthread_sigmask(SIG_SETMASK2, &old_set, NULL__null);
KMP_CHECK_SYSFAIL("pthread_sigmask", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_sigmask"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
564#endif /* KMP_BLOCK_SIGNALS */

return exit_val;
567}

569#if KMP_USE_MONITOR
570/* The monitor thread controls all of the threads in the complex */

572static void *__kmp_launch_monitor(void *thr) {
int status, old_type, old_state;
574#ifdef KMP_BLOCK_SIGNALS
sigset_t new_set;
576#endif /* KMP_BLOCK_SIGNALS */
struct timespec interval;
int yield_count;
int yield_cycles = 0;

KMP_MB(); /* Flush all pending memory write invalidates.  */

KA_TRACE(10, ("__kmp_launch_monitor: #1 launched\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #1 launched\n"
); };

/* register us as the monitor thread */
__kmp_gtid_set_specific(KMP_GTID_MONITOR(-4));
587#ifdef KMP_TDATA_GTID1
__kmp_gtid = KMP_GTID_MONITOR(-4);
589#endif

KMP_MB();

593#if USE_ITT_BUILD1
// Instruct Intel(R) Threading Tools to ignore monitor thread.
__kmp_itt_thread_ignore();
596#endif /* USE_ITT_BUILD */

__kmp_set_stack_info(((kmp_info_t *)thr)->th.th_info.ds.ds_gtid,
                     (kmp_info_t *)thr);

__kmp_check_stack_overlap((kmp_info_t *)thr);

603#ifdef KMP_CANCEL_THREADS
status = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUSPTHREAD_CANCEL_ASYNCHRONOUS, &old_type);
KMP_CHECK_SYSFAIL("pthread_setcanceltype", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcanceltype"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
// josh todo: isn't PTHREAD_CANCEL_ENABLE default for newly-created threads?
status = pthread_setcancelstate(PTHREAD_CANCEL_ENABLEPTHREAD_CANCEL_ENABLE, &old_state);
KMP_CHECK_SYSFAIL("pthread_setcancelstate", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcancelstate"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
609#endif

611#if KMP_REAL_TIME_FIX
// This is a potential fix which allows application with real-time scheduling
// policy work. However, decision about the fix is not made yet, so it is
// disabled by default.
{ // Are program started with real-time scheduling policy?
  int sched = sched_getscheduler(0);
  if (sched == SCHED_FIFO1 || sched == SCHED_RR2) {
    // Yes, we are a part of real-time application. Try to increase the
    // priority of the monitor.
    struct sched_param param;
    int max_priority = sched_get_priority_max(sched);
    int rc;
    KMP_WARNING(RealTimeSchedNotSupported)__kmp_msg(kmp_ms_warning, __kmp_msg_format(kmp_i18n_msg_RealTimeSchedNotSupported
), __kmp_msg_null);
    sched_getparam(0, &param);
    if (param.sched_priority__sched_priority < max_priority) {
      param.sched_priority__sched_priority += 1;
      rc = sched_setscheduler(0, sched, &param);
      if (rc != 0) {
        int error = errno(*__errno_location ());
        kmp_msg_t err_code = KMP_ERR(error)__kmp_msg_error_code(error);
        __kmp_msg(kmp_ms_warning, KMP_MSG(CantChangeMonitorPriority)__kmp_msg_format(kmp_i18n_msg_CantChangeMonitorPriority),
                  err_code, KMP_MSG(MonitorWillStarve)__kmp_msg_format(kmp_i18n_msg_MonitorWillStarve), __kmp_msg_null);
        if (__kmp_generate_warnings == kmp_warnings_off) {
          __kmp_str_free(&err_code.str);
        }
      }
    } else {
      // We cannot abort here, because number of CPUs may be enough for all
      // the threads, including the monitor thread, so application could
      // potentially work...
      __kmp_msg(kmp_ms_warning, KMP_MSG(RunningAtMaxPriority)__kmp_msg_format(kmp_i18n_msg_RunningAtMaxPriority),
                KMP_MSG(MonitorWillStarve)__kmp_msg_format(kmp_i18n_msg_MonitorWillStarve), KMP_HNT(RunningAtMaxPriority)__kmp_msg_format(kmp_i18n_hnt_RunningAtMaxPriority),
                __kmp_msg_null);
    }
  }
  // AC: free thread that waits for monitor started
  TCW_4(__kmp_global.g.g_time.dt.t_value, 0)(__kmp_global.g.g_time.dt.t_value) = (0);
}
649#endif // KMP_REAL_TIME_FIX

KMP_MB(); /* Flush all pending memory write invalidates.  */

if (__kmp_monitor_wakeups == 1) {
  interval.tv_sec = 1;
  interval.tv_nsec = 0;
} else {
  interval.tv_sec = 0;
  interval.tv_nsec = (KMP_NSEC_PER_SEC1000000000L / __kmp_monitor_wakeups);
}

KA_TRACE(10, ("__kmp_launch_monitor: #2 monitor\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #2 monitor\n"
); };

if (__kmp_yield_cycle) {
  __kmp_yielding_on = 0; /* Start out with yielding shut off */
  yield_count = __kmp_yield_off_count;
} else {
  __kmp_yielding_on = 1; /* Yielding is on permanently */
}

while (!TCR_4(__kmp_global.g.g_done)(__kmp_global.g.g_done)) {
  struct timespec now;
  struct timeval tval;

  /*  This thread monitors the state of the system */

  KA_TRACE(15, ("__kmp_launch_monitor: update\n"))if (kmp_a_debug >= 15) { __kmp_debug_printf ("__kmp_launch_monitor: update\n"
); };

  status = gettimeofday(&tval, NULL__null);
  KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "gettimeofday")
, __kmp_msg_error_code(error), __kmp_msg_null); } };
  TIMEVAL_TO_TIMESPEC(&tval, &now){ (&now)->tv_sec = (&tval)->tv_sec; (&now)->
tv_nsec = (&tval)->tv_usec * 1000; };

  now.tv_sec += interval.tv_sec;
  now.tv_nsec += interval.tv_nsec;

  if (now.tv_nsec >= KMP_NSEC_PER_SEC1000000000L) {
    now.tv_sec += 1;
    now.tv_nsec -= KMP_NSEC_PER_SEC1000000000L;
  }

  status = pthread_mutex_lock(&__kmp_wait_mx.m_mutex);
  KMP_CHECK_SYSFAIL("pthread_mutex_lock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_lock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  // AC: the monitor should not fall asleep if g_done has been set
  if (!TCR_4(__kmp_global.g.g_done)(__kmp_global.g.g_done)) { // check once more under mutex
    status = pthread_cond_timedwait(&__kmp_wait_cv.c_cond,
                                    &__kmp_wait_mx.m_mutex, &now);
    if (status != 0) {
      if (status != ETIMEDOUT110 && status != EINTR4) {
        KMP_SYSFAIL("pthread_cond_timedwait", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_cond_timedwait"
), __kmp_msg_error_code(status), __kmp_msg_null);
      }
    }
  }
  status = pthread_mutex_unlock(&__kmp_wait_mx.m_mutex);
  KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };

  if (__kmp_yield_cycle) {
    yield_cycles++;
    if ((yield_cycles % yield_count) == 0) {
      if (__kmp_yielding_on) {
        __kmp_yielding_on = 0; /* Turn it off now */
        yield_count = __kmp_yield_off_count;
      } else {
        __kmp_yielding_on = 1; /* Turn it on now */
        yield_count = __kmp_yield_on_count;
      }
      yield_cycles = 0;
    }
  } else {
    __kmp_yielding_on = 1;
  }

  TCW_4(__kmp_global.g.g_time.dt.t_value,(__kmp_global.g.g_time.dt.t_value) = ((__kmp_global.g.g_time.
dt.t_value) + 1)
        TCR_4(__kmp_global.g.g_time.dt.t_value) + 1)(__kmp_global.g.g_time.dt.t_value) = ((__kmp_global.g.g_time.
dt.t_value) + 1);

  KMP_MB(); /* Flush all pending memory write invalidates.  */
}

KA_TRACE(10, ("__kmp_launch_monitor: #3 cleanup\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #3 cleanup\n"
); };

729#ifdef KMP_BLOCK_SIGNALS
status = sigfillset(&new_set);
KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "sigfillset"), __kmp_msg_error_code
(error), __kmp_msg_null); } };
status = pthread_sigmask(SIG_UNBLOCK1, &new_set, NULL__null);
KMP_CHECK_SYSFAIL("pthread_sigmask", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_sigmask"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
734#endif /* KMP_BLOCK_SIGNALS */

KA_TRACE(10, ("__kmp_launch_monitor: #4 finished\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #4 finished\n"
); };

if (__kmp_global.g.g_abort != 0) {
  /* now we need to terminate the worker threads  */
  /* the value of t_abort is the signal we caught */

  int gtid;

  KA_TRACE(10, ("__kmp_launch_monitor: #5 terminate sig=%d\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #5 terminate sig=%d\n"
, __kmp_global.g.g_abort); }
                __kmp_global.g.g_abort))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #5 terminate sig=%d\n"
, __kmp_global.g.g_abort); };

  /* terminate the OpenMP worker threads */
  /* TODO this is not valid for sibling threads!!
   * the uber master might not be 0 anymore.. */
  for (gtid = 1; gtid < __kmp_threads_capacity; ++gtid)
    __kmp_terminate_thread(gtid);

  __kmp_cleanup();

  KA_TRACE(10, ("__kmp_launch_monitor: #6 raise sig=%d\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #6 raise sig=%d\n"
, __kmp_global.g.g_abort); }
                __kmp_global.g.g_abort))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #6 raise sig=%d\n"
, __kmp_global.g.g_abort); };

  if (__kmp_global.g.g_abort > 0)
    raise(__kmp_global.g.g_abort);
}

KA_TRACE(10, ("__kmp_launch_monitor: #7 exit\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_launch_monitor: #7 exit\n"
); };

return thr;
765}
766#endif // KMP_USE_MONITOR

768void __kmp_create_worker(int gtid, kmp_info_t *th, size_t stack_size) {
pthread_t handle;
pthread_attr_t thread_attr;
int status;

th->th.th_info.ds.ds_gtid = gtid;

775#if KMP_STATS_ENABLED0
// sets up worker thread stats
__kmp_acquire_tas_lock(&__kmp_stats_lock, gtid);

// th->th.th_stats is used to transfer thread-specific stats-pointer to
// __kmp_launch_worker. So when thread is created (goes into
// __kmp_launch_worker) it will set its thread local pointer to
// th->th.th_stats
if (!KMP_UBER_GTID(gtid)) {
  th->th.th_stats = __kmp_stats_list->push_back(gtid);
} else {
  // For root threads, __kmp_stats_thread_ptr is set in __kmp_register_root(),
  // so set the th->th.th_stats field to it.
  th->th.th_stats = __kmp_stats_thread_ptr;
}
__kmp_release_tas_lock(&__kmp_stats_lock, gtid);

792#endif // KMP_STATS_ENABLED

if (KMP_UBER_GTID(gtid)) {
  KA_TRACE(10, ("__kmp_create_worker: uber thread (%d)\n", gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: uber thread (%d)\n"
, gtid); };
  th->th.th_info.ds.ds_thread = pthread_self();
  __kmp_set_stack_info(gtid, th);
  __kmp_check_stack_overlap(th);
  return;
}

KA_TRACE(10, ("__kmp_create_worker: try to create thread (%d)\n", gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: try to create thread (%d)\n"
, gtid); };

KMP_MB(); /* Flush all pending memory write invalidates.  */

806#ifdef KMP_THREAD_ATTR
status = pthread_attr_init(&thread_attr);
if (status != 0) {
  __kmp_fatal(KMP_MSG(CantInitThreadAttrs)__kmp_msg_format(kmp_i18n_msg_CantInitThreadAttrs), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}
status = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE);
if (status != 0) {
  __kmp_fatal(KMP_MSG(CantSetWorkerState)__kmp_msg_format(kmp_i18n_msg_CantSetWorkerState), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}

/* Set stack size for this thread now.
   The multiple of 2 is there because on some machines, requesting an unusual
   stacksize causes the thread to have an offset before the dummy alloca()
   takes place to create the offset.  Since we want the user to have a
   sufficient stacksize AND support a stack offset, we alloca() twice the
   offset so that the upcoming alloca() does not eliminate any premade offset,
   and also gives the user the stack space they requested for all threads */
stack_size += gtid * __kmp_stkoffset * 2;

KA_TRACE(10, ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n", gtid
, ((size_t)(4 * 1024 * 1024)), __kmp_stksize, stack_size); }
              "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n", gtid
, ((size_t)(4 * 1024 * 1024)), __kmp_stksize, stack_size); }
              gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n", gtid
, ((size_t)(4 * 1024 * 1024)), __kmp_stksize, stack_size); };

829#ifdef _POSIX_THREAD_ATTR_STACKSIZE200809L
status = pthread_attr_setstacksize(&thread_attr, stack_size);
831#ifdef KMP_BACKUP_STKSIZE((size_t)(2 * 1024 * 1024))
if (status != 0) {
  if (!__kmp_env_stksize) {
    stack_size = KMP_BACKUP_STKSIZE((size_t)(2 * 1024 * 1024)) + gtid * __kmp_stkoffset;
    __kmp_stksize = KMP_BACKUP_STKSIZE((size_t)(2 * 1024 * 1024));
    KA_TRACE(10, ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "
 "bytes\n", gtid, ((size_t)(4 * 1024 * 1024)), __kmp_stksize,
 stack_size); }
                  "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "
 "bytes\n", gtid, ((size_t)(4 * 1024 * 1024)), __kmp_stksize,
 stack_size); }
                  "bytes\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "
 "bytes\n", gtid, ((size_t)(4 * 1024 * 1024)), __kmp_stksize,
 stack_size); }
                  gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
 "__kmp_stksize = %lu bytes, (backup) final stacksize = %lu "
 "bytes\n", gtid, ((size_t)(4 * 1024 * 1024)), __kmp_stksize,
 stack_size); };
    status = pthread_attr_setstacksize(&thread_attr, stack_size);
  }
}
843#endif /* KMP_BACKUP_STKSIZE */
if (status != 0) {
  __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size)__kmp_msg_format(kmp_i18n_msg_CantSetWorkerStackSize, stack_size
), KMP_ERR(status)__kmp_msg_error_code(status),
              KMP_HNT(ChangeWorkerStackSize)__kmp_msg_format(kmp_i18n_hnt_ChangeWorkerStackSize), __kmp_msg_null);
}
848#endif /* _POSIX_THREAD_ATTR_STACKSIZE */

850#endif /* KMP_THREAD_ATTR */

status =
    pthread_create(&handle, &thread_attr, __kmp_launch_worker, (void *)th);
if (status != 0 || !handle) { // ??? Why do we check handle??
855#ifdef _POSIX_THREAD_ATTR_STACKSIZE200809L
  if (status == EINVAL22) {
    __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size)__kmp_msg_format(kmp_i18n_msg_CantSetWorkerStackSize, stack_size
), KMP_ERR(status)__kmp_msg_error_code(status),
                KMP_HNT(IncreaseWorkerStackSize)__kmp_msg_format(kmp_i18n_hnt_IncreaseWorkerStackSize), __kmp_msg_null);
  }
  if (status == ENOMEM12) {
    __kmp_fatal(KMP_MSG(CantSetWorkerStackSize, stack_size)__kmp_msg_format(kmp_i18n_msg_CantSetWorkerStackSize, stack_size
), KMP_ERR(status)__kmp_msg_error_code(status),
                KMP_HNT(DecreaseWorkerStackSize)__kmp_msg_format(kmp_i18n_hnt_DecreaseWorkerStackSize), __kmp_msg_null);
  }
864#endif /* _POSIX_THREAD_ATTR_STACKSIZE */
  if (status == EAGAIN11) {
    __kmp_fatal(KMP_MSG(NoResourcesForWorkerThread)__kmp_msg_format(kmp_i18n_msg_NoResourcesForWorkerThread), KMP_ERR(status)__kmp_msg_error_code(status),
                KMP_HNT(Decrease_NUM_THREADS)__kmp_msg_format(kmp_i18n_hnt_Decrease_NUM_THREADS), __kmp_msg_null);
  }
  KMP_SYSFAIL("pthread_create", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_create"
), __kmp_msg_error_code(status), __kmp_msg_null);
}

th->th.th_info.ds.ds_thread = handle;

874#ifdef KMP_THREAD_ATTR
status = pthread_attr_destroy(&thread_attr);
if (status) {
  kmp_msg_t err_code = KMP_ERR(status)__kmp_msg_error_code(status);
  __kmp_msg(kmp_ms_warning, KMP_MSG(CantDestroyThreadAttrs)__kmp_msg_format(kmp_i18n_msg_CantDestroyThreadAttrs), err_code,
            __kmp_msg_null);
  if (__kmp_generate_warnings == kmp_warnings_off) {
    __kmp_str_free(&err_code.str);
  }
}
884#endif /* KMP_THREAD_ATTR */

KMP_MB(); /* Flush all pending memory write invalidates.  */

KA_TRACE(10, ("__kmp_create_worker: done creating thread (%d)\n", gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_worker: done creating thread (%d)\n"
, gtid); };

890} // __kmp_create_worker

892#if KMP_USE_MONITOR
893void __kmp_create_monitor(kmp_info_t *th) {
pthread_t handle;
pthread_attr_t thread_attr;
size_t size;
int status;
int auto_adj_size = FALSE0;

if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME(2147483647)) {
  // We don't need monitor thread in case of MAX_BLOCKTIME
  KA_TRACE(10, ("__kmp_create_monitor: skipping monitor thread because of "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: skipping monitor thread because of "
 "MAX blocktime\n"); }
                "MAX blocktime\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: skipping monitor thread because of "
 "MAX blocktime\n"); };
  th->th.th_info.ds.ds_tid = 0; // this makes reap_monitor no-op
  th->th.th_info.ds.ds_gtid = 0;
  return;
}
KA_TRACE(10, ("__kmp_create_monitor: try to create monitor\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: try to create monitor\n"
); };

KMP_MB(); /* Flush all pending memory write invalidates.  */

th->th.th_info.ds.ds_tid = KMP_GTID_MONITOR(-4);
th->th.th_info.ds.ds_gtid = KMP_GTID_MONITOR(-4);
914#if KMP_REAL_TIME_FIX
TCW_4(__kmp_global.g.g_time.dt.t_value,(__kmp_global.g.g_time.dt.t_value) = (-1)
      -1)(__kmp_global.g.g_time.dt.t_value) = (-1); // Will use it for synchronization a bit later.
917#else
TCW_4(__kmp_global.g.g_time.dt.t_value, 0)(__kmp_global.g.g_time.dt.t_value) = (0);
919#endif // KMP_REAL_TIME_FIX

921#ifdef KMP_THREAD_ATTR
if (__kmp_monitor_stksize == 0) {
  __kmp_monitor_stksize = KMP_DEFAULT_MONITOR_STKSIZE;
  auto_adj_size = TRUE(!0);
}
status = pthread_attr_init(&thread_attr);
if (status != 0) {
  __kmp_fatal(KMP_MSG(CantInitThreadAttrs)__kmp_msg_format(kmp_i18n_msg_CantInitThreadAttrs), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}
status = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE);
if (status != 0) {
  __kmp_fatal(KMP_MSG(CantSetMonitorState)__kmp_msg_format(kmp_i18n_msg_CantSetMonitorState), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}

935#ifdef _POSIX_THREAD_ATTR_STACKSIZE200809L
status = pthread_attr_getstacksize(&thread_attr, &size);
KMP_CHECK_SYSFAIL("pthread_attr_getstacksize", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_attr_getstacksize"), __kmp_msg_error_code(status),
 __kmp_msg_null); } };
938#else
size = __kmp_sys_min_stksize;
940#endif /* _POSIX_THREAD_ATTR_STACKSIZE */
941#endif /* KMP_THREAD_ATTR */

if (__kmp_monitor_stksize == 0) {
  __kmp_monitor_stksize = KMP_DEFAULT_MONITOR_STKSIZE;
}
if (__kmp_monitor_stksize < __kmp_sys_min_stksize) {
  __kmp_monitor_stksize = __kmp_sys_min_stksize;
}

KA_TRACE(10, ("__kmp_create_monitor: default stacksize = %lu bytes,"if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: default stacksize = %lu bytes,"
 "requested stacksize = %lu bytes\n", size, __kmp_monitor_stksize
); }
              "requested stacksize = %lu bytes\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: default stacksize = %lu bytes,"
 "requested stacksize = %lu bytes\n", size, __kmp_monitor_stksize
); }
              size, __kmp_monitor_stksize))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: default stacksize = %lu bytes,"
 "requested stacksize = %lu bytes\n", size, __kmp_monitor_stksize
); };

954retry:

956/* Set stack size for this thread now. */
957#ifdef _POSIX_THREAD_ATTR_STACKSIZE200809L
KA_TRACE(10, ("__kmp_create_monitor: setting stacksize = %lu bytes,",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: setting stacksize = %lu bytes,"
, __kmp_monitor_stksize); }
              __kmp_monitor_stksize))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: setting stacksize = %lu bytes,"
, __kmp_monitor_stksize); };
status = pthread_attr_setstacksize(&thread_attr, __kmp_monitor_stksize);
if (status != 0) {
  if (auto_adj_size) {
    __kmp_monitor_stksize *= 2;
    goto retry;
  }
  kmp_msg_t err_code = KMP_ERR(status)__kmp_msg_error_code(status);
  __kmp_msg(kmp_ms_warning, // should this be fatal?  BB
            KMP_MSG(CantSetMonitorStackSize, (long int)__kmp_monitor_stksize)__kmp_msg_format(kmp_i18n_msg_CantSetMonitorStackSize, (long int
)__kmp_monitor_stksize),
            err_code, KMP_HNT(ChangeMonitorStackSize)__kmp_msg_format(kmp_i18n_hnt_ChangeMonitorStackSize), __kmp_msg_null);
  if (__kmp_generate_warnings == kmp_warnings_off) {
    __kmp_str_free(&err_code.str);
  }
}
974#endif /* _POSIX_THREAD_ATTR_STACKSIZE */

status =
    pthread_create(&handle, &thread_attr, __kmp_launch_monitor, (void *)th);

if (status != 0) {
980#ifdef _POSIX_THREAD_ATTR_STACKSIZE200809L
  if (status == EINVAL22) {
    if (auto_adj_size && (__kmp_monitor_stksize < (size_t)0x40000000)) {
      __kmp_monitor_stksize *= 2;
      goto retry;
    }
    __kmp_fatal(KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize)__kmp_msg_format(kmp_i18n_msg_CantSetMonitorStackSize, __kmp_monitor_stksize
),
                KMP_ERR(status)__kmp_msg_error_code(status), KMP_HNT(IncreaseMonitorStackSize)__kmp_msg_format(kmp_i18n_hnt_IncreaseMonitorStackSize),
                __kmp_msg_null);
  }
  if (status == ENOMEM12) {
    __kmp_fatal(KMP_MSG(CantSetMonitorStackSize, __kmp_monitor_stksize)__kmp_msg_format(kmp_i18n_msg_CantSetMonitorStackSize, __kmp_monitor_stksize
),
                KMP_ERR(status)__kmp_msg_error_code(status), KMP_HNT(DecreaseMonitorStackSize)__kmp_msg_format(kmp_i18n_hnt_DecreaseMonitorStackSize),
                __kmp_msg_null);
  }
995#endif /* _POSIX_THREAD_ATTR_STACKSIZE */
  if (status == EAGAIN11) {
    __kmp_fatal(KMP_MSG(NoResourcesForMonitorThread)__kmp_msg_format(kmp_i18n_msg_NoResourcesForMonitorThread), KMP_ERR(status)__kmp_msg_error_code(status),
                KMP_HNT(DecreaseNumberOfThreadsInUse)__kmp_msg_format(kmp_i18n_hnt_DecreaseNumberOfThreadsInUse), __kmp_msg_null);
  }
  KMP_SYSFAIL("pthread_create", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_create"
), __kmp_msg_error_code(status), __kmp_msg_null);
}

th->th.th_info.ds.ds_thread = handle;

1005#if KMP_REAL_TIME_FIX
// Wait for the monitor thread is really started and set its *priority*.
KMP_DEBUG_ASSERT(sizeof(kmp_uint32) ==if (!(sizeof(kmp_uint32) == sizeof(__kmp_global.g.g_time.dt.t_value
))) { __kmp_debug_assert("sizeof(kmp_uint32) == sizeof(__kmp_global.g.g_time.dt.t_value)"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1008); }
                 sizeof(__kmp_global.g.g_time.dt.t_value))if (!(sizeof(kmp_uint32) == sizeof(__kmp_global.g.g_time.dt.t_value
))) { __kmp_debug_assert("sizeof(kmp_uint32) == sizeof(__kmp_global.g.g_time.dt.t_value)"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1008); };
__kmp_wait_yield_4((kmp_uint32 volatile *)&__kmp_global.g.g_time.dt.t_value,
                   -1, &__kmp_neq_4, NULL__null);
1011#endif // KMP_REAL_TIME_FIX

1013#ifdef KMP_THREAD_ATTR
status = pthread_attr_destroy(&thread_attr);
if (status != 0) {
  kmp_msg_t err_code = KMP_ERR(status)__kmp_msg_error_code(status);
  __kmp_msg(kmp_ms_warning, KMP_MSG(CantDestroyThreadAttrs)__kmp_msg_format(kmp_i18n_msg_CantDestroyThreadAttrs), err_code,
            __kmp_msg_null);
  if (__kmp_generate_warnings == kmp_warnings_off) {
    __kmp_str_free(&err_code.str);
  }
}
1023#endif

KMP_MB(); /* Flush all pending memory write invalidates.  */

KA_TRACE(10, ("__kmp_create_monitor: monitor created %#.8lx\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: monitor created %#.8lx\n"
, th->th.th_info.ds.ds_thread); }
              th->th.th_info.ds.ds_thread))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_create_monitor: monitor created %#.8lx\n"
, th->th.th_info.ds.ds_thread); };

1030} // __kmp_create_monitor
1031#endif // KMP_USE_MONITOR

1033void __kmp_exit_thread(int exit_status) {
pthread_exit((void *)(intptr_t)exit_status);
1035} // __kmp_exit_thread

1037#if KMP_USE_MONITOR
1038void __kmp_resume_monitor();

1040void __kmp_reap_monitor(kmp_info_t *th) {
int status;
void *exit_val;

KA_TRACE(10, ("__kmp_reap_monitor: try to reap monitor thread with handle"if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: try to reap monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); }
              " %#.8lx\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: try to reap monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); }
              th->th.th_info.ds.ds_thread))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: try to reap monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); };

// If monitor has been created, its tid and gtid should be KMP_GTID_MONITOR.
// If both tid and gtid are 0, it means the monitor did not ever start.
// If both tid and gtid are KMP_GTID_DNE, the monitor has been shut down.
KMP_DEBUG_ASSERT(th->th.th_info.ds.ds_tid == th->th.th_info.ds.ds_gtid)if (!(th->th.th_info.ds.ds_tid == th->th.th_info.ds.ds_gtid
)) { __kmp_debug_assert("th->th.th_info.ds.ds_tid == th->th.th_info.ds.ds_gtid"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1051); };
if (th->th.th_info.ds.ds_gtid != KMP_GTID_MONITOR(-4)) {
  KA_TRACE(10, ("__kmp_reap_monitor: monitor did not start, returning\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: monitor did not start, returning\n"
); };
  return;
}

KMP_MB(); /* Flush all pending memory write invalidates.  */

/* First, check to see whether the monitor thread exists to wake it up. This
   is to avoid performance problem when the monitor sleeps during
   blocktime-size interval */

status = pthread_kill(th->th.th_info.ds.ds_thread, 0);
if (status != ESRCH3) {
  __kmp_resume_monitor(); // Wake up the monitor thread
}
KA_TRACE(10, ("__kmp_reap_monitor: try to join with monitor\n"))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: try to join with monitor\n"
); };
status = pthread_join(th->th.th_info.ds.ds_thread, &exit_val);
if (exit_val != th) {
  __kmp_fatal(KMP_MSG(ReapMonitorError)__kmp_msg_format(kmp_i18n_msg_ReapMonitorError), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}

th->th.th_info.ds.ds_tid = KMP_GTID_DNE(-2);
th->th.th_info.ds.ds_gtid = KMP_GTID_DNE(-2);

KA_TRACE(10, ("__kmp_reap_monitor: done reaping monitor thread with handle"if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: done reaping monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); }
              " %#.8lx\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: done reaping monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); }
              th->th.th_info.ds.ds_thread))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_monitor: done reaping monitor thread with handle"
 " %#.8lx\n", th->th.th_info.ds.ds_thread); };

KMP_MB(); /* Flush all pending memory write invalidates.  */
1081}
1082#endif // KMP_USE_MONITOR

1084void __kmp_reap_worker(kmp_info_t *th) {
int status;
void *exit_val;

KMP_MB(); /* Flush all pending memory write invalidates.  */

KA_TRACE(if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: try to reap T#%d\n"
, th->th.th_info.ds.ds_gtid); }
    10, ("__kmp_reap_worker: try to reap T#%d\n", th->th.th_info.ds.ds_gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: try to reap T#%d\n"
, th->th.th_info.ds.ds_gtid); };

status = pthread_join(th->th.th_info.ds.ds_thread, &exit_val);
1094#ifdef KMP_DEBUG1
/* Don't expose these to the user until we understand when they trigger */
if (status != 0) {
  __kmp_fatal(KMP_MSG(ReapWorkerError)__kmp_msg_format(kmp_i18n_msg_ReapWorkerError), KMP_ERR(status)__kmp_msg_error_code(status), __kmp_msg_null);
}
if (exit_val != th) {
  KA_TRACE(10, ("__kmp_reap_worker: worker T#%d did not reap properly, "if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: worker T#%d did not reap properly, "
 "exit_val = %p\n", th->th.th_info.ds.ds_gtid, exit_val); }
                "exit_val = %p\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: worker T#%d did not reap properly, "
 "exit_val = %p\n", th->th.th_info.ds.ds_gtid, exit_val); }
                th->th.th_info.ds.ds_gtid, exit_val))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: worker T#%d did not reap properly, "
 "exit_val = %p\n", th->th.th_info.ds.ds_gtid, exit_val); };
}
1104#endif /* KMP_DEBUG */

KA_TRACE(10, ("__kmp_reap_worker: done reaping T#%d\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: done reaping T#%d\n"
, th->th.th_info.ds.ds_gtid); }
              th->th.th_info.ds.ds_gtid))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_reap_worker: done reaping T#%d\n"
, th->th.th_info.ds.ds_gtid); };

KMP_MB(); /* Flush all pending memory write invalidates.  */
1110}

1112#if KMP_HANDLE_SIGNALS(1 || 0)

1114static void __kmp_null_handler(int signo) {
//  Do nothing, for doing SIG_IGN-type actions.
1116} // __kmp_null_handler

1118static void __kmp_team_handler(int signo) {
if (__kmp_global.g.g_abort == 0) {
1120/* Stage 1 signal handler, let's shut down all of the threads */
1121#ifdef KMP_DEBUG1
  __kmp_debug_printf("__kmp_team_handler: caught signal = %d\n", signo);
1123#endif
  switch (signo) {
  case SIGHUP1:
  case SIGINT2:
  case SIGQUIT3:
  case SIGILL4:
  case SIGABRT6:
  case SIGFPE8:
  case SIGBUS7:
  case SIGSEGV11:
1133#ifdef SIGSYS31
  case SIGSYS31:
1135#endif
  case SIGTERM15:
    if (__kmp_debug_buf) {
      __kmp_dump_debug_buffer();
    }
    KMP_MB(); // Flush all pending memory write invalidates.
    TCW_4(__kmp_global.g.g_abort, signo)(__kmp_global.g.g_abort) = (signo);
    KMP_MB(); // Flush all pending memory write invalidates.
    TCW_4(__kmp_global.g.g_done, TRUE)(__kmp_global.g.g_done) = ((!0));
    KMP_MB(); // Flush all pending memory write invalidates.
    break;
  default:
1147#ifdef KMP_DEBUG1
    __kmp_debug_printf("__kmp_team_handler: unknown signal type");
1149#endif
    break;
  }
}
1153} // __kmp_team_handler

1155static void __kmp_sigaction(int signum, const struct sigaction *act,
                          struct sigaction *oldact) {
int rc = sigaction(signum, act, oldact);
KMP_CHECK_SYSFAIL_ERRNO("sigaction", rc){ if (rc != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "sigaction"), __kmp_msg_error_code
(error), __kmp_msg_null); } };
1159}

1161static void __kmp_install_one_handler(int sig, sig_func_t handler_func,
                                    int parallel_init) {
KMP_MB(); // Flush all pending memory write invalidates.
KB_TRACE(60,if (kmp_b_debug >= 60) { __kmp_debug_printf ("__kmp_install_one_handler( %d, ..., %d )\n"
, sig, parallel_init); }
         ("__kmp_install_one_handler( %d, ..., %d )\n", sig, parallel_init))if (kmp_b_debug >= 60) { __kmp_debug_printf ("__kmp_install_one_handler( %d, ..., %d )\n"
, sig, parallel_init); };
if (parallel_init) {
  struct sigaction new_action;
  struct sigaction old_action;
  new_action.sa_handler__sigaction_handler.sa_handler = handler_func;
  new_action.sa_flags = 0;
  sigfillset(&new_action.sa_mask);
  __kmp_sigaction(sig, &new_action, &old_action);
  if (old_action.sa_handler__sigaction_handler.sa_handler == __kmp_sighldrs[sig].sa_handler__sigaction_handler.sa_handler) {
    sigaddset(&__kmp_sigset, sig);
  } else {
    // Restore/keep user's handler if one previously installed.
    __kmp_sigaction(sig, &old_action, NULL__null);
  }
} else {
  // Save initial/system signal handlers to see if user handlers installed.
  __kmp_sigaction(sig, NULL__null, &__kmp_sighldrs[sig]);
}
KMP_MB(); // Flush all pending memory write invalidates.
1184} // __kmp_install_one_handler

1186static void __kmp_remove_one_handler(int sig) {
KB_TRACE(60, ("__kmp_remove_one_handler( %d )\n", sig))if (kmp_b_debug >= 60) { __kmp_debug_printf ("__kmp_remove_one_handler( %d )\n"
, sig); };
if (sigismember(&__kmp_sigset, sig)) {
  struct sigaction old;
  KMP_MB(); // Flush all pending memory write invalidates.
  __kmp_sigaction(sig, &__kmp_sighldrs[sig], &old);
  if ((old.sa_handler__sigaction_handler.sa_handler != __kmp_team_handler) &&
      (old.sa_handler__sigaction_handler.sa_handler != __kmp_null_handler)) {
    // Restore the users signal handler.
    KB_TRACE(10, ("__kmp_remove_one_handler: oops, not our handler, "if (kmp_b_debug >= 10) { __kmp_debug_printf ("__kmp_remove_one_handler: oops, not our handler, "
 "restoring: sig=%d\n", sig); }
                  "restoring: sig=%d\n",if (kmp_b_debug >= 10) { __kmp_debug_printf ("__kmp_remove_one_handler: oops, not our handler, "
 "restoring: sig=%d\n", sig); }
                  sig))if (kmp_b_debug >= 10) { __kmp_debug_printf ("__kmp_remove_one_handler: oops, not our handler, "
 "restoring: sig=%d\n", sig); };
    __kmp_sigaction(sig, &old, NULL__null);
  }
  sigdelset(&__kmp_sigset, sig);
  KMP_MB(); // Flush all pending memory write invalidates.
}
1203} // __kmp_remove_one_handler

1205void __kmp_install_signals(int parallel_init) {
KB_TRACE(10, ("__kmp_install_signals( %d )\n", parallel_init))if (kmp_b_debug >= 10) { __kmp_debug_printf ("__kmp_install_signals( %d )\n"
, parallel_init); };
if (__kmp_handle_signals || !parallel_init) {
  // If ! parallel_init, we do not install handlers, just save original
  // handlers. Let us do it even __handle_signals is 0.
  sigemptyset(&__kmp_sigset);
  __kmp_install_one_handler(SIGHUP1, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGINT2, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGQUIT3, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGILL4, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGABRT6, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGFPE8, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGBUS7, __kmp_team_handler, parallel_init);
  __kmp_install_one_handler(SIGSEGV11, __kmp_team_handler, parallel_init);
1219#ifdef SIGSYS31
  __kmp_install_one_handler(SIGSYS31, __kmp_team_handler, parallel_init);
1221#endif // SIGSYS
  __kmp_install_one_handler(SIGTERM15, __kmp_team_handler, parallel_init);
1223#ifdef SIGPIPE13
  __kmp_install_one_handler(SIGPIPE13, __kmp_team_handler, parallel_init);
1225#endif // SIGPIPE
}
1227} // __kmp_install_signals

1229void __kmp_remove_signals(void) {
int sig;
KB_TRACE(10, ("__kmp_remove_signals()\n"))if (kmp_b_debug >= 10) { __kmp_debug_printf ("__kmp_remove_signals()\n"
); };
for (sig = 1; sig < NSIG65; ++sig) {
  __kmp_remove_one_handler(sig);
}
1235} // __kmp_remove_signals

1237#endif // KMP_HANDLE_SIGNALS

1239void __kmp_enable(int new_state) {
1240#ifdef KMP_CANCEL_THREADS
int status, old_state;
status = pthread_setcancelstate(new_state, &old_state);
KMP_CHECK_SYSFAIL("pthread_setcancelstate", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcancelstate"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
KMP_DEBUG_ASSERT(old_state == PTHREAD_CANCEL_DISABLE)if (!(old_state == PTHREAD_CANCEL_DISABLE)) { __kmp_debug_assert
("old_state == PTHREAD_CANCEL_DISABLE", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1244); };
1245#endif
1246}

1248void __kmp_disable(int *old_state) {
1249#ifdef KMP_CANCEL_THREADS
int status;
status = pthread_setcancelstate(PTHREAD_CANCEL_DISABLEPTHREAD_CANCEL_DISABLE, old_state);
KMP_CHECK_SYSFAIL("pthread_setcancelstate", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setcancelstate"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
1253#endif
1254}

1256static void __kmp_atfork_prepare(void) {
__kmp_acquire_bootstrap_lock(&__kmp_initz_lock);
__kmp_acquire_bootstrap_lock(&__kmp_forkjoin_lock);
1259}

1261static void __kmp_atfork_parent(void) {
__kmp_release_bootstrap_lock(&__kmp_initz_lock);
__kmp_release_bootstrap_lock(&__kmp_forkjoin_lock);
1264}

1266/* Reset the library so execution in the child starts "all over again" with
 clean data structures in initial states.  Don't worry about freeing memory
 allocated by parent, just abandon it to be safe. */
1269static void __kmp_atfork_child(void) {
__kmp_release_bootstrap_lock(&__kmp_forkjoin_lock);
/* TODO make sure this is done right for nested/sibling */
// ATT:  Memory leaks are here? TODO: Check it and fix.
/* KMP_ASSERT( 0 ); */

++__kmp_fork_count;

1277#if KMP_AFFINITY_SUPPORTED1
1278#if KMP_OS_LINUX1
// reset the affinity in the child to the initial thread
// affinity in the parent
kmp_set_thread_affinity_mask_initial();
1282#endif
// Set default not to bind threads tightly in the child (we’re expecting
// over-subscription after the fork and this can improve things for
// scripting languages that use OpenMP inside process-parallel code).
__kmp_affinity_type = affinity_none;
1287#if OMP_40_ENABLED(50 >= 40)
if (__kmp_nested_proc_bind.bind_types != NULL__null) {
  __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
}
1291#endif // OMP_40_ENABLED
1292#endif // KMP_AFFINITY_SUPPORTED

__kmp_init_runtime = FALSE0;
1295#if KMP_USE_MONITOR
__kmp_init_monitor = 0;
1297#endif
__kmp_init_parallel = FALSE0;
__kmp_init_middle = FALSE0;
__kmp_init_serial = FALSE0;
TCW_4(__kmp_init_gtid, FALSE)(__kmp_init_gtid) = (0);
__kmp_init_common = FALSE0;

TCW_4(__kmp_init_user_locks, FALSE)(__kmp_init_user_locks) = (0);
1305#if !KMP_USE_DYNAMIC_LOCK1
__kmp_user_lock_table.used = 1;
__kmp_user_lock_table.allocated = 0;
__kmp_user_lock_table.table = NULL__null;
__kmp_lock_blocks = NULL__null;
1310#endif

__kmp_all_nth = 0;
TCW_4(__kmp_nth, 0)(__kmp_nth) = (0);

__kmp_thread_pool = NULL__null;
__kmp_thread_pool_insert_pt = NULL__null;
__kmp_team_pool = NULL__null;

/* Must actually zero all the *cache arguments passed to __kmpc_threadprivate
   here so threadprivate doesn't use stale data */
KA_TRACE(10, ("__kmp_atfork_child: checking cache address list %p\n",if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_atfork_child: checking cache address list %p\n"
, __kmp_threadpriv_cache_list); }
              __kmp_threadpriv_cache_list))if (kmp_a_debug >= 10) { __kmp_debug_printf ("__kmp_atfork_child: checking cache address list %p\n"
, __kmp_threadpriv_cache_list); };

while (__kmp_threadpriv_cache_list != NULL__null) {

  if (*__kmp_threadpriv_cache_list->addr != NULL__null) {
    KC_TRACE(50, ("__kmp_atfork_child: zeroing cache at address %p\n",if (kmp_c_debug >= 50) { __kmp_debug_printf ("__kmp_atfork_child: zeroing cache at address %p\n"
, &(*__kmp_threadpriv_cache_list->addr)); }
                  &(*__kmp_threadpriv_cache_list->addr)))if (kmp_c_debug >= 50) { __kmp_debug_printf ("__kmp_atfork_child: zeroing cache at address %p\n"
, &(*__kmp_threadpriv_cache_list->addr)); };

    *__kmp_threadpriv_cache_list->addr = NULL__null;
  }
  __kmp_threadpriv_cache_list = __kmp_threadpriv_cache_list->next;
}

__kmp_init_runtime = FALSE0;

/* reset statically initialized locks */
__kmp_init_bootstrap_lock(&__kmp_initz_lock);
__kmp_init_bootstrap_lock(&__kmp_stdio_lock);
__kmp_init_bootstrap_lock(&__kmp_console_lock);
__kmp_init_bootstrap_lock(&__kmp_task_team_lock);

1343#if USE_ITT_BUILD1
__kmp_itt_reset(); // reset ITT's global state
1345#endif /* USE_ITT_BUILD */

/* This is necessary to make sure no stale data is left around */
/* AC: customers complain that we use unsafe routines in the atfork
   handler. Mathworks: dlsym() is unsafe. We call dlsym and dlopen
   in dynamic_link when check the presence of shared tbbmalloc library.
   Suggestion is to make the library initialization lazier, similar
   to what done for __kmpc_begin(). */
// TODO: synchronize all static initializations with regular library
//       startup; look at kmp_global.cpp and etc.
//__kmp_internal_begin ();
1356}

1358void __kmp_register_atfork(void) {
if (__kmp_need_register_atfork) {
  int status = pthread_atfork(__kmp_atfork_prepare, __kmp_atfork_parent,
                              __kmp_atfork_child);
  KMP_CHECK_SYSFAIL("pthread_atfork", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_atfork"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  __kmp_need_register_atfork = FALSE0;
}
1365}

1367void __kmp_suspend_initialize(void) {
int status;
status = pthread_mutexattr_init(&__kmp_suspend_mutex_attr);
KMP_CHECK_SYSFAIL("pthread_mutexattr_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutexattr_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_condattr_init(&__kmp_suspend_cond_attr);
KMP_CHECK_SYSFAIL("pthread_condattr_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_condattr_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
1373}

1375static void __kmp_suspend_initialize_thread(kmp_info_t *th) {
ANNOTATE_HAPPENS_AFTER(&th->th.th_suspend_init_count);
if (th->th.th_suspend_init_count <= __kmp_fork_count) {
  /* this means we haven't initialized the suspension pthread objects for this
     thread in this instance of the process */
  int status;
  status = pthread_cond_init(&th->th.th_suspend_cv.c_cond,
                             &__kmp_suspend_cond_attr);
  KMP_CHECK_SYSFAIL("pthread_cond_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_cond_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  status = pthread_mutex_init(&th->th.th_suspend_mx.m_mutex,
                              &__kmp_suspend_mutex_attr);
  KMP_CHECK_SYSFAIL("pthread_mutex_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  *(volatile int *)&th->th.th_suspend_init_count = __kmp_fork_count + 1;
  ANNOTATE_HAPPENS_BEFORE(&th->th.th_suspend_init_count);
}
1390}

1392void __kmp_suspend_uninitialize_thread(kmp_info_t *th) {
if (th->th.th_suspend_init_count > __kmp_fork_count) {
  /* this means we have initialize the suspension pthread objects for this
     thread in this instance of the process */
  int status;

  status = pthread_cond_destroy(&th->th.th_suspend_cv.c_cond);
  if (status != 0 && status != EBUSY16) {
    KMP_SYSFAIL("pthread_cond_destroy", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_cond_destroy"
), __kmp_msg_error_code(status), __kmp_msg_null);
  }
  status = pthread_mutex_destroy(&th->th.th_suspend_mx.m_mutex);
  if (status != 0 && status != EBUSY16) {
    KMP_SYSFAIL("pthread_mutex_destroy", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_mutex_destroy"
), __kmp_msg_error_code(status), __kmp_msg_null);
  }
  --th->th.th_suspend_init_count;
  KMP_DEBUG_ASSERT(th->th.th_suspend_init_count == __kmp_fork_count)if (!(th->th.th_suspend_init_count == __kmp_fork_count)) {
 __kmp_debug_assert("th->th.th_suspend_init_count == __kmp_fork_count"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1407); };
}
1409}

1411/* This routine puts the calling thread to sleep after setting the
 sleep bit for the indicated flag variable to true. */
1413template <class C>
1414static inline void __kmp_suspend_template(int th_gtid, C *flag) {
KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(USER_suspend)((void)0);
kmp_info_t *th = __kmp_threads[th_gtid];
int status;
typename C::flag_t old_spin;

KF_TRACE(30, ("__kmp_suspend_template: T#%d enter for flag = %p\n", th_gtid,if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_suspend_template: T#%d enter for flag = %p\n"
, th_gtid, flag->get()); }
              flag->get()))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_suspend_template: T#%d enter for flag = %p\n"
, th_gtid, flag->get()); };

__kmp_suspend_initialize_thread(th);

status = pthread_mutex_lock(&th->th.th_suspend_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_lock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_lock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };

KF_TRACE(10, ("__kmp_suspend_template: T#%d setting sleep bit for spin(%p)\n",if (kmp_f_debug >= 10) { __kmp_debug_printf ("__kmp_suspend_template: T#%d setting sleep bit for spin(%p)\n"
, th_gtid, flag->get()); }
              th_gtid, flag->get()))if (kmp_f_debug >= 10) { __kmp_debug_printf ("__kmp_suspend_template: T#%d setting sleep bit for spin(%p)\n"
, th_gtid, flag->get()); };

/* TODO: shouldn't this use release semantics to ensure that
   __kmp_suspend_initialize_thread gets called first? */
old_spin = flag->set_sleeping();

KF_TRACE(5, ("__kmp_suspend_template: T#%d set sleep bit for spin(%p)==%x,"if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d set sleep bit for spin(%p)==%x,"
 " was %x\n", th_gtid, flag->get(), flag->load(), old_spin
); }
             " was %x\n",if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d set sleep bit for spin(%p)==%x,"
 " was %x\n", th_gtid, flag->get(), flag->load(), old_spin
); }
             th_gtid, flag->get(), flag->load(), old_spin))if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d set sleep bit for spin(%p)==%x,"
 " was %x\n", th_gtid, flag->get(), flag->load(), old_spin
); };

if (flag->done_check_val(old_spin)) {
  old_spin = flag->unset_sleeping();
  KF_TRACE(5, ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "
 "for spin(%p)\n", th_gtid, flag->get()); }
               "for spin(%p)\n",if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "
 "for spin(%p)\n", th_gtid, flag->get()); }
               th_gtid, flag->get()))if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "
 "for spin(%p)\n", th_gtid, flag->get()); };
} else {
  /* Encapsulate in a loop as the documentation states that this may
     "with low probability" return when the condition variable has
     not been signaled or broadcast */
  int deactivated = FALSE0;
  TCW_PTR(th->th.th_sleep_loc, (void *)flag)((th->th.th_sleep_loc)) = (((void *)flag));

  while (flag->is_sleeping()) {
1452#ifdef DEBUG_SUSPEND
    char buffer[128];
    __kmp_suspend_count++;
    __kmp_print_cond(buffer, &th->th.th_suspend_cv);
    __kmp_printf("__kmp_suspend_template: suspending T#%d: %s\n", th_gtid,
                 buffer);
1458#endif
    // Mark the thread as no longer active (only in the first iteration of the
    // loop).
    if (!deactivated) {
      th->th.th_active = FALSE0;
      if (th->th.th_active_in_pool) {
        th->th.th_active_in_pool = FALSE0;
        KMP_ATOMIC_DEC(&__kmp_thread_pool_active_nth)(&__kmp_thread_pool_active_nth)->fetch_sub(1, std::memory_order_acq_rel
);
        KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0)if (!((__kmp_thread_pool_active_nth) >= 0)) { __kmp_debug_assert
("(__kmp_thread_pool_active_nth) >= 0", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1466); };
      }
      deactivated = TRUE(!0);
    }

1471#if USE_SUSPEND_TIMEOUT
    struct timespec now;
    struct timeval tval;
    int msecs;

    status = gettimeofday(&tval, NULL__null);
    KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "gettimeofday")
, __kmp_msg_error_code(error), __kmp_msg_null); } };
    TIMEVAL_TO_TIMESPEC(&tval, &now){ (&now)->tv_sec = (&tval)->tv_sec; (&now)->
tv_nsec = (&tval)->tv_usec * 1000; };

    msecs = (4 * __kmp_dflt_blocktime) + 200;
    now.tv_sec += msecs / 1000;
    now.tv_nsec += (msecs % 1000) * 1000;

    KF_TRACE(15, ("__kmp_suspend_template: T#%d about to perform "if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform "
 "pthread_cond_timedwait\n", th_gtid); }
                  "pthread_cond_timedwait\n",if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform "
 "pthread_cond_timedwait\n", th_gtid); }
                  th_gtid))if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform "
 "pthread_cond_timedwait\n", th_gtid); };
    status = pthread_cond_timedwait(&th->th.th_suspend_cv.c_cond,
                                    &th->th.th_suspend_mx.m_mutex, &now);
1489#else
    KF_TRACE(15, ("__kmp_suspend_template: T#%d about to perform"if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform"
 " pthread_cond_wait\n", th_gtid); }
                  " pthread_cond_wait\n",if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform"
 " pthread_cond_wait\n", th_gtid); }
                  th_gtid))if (kmp_f_debug >= 15) { __kmp_debug_printf ("__kmp_suspend_template: T#%d about to perform"
 " pthread_cond_wait\n", th_gtid); };
    status = pthread_cond_wait(&th->th.th_suspend_cv.c_cond,
                               &th->th.th_suspend_mx.m_mutex);
1495#endif

    if ((status != 0) && (status != EINTR4) && (status != ETIMEDOUT110)) {
      KMP_SYSFAIL("pthread_cond_wait", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_cond_wait"
), __kmp_msg_error_code(status), __kmp_msg_null);
    }
1500#ifdef KMP_DEBUG1
    if (status == ETIMEDOUT110) {
      if (flag->is_sleeping()) {
        KF_TRACE(100,if (kmp_f_debug >= 100) { __kmp_debug_printf ("__kmp_suspend_template: T#%d timeout wakeup\n"
, th_gtid); }
                 ("__kmp_suspend_template: T#%d timeout wakeup\n", th_gtid))if (kmp_f_debug >= 100) { __kmp_debug_printf ("__kmp_suspend_template: T#%d timeout wakeup\n"
, th_gtid); };
      } else {
        KF_TRACE(2, ("__kmp_suspend_template: T#%d timeout wakeup, sleep bit "if (kmp_f_debug >= 2) { __kmp_debug_printf ("__kmp_suspend_template: T#%d timeout wakeup, sleep bit "
 "not set!\n", th_gtid); }
                     "not set!\n",if (kmp_f_debug >= 2) { __kmp_debug_printf ("__kmp_suspend_template: T#%d timeout wakeup, sleep bit "
 "not set!\n", th_gtid); }
                     th_gtid))if (kmp_f_debug >= 2) { __kmp_debug_printf ("__kmp_suspend_template: T#%d timeout wakeup, sleep bit "
 "not set!\n", th_gtid); };
      }
    } else if (flag->is_sleeping()) {
      KF_TRACE(100,if (kmp_f_debug >= 100) { __kmp_debug_printf ("__kmp_suspend_template: T#%d spurious wakeup\n"
, th_gtid); }
               ("__kmp_suspend_template: T#%d spurious wakeup\n", th_gtid))if (kmp_f_debug >= 100) { __kmp_debug_printf ("__kmp_suspend_template: T#%d spurious wakeup\n"
, th_gtid); };
    }
1514#endif
  } // while

  // Mark the thread as active again (if it was previous marked as inactive)
  if (deactivated) {
    th->th.th_active = TRUE(!0);
    if (TCR_4(th->th.th_in_pool)(th->th.th_in_pool)) {
      KMP_ATOMIC_INC(&__kmp_thread_pool_active_nth)(&__kmp_thread_pool_active_nth)->fetch_add(1, std::memory_order_acq_rel
);
      th->th.th_active_in_pool = TRUE(!0);
    }
  }
}
1526#ifdef DEBUG_SUSPEND
{
  char buffer[128];
  __kmp_print_cond(buffer, &th->th.th_suspend_cv);
  __kmp_printf("__kmp_suspend_template: T#%d has awakened: %s\n", th_gtid,
               buffer);
}
1533#endif

status = pthread_mutex_unlock(&th->th.th_suspend_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
KF_TRACE(30, ("__kmp_suspend_template: T#%d exit\n", th_gtid))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_suspend_template: T#%d exit\n"
, th_gtid); };
1538}

1540void __kmp_suspend_32(int th_gtid, kmp_flag_32 *flag) {
__kmp_suspend_template(th_gtid, flag);
1542}
1543void __kmp_suspend_64(int th_gtid, kmp_flag_64 *flag) {
__kmp_suspend_template(th_gtid, flag);
1545}
1546void __kmp_suspend_oncore(int th_gtid, kmp_flag_oncore *flag) {
__kmp_suspend_template(th_gtid, flag);
1548}

1550/* This routine signals the thread specified by target_gtid to wake up
 after setting the sleep bit indicated by the flag argument to FALSE.
 The target thread must already have called __kmp_suspend_template() */
1553template <class C>
1554static inline void __kmp_resume_template(int target_gtid, C *flag) {
KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(USER_resume)((void)0);
kmp_info_t *th = __kmp_threads[target_gtid];
int status;

1559#ifdef KMP_DEBUG1
int gtid = TCR_4(__kmp_init_gtid)(__kmp_init_gtid) ? __kmp_get_gtid()__kmp_get_global_thread_id() : -1;
1561#endif

KF_TRACE(30, ("__kmp_resume_template: T#%d wants to wakeup T#%d enter\n",if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_template: T#%d wants to wakeup T#%d enter\n"
, gtid, target_gtid); }
              gtid, target_gtid))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_template: T#%d wants to wakeup T#%d enter\n"
, gtid, target_gtid); };
KMP_DEBUG_ASSERT(gtid != target_gtid)if (!(gtid != target_gtid)) { __kmp_debug_assert("gtid != target_gtid"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1565); };

__kmp_suspend_initialize_thread(th);

status = pthread_mutex_lock(&th->th.th_suspend_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_lock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_lock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };

if (!flag) { // coming from __kmp_null_resume_wrapper
  flag = (C *)CCAST(void *, th->th.th_sleep_loc)const_cast<void *>(th->th.th_sleep_loc);
}

// First, check if the flag is null or its type has changed. If so, someone
// else woke it up.
if (!flag || flag->get_type() != flag->get_ptr_type()) { // get_ptr_type
  // simply shows what
  // flag was cast to
  KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p)\n", gtid, target_gtid, __null); }
               "awake: flag(%p)\n",if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p)\n", gtid, target_gtid, __null); }
               gtid, target_gtid, NULL))if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p)\n", gtid, target_gtid, __null); };
  status = pthread_mutex_unlock(&th->th.th_suspend_mx.m_mutex);
  KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
  return;
} else { // if multiple threads are sleeping, flag should be internally
  // referring to a specific thread here
  typename C::flag_t old_spin = flag->unset_sleeping();
  if (!flag->is_sleeping_val(old_spin)) {
    KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p): " "%u => %u\n", gtid, target_gtid, flag
->get(), old_spin, flag->load()); }
                 "awake: flag(%p): "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p): " "%u => %u\n", gtid, target_gtid, flag
->get(), old_spin, flag->load()); }
                 "%u => %u\n",if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p): " "%u => %u\n", gtid, target_gtid, flag
->get(), old_spin, flag->load()); }
                 gtid, target_gtid, flag->get(), old_spin, flag->load()))if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting, thread T#%d already "
 "awake: flag(%p): " "%u => %u\n", gtid, target_gtid, flag
->get(), old_spin, flag->load()); };
    status = pthread_mutex_unlock(&th->th.th_suspend_mx.m_mutex);
    KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
    return;
  }
  KF_TRACE(5, ("__kmp_resume_template: T#%d about to wakeup T#%d, reset "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d about to wakeup T#%d, reset "
 "sleep bit for flag's loc(%p): " "%u => %u\n", gtid, target_gtid
, flag->get(), old_spin, flag->load()); }
               "sleep bit for flag's loc(%p): "if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d about to wakeup T#%d, reset "
 "sleep bit for flag's loc(%p): " "%u => %u\n", gtid, target_gtid
, flag->get(), old_spin, flag->load()); }
               "%u => %u\n",if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d about to wakeup T#%d, reset "
 "sleep bit for flag's loc(%p): " "%u => %u\n", gtid, target_gtid
, flag->get(), old_spin, flag->load()); }
               gtid, target_gtid, flag->get(), old_spin, flag->load()))if (kmp_f_debug >= 5) { __kmp_debug_printf ("__kmp_resume_template: T#%d about to wakeup T#%d, reset "
 "sleep bit for flag's loc(%p): " "%u => %u\n", gtid, target_gtid
, flag->get(), old_spin, flag->load()); };
}
TCW_PTR(th->th.th_sleep_loc, NULL)((th->th.th_sleep_loc)) = ((__null));

1606#ifdef DEBUG_SUSPEND
{
  char buffer[128];
  __kmp_print_cond(buffer, &th->th.th_suspend_cv);
  __kmp_printf("__kmp_resume_template: T#%d resuming T#%d: %s\n", gtid,
               target_gtid, buffer);
}
1613#endif
status = pthread_cond_signal(&th->th.th_suspend_cv.c_cond);
KMP_CHECK_SYSFAIL("pthread_cond_signal", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_cond_signal"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_mutex_unlock(&th->th.th_suspend_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
KF_TRACE(30, ("__kmp_resume_template: T#%d exiting after signaling wake up"if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, target_gtid); }
              " for T#%d\n",if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, target_gtid); }
              gtid, target_gtid))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_template: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, target_gtid); };
1621}

1623void __kmp_resume_32(int target_gtid, kmp_flag_32 *flag) {
__kmp_resume_template(target_gtid, flag);
1625}
1626void __kmp_resume_64(int target_gtid, kmp_flag_64 *flag) {
__kmp_resume_template(target_gtid, flag);
1628}
1629void __kmp_resume_oncore(int target_gtid, kmp_flag_oncore *flag) {
__kmp_resume_template(target_gtid, flag);
1631}

1633#if KMP_USE_MONITOR
1634void __kmp_resume_monitor() {
KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(USER_resume)((void)0);
int status;
1637#ifdef KMP_DEBUG1
int gtid = TCR_4(__kmp_init_gtid)(__kmp_init_gtid) ? __kmp_get_gtid()__kmp_get_global_thread_id() : -1;
KF_TRACE(30, ("__kmp_resume_monitor: T#%d wants to wakeup T#%d enter\n", gtid,if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_monitor: T#%d wants to wakeup T#%d enter\n"
, gtid, (-4)); }
              KMP_GTID_MONITOR))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_monitor: T#%d wants to wakeup T#%d enter\n"
, gtid, (-4)); };
KMP_DEBUG_ASSERT(gtid != KMP_GTID_MONITOR)if (!(gtid != (-4))) { __kmp_debug_assert("gtid != (-4)", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1641); };
1642#endif
status = pthread_mutex_lock(&__kmp_wait_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_lock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_lock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
1645#ifdef DEBUG_SUSPEND
{
  char buffer[128];
  __kmp_print_cond(buffer, &__kmp_wait_cv.c_cond);
  __kmp_printf("__kmp_resume_monitor: T#%d resuming T#%d: %s\n", gtid,
               KMP_GTID_MONITOR(-4), buffer);
}
1652#endif
status = pthread_cond_signal(&__kmp_wait_cv.c_cond);
KMP_CHECK_SYSFAIL("pthread_cond_signal", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_cond_signal"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_mutex_unlock(&__kmp_wait_mx.m_mutex);
KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_unlock"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
KF_TRACE(30, ("__kmp_resume_monitor: T#%d exiting after signaling wake up"if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_monitor: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, (-4)); }
              " for T#%d\n",if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_monitor: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, (-4)); }
              gtid, KMP_GTID_MONITOR))if (kmp_f_debug >= 30) { __kmp_debug_printf ("__kmp_resume_monitor: T#%d exiting after signaling wake up"
 " for T#%d\n", gtid, (-4)); };
1660}
1661#endif // KMP_USE_MONITOR

1663void __kmp_yield(int cond) {
if (!cond)
  return;
1666#if KMP_USE_MONITOR
if (!__kmp_yielding_on)
  return;
1669#else
if (__kmp_yield_cycle && !KMP_YIELD_NOW()((__kmp_hardware_timestamp() / __kmp_ticks_per_msec) / ((__kmp_dflt_blocktime
) > (1) ? (__kmp_dflt_blocktime) : (1)) % (__kmp_yield_on_count
 + __kmp_yield_off_count) < (kmp_uint32)__kmp_yield_on_count
))
  return;
1672#endif
sched_yield();
1674}

1676void __kmp_gtid_set_specific(int gtid) {
if (__kmp_init_gtid) {
  int status;
  status = pthread_setspecific(__kmp_gtid_threadprivate_key,
                               (void *)(intptr_t)(gtid + 1));
  KMP_CHECK_SYSFAIL("pthread_setspecific", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_setspecific"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
} else {
  KA_TRACE(50, ("__kmp_gtid_set_specific: runtime shutdown, returning\n"))if (kmp_a_debug >= 50) { __kmp_debug_printf ("__kmp_gtid_set_specific: runtime shutdown, returning\n"
); };
}
1685}

1687int __kmp_gtid_get_specific() {
int gtid;
if (!__kmp_init_gtid) {
  KA_TRACE(50, ("__kmp_gtid_get_specific: runtime shutdown, returning "if (kmp_a_debug >= 50) { __kmp_debug_printf ("__kmp_gtid_get_specific: runtime shutdown, returning "
 "KMP_GTID_SHUTDOWN\n"); }
                "KMP_GTID_SHUTDOWN\n"))if (kmp_a_debug >= 50) { __kmp_debug_printf ("__kmp_gtid_get_specific: runtime shutdown, returning "
 "KMP_GTID_SHUTDOWN\n"); };
  return KMP_GTID_SHUTDOWN(-3);
}
gtid = (int)(size_t)pthread_getspecific(__kmp_gtid_threadprivate_key);
if (gtid == 0) {
  gtid = KMP_GTID_DNE(-2);
} else {
  gtid--;
}
KA_TRACE(50, ("__kmp_gtid_get_specific: key:%d gtid:%d\n",if (kmp_a_debug >= 50) { __kmp_debug_printf ("__kmp_gtid_get_specific: key:%d gtid:%d\n"
, __kmp_gtid_threadprivate_key, gtid); }
              __kmp_gtid_threadprivate_key, gtid))if (kmp_a_debug >= 50) { __kmp_debug_printf ("__kmp_gtid_get_specific: key:%d gtid:%d\n"
, __kmp_gtid_threadprivate_key, gtid); };
return gtid;
1703}

1705double __kmp_read_cpu_time(void) {
/*clock_t   t;*/
struct tms buffer;

/*t =*/times(&buffer);

return (buffer.tms_utime + buffer.tms_cutime) / (double)CLOCKS_PER_SEC((clock_t) 1000000);
1712}

1714int __kmp_read_system_info(struct kmp_sys_info *info) {
int status;
struct rusage r_usage;

memset(info, 0, sizeof(*info));

status = getrusage(RUSAGE_SELFRUSAGE_SELF, &r_usage);
KMP_CHECK_SYSFAIL_ERRNO("getrusage", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "getrusage"), __kmp_msg_error_code
(error), __kmp_msg_null); } };

// The maximum resident set size utilized (in kilobytes)
info->maxrss = r_usage.ru_maxrss;
// The number of page faults serviced without any I/O
info->minflt = r_usage.ru_minflt;
// The number of page faults serviced that required I/O
info->majflt = r_usage.ru_majflt;
// The number of times a process was "swapped" out of memory
info->nswap = r_usage.ru_nswap;
// The number of times the file system had to perform input
info->inblock = r_usage.ru_inblock;
// The number of times the file system had to perform output
info->oublock = r_usage.ru_oublock;
// The number of times a context switch was voluntarily
info->nvcsw = r_usage.ru_nvcsw;
// The number of times a context switch was forced
info->nivcsw = r_usage.ru_nivcsw;

return (status != 0);
1741}

1743void __kmp_read_system_time(double *delta) {
double t_ns;
struct timeval tval;
struct timespec stop;
int status;

status = gettimeofday(&tval, NULL__null);
KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "gettimeofday")
, __kmp_msg_error_code(error), __kmp_msg_null); } };
TIMEVAL_TO_TIMESPEC(&tval, &stop){ (&stop)->tv_sec = (&tval)->tv_sec; (&stop
)->tv_nsec = (&tval)->tv_usec * 1000; };
t_ns = TS2NS(stop)(((stop).tv_sec * 1e9) + (stop).tv_nsec) - TS2NS(__kmp_sys_timer_data.start)(((__kmp_sys_timer_data.start).tv_sec * 1e9) + (__kmp_sys_timer_data
.start).tv_nsec);
*delta = (t_ns * 1e-9);
1754}

1756void __kmp_clear_system_time(void) {
struct timeval tval;
int status;
status = gettimeofday(&tval, NULL__null);
KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "gettimeofday")
, __kmp_msg_error_code(error), __kmp_msg_null); } };
TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start){ (&__kmp_sys_timer_data.start)->tv_sec = (&tval)->
tv_sec; (&__kmp_sys_timer_data.start)->tv_nsec = (&
tval)->tv_usec * 1000; };
1762}

1764static int __kmp_get_xproc(void) {

int r = 0;

1768#if KMP_OS_LINUX1 || KMP_OS_FREEBSD0 || KMP_OS_NETBSD0

r = sysconf(_SC_NPROCESSORS_ONLN_SC_NPROCESSORS_ONLN);

1772#elif KMP_OS_DARWIN0

// Bug C77011 High "OpenMP Threads and number of active cores".

// Find the number of available CPUs.
kern_return_t rc;
host_basic_info_data_t info;
mach_msg_type_number_t num = HOST_BASIC_INFO_COUNT;
rc = host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&info, &num);
if (rc == 0 && num == HOST_BASIC_INFO_COUNT) {
  // Cannot use KA_TRACE() here because this code works before trace support
  // is initialized.
  r = info.avail_cpus;
} else {
  KMP_WARNING(CantGetNumAvailCPU)__kmp_msg(kmp_ms_warning, __kmp_msg_format(kmp_i18n_msg_CantGetNumAvailCPU
), __kmp_msg_null);
  KMP_INFORM(AssumedNumCPU)__kmp_msg(kmp_ms_inform, __kmp_msg_format(kmp_i18n_msg_AssumedNumCPU
), __kmp_msg_null);
}

1790#else

1792#error "Unknown or unsupported OS."

1794#endif

return r > 0 ? r : 2; /* guess value of 2 if OS told us 0 */

1798} // __kmp_get_xproc

1800int __kmp_read_from_file(char const *path, char const *format, ...) {
int result;
va_list args;

va_start(args, format)__builtin_va_start(args, format);
FILE *f = fopen(path, "rb");
if (f == NULL__null)
  return 0;
result = vfscanf(f, format, args);
fclose(f);

return result;
1812}

1814void __kmp_runtime_initialize(void) {
int status;
pthread_mutexattr_t mutex_attr;
pthread_condattr_t cond_attr;

if (__kmp_init_runtime) {
  return;
}

1823#if (KMP_ARCH_X860 || KMP_ARCH_X86_641)
if (!__kmp_cpuinfo.initialized) {
  __kmp_query_cpuid(&__kmp_cpuinfo);
}
1827#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */

__kmp_xproc = __kmp_get_xproc();

if (sysconf(_SC_THREADS_SC_THREADS)) {

  /* Query the maximum number of threads */
  __kmp_sys_max_nth = sysconf(_SC_THREAD_THREADS_MAX_SC_THREAD_THREADS_MAX);
  if (__kmp_sys_max_nth == -1) {
    /* Unlimited threads for NPTL */
    __kmp_sys_max_nth = INT_MAX2147483647;
  } else if (__kmp_sys_max_nth <= 1) {
    /* Can't tell, just use PTHREAD_THREADS_MAX */
    __kmp_sys_max_nth = KMP_MAX_NTH2147483647;
  }

  /* Query the minimum stack size */
  __kmp_sys_min_stksize = sysconf(_SC_THREAD_STACK_MIN_SC_THREAD_STACK_MIN);
  if (__kmp_sys_min_stksize <= 1) {
    __kmp_sys_min_stksize = KMP_MIN_STKSIZE16384;
  }
}

/* Set up minimum number of threads to switch to TLS gtid */
__kmp_tls_gtid_min = KMP_TLS_GTID_MIN5;

status = pthread_key_create(&__kmp_gtid_threadprivate_key,
                            __kmp_internal_end_dest);
KMP_CHECK_SYSFAIL("pthread_key_create", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_key_create"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_mutexattr_init(&mutex_attr);
KMP_CHECK_SYSFAIL("pthread_mutexattr_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutexattr_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_mutex_init(&__kmp_wait_mx.m_mutex, &mutex_attr);
KMP_CHECK_SYSFAIL("pthread_mutex_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_mutex_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_condattr_init(&cond_attr);
KMP_CHECK_SYSFAIL("pthread_condattr_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_condattr_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
status = pthread_cond_init(&__kmp_wait_cv.c_cond, &cond_attr);
KMP_CHECK_SYSFAIL("pthread_cond_init", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_cond_init"), __kmp_msg_error_code(status), __kmp_msg_null
); } };
1864#if USE_ITT_BUILD1
__kmp_itt_initialize();
1866#endif /* USE_ITT_BUILD */

__kmp_init_runtime = TRUE(!0);
1869}

1871void __kmp_runtime_destroy(void) {
int status;

if (!__kmp_init_runtime) {
  return; // Nothing to do.
}

1878#if USE_ITT_BUILD1
__kmp_itt_destroy();
1880#endif /* USE_ITT_BUILD */

status = pthread_key_delete(__kmp_gtid_threadprivate_key);
KMP_CHECK_SYSFAIL("pthread_key_delete", status){ if (status) { __kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError
, "pthread_key_delete"), __kmp_msg_error_code(status), __kmp_msg_null
); } };

status = pthread_mutex_destroy(&__kmp_wait_mx.m_mutex);
if (status != 0 && status != EBUSY16) {
  KMP_SYSFAIL("pthread_mutex_destroy", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_mutex_destroy"
), __kmp_msg_error_code(status), __kmp_msg_null);
}
status = pthread_cond_destroy(&__kmp_wait_cv.c_cond);
if (status != 0 && status != EBUSY16) {
  KMP_SYSFAIL("pthread_cond_destroy", status)__kmp_fatal(__kmp_msg_format(kmp_i18n_msg_FunctionError, "pthread_cond_destroy"
), __kmp_msg_error_code(status), __kmp_msg_null);
}
1893#if KMP_AFFINITY_SUPPORTED1
__kmp_affinity_uninitialize();
1895#endif

__kmp_init_runtime = FALSE0;
1898}

1900/* Put the thread to sleep for a time period */
1901/* NOTE: not currently used anywhere */
1902void __kmp_thread_sleep(int millis) { sleep((millis + 500) / 1000); }

1904/* Calculate the elapsed wall clock time for the user */
1905void __kmp_elapsed(double *t) {
int status;
1907#ifdef FIX_SGI_CLOCK
struct timespec ts;

status = clock_gettime(CLOCK_PROCESS_CPUTIME_ID2, &ts);
KMP_CHECK_SYSFAIL_ERRNO("clock_gettime", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "clock_gettime"
), __kmp_msg_error_code(error), __kmp_msg_null); } };
*t =
    (double)ts.tv_nsec * (1.0 / (double)KMP_NSEC_PER_SEC1000000000L) + (double)ts.tv_sec;
1914#else
struct timeval tv;

status = gettimeofday(&tv, NULL__null);
KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status){ if (status != 0) { int error = (*__errno_location ()); __kmp_fatal
(__kmp_msg_format(kmp_i18n_msg_FunctionError, "gettimeofday")
, __kmp_msg_error_code(error), __kmp_msg_null); } };
*t =
    (double)tv.tv_usec * (1.0 / (double)KMP_USEC_PER_SEC1000000L) + (double)tv.tv_sec;
1921#endif
1922}

1924/* Calculate the elapsed wall clock tick for the user */
1925void __kmp_elapsed_tick(double *t) { *t = 1 / (double)CLOCKS_PER_SEC((clock_t) 1000000); }

1927/* Return the current time stamp in nsec */
1928kmp_uint64 __kmp_now_nsec() {
struct timeval t;
gettimeofday(&t, NULL__null);
return KMP_NSEC_PER_SEC1000000000L * t.tv_sec + 1000 * t.tv_usec;
1932}

1934#if KMP_ARCH_X860 || KMP_ARCH_X86_641
1935/* Measure clock ticks per millisecond */
1936void __kmp_initialize_system_tick() {
kmp_uint64 delay = 100000; // 50~100 usec on most machines.
kmp_uint64 nsec = __kmp_now_nsec();
kmp_uint64 goal = __kmp_hardware_timestamp() + delay;
kmp_uint64 now;
while ((now = __kmp_hardware_timestamp()) < goal)
  ;
__kmp_ticks_per_msec =
    (kmp_uint64)(1e6 * (delay + (now - goal)) / (__kmp_now_nsec() - nsec));
1945}
1946#endif

1948/* Determine whether the given address is mapped into the current address
 space. */

1951int __kmp_is_address_mapped(void *addr) {

int found = 0;
int rc;

1956#if KMP_OS_LINUX1 || KMP_OS_FREEBSD0

/* On Linux* OS, read the /proc/<pid>/maps pseudo-file to get all the address
   ranges mapped into the address space. */

char *name = __kmp_str_format("/proc/%d/maps", getpid());
FILE *file = NULL__null;

file = fopen(name, "r");
KMP_ASSERT(file != NULL)if (!(file != __null)) { __kmp_debug_assert("file != NULL", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1965); };

for (;;) {

  void *beginning = NULL__null;
  void *ending = NULL__null;
  char perms[5];

  rc = fscanf(file, "%p-%p %4s %*[^\n]\n", &beginning, &ending, perms);
  if (rc == EOF(-1)) {
    break;
  }
  KMP_ASSERT(rc == 3 &&if (!(rc == 3 && strlen(perms) == 4)) { __kmp_debug_assert
("rc == 3 && KMP_STRLEN(perms) == 4", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1978); }
             KMP_STRLEN(perms) == 4)if (!(rc == 3 && strlen(perms) == 4)) { __kmp_debug_assert
("rc == 3 && KMP_STRLEN(perms) == 4", "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 1978); }; // Make sure all fields are read.

  // Ending address is not included in the region, but beginning is.
  if ((addr >= beginning) && (addr < ending)) {
    perms[2] = 0; // 3th and 4th character does not matter.
    if (strcmp(perms, "rw") == 0) {
      // Memory we are looking for should be readable and writable.
      found = 1;
    }
    break;
  }
}

// Free resources.
fclose(file);
KMP_INTERNAL_FREE(name)free(name);

1995#elif KMP_OS_DARWIN0

/* On OS X*, /proc pseudo filesystem is not available. Try to read memory
   using vm interface. */

int buffer;
vm_size_t count;
rc = vm_read_overwrite(
    mach_task_self(), // Task to read memory of.
    (vm_address_t)(addr), // Address to read from.
    1, // Number of bytes to be read.
    (vm_address_t)(&buffer), // Address of buffer to save read bytes in.
    &count // Address of var to save number of read bytes in.
    );
if (rc == 0) {
  // Memory successfully read.
  found = 1;
}

2014#elif KMP_OS_FREEBSD0 || KMP_OS_NETBSD0

// FIXME(FreeBSD, NetBSD): Implement this
found = 1;

2019#else

2021#error "Unknown or unsupported OS"

2023#endif

return found;

2027} // __kmp_is_address_mapped

2029#ifdef USE_LOAD_BALANCE1

2031#if KMP_OS_DARWIN0

2033// The function returns the rounded value of the system load average
2034// during given time interval which depends on the value of
2035// __kmp_load_balance_interval variable (default is 60 sec, other values
2036// may be 300 sec or 900 sec).
2037// It returns -1 in case of error.
2038int __kmp_get_load_balance(int max) {
double averages[3];
int ret_avg = 0;

int res = getloadavg(averages, 3);

// Check __kmp_load_balance_interval to determine which of averages to use.
// getloadavg() may return the number of samples less than requested that is
// less than 3.
if (__kmp_load_balance_interval < 180 && (res >= 1)) {
  ret_avg = averages[0]; // 1 min
} else if ((__kmp_load_balance_interval >= 180 &&
            __kmp_load_balance_interval < 600) &&
           (res >= 2)) {
  ret_avg = averages[1]; // 5 min
} else if ((__kmp_load_balance_interval >= 600) && (res == 3)) {
  ret_avg = averages[2]; // 15 min
} else { // Error occurred
  return -1;
}

return ret_avg;
2060}

2062#else // Linux* OS

2064// The fuction returns number of running (not sleeping) threads, or -1 in case
2065// of error. Error could be reported if Linux* OS kernel too old (without
2066// "/proc" support). Counting running threads stops if max running threads
2067// encountered.
2068int __kmp_get_load_balance(int max) {
static int permanent_error = 0;
static int glb_running_threads = 0; // Saved count of the running threads for
// the thread balance algortihm
static double glb_call_time = 0; /* Thread balance algorithm call time */

int running_threads = 0; // Number of running threads in the system.

DIR *proc_dir = NULL__null; // Handle of "/proc/" directory.
struct dirent *proc_entry = NULL__null;

kmp_str_buf_t task_path; // "/proc/<pid>/task/<tid>/" path.
DIR *task_dir = NULL__null; // Handle of "/proc/<pid>/task/<tid>/" directory.
struct dirent *task_entry = NULL__null;
int task_path_fixed_len;

kmp_str_buf_t stat_path; // "/proc/<pid>/task/<tid>/stat" path.
int stat_file = -1;
int stat_path_fixed_len;

int total_processes = 0; // Total number of processes in system.
int total_threads = 0; // Total number of threads in system.

double call_time = 0.0;

__kmp_str_buf_init(&task_path){ (&task_path)->str = (&task_path)->bulk; (&
task_path)->size = sizeof((&task_path)->bulk); (&
task_path)->used = 0; (&task_path)->bulk[0] = 0; };
__kmp_str_buf_init(&stat_path){ (&stat_path)->str = (&stat_path)->bulk; (&
stat_path)->size = sizeof((&stat_path)->bulk); (&
stat_path)->used = 0; (&stat_path)->bulk[0] = 0; };

__kmp_elapsed(&call_time);

if (glb_call_time &&
    (call_time - glb_call_time < __kmp_load_balance_interval)) {
  running_threads = glb_running_threads;
  goto finish;
}

glb_call_time = call_time;

// Do not spend time on scanning "/proc/" if we have a permanent error.
if (permanent_error) {
  running_threads = -1;
  goto finish;
}

if (max <= 0) {
  max = INT_MAX2147483647;
}

// Open "/proc/" directory.
proc_dir = opendir("/proc");
if (proc_dir == NULL__null) {
  // Cannot open "/prroc/". Probably the kernel does not support it. Return an
  // error now and in subsequent calls.
  running_threads = -1;
  permanent_error = 1;
  goto finish;
}

// Initialize fixed part of task_path. This part will not change.
__kmp_str_buf_cat(&task_path, "/proc/", 6);
task_path_fixed_len = task_path.used; // Remember number of used characters.

proc_entry = readdir(proc_dir);
while (proc_entry != NULL__null) {
  // Proc entry is a directory and name starts with a digit. Assume it is a
  // process' directory.
  if (proc_entry->d_type == DT_DIRDT_DIR && isdigit(proc_entry->d_name[0])) {

    ++total_processes;
    // Make sure init process is the very first in "/proc", so we can replace
    // strcmp( proc_entry->d_name, "1" ) == 0 with simpler total_processes ==
    // 1. We are going to check that total_processes == 1 => d_name == "1" is
    // true (where "=>" is implication). Since C++ does not have => operator,
    // let us replace it with its equivalent: a => b == ! a || b.
    KMP_DEBUG_ASSERT(total_processes != 1 ||if (!(total_processes != 1 || strcmp(proc_entry->d_name, "1"
) == 0)) { __kmp_debug_assert("total_processes != 1 || strcmp(proc_entry->d_name, \"1\") == 0"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 2143); }
                     strcmp(proc_entry->d_name, "1") == 0)if (!(total_processes != 1 || strcmp(proc_entry->d_name, "1"
) == 0)) { __kmp_debug_assert("total_processes != 1 || strcmp(proc_entry->d_name, \"1\") == 0"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 2143); };

    // Construct task_path.
    task_path.used = task_path_fixed_len; // Reset task_path to "/proc/".
    __kmp_str_buf_cat(&task_path, proc_entry->d_name,
                      KMP_STRLENstrlen(proc_entry->d_name));
    __kmp_str_buf_cat(&task_path, "/task", 5);

    task_dir = opendir(task_path.str);
    if (task_dir == NULL__null) {
      // Process can finish between reading "/proc/" directory entry and
      // opening process' "task/" directory. So, in general case we should not
      // complain, but have to skip this process and read the next one. But on
      // systems with no "task/" support we will spend lot of time to scan
      // "/proc/" tree again and again without any benefit. "init" process
      // (its pid is 1) should exist always, so, if we cannot open
      // "/proc/1/task/" directory, it means "task/" is not supported by
      // kernel. Report an error now and in the future.
      if (strcmp(proc_entry->d_name, "1") == 0) {
        running_threads = -1;
        permanent_error = 1;
        goto finish;
      }
    } else {
      // Construct fixed part of stat file path.
      __kmp_str_buf_clear(&stat_path);
      __kmp_str_buf_cat(&stat_path, task_path.str, task_path.used);
      __kmp_str_buf_cat(&stat_path, "/", 1);
      stat_path_fixed_len = stat_path.used;

      task_entry = readdir(task_dir);
      while (task_entry != NULL__null) {
        // It is a directory and name starts with a digit.
        if (proc_entry->d_type == DT_DIRDT_DIR && isdigit(task_entry->d_name[0])) {
          ++total_threads;

          // Consruct complete stat file path. Easiest way would be:
          //  __kmp_str_buf_print( & stat_path, "%s/%s/stat", task_path.str,
          //  task_entry->d_name );
          // but seriae of __kmp_str_buf_cat works a bit faster.
          stat_path.used =
              stat_path_fixed_len; // Reset stat path to its fixed part.
          __kmp_str_buf_cat(&stat_path, task_entry->d_name,
                            KMP_STRLENstrlen(task_entry->d_name));
          __kmp_str_buf_cat(&stat_path, "/stat", 5);

          // Note: Low-level API (open/read/close) is used. High-level API
          // (fopen/fclose)  works ~ 30 % slower.
          stat_file = open(stat_path.str, O_RDONLY00);
          if (stat_file == -1) {
            // We cannot report an error because task (thread) can terminate
            // just before reading this file.
          } else {
            /* Content of "stat" file looks like:
               24285 (program) S ...

               It is a single line (if program name does not include funny
               symbols). First number is a thread id, then name of executable
               file name in paretheses, then state of the thread. We need just
               thread state.

               Good news: Length of program name is 15 characters max. Longer
               names are truncated.

               Thus, we need rather short buffer: 15 chars for program name +
               2 parenthesis, + 3 spaces + ~7 digits of pid = 37.

               Bad news: Program name may contain special symbols like space,
               closing parenthesis, or even new line. This makes parsing
               "stat" file not 100 % reliable. In case of fanny program names
               parsing may fail (report incorrect thread state).

               Parsing "status" file looks more promissing (due to different
               file structure and escaping special symbols) but reading and
               parsing of "status" file works slower.
                -- ln
            */
            char buffer[65];
            int len;
            len = read(stat_file, buffer, sizeof(buffer) - 1);
            if (len >= 0) {
              buffer[len] = 0;
              // Using scanf:
              //     sscanf( buffer, "%*d (%*s) %c ", & state );
              // looks very nice, but searching for a closing parenthesis
              // works a bit faster.
              char *close_parent = strstr(buffer, ") ");
              if (close_parent != NULL__null) {
                char state = *(close_parent + 2);
                if (state == 'R') {
                  ++running_threads;
                  if (running_threads >= max) {
                    goto finish;
                  }
                }
              }
            }
            close(stat_file);
            stat_file = -1;
          }
        }
        task_entry = readdir(task_dir);
      }
      closedir(task_dir);
      task_dir = NULL__null;
    }
  }
  proc_entry = readdir(proc_dir);
}

// There _might_ be a timing hole where the thread executing this
// code get skipped in the load balance, and running_threads is 0.
// Assert in the debug builds only!!!
KMP_DEBUG_ASSERT(running_threads > 0)if (!(running_threads > 0)) { __kmp_debug_assert("running_threads > 0"
, "/build/llvm-toolchain-snapshot-8~svn345461/projects/openmp/runtime/src/z_Linux_util.cpp"
, 2256); };
if (running_threads <= 0) {
  running_threads = 1;
}

2261finish: // Clean up and exit.
if (proc_dir != NULL__null) {
  closedir(proc_dir);
}
__kmp_str_buf_free(&task_path);
if (task_dir != NULL__null) {
  closedir(task_dir);
}
__kmp_str_buf_free(&stat_path);
if (stat_file != -1) {
  close(stat_file);
}

glb_running_threads = running_threads;

return running_threads;

2278} // __kmp_get_load_balance

2280#endif // KMP_OS_DARWIN

2282#endif // USE_LOAD_BALANCE

2284#if !(KMP_ARCH_X860 || KMP_ARCH_X86_641 || KMP_MIC0 ||                            \
    ((KMP_OS_LINUX1 || KMP_OS_DARWIN0) && KMP_ARCH_AARCH640) || KMP_ARCH_PPC64(0 || 0))

2287// we really only need the case with 1 argument, because CLANG always build
2288// a struct of pointers to shared variables referenced in the outlined function
2289int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
                         void *p_argv[]
2291#if OMPT_SUPPORT1
                         ,
                         void **exit_frame_ptr
2294#endif
                         ) {
2296#if OMPT_SUPPORT1
*exit_frame_ptr = OMPT_GET_FRAME_ADDRESS(0)__builtin_frame_address(0);
2298#endif

switch (argc) {
default:
  fprintf(stderrstderr, "Too many args to microtask: %d!\n", argc);
  fflush(stderrstderr);
  exit(-1);
case 0:
  (*pkfn)(&gtid, &tid);
  break;
case 1:
  (*pkfn)(&gtid, &tid, p_argv[0]);
  break;
case 2:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1]);
  break;
case 3:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2]);
  break;
case 4:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3]);
  break;
case 5:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4]);
  break;
case 6:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5]);
  break;
case 7:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6]);
  break;
case 8:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7]);
  break;
case 9:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8]);
  break;
case 10:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9]);
  break;
case 11:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10]);
  break;
case 12:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
          p_argv[11]);
  break;
case 13:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
          p_argv[11], p_argv[12]);
  break;
case 14:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
          p_argv[11], p_argv[12], p_argv[13]);
  break;
case 15:
  (*pkfn)(&gtid, &tid, p_argv[0], p_argv[1], p_argv[2], p_argv[3], p_argv[4],
          p_argv[5], p_argv[6], p_argv[7], p_argv[8], p_argv[9], p_argv[10],
          p_argv[11], p_argv[12], p_argv[13], p_argv[14]);
  break;
}

2369#if OMPT_SUPPORT1
*exit_frame_ptr = 0;
2371#endif

return 1;
2374}

2376#endif

2378// end of file //