Teach OpenMP Library to use Hwloc on Windows

[jlpeyton]

Summary

This patch allows a user to enable Hwloc on windows. There are three main changes in here:

1. kmp.h - Move definitions/declarations out of KMP_OS_WINDOWS guard (our windows implementation of affinity) because they need to be defined when KMP_USE_HWLOC is on as well.
2. teach __kmp_set_system_affinity, __kmp_get_system_affinity, __kmp_get_proc_group, and __kmp_affinity_bind_thread how to use hwloc.
3. teach CMake how to include hwloc when building Windows

Another minor change in here is to make sure that anything under KMP_USE_HWLOC
is also guarded by KMP_AFFINITY_SUPPORTED as well. This is to prevent Mac
builds from requiring anything from Hwloc.

[tlwilmar]

LGTM

openmp/trunk/runtime/cmake/config-ix.cmake

if(LIBOMP_HAVE_WEAK_ATTRIBUTE OR LIBOMP_HAVE_PSAPI)
     set(LIBOMP_HAVE_OMPT_SUPPORT TRUE)
   else()
     set(LIBOMP_HAVE_OMPT_SUPPORT FALSE)
   endif()
 endif()
 
 # Check if HWLOC support is available
 if(${LIBOMP_USE_HWLOC})
-  if(WIN32)
-    set(LIBOMP_HAVE_HWLOC FALSE)
-    libomp_say("Using hwloc not supported on Windows yet")
-  else()
-    set(CMAKE_REQUIRED_INCLUDES ${LIBOMP_HWLOC_INSTALL_DIR}/include)
-    check_include_file(hwloc.h LIBOMP_HAVE_HWLOC_H)
-    set(CMAKE_REQUIRED_INCLUDES)
-    check_library_exists(hwloc hwloc_topology_init
+  find_library(LIBOMP_HWLOC_LIBRARY
+    NAMES hwloc libhwloc
+    HINTS ${LIBOMP_HWLOC_INSTALL_DIR}/lib)
+  if(LIBOMP_HWLOC_LIBRARY)
+    check_library_exists(${LIBOMP_HWLOC_LIBRARY} hwloc_topology_init
       ${LIBOMP_HWLOC_INSTALL_DIR}/lib LIBOMP_HAVE_LIBHWLOC)
-    find_library(LIBOMP_HWLOC_LIBRARY hwloc ${LIBOMP_HWLOC_INSTALL_DIR}/lib)
     get_filename_component(LIBOMP_HWLOC_LIBRARY_DIR ${LIBOMP_HWLOC_LIBRARY} PATH)
-    if(LIBOMP_HAVE_HWLOC_H AND LIBOMP_HAVE_LIBHWLOC AND LIBOMP_HWLOC_LIBRARY)
-      set(LIBOMP_HAVE_HWLOC TRUE)
-    else()
-      set(LIBOMP_HAVE_HWLOC FALSE)
-      libomp_say("Could not find hwloc")
-    endif()
-  endif()
-endif()
+  endif()
 

openmp/trunk/runtime/src/kmp.h

 #include "kmp_os.h"
 
 #include "kmp_safe_c_api.h"
 
 #if KMP_STATS_ENABLED
 class kmp_stats_list;
 #endif
 
-#if KMP_USE_HWLOC
-#include "hwloc.h"
-extern hwloc_topology_t __kmp_hwloc_topology;
-extern int __kmp_hwloc_error;
+#if KMP_USE_HWLOC && KMP_AFFINITY_SUPPORTED
+# include "hwloc.h"
 #endif
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 #include <xmmintrin.h>
 #endif
 
 #include "kmp_version.h"
 #include "kmp_debug.h"

 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 /*
  * Only Linux* OS and Windows* OS support thread affinity.
  */
 #if KMP_AFFINITY_SUPPORTED
 
+# if KMP_GROUP_AFFINITY
+// GROUP_AFFINITY is already defined for _MSC_VER>=1600 (VS2010 and later).
+#  if _MSC_VER < 1600
+typedef struct GROUP_AFFINITY {
+    KAFFINITY Mask;
+    WORD Group;
+    WORD Reserved[3];
+} GROUP_AFFINITY;
+#  endif /* _MSC_VER < 1600 */
+extern int __kmp_num_proc_groups;
+typedef DWORD (*kmp_GetActiveProcessorCount_t)(WORD);
+extern kmp_GetActiveProcessorCount_t __kmp_GetActiveProcessorCount;
+
+typedef WORD (*kmp_GetActiveProcessorGroupCount_t)(void);
+extern kmp_GetActiveProcessorGroupCount_t __kmp_GetActiveProcessorGroupCount;
+
+typedef BOOL (*kmp_GetThreadGroupAffinity_t)(HANDLE, GROUP_AFFINITY *);
+extern kmp_GetThreadGroupAffinity_t __kmp_GetThreadGroupAffinity;
+
+typedef BOOL (*kmp_SetThreadGroupAffinity_t)(HANDLE, const GROUP_AFFINITY *, GROUP_AFFINITY *);
+extern kmp_SetThreadGroupAffinity_t __kmp_SetThreadGroupAffinity;
+# endif /* KMP_GROUP_AFFINITY */
+
 extern size_t __kmp_affin_mask_size;
 # define KMP_AFFINITY_CAPABLE() (__kmp_affin_mask_size > 0)
 # define KMP_AFFINITY_DISABLE() (__kmp_affin_mask_size = 0)
 # define KMP_AFFINITY_ENABLE(mask_size) (__kmp_affin_mask_size = mask_size)
-# define KMP_CPU_SETSIZE        (__kmp_affin_mask_size * CHAR_BIT)
+# if !KMP_USE_HWLOC
+#  define KMP_CPU_SETSIZE        (__kmp_affin_mask_size * CHAR_BIT)
+#  define KMP_CPU_SET_ITERATE(i,mask) \
+    for(i = 0; (size_t)i < KMP_CPU_SETSIZE; ++i)
+# endif
 
 #if KMP_USE_HWLOC
 
+extern hwloc_topology_t __kmp_hwloc_topology;
+extern int __kmp_hwloc_error;
 typedef hwloc_cpuset_t kmp_affin_mask_t;
 # define KMP_CPU_SET(i,mask)       hwloc_bitmap_set((hwloc_cpuset_t)mask, (unsigned)i)
 # define KMP_CPU_ISSET(i,mask)     hwloc_bitmap_isset((hwloc_cpuset_t)mask, (unsigned)i)
 # define KMP_CPU_CLR(i,mask)       hwloc_bitmap_clr((hwloc_cpuset_t)mask, (unsigned)i)
 # define KMP_CPU_ZERO(mask)        hwloc_bitmap_zero((hwloc_cpuset_t)mask)
 # define KMP_CPU_COPY(dest, src)   hwloc_bitmap_copy((hwloc_cpuset_t)dest, (hwloc_cpuset_t)src)
 # define KMP_CPU_AND(dest, src)    hwloc_bitmap_and((hwloc_cpuset_t)dest, (hwloc_cpuset_t)dest, (hwloc_cpuset_t)src)
 # define KMP_CPU_COMPLEMENT(max_bit_number, mask) \
# define KMP_CPU_INTERNAL_FREE_ARRAY(arr, n) { \
     unsigned i;                                 \
     for(i=0;i<(unsigned)n;i++) {                \
         hwloc_bitmap_free(arr[i]);              \
     }                                           \
     KMP_INTERNAL_FREE(arr);                     \
    }
 
 #else /* KMP_USE_HWLOC */
