elseif(${INTEL64})

    elseif(${INTEL64})

      libomp_append(libomp_expected_library_deps libc.so.6)

      libomp_append(libomp_expected_library_deps libc.so.6)

      libomp_append(libomp_expected_library_deps ld-linux-x86-64.so.2)

      libomp_append(libomp_expected_library_deps ld-linux-x86-64.so.2)

    elseif(${ARM})

    elseif(${ARM})

      libomp_append(libomp_expected_library_deps libc.so.6)

      libomp_append(libomp_expected_library_deps libc.so.6)

      libomp_append(libomp_expected_library_deps libffi.so.6)

      libomp_append(libomp_expected_library_deps libffi.so.6)

#endif

#endif

#endif

#endif

#include <xmmintrin.h>

#include <xmmintrin.h>

#endif

#endif

#define KMP_FAST_REDUCTION_BARRIER 1

#define KMP_FAST_REDUCTION_BARRIER 1

#undef KMP_FAST_REDUCTION_CORE_DUO

#undef KMP_FAST_REDUCTION_CORE_DUO

#define KMP_FAST_REDUCTION_CORE_DUO 1

#define KMP_FAST_REDUCTION_CORE_DUO 1

#endif

#endif

#if KMP_ARCH_X86 || KMP_ARCH_X86_64

#if KMP_ARCH_X86 || KMP_ARCH_X86_64

  affinity_top_method_apicid,

  affinity_top_method_apicid,

  affinity_top_method_x2apicid,

  affinity_top_method_x2apicid,

  affinity_top_method_cpuinfo, // KMP_CPUINFO_FILE is usable on Windows* OS, too

  affinity_top_method_cpuinfo, // KMP_CPUINFO_FILE is usable on Windows* OS, too

#if KMP_GROUP_AFFINITY

#if KMP_GROUP_AFFINITY

  affinity_top_method_group,

  affinity_top_method_group,

#define KMP_MAX_STKSIZE (~((size_t)1 << ((sizeof(size_t) * (1 << 3)) - 1)))

#define KMP_MAX_STKSIZE (~((size_t)1 << ((sizeof(size_t) * (1 << 3)) - 1)))

#define KMP_DEFAULT_STKSIZE ((size_t)(2 * 1024 * 1024))

#define KMP_DEFAULT_STKSIZE ((size_t)(2 * 1024 * 1024))

#elif KMP_ARCH_X86_64

#elif KMP_ARCH_X86_64

#define KMP_DEFAULT_STKSIZE ((size_t)(4 * 1024 * 1024))

#define KMP_DEFAULT_STKSIZE ((size_t)(4 * 1024 * 1024))

#else

#else

#define KMP_BLOCKTIME(team, tid)                                               \

#define KMP_BLOCKTIME(team, tid)                                               \

  (get__bt_set(team, tid) ? get__blocktime(team, tid) : __kmp_dflt_blocktime)

  (get__bt_set(team, tid) ? get__blocktime(team, tid) : __kmp_dflt_blocktime)

// HW TSC is used to reduce overhead (clock tick instead of nanosecond).

// HW TSC is used to reduce overhead (clock tick instead of nanosecond).

extern kmp_uint64 __kmp_ticks_per_msec;

extern kmp_uint64 __kmp_ticks_per_msec;

#if KMP_COMPILER_ICC

#if KMP_COMPILER_ICC

/* Minimum number of threads before switch to TLS gtid (experimentally

/* Minimum number of threads before switch to TLS gtid (experimentally

   determined) */

   determined) */

/* josh TODO: what about OS X* tuning? */

/* josh TODO: what about OS X* tuning? */

#define KMP_TLS_GTID_MIN 5

#define KMP_TLS_GTID_MIN 5

#else

#else

#define KMP_TLS_GTID_MIN INT_MAX

#define KMP_TLS_GTID_MIN INT_MAX

#define KMP_NEXT_WAIT 512U /* susequent number of spin-tests */

#define KMP_NEXT_WAIT 512U /* susequent number of spin-tests */

#endif

#endif

typedef struct kmp_cpuid {

typedef struct kmp_cpuid {

  kmp_uint32 eax;

  kmp_uint32 eax;

  kmp_uint32 ebx;

  kmp_uint32 ebx;

  long nivcsw; /* the number of times a context switch was forced           */

  long nivcsw; /* the number of times a context switch was forced           */

} kmp_sys_info_t;

} kmp_sys_info_t;

