Mask processing improvements

[tlwilmar]

Summary

Remove static specifier from var fullMask and remove kmp_get_fullMask() routine.
When iterating through procs in a mask, always check if proc is in fullMask (this check was missing in a few places).

Patch by Brian Bliss.

[tlwilmar]

Also, rename fullMask to __kmp_affin_fullMask.

[jlpeyton]

LGTM

runtime/src/kmp.h

# define KMP_CPU_COMPLEMENT(max_bit_number, mask) \
         for(i=0;i<(unsigned)max_bit_number+1;i++) { \
             if(hwloc_bitmap_isset((hwloc_cpuset_t)mask, i)) { \
                 hwloc_bitmap_clr((hwloc_cpuset_t)mask, i); \
             } else { \
                 hwloc_bitmap_set((hwloc_cpuset_t)mask, i); \
             } \
         } \
         hwloc_bitmap_and((hwloc_cpuset_t)mask, (hwloc_cpuset_t)mask, \
-            (hwloc_cpuset_t)__kmp_affinity_get_fullMask()); \
+            (hwloc_cpuset_t)fullMask); \
     } \
 
 # define KMP_CPU_UNION(dest, src)  hwloc_bitmap_or((hwloc_cpuset_t)dest, (hwloc_cpuset_t)dest, (hwloc_cpuset_t)src)
 # define KMP_CPU_SET_ITERATE(i,mask) \
     for(i = hwloc_bitmap_first((hwloc_cpuset_t)mask); (int)i != -1; i = hwloc_bitmap_next((hwloc_cpuset_t)mask, i))
 
 # define KMP_CPU_ALLOC(ptr) ptr = (kmp_affin_mask_t*)hwloc_bitmap_alloc()
 # define KMP_CPU_FREE(ptr) hwloc_bitmap_free((hwloc_bitmap_t)ptr);

 
 #  define KMP_CPU_COMPLEMENT(max_bit_number, mask) \
         {                                                                    \
             size_t __i;                                                      \
             for (__i = 0; __i < __kmp_affin_mask_size; __i++) {              \
                 ((kmp_affin_mask_t *)(mask))[__i]                            \
                   = ~((kmp_affin_mask_t *)(mask))[__i];                      \
             }                                                                \
-            KMP_CPU_AND(mask, __kmp_affinity_get_fullMask());                \
+            KMP_CPU_AND(mask, fullMask);                                     \
         }
 
 #  define KMP_CPU_UNION(dest, src) \
         {                                                                    \
             size_t __i;                                                      \
             for (__i = 0; __i < __kmp_affin_mask_size; __i++) {              \
                 ((kmp_affin_mask_t *)(dest))[__i]                            \
                   |= ((kmp_affin_mask_t *)(src))[__i];                       \

 
 #   define KMP_CPU_COMPLEMENT(max_bit_number, mask) \
         {                                                                    \
             int __i;                                                         \
             for (__i = 0; __i < __kmp_num_proc_groups; __i++) {              \
                 ((kmp_affin_mask_t *)(mask))[__i]                            \
                   = ~((kmp_affin_mask_t *)(mask))[__i];                      \
             }                                                                \
-            KMP_CPU_AND(mask, __kmp_affinity_get_fullMask());                \
+            KMP_CPU_AND(mask, fullMask);                                     \
         }
 
 #   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_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_ZERO(mask)       (*(mask) = 0)
 #   define KMP_CPU_COPY(dest, src)  (*(dest) = *(src))
 #   define KMP_CPU_AND(dest, src)   (*(dest) &= *(src))
-#   define KMP_CPU_COMPLEMENT(max_bit_number, mask) (*(mask) = ~*(mask)); KMP_CPU_AND(mask, __kmp_affinity_get_fullMask())
+#   define KMP_CPU_COMPLEMENT(max_bit_number, mask) (*(mask) = ~*(mask)); KMP_CPU_AND(mask, fullMask)
 #   define KMP_CPU_UNION(dest, src) (*(dest) |= *(src))
 
 #  endif /* KMP_GROUP_AFFINITY */
 
 # endif /* KMP_OS_WINDOWS */
 
 //
 // __kmp_allocate() will return memory allocated on a 4-bytes boundary.

 extern int __kmp_affinity_respect_mask; /* Respect process' initial affinity mask? */
 extern char * __kmp_affinity_proclist; /* proc ID list */
 extern kmp_affin_mask_t *__kmp_affinity_masks;
 extern unsigned __kmp_affinity_num_masks;
 extern int __kmp_get_system_affinity(kmp_affin_mask_t *mask, int abort_on_error);
 extern int __kmp_set_system_affinity(kmp_affin_mask_t const *mask, int abort_on_error);
 extern void __kmp_affinity_bind_thread(int which);
 
-extern kmp_affin_mask_t *__kmp_affinity_get_fullMask();
+extern kmp_affin_mask_t *fullMask;
 extern char const * __kmp_cpuinfo_file;
 
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if OMP_40_ENABLED
 
 //
 // This needs to be kept in sync with the values in omp.h !!!

runtime/src/kmp_affinity.cpp

 // return the number of levels in the machine topology tree (zero if
 // __kmp_affinity_type == affinity_none).
 //
 // All of the __kmp_affinity_create_*_map() routines should set *fullMask
 // to the affinity mask for the initialization thread.  They need to save and
 // restore the mask, and it could be needed later, so saving it is just an
 // optimization to avoid calling kmp_get_system_affinity() again.
 //
-static kmp_affin_mask_t *fullMask = NULL;
-
-kmp_affin_mask_t *
-__kmp_affinity_get_fullMask() { return fullMask; }
-
+kmp_affin_mask_t *fullMask = NULL;
 
 static int nCoresPerPkg, nPackages;
 static int __kmp_nThreadsPerCore;
 #ifndef KMP_DFLT_NTH_CORES
 static int __kmp_ncores;
 #endif
 
 //
for (;;) {
             KMP_CPU_COPY(previousMask, tempMask);
             ADD_MASK(previousMask);
             KMP_CPU_ZERO(tempMask);
             setSize = 0;
             KMP_CPU_SET_ITERATE(j, previousMask) {
                 if (! KMP_CPU_ISSET(j, previousMask)) {
                     continue;
                 }
-                else if ((j+stride > maxOsId) || (j+stride < 0) ||
+                if ((j+stride > maxOsId) || (j+stride < 0) ||
+                  (! KMP_CPU_ISSET(j, fullMask)) ||
                   (! KMP_CPU_ISSET(j+stride, KMP_CPU_INDEX(osId2Mask, j+stride)))) {
                     if ((__kmp_affinity_verbose || (__kmp_affinity_warnings
                       && (__kmp_affinity_type != affinity_none))) && i < count - 1) {
                         KMP_WARNING(AffIgnoreInvalidProcID, j+stride);
                     }
+                    continue;
                 }
-                else {
-                    KMP_CPU_SET(j+stride, tempMask);
-                    setSize++;
-                }
-            }
-        }
         KMP_CPU_ZERO(tempMask);
         setSize = 0;
 
         //
         // valid follow sets are ',' and EOL
         //
         SKIP_WS(scan);
         if (*scan == '\0') {
if (__kmp_env_consistency_check) {
         if ((mask == NULL) || (*mask == NULL)) {
             KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
         }
         else {
             unsigned proc;
             int num_procs = 0;
 
             KMP_CPU_SET_ITERATE(proc, ((kmp_affin_mask_t*)(*mask))) {
+                if (! KMP_CPU_ISSET(proc, fullMask)) {
+                    KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
+                }
                 if (! KMP_CPU_ISSET(proc, (kmp_affin_mask_t *)(*mask))) {
                     continue;
                 }
                 num_procs++;
-                if (! KMP_CPU_ISSET(proc, fullMask)) {
-                    KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
-                    break;
-                }
             }
             if (num_procs == 0) {
                 KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
             }
 
 # if KMP_GROUP_AFFINITY
             if (__kmp_get_proc_group((kmp_affin_mask_t *)(*mask)) < 0) {
                 KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");

runtime/src/kmp_ftn_entry.h

#else
         int retval = 0;
         if ( ! TCR_4(__kmp_init_middle) ) {
             __kmp_middle_initialize();
         }
         if ( place_num < 0 || place_num >= (int)__kmp_affinity_num_masks )
             return 0;
         kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
         KMP_CPU_SET_ITERATE(i, mask) {
-            if ( !KMP_CPU_ISSET(i, mask) )
+            if ((! KMP_CPU_ISSET(i, fullMask)) ||
+              (!KMP_CPU_ISSET(i, mask))) {
                 continue;
+            }
             ++retval;
         }
         return retval;
     #endif
 }
 
 void FTN_STDCALL
 FTN_GET_PLACE_PROC_IDS( int place_num, int *ids )
 {
     #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
     // Nothing.
     #else
         int i,j;
         if ( ! TCR_4(__kmp_init_middle) ) {
             __kmp_middle_initialize();
         }
         if ( place_num < 0 || place_num >= (int)__kmp_affinity_num_masks )
             return;
         kmp_affin_mask_t *mask = KMP_CPU_INDEX(__kmp_affinity_masks, place_num);
         j = 0;
         KMP_CPU_SET_ITERATE(i, mask) {
-            if ( !KMP_CPU_ISSET(i, mask) )
+            if ((! KMP_CPU_ISSET(i, fullMask)) ||
+              (!KMP_CPU_ISSET(i, mask))) {
                 continue;
+            }
             ids[j++] = i;
         }
     #endif
 }
 
 int FTN_STDCALL
 FTN_GET_PLACE_NUM( void )
 {

runtime/src/kmp_runtime.c

if ( KMP_AFFINITY_CAPABLE() ) {
                 __kmp_msg(
                     kmp_ms_fatal,
                     KMP_MSG( ChangeThreadAffMaskError ),
                     KMP_ERR( error ),
                     __kmp_msg_null
                 );
             }
         }
-        __kmp_set_system_affinity( __kmp_affinity_get_fullMask(), TRUE );
+        __kmp_set_system_affinity( fullMask, TRUE );
     }
 }
 #endif
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
 
 //
 // __kmp_partition_places() is the heart of the OpenMP 4.0 affinity mechanism.