-#  define KMP_CPU_SET_ITERATE(i,mask) \
-    for(i = 0; (size_t)i < KMP_CPU_SETSIZE; ++i)
-
 # if KMP_OS_LINUX
 //
 // On Linux* OS, the mask is actually a vector of length __kmp_affin_mask_size
 // (in bytes).  It should be allocated on a word boundary.
 //
 // WARNING!!!  We have made the base type of the affinity mask unsigned char,
 // in order to eliminate a lot of checks that the true system mask size is
 // really a multiple of 4 bytes (on Linux* OS).

 
 # if KMP_OS_WINDOWS
 //
 // On Windows* OS, the mask size is 4 bytes for IA-32 architecture, and on
 // Intel(R) 64 it is 8 bytes times the number of processor groups.
 //
 
 #  if KMP_GROUP_AFFINITY
-
-// GROUP_AFFINITY is already defined for _MSC_VER>=1600 (VS2010 and later).
-#   if _MSC_VER < 1600
-typedef struct GROUP_AFFINITY {
-    KAFFINITY Mask;
-    WORD Group;
-    WORD Reserved[3];
-} GROUP_AFFINITY;
-#   endif
-
 typedef DWORD_PTR kmp_affin_mask_t;
 
-extern int __kmp_num_proc_groups;
-
 #   define _KMP_CPU_SET(i,mask) \
         (mask[i/(CHAR_BIT * sizeof(kmp_affin_mask_t))] |=                    \
         (((kmp_affin_mask_t)1) << (i % (CHAR_BIT * sizeof(kmp_affin_mask_t)))))
 
 #   define KMP_CPU_SET(i,mask) \
         _KMP_CPU_SET((i), ((kmp_affin_mask_t *)(mask)))
 
 #   define _KMP_CPU_ISSET(i,mask) \