typedef struct kmp_cpuinfo {

typedef struct kmp_cpuinfo {

  int initialized; // If 0, other fields are not initialized.

  int initialized; // If 0, other fields are not initialized.

  int signature; // CPUID(1).EAX

  int signature; // CPUID(1).EAX

// t_inline_argv. Historically, we have supported at least 96 bytes. Using a

// t_inline_argv. Historically, we have supported at least 96 bytes. Using a

// larger value for more space between the master write/worker read section and

// larger value for more space between the master write/worker read section and

// read/write by all section seems to buy more performance on EPCC PARALLEL.

// read/write by all section seems to buy more performance on EPCC PARALLEL.

#define KMP_INLINE_ARGV_BYTES                                                  \

#define KMP_INLINE_ARGV_BYTES                                                  \

  (4 * CACHE_LINE -                                                            \

  (4 * CACHE_LINE -                                                            \

   ((3 * KMP_PTR_SKIP + 2 * sizeof(int) + 2 * sizeof(kmp_int8) +               \

   ((3 * KMP_PTR_SKIP + 2 * sizeof(int) + 2 * sizeof(kmp_int8) +               \

  ompt_lw_taskteam_t *ompt_serialized_team_info;

  ompt_lw_taskteam_t *ompt_serialized_team_info;

#endif

#endif

  kmp_int8 t_fp_control_saved;

  kmp_int8 t_fp_control_saved;

  kmp_int8 t_pad2b;

  kmp_int8 t_pad2b;

  kmp_int16 t_x87_fpu_control_word; // FP control regs

  kmp_int16 t_x87_fpu_control_word; // FP control regs

  kmp_uint32 t_mxcsr;

  kmp_uint32 t_mxcsr;

  void *t_inline_argv[KMP_INLINE_ARGV_ENTRIES];

  void *t_inline_argv[KMP_INLINE_ARGV_ENTRIES];

// omp_set_num_threads() call

// omp_set_num_threads() call

// Read/write by workers as well

// Read/write by workers as well

  // Using CACHE_LINE=64 reduces memory footprint, but causes a big perf

  // Using CACHE_LINE=64 reduces memory footprint, but causes a big perf

  // regression of epcc 'parallel' and 'barrier' on fxe256lin01. This extra

  // regression of epcc 'parallel' and 'barrier' on fxe256lin01. This extra

  // padding serves to fix the performance of epcc 'parallel' and 'barrier' when

  // padding serves to fix the performance of epcc 'parallel' and 'barrier' when

                                         placement info */

                                         placement info */

extern int __kmp_storage_map_verbose_specified;

extern int __kmp_storage_map_verbose_specified;

extern kmp_cpuinfo_t __kmp_cpuinfo;

extern kmp_cpuinfo_t __kmp_cpuinfo;

#endif

#endif

#endif

#endif

extern int __kmp_tls_gtid_min; /* #threads below which use sp search for gtid */

extern int __kmp_tls_gtid_min; /* #threads below which use sp search for gtid */

extern int __kmp_foreign_tp; // If true, separate TP var for each foreign thread

extern int __kmp_foreign_tp; // If true, separate TP var for each foreign thread

extern int __kmp_inherit_fp_control; // copy fp creg(s) parent->workers at fork

extern int __kmp_inherit_fp_control; // copy fp creg(s) parent->workers at fork

extern kmp_int16 __kmp_init_x87_fpu_control_word; // init thread's FP ctrl reg

extern kmp_int16 __kmp_init_x87_fpu_control_word; // init thread's FP ctrl reg

extern kmp_uint32 __kmp_init_mxcsr; /* init thread's mxscr */

extern kmp_uint32 __kmp_init_mxcsr; /* init thread's mxscr */

extern int __kmp_dflt_max_active_levels; /* max_active_levels for nested

extern int __kmp_dflt_max_active_levels; /* max_active_levels for nested

                                            parallelism enabled by default via

                                            parallelism enabled by default via

extern void __kmp_expand_host_name(char *buffer, size_t size);

extern void __kmp_expand_host_name(char *buffer, size_t size);

extern void __kmp_expand_file_name(char *result, size_t rlen, char *pattern);

extern void __kmp_expand_file_name(char *result, size_t rlen, char *pattern);

extern void

extern void

__kmp_initialize_system_tick(void); /* Initialize timer tick value */

__kmp_initialize_system_tick(void); /* Initialize timer tick value */

#endif

#endif

                           enum fork_context_e fork_context, kmp_int32 argc,

                           enum fork_context_e fork_context, kmp_int32 argc,

                           microtask_t microtask, launch_t invoker,

                           microtask_t microtask, launch_t invoker,

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

                           va_list *ap

                           va_list *ap

#else

#else

                           va_list ap

                           va_list ap

// Assembly routines that have no compiler intrinsic replacement

// Assembly routines that have no compiler intrinsic replacement

//

//

extern void __kmp_query_cpuid(kmp_cpuinfo_t *p);

extern void __kmp_query_cpuid(kmp_cpuinfo_t *p);

extern void __kmp_clear_x87_fpu_status_word();

extern void __kmp_clear_x87_fpu_status_word();

#define KMP_X86_MXCSR_MASK 0xffffffc0 /* ignore status flags (6 lsb) */

#define KMP_X86_MXCSR_MASK 0xffffffc0 /* ignore status flags (6 lsb) */

extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc,

extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc,

                                  void *argv[]

                                  void *argv[]

#endif /* KMP_GROUP_AFFINITY */

#endif /* KMP_GROUP_AFFINITY */

static int __kmp_cpuid_mask_width(int count) {

static int __kmp_cpuid_mask_width(int count) {

  int r = 0;

  int r = 0;

  return depth;

  return depth;

}

}

#define osIdIndex 0

#define osIdIndex 0

#define threadIdIndex 1

#define threadIdIndex 1

          goto dup_field;

          goto dup_field;

#endif

#endif

        threadInfo[num_avail][osIdIndex] = val;

        threadInfo[num_avail][osIdIndex] = val;

        char path[256];

        char path[256];

        KMP_SNPRINTF(

        KMP_SNPRINTF(

            path, sizeof(path),

            path, sizeof(path),

    }

    }

#endif

#endif

    if (depth < 0) {

    if (depth < 0) {

      if (__kmp_affinity_verbose) {

      if (__kmp_affinity_verbose) {

      }

      }

    }

    }

#if KMP_OS_LINUX

#if KMP_OS_LINUX

// used, then we abort if that method fails. The exception is group affinity,

// used, then we abort if that method fails. The exception is group affinity,

// which might have been implicitly set.

// which might have been implicitly set.

  else if (__kmp_affinity_top_method == affinity_top_method_x2apicid) {

  else if (__kmp_affinity_top_method == affinity_top_method_x2apicid) {

    if (__kmp_affinity_verbose) {

    if (__kmp_affinity_verbose) {

    }

    }

  }

  }

  else if (__kmp_affinity_top_method == affinity_top_method_cpuinfo) {

  else if (__kmp_affinity_top_method == affinity_top_method_cpuinfo) {

    const char *filename;

    const char *filename;

#elif __NR_sched_getaffinity != 204

#elif __NR_sched_getaffinity != 204

#error Wrong code for getaffinity system call.

#error Wrong code for getaffinity system call.

#endif /* __NR_sched_getaffinity */

#endif /* __NR_sched_getaffinity */

#elif KMP_ARCH_PPC64

#elif KMP_ARCH_PPC64

#ifndef __NR_sched_setaffinity

#ifndef __NR_sched_setaffinity

#define __NR_sched_setaffinity 222

#define __NR_sched_setaffinity 222

// end of the first part of the workaround for C78287

// end of the first part of the workaround for C78287

#endif // USE_CMPXCHG_FIX

#endif // USE_CMPXCHG_FIX

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ====================================

// X86 or X86_64: no alignment problems ====================================

  }

  }

// end of the second part of the workaround for C78287

// end of the second part of the workaround for C78287

#endif // USE_CMPXCHG_FIX

#endif // USE_CMPXCHG_FIX

// Routines for ATOMIC 4-byte operands addition and subtraction

// Routines for ATOMIC 4-byte operands addition and subtraction

ATOMIC_FIXED_ADD(fixed4, add, kmp_int32, 32, +, 4i, 3,

ATOMIC_FIXED_ADD(fixed4, add, kmp_int32, 32, +, 4i, 3,

  OP_CRITICAL(= *lhs OP, LCK_ID)                                               \

  OP_CRITICAL(= *lhs OP, LCK_ID)                                               \

  }

  }

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ===================================

// X86 or X86_64: no alignment problems ===================================

    OP_CRITICAL(= *lhs OP, LCK_ID) /* unaligned - use critical */              \

    OP_CRITICAL(= *lhs OP, LCK_ID) /* unaligned - use critical */              \

  }                                                                            \

  }                                                                            \

  }

  }

ATOMIC_CMPX_L(fixed1, andl, char, 8, &&, 1i, 0,

ATOMIC_CMPX_L(fixed1, andl, char, 8, &&, 1i, 0,

              KMP_ARCH_X86) // __kmpc_atomic_fixed1_andl

              KMP_ARCH_X86) // __kmpc_atomic_fixed1_andl

  }                                                                            \

  }                                                                            \

  }

  }

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ====================================

