Dynamic Intel(R) Many Integrated Core Architecture detection.

[jlpeyton]

Summary

Inserted code to detect MIC dynamically and set certain default settings (e.g., affinity) at runtime instead of build time.

[hfinkel]

LGTM.

runtime/src/kmp.h

401

Why is 'dummy' here? You don't seem to use it anywhere.

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)
+enum mic_type {
+    non_mic,
+    mic1,
+    mic2,
+    mic3,
+    dummy
+};
+#endif
+
 /* ------------------------------------------------------------------------ */
 /* -- fast reduction stuff ------------------------------------------------ */
 
 #undef KMP_FAST_REDUCTION_BARRIER
 #define KMP_FAST_REDUCTION_BARRIER 1
 
 #undef KMP_FAST_REDUCTION_CORE_DUO
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64

 #  define KMP_NEXT_WAIT   512U          /* susequent number of spin-tests */
 #elif KMP_OS_FREEBSD
 /* TODO: tune for KMP_OS_FREEBSD */
 #  define KMP_INIT_WAIT  1024U          /* initial number of spin-tests   */
 #  define KMP_NEXT_WAIT   512U          /* susequent number of spin-tests */
 #endif
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-struct kmp_cpuid {
+typedef struct kmp_cpuid {
     kmp_uint32  eax;
     kmp_uint32  ebx;
     kmp_uint32  ecx;
     kmp_uint32  edx;
-};
+} kmp_cpuid_t;
 extern void __kmp_x86_cpuid( int mode, int mode2, struct kmp_cpuid *p );
 # if KMP_ARCH_X86
   extern void __kmp_x86_pause( void );
 # elif KMP_MIC
   static void __kmp_x86_pause( void ) { _mm_delay_32( 100 ); };
 # else
   static void __kmp_x86_pause( void ) { _mm_pause(); };
 # endif

 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)