#   define KMP_CPU_UNION(dest, src) \
         {                                                                    \
             int __i;                                                         \
             for (__i = 0; __i < __kmp_num_proc_groups; __i++) {              \
                 ((kmp_affin_mask_t *)(dest))[__i]                            \
                   |= ((kmp_affin_mask_t *)(src))[__i];                       \
             }                                                                \
         }
 
-typedef DWORD (*kmp_GetActiveProcessorCount_t)(WORD);
-extern kmp_GetActiveProcessorCount_t __kmp_GetActiveProcessorCount;
-
-typedef WORD (*kmp_GetActiveProcessorGroupCount_t)(void);
-extern kmp_GetActiveProcessorGroupCount_t __kmp_GetActiveProcessorGroupCount;
-
-typedef BOOL (*kmp_GetThreadGroupAffinity_t)(HANDLE, GROUP_AFFINITY *);
-extern kmp_GetThreadGroupAffinity_t __kmp_GetThreadGroupAffinity;
-
-typedef BOOL (*kmp_SetThreadGroupAffinity_t)(HANDLE, const GROUP_AFFINITY *, GROUP_AFFINITY *);
-extern kmp_SetThreadGroupAffinity_t __kmp_SetThreadGroupAffinity;
-
-extern int __kmp_get_proc_group(kmp_affin_mask_t const *mask);
 
 #  else /* KMP_GROUP_AFFINITY */
 
 typedef DWORD kmp_affin_mask_t; /* for compatibility with older winbase.h */
 
 #   define KMP_CPU_SET(i,mask)      (*(mask) |= (((kmp_affin_mask_t)1) << (i)))
 #   define KMP_CPU_ISSET(i,mask)    (!!(*(mask) & (((kmp_affin_mask_t)1) << (i))))
 #   define KMP_CPU_CLR(i,mask)      (*(mask) &= ~(((kmp_affin_mask_t)1) << (i)))
# define KMP_CPU_INDEX(array,i) \
         ((kmp_affin_mask_t *)(((char *)(array)) + (i) * __kmp_affin_mask_size))
 # define KMP_CPU_ALLOC_ARRAY(arr, n)  arr = (kmp_affin_mask_t *)__kmp_allocate(n * __kmp_affin_mask_size)
 # define KMP_CPU_FREE_ARRAY(arr, n) __kmp_free(arr);
 # define KMP_CPU_INTERNAL_ALLOC_ARRAY(arr, n)  arr = (kmp_affin_mask_t *)KMP_INTERNAL_MALLOC(n * __kmp_affin_mask_size)
 # define KMP_CPU_INTERNAL_FREE_ARRAY(arr, n) KMP_INTERNAL_FREE(arr);
 
 #endif /* KMP_USE_HWLOC */
 
+// prototype after typedef of kmp_affin_mask_t
+#if KMP_GROUP_AFFINITY
+extern int __kmp_get_proc_group(kmp_affin_mask_t const *mask);
+#endif
+
 //
 // Declare local char buffers with this size for printing debug and info
 // messages, using __kmp_affinity_print_mask().
 //
 #define KMP_AFFIN_MASK_PRINT_LEN        1024
 
 enum affinity_type {
     affinity_none = 0,

openmp/trunk/runtime/src/kmp_ftn_entry.h

#else
         //
         if ( ! TCR_4(__kmp_init_middle) ) {
             __kmp_middle_initialize();
         }
         if ( ! ( KMP_AFFINITY_CAPABLE() ) ) {
             return 0;
         }
 
-    #if KMP_GROUP_AFFINITY && !KMP_USE_HWLOC
+    #if KMP_GROUP_AFFINITY
         if ( __kmp_num_proc_groups > 1 ) {
-            return (int)KMP_CPU_SETSIZE;
+            return (int)(__kmp_num_proc_groups*sizeof(DWORD_PTR)*CHAR_BIT);
         }
     #endif /* KMP_GROUP_AFFINITY */
         return __kmp_xproc;
     #endif
 }
 
 void FTN_STDCALL
 FTN_CREATE_AFFINITY_MASK( void **mask )