// X86 or X86_64: no alignment problems ====================================

    }                                                                          \

    }                                                                          \

  }                                                                            \

  }                                                                            \

  }

  }

MIN_MAX_COMPXCHG(fixed1, max, char, 8, <, 1i, 0,

MIN_MAX_COMPXCHG(fixed1, max, char, 8, <, 1i, 0,

                 KMP_ARCH_X86) // __kmpc_atomic_fixed1_max

                 KMP_ARCH_X86) // __kmpc_atomic_fixed1_max

  }

  }

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ===================================

// X86 or X86_64: no alignment problems ===================================

#define ATOMIC_CMPX_EQV(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,          \

#define ATOMIC_CMPX_EQV(TYPE_ID, OP_ID, TYPE, BITS, OP, LCK_ID, MASK,          \

    OP_CRITICAL(^= ~, LCK_ID) /* unaligned address - use critical */           \

    OP_CRITICAL(^= ~, LCK_ID) /* unaligned address - use critical */           \

  }                                                                            \

  }                                                                            \

  }

  }

ATOMIC_CMPXCHG(fixed1, neqv, kmp_int8, 8, ^, 1i, 0,

ATOMIC_CMPXCHG(fixed1, neqv, kmp_int8, 8, ^, 1i, 0,

               KMP_ARCH_X86) // __kmpc_atomic_fixed1_neqv

               KMP_ARCH_X86) // __kmpc_atomic_fixed1_neqv

// OpenMP 4.0: x = expr binop x for non-commutative operations.

// OpenMP 4.0: x = expr binop x for non-commutative operations.

// Supported only on IA-32 architecture and Intel(R) 64

// Supported only on IA-32 architecture and Intel(R) 64

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// Operation on *lhs, rhs bound by critical section

// Operation on *lhs, rhs bound by critical section

#endif

#endif

#endif

#endif

// End of OpenMP 4.0: x = expr binop x for non-commutative operations.

// End of OpenMP 4.0: x = expr binop x for non-commutative operations.

#endif // OMP_40_ENABLED

#endif // OMP_40_ENABLED

  }

  }

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ====================================

// X86 or X86_64: no alignment problems ====================================

#define ATOMIC_CMPXCHG_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,    \

#define ATOMIC_CMPXCHG_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID, RTYPE,    \

    OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \

    OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \

  }                                                                            \

  }                                                                            \

  }

  }

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

// -------------------------------------------------------------------------

#define ATOMIC_CMPXCHG_REV_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID,       \

#define ATOMIC_CMPXCHG_REV_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID,       \

                               RTYPE, LCK_ID, MASK, GOMP_FLAG)                 \

                               RTYPE, LCK_ID, MASK, GOMP_FLAG)                 \

  OP_GOMP_CRITICAL_REV(OP, GOMP_FLAG)                                          \

  OP_GOMP_CRITICAL_REV(OP, GOMP_FLAG)                                          \

  OP_CRITICAL_REV(OP, LCK_ID)                                                  \

  OP_CRITICAL_REV(OP, LCK_ID)                                                  \

  }

  }

// RHS=float8

// RHS=float8

ATOMIC_CMPXCHG_MIX(fixed1, char, mul, 8, *, float8, kmp_real64, 1i, 0,

ATOMIC_CMPXCHG_MIX(fixed1, char, mul, 8, *, float8, kmp_real64, 1i, 0,

ATOMIC_CRITICAL_FP(float10, long double, div, /, fp, _Quad, 10r,

ATOMIC_CRITICAL_FP(float10, long double, div, /, fp, _Quad, 10r,

                   1) // __kmpc_atomic_float10_div_fp

                   1) // __kmpc_atomic_float10_div_fp

// Reverse operations

// Reverse operations

ATOMIC_CMPXCHG_REV_MIX(fixed1, char, sub_rev, 8, -, fp, _Quad, 1i, 0,

ATOMIC_CMPXCHG_REV_MIX(fixed1, char, sub_rev, 8, -, fp, _Quad, 1i, 0,

                       KMP_ARCH_X86) // __kmpc_atomic_fixed1_sub_rev_fp

                       KMP_ARCH_X86) // __kmpc_atomic_fixed1_sub_rev_fp

                       1) // __kmpc_atomic_float10_sub_rev_fp

                       1) // __kmpc_atomic_float10_sub_rev_fp