+extern enum mic_type __kmp_mic_type;
+#endif
+
 # ifdef USE_LOAD_BALANCE
 extern double      __kmp_load_balance_interval;   /* Interval for the load balance algorithm */
 # endif /* USE_LOAD_BALANCE */
 
 // OpenMP 3.1 - Nested num threads array
 typedef struct kmp_nested_nthreads_t {
     int * nth;
     int   size;

runtime/src/kmp_global.c

kmp_sch_trapezoidal         // ==> kmp_sched_trapezoidal       = 101
                                 // 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)
+enum mic_type __kmp_mic_type = non_mic;
+#endif
+
 #if KMP_AFFINITY_SUPPORTED
 
 # if KMP_GROUP_AFFINITY
 
 int __kmp_num_proc_groups = 1;
 
 kmp_GetActiveProcessorCount_t __kmp_GetActiveProcessorCount = NULL;
 kmp_GetActiveProcessorGroupCount_t __kmp_GetActiveProcessorGroupCount = NULL;

runtime/src/kmp_runtime.c

__kmp_unregister_library( void ) {
     __kmp_registration_str  = NULL;
 
 } // __kmp_unregister_library
 
 
 // End of Library registration stuff.
 // -------------------------------------------------------------------------------------------------
 
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+
+static void __kmp_check_mic_type()
+{
+    kmp_cpuid_t cpuid_state = {0};
+    kmp_cpuid_t * cs_p = &cpuid_state;
+    cs_p->eax=1;
+    cs_p->ecx=0;
+    __asm__ __volatile__("cpuid"
+       : "+a" (cs_p->eax), "=b" (cs_p->ebx), "+c" (cs_p->ecx), "=d" (cs_p->edx));
+    // 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) */
+
 static void
 __kmp_do_serial_initialize( void )
 {
     int i, gtid;
     int size;
 
     KA_TRACE( 10, ("__kmp_do_serial_initialize: enter\n" ) );
 
#endif
     __kmp_init_bootstrap_lock( & __kmp_exit_lock      );
     __kmp_init_bootstrap_lock( & __kmp_monitor_lock   );
     __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)
+    __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;
 
     // From __kmp_init_dflt_team_nth()
     /* assume the entire machine will be used */
for ( i=bs_plain_barrier; i<bs_last_barrier; i++ ) {
         #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_MIC
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+    if( __kmp_mic_type != non_mic ) {
         // AC: plane=3,2, forkjoin=2,1 are optimal for 240 threads on KNC
         __kmp_barrier_gather_branch_bits [ bs_plain_barrier ] = 3;  // plane 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 != non_mic ) {
         __kmp_barrier_gather_pattern [ bs_reduction_barrier ] = bp_hierarchical_bar;
         __kmp_barrier_release_pattern[ bs_reduction_barrier ] = bp_hierarchical_bar;
+    }
 #endif
-    #endif
 
     // 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
 
__kmp_determine_reduction_method( ident_t *loc, kmp_int32 global_tid,
     // If ( reduce_data!=NULL && reduce_func!=NULL ): the tree-reduction method can be selected by RTL
     // If loc->flags contains KMP_IDENT_ATOMIC_REDUCE, the atomic reduce method can be selected by RTL
     // Finally, it's up to OpenMP RTL to make a decision on which method to select among generated by PAROPT.
 
     PACKED_REDUCTION_METHOD_T retval;
 
     int team_size;
 
+    int teamsize_cutoff = 4;
+
     KMP_DEBUG_ASSERT( loc );    // it would be nice to test ( loc != 0 )
     KMP_DEBUG_ASSERT( lck );    // it would be nice to test ( lck != 0 )
 
     #define FAST_REDUCTION_ATOMIC_METHOD_GENERATED ( ( loc->flags & ( KMP_IDENT_ATOMIC_REDUCE ) ) == ( KMP_IDENT_ATOMIC_REDUCE ) )
     #define FAST_REDUCTION_TREE_METHOD_GENERATED   ( ( reduce_data ) && ( reduce_func ) )
 
     retval = critical_reduce_block;
 
     team_size = __kmp_get_team_num_threads( global_tid ); // another choice of getting a team size ( with 1 dynamic deference ) is slower
 
     if( team_size == 1 ) {
 
         retval = empty_reduce_block;
 
     } else {
 
         int atomic_available = FAST_REDUCTION_ATOMIC_METHOD_GENERATED;
         int tree_available   = FAST_REDUCTION_TREE_METHOD_GENERATED;
 
         #if KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64
 
             #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS || KMP_OS_DARWIN
-                #if KMP_MIC
-                    #define REDUCTION_TEAMSIZE_CUTOFF 8
-                #else // KMP_MIC
-                    #define REDUCTION_TEAMSIZE_CUTOFF 4
-                #endif // KMP_MIC
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+                if( __kmp_mic_type != non_mic ) {
+                    teamsize_cutoff = 8;
+                }
+#endif
                 if( tree_available ) {
-                    if( team_size <= REDUCTION_TEAMSIZE_CUTOFF ) {
+                    if( team_size <= teamsize_cutoff ) {
                         if ( atomic_available ) {
                             retval = atomic_reduce_block;
                         }
                     } else {
                         retval = TREE_REDUCE_BLOCK_WITH_REDUCTION_BARRIER;
                     }
                 } else if ( atomic_available ) {
                     retval = atomic_reduce_block;

runtime/src/kmp_settings.c

switch ( *out_type ) {
             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_MIC
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+                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
+                } else
+#endif
+                {
                     if( __kmp_affinity_verbose || __kmp_affinity_warnings ) {
                         KMP_WARNING( AffGranUsing, "KMP_AFFINITY", "core" );
                     }
                     __kmp_affinity_gran = affinity_gran_core;
-# endif /* KMP_MIC */
+                }
             }
         } break;
         case affinity_scatter:
         case affinity_compact: {
             if ( count > 0 ) {
                 *out_compact = number[ 0 ];
             }; // if
             if ( count > 1 ) {
__kmp_stg_parse_proc_bind( char const * name, char const * value, void * data )
     //
     __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_MIC
+            if( __kmp_mic_type != non_mic ) {
                 __kmp_affinity_gran = affinity_gran_fine;
-#  else
+            } else {
                 __kmp_affinity_gran = affinity_gran_core;
-#  endif /* KMP_MIC */
+            }
     }
     else {
         __kmp_affinity_type = affinity_none;
     }
 } // __kmp_parse_proc_bind
 
 # endif /* if (! OMP_40_ENABLED) */
 
# 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 KMP_MIC
-                    __kmp_affinity_type = affinity_scatter;
-#  if OMP_40_ENABLED
+#if OMP_40_ENABLED
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+                    if( __kmp_mic_type != non_mic ) {
                         __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
-#  endif
-# else
-                    __kmp_affinity_type = affinity_none;
-#  if OMP_40_ENABLED
+                    } else
+#endif
+                    {
                         __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
-#  endif
-# endif
+                    }
+#endif /* OMP_40_ENABLED */
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+                    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_MIC
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
+                    if( __kmp_mic_type != non_mic ) {
                         __kmp_affinity_gran = affinity_gran_fine;
-# else
-                    __kmp_affinity_gran = affinity_gran_core;
-# endif
+                    } else
+#endif
+                    {
+                        __kmp_affinity_gran = affinity_gran_core;
+                    }
                 }
                 if ( __kmp_affinity_top_method == affinity_top_method_default ) {
                     __kmp_affinity_top_method = affinity_top_method_all;
                 }
             }
         }
 
         K_DIAG( 1, ( "__kmp_affinity_type         == %d\n", __kmp_affinity_type         ) );