openmp/trunk/runtime/src/kmp_global.c

 kmp_stats_list __kmp_stats_list;
 
 // thread local pointer to stats node within list
 __thread kmp_stats_list* __kmp_stats_thread_ptr = &__kmp_stats_list;
 
 // gives reference tick for all events (considered the 0 tick)
 tsc_tick_count __kmp_stats_start_time;
 #endif
-#if KMP_USE_HWLOC
-int __kmp_hwloc_error = FALSE;
-hwloc_topology_t __kmp_hwloc_topology = NULL;
-#endif
 
 /* ----------------------------------------------------- */
 /* INITIALIZATION VARIABLES */
 /* they are syncronized to write during init, but read anytime */
 volatile int        __kmp_init_serial     = FALSE;
 volatile int        __kmp_init_gtid       = FALSE;
 volatile int        __kmp_init_common     = FALSE;
 volatile int        __kmp_init_middle     = FALSE;

 #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_USE_HWLOC
+int __kmp_hwloc_error = FALSE;
+hwloc_topology_t __kmp_hwloc_topology = NULL;
+# endif
+
 # if KMP_GROUP_AFFINITY
 
 int __kmp_num_proc_groups = 1;
 
 kmp_GetActiveProcessorCount_t __kmp_GetActiveProcessorCount = NULL;
 kmp_GetActiveProcessorGroupCount_t __kmp_GetActiveProcessorGroupCount = NULL;
 kmp_GetThreadGroupAffinity_t __kmp_GetThreadGroupAffinity = NULL;
 kmp_SetThreadGroupAffinity_t __kmp_SetThreadGroupAffinity = NULL;

openmp/trunk/runtime/src/z_Windows_NT_util.c

 // Return the appropriate index, or -1 for an invalid mask.
 //
 int
 __kmp_get_proc_group( kmp_affin_mask_t const *mask )
 {
     int i;
     int group = -1;
     for (i = 0; i < __kmp_num_proc_groups; i++) {
+#if KMP_USE_HWLOC
+        // On windows, the long type is always 32 bits
+        unsigned long first_32_bits = hwloc_bitmap_to_ith_ulong((hwloc_const_bitmap_t)mask, i*2);
+        unsigned long second_32_bits = hwloc_bitmap_to_ith_ulong((hwloc_const_bitmap_t)mask, i*2+1);
+        if (first_32_bits == 0 && second_32_bits == 0) {
+            continue;
+        }
+#else
         if (mask[i] == 0) {
             continue;
         }
+#endif
         if (group >= 0) {
             return -1;
         }
         group = i;
     }
     return group;
 }
 
 #endif /* KMP_GROUP_AFFINITY */
 
 int
 __kmp_set_system_affinity( kmp_affin_mask_t const *mask, int abort_on_error )
 {
-
-#if KMP_GROUP_AFFINITY
+#if KMP_USE_HWLOC
+    int retval = hwloc_set_cpubind(__kmp_hwloc_topology, (hwloc_cpuset_t)mask, HWLOC_CPUBIND_THREAD);
+    if (retval >= 0) {
+        return 0;
+    }
+    int error = errno;
+    if (abort_on_error) {
+        __kmp_msg(
+            kmp_ms_fatal,
+            KMP_MSG( FatalSysError ),
+            KMP_ERR( error ),
+            __kmp_msg_null
+        );
+    }
+    return error;
+#else
+# if KMP_GROUP_AFFINITY
 
     if (__kmp_num_proc_groups > 1) {
         //
         // Check for a valid mask.
         //
         GROUP_AFFINITY ga;
         int group = __kmp_get_proc_group( mask );
         if (group < 0) {
if (__kmp_num_proc_groups > 1) {
                     __kmp_msg_null
                 );
             }
             return error;
         }
     }
     else
 