ATOMIC_CRITICAL_REV_FP(float10, long double, div_rev, /, fp, _Quad, 10r,

ATOMIC_CRITICAL_REV_FP(float10, long double, div_rev, /, fp, _Quad, 10r,

                       1) // __kmpc_atomic_float10_div_rev_fp

                       1) // __kmpc_atomic_float10_div_rev_fp

#endif

#endif

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// X86 or X86_64: no alignment problems ====================================

// X86 or X86_64: no alignment problems ====================================

#if USE_CMPXCHG_FIX

#if USE_CMPXCHG_FIX

    OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \

    OP_CRITICAL(OP## =, LCK_ID) /* unaligned address - use critical */         \

  }                                                                            \

  }                                                                            \

  }

  }

ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, add, 64, +, cmplx8, kmp_cmplx64, 8c,

ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, add, 64, +, cmplx8, kmp_cmplx64, 8c,

                     7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_add_cmplx8

                     7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_add_cmplx8

                     7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_div_cmplx8

                     7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_div_cmplx8

// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64

// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64

// ------------------------------------------------------------------------

// ------------------------------------------------------------------------

// Atomic READ routines

// Atomic READ routines

#endif // OMP_40_ENABLED

#endif // OMP_40_ENABLED

#undef OP_CRITICAL

#undef OP_CRITICAL

  if (

  if (

#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)

#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)

      FALSE /* must use lock */

      FALSE /* must use lock */

      TRUE /* no alignment problems */

      TRUE /* no alignment problems */

#else

#else

      !((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */

      !((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */

  if (

  if (

// FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints.

// FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints.

// Gomp compatibility is broken if this routine is called for floats.

// Gomp compatibility is broken if this routine is called for floats.

      TRUE /* no alignment problems */

      TRUE /* no alignment problems */

#else

#else

      !((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */

      !((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */

#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)

#if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)

      FALSE /* must use lock */

      FALSE /* must use lock */

      TRUE /* no alignment problems */

      TRUE /* no alignment problems */

#else

#else

      !((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */

      !((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */

// OpenMP 4.0: x = expr binop x for non-commutative operations.

// OpenMP 4.0: x = expr binop x for non-commutative operations.

// Supported only on IA-32 architecture and Intel(R) 64

// Supported only on IA-32 architecture and Intel(R) 64

void __kmpc_atomic_fixed1_sub_rev(ident_t *id_ref, int gtid, char *lhs,

void __kmpc_atomic_fixed1_sub_rev(ident_t *id_ref, int gtid, char *lhs,

                                  char rhs);

                                  char rhs);

#endif

#endif

#endif // KMP_HAVE_QUAD

#endif // KMP_HAVE_QUAD

#endif // OMP_40_ENABLED

#endif // OMP_40_ENABLED

                      void (*f)(void *, void *, void *));

                      void (*f)(void *, void *, void *));

// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64

// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64

//  Below routines for atomic READ are listed

//  Below routines for atomic READ are listed

char __kmpc_atomic_fixed1_rd(ident_t *id_ref, int gtid, char *loc);

char __kmpc_atomic_fixed1_rd(ident_t *id_ref, int gtid, char *loc);

#endif // OMP_40_ENABLED

#endif // OMP_40_ENABLED

/* ------------------------------------------------------------------------ */

/* ------------------------------------------------------------------------ */

                    VOLATILE_CAST(microtask_t) microtask, // "wrapped" task

                    VOLATILE_CAST(microtask_t) microtask, // "wrapped" task

                    VOLATILE_CAST(launch_t) __kmp_invoke_task_func,

                    VOLATILE_CAST(launch_t) __kmp_invoke_task_func,

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

                    &ap

                    &ap

#else

#else

                    ap

                    ap

                  VOLATILE_CAST(microtask_t)

                  VOLATILE_CAST(microtask_t)

                      __kmp_teams_master, // "wrapped" task

                      __kmp_teams_master, // "wrapped" task

                  VOLATILE_CAST(launch_t) __kmp_invoke_teams_master,

                  VOLATILE_CAST(launch_t) __kmp_invoke_teams_master,

                  &ap

                  &ap

#else

#else

                  ap

                  ap

/* return to the parallel section */

/* return to the parallel section */

    if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {

    if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {

      __kmp_clear_x87_fpu_status_word();

      __kmp_clear_x87_fpu_status_word();

      __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);

      __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);

      __kmp_load_mxcsr(&serial_team->t.t_mxcsr);

      __kmp_load_mxcsr(&serial_team->t.t_mxcsr);

    }

    }

    this_thr->th.th_team = serial_team->t.t_parent;

    this_thr->th.th_team = serial_team->t.t_parent;

    this_thr->th.th_info.ds.ds_tid = serial_team->t.t_master_tid;

    this_thr->th.th_info.ds.ds_tid = serial_team->t.t_master_tid;

  /* need explicit __mf() here since use volatile instead in library */

  /* need explicit __mf() here since use volatile instead in library */

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

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

#if KMP_MIC

#if KMP_MIC

// fence-style instructions do not exist, but lock; xaddl $0,(%rsp) can be used.

// fence-style instructions do not exist, but lock; xaddl $0,(%rsp) can be used.

// We shouldn't need it, though, since the ABI rules require that

// We shouldn't need it, though, since the ABI rules require that

#define KMP_TSX_LOCK(seq) __kmp_user_lock_seq

#define KMP_TSX_LOCK(seq) __kmp_user_lock_seq

#endif

#endif

#define KMP_CPUINFO_RTM (__kmp_cpuinfo.rtm)

#define KMP_CPUINFO_RTM (__kmp_cpuinfo.rtm)

#else

#else

#define KMP_CPUINFO_RTM 0

#define KMP_CPUINFO_RTM 0

  if ((__kmp_user_lock_kind == lk_tas) &&

  if ((__kmp_user_lock_kind == lk_tas) &&

      (sizeof(lck->tas.lk.poll) <= OMP_LOCK_T_SIZE)) {

      (sizeof(lck->tas.lk.poll) <= OMP_LOCK_T_SIZE)) {

#if KMP_OS_LINUX &&                                                            \

#if KMP_OS_LINUX &&                                                            \

// "fast" path implemented to fix customer performance issue

// "fast" path implemented to fix customer performance issue

#if USE_ITT_BUILD

#if USE_ITT_BUILD

    __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);

    __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);

      (sizeof(lck->tas.lk.poll) + sizeof(lck->tas.lk.depth_locked) <=

      (sizeof(lck->tas.lk.poll) + sizeof(lck->tas.lk.depth_locked) <=

       OMP_NEST_LOCK_T_SIZE)) {

       OMP_NEST_LOCK_T_SIZE)) {

#if KMP_OS_LINUX &&                                                            \

#if KMP_OS_LINUX &&                                                            \

    // "fast" path implemented to fix customer performance issue

    // "fast" path implemented to fix customer performance issue

    kmp_tas_lock_t *tl = (kmp_tas_lock_t *)user_lock;

    kmp_tas_lock_t *tl = (kmp_tas_lock_t *)user_lock;

#if USE_ITT_BUILD

#if USE_ITT_BUILD

kmp_key_t __kmp_gtid_threadprivate_key;

kmp_key_t __kmp_gtid_threadprivate_key;

kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized

kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized

#endif

#endif

#endif /* KMP_TDATA_GTID */

#endif /* KMP_TDATA_GTID */

int __kmp_tls_gtid_min = INT_MAX;

int __kmp_tls_gtid_min = INT_MAX;

int __kmp_foreign_tp = TRUE;

int __kmp_foreign_tp = TRUE;

int __kmp_inherit_fp_control = TRUE;

int __kmp_inherit_fp_control = TRUE;

kmp_int16 __kmp_init_x87_fpu_control_word = 0;

kmp_int16 __kmp_init_x87_fpu_control_word = 0;

kmp_uint32 __kmp_init_mxcsr = 0;

kmp_uint32 __kmp_init_mxcsr = 0;

#ifdef USE_LOAD_BALANCE

#ifdef USE_LOAD_BALANCE

double __kmp_load_balance_interval = 1.0;

double __kmp_load_balance_interval = 1.0;

  rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc, wrapper,

  rc = __kmp_fork_call(loc, gtid, fork_context_gnu, argc, wrapper,

                       __kmp_invoke_task_func,

                       __kmp_invoke_task_func,

                       &ap

                       &ap

#else

#else

                       ap

                       ap

   therefore uninteresting when collecting traces for architecture simulation.

   therefore uninteresting when collecting traces for architecture simulation.

 */

 */

#ifndef INCLUDE_SSC_MARKS

#ifndef INCLUDE_SSC_MARKS

#endif

#endif

// Portable (at least for gcc and icc) code to insert the necessary instructions

// Portable (at least for gcc and icc) code to insert the necessary instructions

// to set %ebx and execute the unlikely no-op.

// to set %ebx and execute the unlikely no-op.

#if defined(__INTEL_COMPILER)

#if defined(__INTEL_COMPILER)

}

}

// Time stamp counter

// Time stamp counter

#define __kmp_tsc() __kmp_hardware_timestamp()

#define __kmp_tsc() __kmp_hardware_timestamp()

// Runtime's default backoff parameters

// Runtime's default backoff parameters

kmp_backoff_t __kmp_spin_backoff_params = {1, 4096, 100};

kmp_backoff_t __kmp_spin_backoff_params = {1, 4096, 100};

#define KMP_USE_FUTEX                                                          \

#define KMP_USE_FUTEX                                                          \

  (KMP_OS_LINUX && !KMP_OS_CNK &&                                              \

  (KMP_OS_LINUX && !KMP_OS_CNK &&                                              \

#if KMP_USE_FUTEX

#if KMP_USE_FUTEX

                                                   kmp_int32 gtid);

                                                   kmp_int32 gtid);

#if KMP_OS_LINUX &&                                                            \

#if KMP_OS_LINUX &&                                                            \

#define __kmp_acquire_user_lock_with_checks(lck, gtid)                         \

#define __kmp_acquire_user_lock_with_checks(lck, gtid)                         \

  if (__kmp_user_lock_kind == lk_tas) {                                        \

  if (__kmp_user_lock_kind == lk_tas) {                                        \

                                                kmp_int32 gtid);

                                                kmp_int32 gtid);

#if KMP_OS_LINUX &&                                                            \

#if KMP_OS_LINUX &&                                                            \

#include "kmp_i18n.h" /* AC: KMP_FATAL definition */

#include "kmp_i18n.h" /* AC: KMP_FATAL definition */

extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */

extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */

extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck,

extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck,

                                                          kmp_int32 gtid);

                                                          kmp_int32 gtid);

#define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth)           \

#define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth)           \

  if (__kmp_user_lock_kind == lk_tas) {                                        \

  if (__kmp_user_lock_kind == lk_tas) {                                        \

extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck,

extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck,

                                                       kmp_int32 gtid);

                                                       kmp_int32 gtid);

static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,

static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,

                                                          kmp_int32 gtid) {

                                                          kmp_int32 gtid) {

  if (__kmp_user_lock_kind == lk_tas) {

  if (__kmp_user_lock_kind == lk_tas) {

// Shortcuts

// Shortcuts

#define KMP_USE_INLINED_TAS                                                    \

#define KMP_USE_INLINED_TAS                                                    \

#define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0

#define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0

// List of lock definitions; all nested locks are indirect locks.

// List of lock definitions; all nested locks are indirect locks.

#error "Can't determine size_t printf format specifier."

#error "Can't determine size_t printf format specifier."

#endif

#endif

#define KMP_SIZE_T_MAX (0xFFFFFFFF)

#define KMP_SIZE_T_MAX (0xFFFFFFFF)

#else

#else

#define KMP_SIZE_T_MAX (0xFFFFFFFFFFFFFFFF)

#define KMP_SIZE_T_MAX (0xFFFFFFFFFFFFFFFF)

#define KMP_ARCH_X86 0

#define KMP_ARCH_X86 0

#define KMP_ARCH_X86_64 0

#define KMP_ARCH_X86_64 0

#define KMP_ARCH_AARCH64 0

#define KMP_ARCH_AARCH64 0

#define KMP_ARCH_PPC64_BE 0

#define KMP_ARCH_PPC64_BE 0

#define KMP_ARCH_PPC64_LE 0

#define KMP_ARCH_PPC64_LE 0

#if KMP_OS_UNIX

#if KMP_OS_UNIX

#if defined __x86_64

#if defined __x86_64

#undef KMP_ARCH_X86_64

#undef KMP_ARCH_X86_64

#define KMP_ARCH_X86_64 1

#define KMP_ARCH_X86_64 1

#elif defined __i386

#elif defined __i386

#undef KMP_ARCH_X86

#undef KMP_ARCH_X86

#define KMP_ARCH_X86 1

#define KMP_ARCH_X86 1

// Platforms which support Intel(R) Many Integrated Core Architecture

// Platforms which support Intel(R) Many Integrated Core Architecture

#define KMP_MIC_SUPPORTED                                                      \

#define KMP_MIC_SUPPORTED                                                      \

// TODO: Fixme - This is clever, but really fugly

// TODO: Fixme - This is clever, but really fugly

#if (1 !=                                                                      \

#if (1 !=                                                                      \

#error Unknown or unsupported architecture

#error Unknown or unsupported architecture

#endif

#endif

  KMP_MB();

  KMP_MB();

}

}

// Propagate any changes to the floating point control registers out to the team

// Propagate any changes to the floating point control registers out to the team

// We try to avoid unnecessary writes to the relevant cache line in the team

// We try to avoid unnecessary writes to the relevant cache line in the team

// structure, so we don't make changes unless they are needed.

// structure, so we don't make changes unless they are needed.

#else

#else

#define propagateFPControl(x) ((void)0)

#define propagateFPControl(x) ((void)0)

#define updateHWFPControl(x) ((void)0)

#define updateHWFPControl(x) ((void)0)

static void __kmp_alloc_argv_entries(int argc, kmp_team_t *team,

static void __kmp_alloc_argv_entries(int argc, kmp_team_t *team,

                                     int realloc); // forward declaration

                                     int realloc); // forward declaration

                    enum fork_context_e call_context, // Intel, GNU, ...

                    enum fork_context_e call_context, // Intel, GNU, ...

                    kmp_int32 argc, microtask_t microtask, launch_t invoker,

                    kmp_int32 argc, microtask_t microtask, launch_t invoker,

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

                    va_list *ap

                    va_list *ap

#else

#else

                    va_list ap

                    va_list ap

      argv = (void **)parent_team->t.t_argv;

      argv = (void **)parent_team->t.t_argv;

      for (i = argc - 1; i >= 0; --i)

      for (i = argc - 1; i >= 0; --i)

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

/* TODO: revert workaround for Intel(R) 64 tracker #96 */

        *argv++ = va_arg(*ap, void *);

        *argv++ = va_arg(*ap, void *);

#else

#else

        *argv++ = va_arg(ap, void *);

        *argv++ = va_arg(ap, void *);

    if (nthreads == 1) {

    if (nthreads == 1) {

/* josh todo: hypothetical question: what do we do for OS X*? */

/* josh todo: hypothetical question: what do we do for OS X*? */

#if KMP_OS_LINUX &&                                                            \

#if KMP_OS_LINUX &&                                                            \

      void *args[argc];

      void *args[argc];

#else

#else

      void **args = (void **)KMP_ALLOCA(argc * sizeof(void *));

      void **args = (void **)KMP_ALLOCA(argc * sizeof(void *));

          KMP_ARCH_AARCH64) */

          KMP_ARCH_AARCH64) */

      KA_TRACE(20,

      KA_TRACE(20,

          if (ap) {

          if (ap) {

            for (i = argc - 1; i >= 0; --i)

            for (i = argc - 1; i >= 0; --i)

// TODO: revert workaround for Intel(R) 64 tracker #96

// TODO: revert workaround for Intel(R) 64 tracker #96

              *argv++ = va_arg(*ap, void *);

              *argv++ = va_arg(*ap, void *);

#else

#else

              *argv++ = va_arg(ap, void *);

              *argv++ = va_arg(ap, void *);

          argv = args;

          argv = args;

          for (i = argc - 1; i >= 0; --i)

          for (i = argc - 1; i >= 0; --i)

// TODO: revert workaround for Intel(R) 64 tracker #96

// TODO: revert workaround for Intel(R) 64 tracker #96

            *argv++ = va_arg(*ap, void *);

            *argv++ = va_arg(*ap, void *);

#else

#else

          *argv++ = va_arg(ap, void *);

          *argv++ = va_arg(ap, void *);

#endif /* OMP_40_ENABLED */

#endif /* OMP_40_ENABLED */

      for (i = argc - 1; i >= 0; --i) {

      for (i = argc - 1; i >= 0; --i) {

// TODO: revert workaround for Intel(R) 64 tracker #96

// TODO: revert workaround for Intel(R) 64 tracker #96

        void *new_argv = va_arg(*ap, void *);

        void *new_argv = va_arg(*ap, void *);

#else

#else

      void *new_argv = va_arg(ap, void *);

      void *new_argv = va_arg(ap, void *);

  // TODO???: team->t.t_max_active_levels       = new_max_active_levels;

  // TODO???: team->t.t_max_active_levels       = new_max_active_levels;

  team->t.t_sched.sched = new_icvs->sched.sched;

  team->t.t_sched.sched = new_icvs->sched.sched;

  team->t.t_fp_control_saved = FALSE; /* not needed */

  team->t.t_fp_control_saved = FALSE; /* not needed */

  team->t.t_x87_fpu_control_word = 0; /* not needed */

  team->t.t_x87_fpu_control_word = 0; /* not needed */

  team->t.t_mxcsr = 0; /* not needed */

  team->t.t_mxcsr = 0; /* not needed */

  team->t.t_construct = 0;

  team->t.t_construct = 0;

    double dtime;

    double dtime;

    long ltime;

    long ltime;

  } time;

  } time;

  __kmp_initialize_system_tick();

  __kmp_initialize_system_tick();

#endif

#endif

  __kmp_read_system_time(&time.dtime);

  __kmp_read_system_time(&time.dtime);

  KA_TRACE(10, ("__kmp_parallel_initialize: enter\n"));

  KA_TRACE(10, ("__kmp_parallel_initialize: enter\n"));

  KMP_ASSERT(KMP_UBER_GTID(gtid));

  KMP_ASSERT(KMP_UBER_GTID(gtid));

  // Save the FP control regs.

  // Save the FP control regs.

  // Worker threads will set theirs to these values at thread startup.

  // Worker threads will set theirs to these values at thread startup.

  __kmp_store_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);

  __kmp_store_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);

  __kmp_store_mxcsr(&__kmp_init_mxcsr);

  __kmp_store_mxcsr(&__kmp_init_mxcsr);

  __kmp_init_mxcsr &= KMP_X86_MXCSR_MASK;

  __kmp_init_mxcsr &= KMP_X86_MXCSR_MASK;

#if KMP_OS_UNIX

#if KMP_OS_UNIX

#if KMP_HANDLE_SIGNALS

#if KMP_HANDLE_SIGNALS

#endif // KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_WINDOWS ||

#endif // KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_WINDOWS ||

// KMP_OS_DARWIN

// KMP_OS_DARWIN

#if KMP_OS_LINUX || KMP_OS_WINDOWS

#if KMP_OS_LINUX || KMP_OS_WINDOWS

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// KMP_INHERIT_FP_CONTROL

// KMP_INHERIT_FP_CONTROL

static void __kmp_stg_parse_inherit_fp_control(char const *name,

static void __kmp_stg_parse_inherit_fp_control(char const *name,

                                               char const *value, void *data) {

                                               char const *value, void *data) {

#endif /* KMP_DEBUG */

#endif /* KMP_DEBUG */

} // __kmp_stg_print_inherit_fp_control

} // __kmp_stg_print_inherit_fp_control

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------

// KMP_LIBRARY, OMP_WAIT_POLICY

// KMP_LIBRARY, OMP_WAIT_POLICY

    __kmp_affinity_top_method = affinity_top_method_hwloc;

    __kmp_affinity_top_method = affinity_top_method_hwloc;

  }

  }

#endif

#endif

  else if (__kmp_str_match("x2apic id", 9, value) ||

  else if (__kmp_str_match("x2apic id", 9, value) ||

           __kmp_str_match("x2apic_id", 9, value) ||

           __kmp_str_match("x2apic_id", 9, value) ||

           __kmp_str_match("x2apic-id", 9, value) ||

           __kmp_str_match("x2apic-id", 9, value) ||

             __kmp_str_match("leaf4", 5, value)) {

             __kmp_str_match("leaf4", 5, value)) {

    __kmp_affinity_top_method = affinity_top_method_apicid;

    __kmp_affinity_top_method = affinity_top_method_apicid;

  }

  }

  else if (__kmp_str_match("/proc/cpuinfo", 2, value) ||

  else if (__kmp_str_match("/proc/cpuinfo", 2, value) ||

           __kmp_str_match("cpuinfo", 5, value)) {

           __kmp_str_match("cpuinfo", 5, value)) {

    __kmp_affinity_top_method = affinity_top_method_cpuinfo;

    __kmp_affinity_top_method = affinity_top_method_cpuinfo;

    value = "all";

    value = "all";

    break;

    break;

  case affinity_top_method_x2apicid:

  case affinity_top_method_x2apicid:

    value = "x2APIC id";

    value = "x2APIC id";

    break;

    break;

  case affinity_top_method_apicid:

  case affinity_top_method_apicid:

    value = "APIC id";

    value = "APIC id";

    break;

    break;

#if KMP_USE_HWLOC

#if KMP_USE_HWLOC

  case affinity_top_method_hwloc:

  case affinity_top_method_hwloc:

     __kmp_stg_print_handle_signals, NULL, 0, 0},

     __kmp_stg_print_handle_signals, NULL, 0, 0},

#endif

#endif

    {"KMP_INHERIT_FP_CONTROL", __kmp_stg_parse_inherit_fp_control,

    {"KMP_INHERIT_FP_CONTROL", __kmp_stg_parse_inherit_fp_control,

     __kmp_stg_print_inherit_fp_control, NULL, 0, 0},

     __kmp_stg_print_inherit_fp_control, NULL, 0, 0},

#ifdef KMP_GOMP_COMPAT

#ifdef KMP_GOMP_COMPAT

    {"GOMP_STACKSIZE", __kmp_stg_parse_stacksize, NULL, NULL, 0, 0},

    {"GOMP_STACKSIZE", __kmp_stg_parse_stacksize, NULL, NULL, 0, 0},

  fprintf(statsOut, "# Time of run: %s\n", &buffer[0]);

  fprintf(statsOut, "# Time of run: %s\n", &buffer[0]);

  if (gethostname(&hostName[0], sizeof(hostName)) == 0)

  if (gethostname(&hostName[0], sizeof(hostName)) == 0)

    fprintf(statsOut, "# Hostname: %s\n", &hostName[0]);

    fprintf(statsOut, "# Hostname: %s\n", &hostName[0]);

  fprintf(statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);

  fprintf(statsOut, "# CPU:  %s\n", &__kmp_cpuinfo.name[0]);

  fprintf(statsOut, "# Family: %d, Model: %d, Stepping: %d\n",

  fprintf(statsOut, "# Family: %d, Model: %d, Stepping: %d\n",

          __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);

          __kmp_cpuinfo.family, __kmp_cpuinfo.model, __kmp_cpuinfo.stepping);

  // pretty bad assumption of 1GHz clock for MIC

  // pretty bad assumption of 1GHz clock for MIC

  return 1 / ((double)1000 * 1.e6);

  return 1 / ((double)1000 * 1.e6);

}

}

#include <string.h>

#include <string.h>

// Extract the value from the CPUID information

// Extract the value from the CPUID information

double tsc_tick_count::tick_time() {

double tsc_tick_count::tick_time() {

    __kmp_pop_workshare(global_tid, ct_taskq, loc);

    __kmp_pop_workshare(global_tid, ct_taskq, loc);

  if (in_parallel) {

  if (in_parallel) {

    KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),

    KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),

                       TQF_ALL_TASKS_QUEUED);

                       TQF_ALL_TASKS_QUEUED);

#else

#else

      /* No synchronization needed for serial context */

      /* No synchronization needed for serial context */

      queue->tq_flags |= TQF_IS_LAST_TASK;

      queue->tq_flags |= TQF_IS_LAST_TASK;

    } else {

    } else {

      KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),

      KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),

                         TQF_IS_LAST_TASK);

                         TQF_IS_LAST_TASK);

#else

#else

static const char *unknown = "unknown";

static const char *unknown = "unknown";

/* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then

/* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then

   the debugging package has not been initialized yet, and only "0" will print

   the debugging package has not been initialized yet, and only "0" will print

  }

  }

}

}

void __kmp_expand_host_name(char *buffer, size_t size) {

void __kmp_expand_host_name(char *buffer, size_t size) {

  KMP_DEBUG_ASSERT(size >= sizeof(unknown));

  KMP_DEBUG_ASSERT(size >= sizeof(unknown));

#include "kmp_config.h"

#include "kmp_config.h"

# if KMP_MIC

# if KMP_MIC

// the 'delay r16/r32/r64' should be used instead of the 'pause'.

// the 'delay r16/r32/r64' should be used instead of the 'pause'.

#endif /* KMP_GOMP_COMPAT */

#endif /* KMP_GOMP_COMPAT */

// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

// microtasking routines specifically written for IA-32 architecture

// microtasking routines specifically written for IA-32 architecture

#endif /* KMP_ARCH_X86 */

#endif /* KMP_ARCH_X86 */

// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

// microtasking routines specifically written for IA-32 architecture and

// microtasking routines specifically written for IA-32 architecture and

// -----------------------------------------------------------------------

// -----------------------------------------------------------------------

// '

// '

#if (KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64

#if (KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64

#endif // KMP_USE_FUTEX

#endif // KMP_USE_FUTEX

/* Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to

/* Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to

   use compare_and_store for these routines */

   use compare_and_store for these routines */

  return old_value;

  return old_value;

}

}

void __kmp_terminate_thread(int gtid) {

void __kmp_terminate_thread(int gtid) {

  int status;

  int status;

  KMP_CHECK_SYSFAIL("pthread_setcancelstate", status);

  KMP_CHECK_SYSFAIL("pthread_setcancelstate", status);

#endif

#endif

  // Set FP control regs to be a copy of the parallel initialization thread's.

  // Set FP control regs to be a copy of the parallel initialization thread's.

  __kmp_clear_x87_fpu_status_word();

  __kmp_clear_x87_fpu_status_word();

  __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);

  __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);

  __kmp_load_mxcsr(&__kmp_init_mxcsr);

  __kmp_load_mxcsr(&__kmp_init_mxcsr);

#ifdef KMP_BLOCK_SIGNALS

#ifdef KMP_BLOCK_SIGNALS

  status = sigfillset(&new_set);

  status = sigfillset(&new_set);

    return;

    return;

  }

  }

  if (!__kmp_cpuinfo.initialized) {

  if (!__kmp_cpuinfo.initialized) {

    __kmp_query_cpuid(&__kmp_cpuinfo);

    __kmp_query_cpuid(&__kmp_cpuinfo);

  }

  }

  __kmp_xproc = __kmp_get_xproc();

  __kmp_xproc = __kmp_get_xproc();

  return KMP_NSEC_PER_SEC * t.tv_sec + 1000 * t.tv_usec;

  return KMP_NSEC_PER_SEC * t.tv_sec + 1000 * t.tv_usec;

}

}

/* Measure clock ticks per millisecond */

/* Measure clock ticks per millisecond */

void __kmp_initialize_system_tick() {

void __kmp_initialize_system_tick() {

  kmp_uint64 delay = 100000; // 50~100 usec on most machines.

  kmp_uint64 delay = 100000; // 50~100 usec on most machines.

#endif // USE_LOAD_BALANCE

#endif // USE_LOAD_BALANCE

      ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) || KMP_ARCH_PPC64)

      ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) || KMP_ARCH_PPC64)

// we really only need the case with 1 argument, because CLANG always build

// we really only need the case with 1 argument, because CLANG always build

  define_ompt_label(id) \

  define_ompt_label(id) \

  print_possible_return_addresses(get_ompt_label_address(id))

  print_possible_return_addresses(get_ompt_label_address(id))

// On X86 the NOP instruction is 1 byte long. In addition, the comiler inserts

// On X86 the NOP instruction is 1 byte long. In addition, the comiler inserts

// a MOV instruction for non-void runtime functions which is 3 bytes long.

// a MOV instruction for non-void runtime functions which is 3 bytes long.

#define print_possible_return_addresses(addr) \

#define print_possible_return_addresses(addr) \