Replace platform macro with KMP_MIC_SUPPORTED

[jlpeyton]

Summary

Replace the KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS) platform specific pattern with KMP_MIC_SUPPORTED. This patch also allows 32-bit to support KNL.

[tlwilmar]

LGTM

openmp/trunk/runtime/src/kmp.h

 
 #if KMP_OS_LINUX
 enum clock_function_type {
   clock_function_gettimeofday,
   clock_function_clock_gettime
 };
 #endif /* KMP_OS_LINUX */
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
 enum mic_type { non_mic, mic1, mic2, mic3, dummy };
 #endif
 
 /* -- fast reduction stuff ------------------------------------------------ */
 
 #undef KMP_FAST_REDUCTION_BARRIER
 #define KMP_FAST_REDUCTION_BARRIER 1
 

 extern int __kmp_hot_teams_max_level;
 #endif
 
 #if KMP_OS_LINUX
 extern enum clock_function_type __kmp_clock_function;
 extern int __kmp_clock_function_param;
 #endif /* KMP_OS_LINUX */
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
 extern enum mic_type __kmp_mic_type;
 #endif
 
 #ifdef USE_LOAD_BALANCE
 extern double __kmp_load_balance_interval; // load balance algorithm interval
 #endif /* USE_LOAD_BALANCE */
 
 // OpenMP 3.1 - Nested num threads array

openmp/trunk/runtime/src/kmp_global.cpp

enum sched_type __kmp_sch_map[kmp_sched_upper - kmp_sched_lower_ext +
     // of public intel extension schedules
 };
 
 #if KMP_OS_LINUX
 enum clock_function_type __kmp_clock_function;
 int __kmp_clock_function_param;
 #endif /* KMP_OS_LINUX */
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
 enum mic_type __kmp_mic_type = non_mic;
 #endif
 
 #if KMP_AFFINITY_SUPPORTED
 
 KMPAffinity *__kmp_affinity_dispatch = NULL;
 
 #if KMP_USE_HWLOC

openmp/trunk/runtime/src/kmp_platform.h

 #define KMP_MIC 0
 #define KMP_MIC1 0
 #define KMP_MIC2 0
 #endif
 
 /* Specify 32 bit architectures here */
 #define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS)
 