-#endif /* KMP_GROUP_AFFINITY */
+# endif /* KMP_GROUP_AFFINITY */
 
     {
         if (!SetThreadAffinityMask( GetCurrentThread(), *mask )) {
             DWORD error = GetLastError();
             if (abort_on_error) {
                 __kmp_msg(
                     kmp_ms_fatal,
                     KMP_MSG( CantSetThreadAffMask ),
                     KMP_ERR( error ),
                     __kmp_msg_null
                 );
             }
             return error;
         }
     }
+#endif /* KMP_USE_HWLOC */
     return 0;
 }
 
 int
 __kmp_get_system_affinity( kmp_affin_mask_t *mask, int abort_on_error )
 {
-
-#if KMP_GROUP_AFFINITY
+#if KMP_USE_HWLOC
+    int retval = hwloc_get_cpubind(__kmp_hwloc_topology, (hwloc_cpuset_t)mask, HWLOC_CPUBIND_THREAD);
+    if (retval >= 0) {
+        return 0;
+    }
+    int error = errno;
+    if (abort_on_error) {
+        __kmp_msg(
+            kmp_ms_fatal,
+            KMP_MSG( FatalSysError ),
+            KMP_ERR( error ),
+            __kmp_msg_null
+        );
+    }
+    return error;
+#else /* KMP_USE_HWLOC */
+# if KMP_GROUP_AFFINITY
 
     if (__kmp_num_proc_groups > 1) {
         KMP_CPU_ZERO(mask);
         GROUP_AFFINITY ga;
         KMP_DEBUG_ASSERT(__kmp_GetThreadGroupAffinity != NULL);
 
         if (__kmp_GetThreadGroupAffinity(GetCurrentThread(), &ga) == 0) {
             DWORD error = GetLastError();
if (__kmp_num_proc_groups > 1) {
           || (ga.Mask == 0)) {
             return -1;
         }
 
         mask[ga.Group] = ga.Mask;
     }
     else
 
-#endif /* KMP_GROUP_AFFINITY */
+# endif /* KMP_GROUP_AFFINITY */
 
     {
         kmp_affin_mask_t newMask, sysMask, retval;
 
         if (!GetProcessAffinityMask(GetCurrentProcess(), &newMask, &sysMask)) {
             DWORD error = GetLastError();
             if (abort_on_error) {
                 __kmp_msg(
# endif /* KMP_GROUP_AFFINITY */
                     KMP_MSG(FunctionError, "SetThreadAffinityMask()"),
                     KMP_ERR(error),
                     __kmp_msg_null
                 );
             }
         }
         *mask = retval;
     }
+#endif /* KMP_USE_HWLOC */
     return 0;
 }
 
 void
 __kmp_affinity_bind_thread( int proc )
 {
-
-#if KMP_GROUP_AFFINITY
+#if KMP_USE_HWLOC
+    kmp_affin_mask_t *mask;
+    KMP_CPU_ALLOC_ON_STACK(mask);
+    KMP_CPU_ZERO(mask);
+    KMP_CPU_SET(proc, mask);
+    __kmp_set_system_affinity(mask, TRUE);
+    KMP_CPU_FREE_FROM_STACK(mask);
+#else /* KMP_USE_HWLOC */
+# if KMP_GROUP_AFFINITY
 
     if (__kmp_num_proc_groups > 1) {
         //
         // Form the GROUP_AFFINITY struct directly, rather than filling
         // out a bit vector and calling __kmp_set_system_affinity().
         //
         GROUP_AFFINITY ga;
         KMP_DEBUG_ASSERT((proc >= 0) && (proc < (__kmp_num_proc_groups
if (__kmp_num_proc_groups > 1) {
                     KMP_ERR( error ),
                     __kmp_msg_null
                 );
             }
         }
     }
     else
 
-#endif /* KMP_GROUP_AFFINITY */
+# endif /* KMP_GROUP_AFFINITY */
 
     {
         kmp_affin_mask_t mask;
         KMP_CPU_ZERO(&mask);
         KMP_CPU_SET(proc, &mask);
         __kmp_set_system_affinity(&mask, TRUE);
     }
+#endif /* KMP_USE_HWLOC */
 }
 
 void
 __kmp_affinity_determine_capable( const char *env_var )
 {
     //
     // All versions of Windows* OS (since Win '95) support SetThreadAffinityMask().
     //