+// Platforms which support Intel(R) Many Integrated Core Architecture
+#define KMP_MIC_SUPPORTED                                                      \
+  ((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
+
 // TODO: Fixme - This is clever, but really fugly
 #if (1 !=                                                                      \
      KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +          \
          KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64)
 #error Unknown or unsupported architecture
 #endif
 
 #endif // KMP_PLATFORM_H

openmp/trunk/runtime/src/kmp_runtime.cpp

void __kmp_unregister_library(void) {
   __kmp_registration_flag = 0;
   __kmp_registration_str = NULL;
 
 } // __kmp_unregister_library
 
 // End of Library registration stuff.
 // -----------------------------------------------------------------------------
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
 
 static void __kmp_check_mic_type() {
   kmp_cpuid_t cpuid_state = {0};
   kmp_cpuid_t *cs_p = &cpuid_state;
   __kmp_x86_cpuid(1, 0, cs_p);
   // We don't support mic1 at the moment
   if ((cs_p->eax & 0xff0) == 0xB10) {
     __kmp_mic_type = mic2;
   } else if ((cs_p->eax & 0xf0ff0) == 0x50670) {
     __kmp_mic_type = mic3;
   } else {
     __kmp_mic_type = non_mic;
   }
 }
 
-#endif /* KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS) */
+#endif /* KMP_MIC_SUPPORTED */
 
 static void __kmp_do_serial_initialize(void) {
   int i, gtid;
   int size;
 
   KA_TRACE(10, ("__kmp_do_serial_initialize: enter\n"));
 
   KMP_DEBUG_ASSERT(sizeof(kmp_int32) == 4);
#if KMP_USE_MONITOR
   __kmp_init_bootstrap_lock(&__kmp_monitor_lock);
 #endif
   __kmp_init_bootstrap_lock(&__kmp_tp_cached_lock);
 
   /* conduct initialization and initial setup of configuration */
 
   __kmp_runtime_initialize();
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
   __kmp_check_mic_type();
 #endif
 
 // Some global variable initialization moved here from kmp_env_initialize()
 #ifdef KMP_DEBUG
   kmp_diag = 0;
 #endif
   __kmp_abort_delay = 0;

 #endif // KMP_FAST_REDUCTION_BARRIER
   }
 #if KMP_FAST_REDUCTION_BARRIER
 #undef kmp_reduction_barrier_release_pat
 #undef kmp_reduction_barrier_gather_pat
 #undef kmp_reduction_barrier_release_bb
 #undef kmp_reduction_barrier_gather_bb
 #endif // KMP_FAST_REDUCTION_BARRIER
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
   if (__kmp_mic_type == mic2) { // KNC
     // AC: plane=3,2, forkjoin=2,1 are optimal for 240 threads on KNC
     __kmp_barrier_gather_branch_bits[bs_plain_barrier] = 3; // plain gather
     __kmp_barrier_release_branch_bits[bs_forkjoin_barrier] =
         1; // forkjoin release
     __kmp_barrier_gather_pattern[bs_forkjoin_barrier] = bp_hierarchical_bar;
     __kmp_barrier_release_pattern[bs_forkjoin_barrier] = bp_hierarchical_bar;
   }
 #if KMP_FAST_REDUCTION_BARRIER
   if (__kmp_mic_type == mic2) { // KNC
     __kmp_barrier_gather_pattern[bs_reduction_barrier] = bp_hierarchical_bar;
     __kmp_barrier_release_pattern[bs_reduction_barrier] = bp_hierarchical_bar;
   }
-#endif
-#endif
+#endif // KMP_FAST_REDUCTION_BARRIER
+#endif // KMP_MIC_SUPPORTED
 
 // From KMP_CHECKS initialization
 #ifdef KMP_DEBUG
   __kmp_env_checks = TRUE; /* development versions have the extra checks */
 #else
   __kmp_env_checks = FALSE; /* port versions do not have the extra checks */
 #endif
 

 
 #if KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64
 
 #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_WINDOWS ||       \
     KMP_OS_DARWIN
 
     int teamsize_cutoff = 4;
 
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
     if (__kmp_mic_type != non_mic) {
       teamsize_cutoff = 8;
     }
 #endif
     if (tree_available) {
       if (team_size <= teamsize_cutoff) {
         if (atomic_available) {
           retval = atomic_reduce_block;

openmp/trunk/runtime/src/kmp_settings.cpp

case affinity_balanced: {
     if (count > 0) {
       *out_compact = number[0];
     }; // if
     if (count > 1) {
       *out_offset = number[1];
     }; // if
 
     if (__kmp_affinity_gran == affinity_gran_default) {
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
       if (__kmp_mic_type != non_mic) {
         if (__kmp_affinity_verbose || __kmp_affinity_warnings) {
           KMP_WARNING(AffGranUsing, "KMP_AFFINITY", "fine");
         }
         __kmp_affinity_gran = affinity_gran_fine;
       } else
 #endif
       {
static void __kmp_stg_parse_proc_bind(char const *name, char const *value,
   }
 
   // In OMP 3.1, OMP_PROC_BIND is strictly a boolean
   __kmp_stg_parse_bool(name, value, &enabled);
   if (enabled) {
     // OMP_PROC_BIND => granularity=fine,scatter on MIC
     // OMP_PROC_BIND => granularity=core,scatter elsewhere
     __kmp_affinity_type = affinity_scatter;
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
     if (__kmp_mic_type != non_mic)
       __kmp_affinity_gran = affinity_gran_fine;
     else
 #endif
       __kmp_affinity_gran = affinity_gran_core;
   } else {
     __kmp_affinity_type = affinity_none;
   }
#if OMP_40_ENABLED
           if (__kmp_affinity_type == affinity_default) {
             __kmp_affinity_type = affinity_compact;
             __kmp_affinity_dups = FALSE;
           }
         } else
 #endif /* OMP_40_ENABLED */
             if (__kmp_affinity_type == affinity_default) {
 #if OMP_40_ENABLED
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
           if (__kmp_mic_type != non_mic) {
             __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
           } else
 #endif
           {
             __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
           }
 #endif /* OMP_40_ENABLED */
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
           if (__kmp_mic_type != non_mic) {
             __kmp_affinity_type = affinity_scatter;
           } else
 #endif
           {
             __kmp_affinity_type = affinity_none;
           }
         }
         if ((__kmp_affinity_gran == affinity_gran_default) &&
             (__kmp_affinity_gran_levels < 0)) {
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+#if KMP_MIC_SUPPORTED
           if (__kmp_mic_type != non_mic) {
             __kmp_affinity_gran = affinity_gran_fine;
           } else
 #endif
           {
             __kmp_affinity_gran = affinity_gran_core;
           }
         }