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)__kmp_affin_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, __kmp_affin_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, __kmp_affin_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, __kmp_affin_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 *__kmp_affin_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

 
 //
 // All of the __kmp_affinity_create_*_map() routines should set
 // __kmp_affinity_masks to a vector of affinity mask objects of length
 // __kmp_affinity_num_masks, if __kmp_affinity_type != affinity_none, and
 // 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
+// All of the __kmp_affinity_create_*_map() routines should set *__kmp_affin_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 *__kmp_affin_fullMask = NULL;
 
 static int nCoresPerPkg, nPackages;
 static int __kmp_nThreadsPerCore;
 #ifndef KMP_DFLT_NTH_CORES
 static int __kmp_ncores;
 #endif
 
 //
for(socket = hwloc_get_obj_by_type(__kmp_hwloc_topology, HWLOC_OBJ_SOCKET, 0);
         {
             int pu_identifier = 0;
             for(pu = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, core->type, core->logical_index, HWLOC_OBJ_PU, 0);
                 pu != NULL && hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology, core->type, pu) == core;
                 pu = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, HWLOC_OBJ_PU, pu),
                 pu_identifier++)
             {
                 Address addr(3);
-                if(! KMP_CPU_ISSET(pu->os_index, fullMask))
+                if(! KMP_CPU_ISSET(pu->os_index, __kmp_affin_fullMask))
                     continue;
                 KA_TRACE(20, ("Hwloc inserting %d (%d) %d (%d) %d (%d) into address2os\n",
                     socket->os_index, socket->logical_index, core->os_index, core->logical_index, pu->os_index,pu->logical_index));
                 addr.labels[0] = socket_identifier; // package
                 addr.labels[1] = core_identifier; // core
                 addr.labels[2] = pu_identifier; // pu
                 retval[nActiveThreads] = AddrUnsPair(addr, pu->os_index);
                 nActiveThreads++;
kmp_i18n_id_t *const msg_id)
     // __kmp_ncores, as well as __kmp_nThreadsPerCore,
     // nCoresPerPkg, & nPackages.  Make sure all these vars are set
     //  correctly, and return now if affinity is not enabled.
     //
     __kmp_ncores = nPackages = __kmp_avail_proc;
     __kmp_nThreadsPerCore = nCoresPerPkg = 1;
     if (__kmp_affinity_verbose) {
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
-        __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, fullMask);
+        __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affin_fullMask);
 
         KMP_INFORM(AffCapableUseFlat, "KMP_AFFINITY");
         if (__kmp_affinity_respect_mask) {
             KMP_INFORM(InitOSProcSetRespect, "KMP_AFFINITY", buf);
         } else {
             KMP_INFORM(InitOSProcSetNotRespect, "KMP_AFFINITY", buf);
         }
         KMP_INFORM(AvailableOSProc, "KMP_AFFINITY", __kmp_avail_proc);
         KMP_INFORM(Uniform, "KMP_AFFINITY");
         KMP_INFORM(Topology, "KMP_AFFINITY", nPackages, nCoresPerPkg,
           __kmp_nThreadsPerCore, __kmp_ncores);
     }
     if (__kmp_affinity_type == affinity_none) {
         return 0;
     }
 
     //
     // Contruct the data structure to be returned.
     //
     *address2os = (AddrUnsPair*)
       __kmp_allocate(sizeof(**address2os) * __kmp_avail_proc);
     int avail_ct = 0;
     unsigned int i;
-    KMP_CPU_SET_ITERATE(i, fullMask) {
+    KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
         //
         // Skip this proc if it is not included in the machine model.
         //
-        if (! KMP_CPU_ISSET(i, fullMask)) {
+        if (! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
             continue;
         }
 
         Address addr(1);
         addr.labels[0] = i;
         (*address2os)[avail_ct++] = AddrUnsPair(addr,i);
     }
     if (__kmp_affinity_verbose) {

 {
     *address2os = NULL;
     *msg_id = kmp_i18n_null;
 
     //
     // If we don't have multiple processor groups, return now.
     // The flat mapping will be used.
     //
-    if ((! KMP_AFFINITY_CAPABLE()) || (__kmp_get_proc_group(fullMask) >= 0)) {
+    if ((! KMP_AFFINITY_CAPABLE()) || (__kmp_get_proc_group(__kmp_affin_fullMask) >= 0)) {
         // FIXME set *msg_id
         return -1;
     }
 
     //
     // Contruct the data structure to be returned.
     //
     *address2os = (AddrUnsPair*)
       __kmp_allocate(sizeof(**address2os) * __kmp_avail_proc);
     int avail_ct = 0;
     int i;
-    KMP_CPU_SET_ITERATE(i, fullMask) {
+    KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
         //
         // Skip this proc if it is not included in the machine model.
         //
-        if (! KMP_CPU_ISSET(i, fullMask)) {
+        if (! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
             continue;
         }
 
         Address addr(2);
         addr.labels[0] = i / (CHAR_BIT * sizeof(DWORD_PTR));
         addr.labels[1] = i % (CHAR_BIT * sizeof(DWORD_PTR));
         (*address2os)[avail_ct++] = AddrUnsPair(addr,i);
 
kmp_i18n_id_t *const msg_id)
     //
     // From this information, deduce the package Id, core Id, and thread Id,
     // and set the corresponding fields in the apicThreadInfo struct.
     //
     unsigned i;
     apicThreadInfo *threadInfo = (apicThreadInfo *)__kmp_allocate(
       __kmp_avail_proc * sizeof(apicThreadInfo));
     unsigned nApics = 0;
-    KMP_CPU_SET_ITERATE(i, fullMask) {
+    KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
         //
         // Skip this proc if it is not included in the machine model.
         //
-        if (! KMP_CPU_ISSET(i, fullMask)) {
+        if (! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
             continue;
         }
         KMP_DEBUG_ASSERT((int)nApics < __kmp_avail_proc);
 
         __kmp_affinity_bind_thread(i);
         threadInfo[nApics].osId = i;
 
         //
AddrUnsPair *retval = (AddrUnsPair *)
       __kmp_allocate(sizeof(AddrUnsPair) * __kmp_avail_proc);
 
     //
     // Run through each of the available contexts, binding the current thread
     // to it, and obtaining the pertinent information using the cpuid instr.
     //
     unsigned int proc;
     int nApics = 0;
-    KMP_CPU_SET_ITERATE(proc, fullMask) {
+    KMP_CPU_SET_ITERATE(proc, __kmp_affin_fullMask) {
         //
         // Skip this proc if it is not included in the machine model.
         //
-        if (! KMP_CPU_ISSET(proc, fullMask)) {
+        if (! KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
             continue;
         }
         KMP_DEBUG_ASSERT(nApics < __kmp_avail_proc);
 
         __kmp_affinity_bind_thread(proc);
 
         //
         // Extrach the labels for each level in the machine topology map
#endif // KMP_OS_LINUX && USE_SYSFS_INFO
                 CLEANUP_THREAD_INFO;
                 *msg_id = kmp_i18n_str_MissingPhysicalIDField;
                 return -1;
             }
 
             //
             // Skip this proc if it is not included in the machine model.
             //
-            if (! KMP_CPU_ISSET(threadInfo[num_avail][osIdIndex], fullMask)) {
+            if (! KMP_CPU_ISSET(threadInfo[num_avail][osIdIndex], __kmp_affin_fullMask)) {
                 INIT_PROC_INFO(threadInfo[num_avail]);
                 continue;
             }
 
             //
             // We have a successful parse of this proc's info.
             // Increment the counter, and prepare for the next proc.
             //
if (num_avail == 1) {
             if (! KMP_AFFINITY_CAPABLE()) {
                 KMP_INFORM(AffNotCapableUseCpuinfo, "KMP_AFFINITY");
                 KMP_INFORM(AvailableOSProc, "KMP_AFFINITY", __kmp_avail_proc);
                 KMP_INFORM(Uniform, "KMP_AFFINITY");
             }
             else {
                 char buf[KMP_AFFIN_MASK_PRINT_LEN];
                 __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
-                  fullMask);
+                  __kmp_affin_fullMask);
                 KMP_INFORM(AffCapableUseCpuinfo, "KMP_AFFINITY");
                 if (__kmp_affinity_respect_mask) {
                     KMP_INFORM(InitOSProcSetRespect, "KMP_AFFINITY", buf);
                 } else {
                     KMP_INFORM(InitOSProcSetNotRespect, "KMP_AFFINITY", buf);
                 }
                 KMP_INFORM(AvailableOSProc, "KMP_AFFINITY", __kmp_avail_proc);
                 KMP_INFORM(Uniform, "KMP_AFFINITY");
if (__kmp_affinity_verbose) {
                 if (uniform) {
                     KMP_INFORM(Uniform, "KMP_AFFINITY");
                 } else {
                     KMP_INFORM(NonUniform, "KMP_AFFINITY");
                 }
         }
         else {
             char buf[KMP_AFFIN_MASK_PRINT_LEN];
-            __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, fullMask);
+            __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN, __kmp_affin_fullMask);
                 KMP_INFORM(AffCapableUseCpuinfo, "KMP_AFFINITY");
                 if (__kmp_affinity_respect_mask) {
                     KMP_INFORM(InitOSProcSetRespect, "KMP_AFFINITY", buf);
                 } else {
                     KMP_INFORM(InitOSProcSetNotRespect, "KMP_AFFINITY", buf);
                 }
                 KMP_INFORM(AvailableOSProc, "KMP_AFFINITY", __kmp_avail_proc);
                 if (uniform) {
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, __kmp_affin_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') {

 static AddrUnsPair *address2os = NULL;
 static int           * procarr = NULL;
 static int     __kmp_aff_depth = 0;
 
 static void
 __kmp_aux_affinity_initialize(void)
 {
     if (__kmp_affinity_masks != NULL) {
-        KMP_ASSERT(fullMask != NULL);
+        KMP_ASSERT(__kmp_affin_fullMask != NULL);
         return;
     }
 
     //
     // Create the "full" mask - this defines all of the processors that we
     // consider to be in the machine model.  If respect is set, then it is
     // the initialization thread's affinity mask.  Otherwise, it is all
     // processors that we know about on the machine.
     //
-    if (fullMask == NULL) {
-        KMP_CPU_ALLOC(fullMask);
+    if (__kmp_affin_fullMask == NULL) {
+        KMP_CPU_ALLOC(__kmp_affin_fullMask);
     }
     if (KMP_AFFINITY_CAPABLE()) {
         if (__kmp_affinity_respect_mask) {
-            __kmp_get_system_affinity(fullMask, TRUE);
+            __kmp_get_system_affinity(__kmp_affin_fullMask, TRUE);
 
             //
             // Count the number of available processors.
             //
             unsigned i;
             __kmp_avail_proc = 0;
-            KMP_CPU_SET_ITERATE(i, fullMask) {
-                if (! KMP_CPU_ISSET(i, fullMask)) {
+            KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
+                if (! KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
                     continue;
                 }
                 __kmp_avail_proc++;
             }
             if (__kmp_avail_proc > __kmp_xproc) {
                 if (__kmp_affinity_verbose || (__kmp_affinity_warnings
                   && (__kmp_affinity_type != affinity_none))) {
                     KMP_WARNING(ErrorInitializeAffinity);
                 }
                 __kmp_affinity_type = affinity_none;
                 KMP_AFFINITY_DISABLE();
                 return;
             }
         }
         else {
-            __kmp_affinity_entire_machine_mask(fullMask);
+            __kmp_affinity_entire_machine_mask(__kmp_affin_fullMask);
             __kmp_avail_proc = __kmp_xproc;
         }
     }
 
     int depth = -1;
     kmp_i18n_id_t msg_id = kmp_i18n_null;
 
     //

 
 void
 __kmp_affinity_uninitialize(void)
 {
     if (__kmp_affinity_masks != NULL) {
         KMP_CPU_FREE_ARRAY(__kmp_affinity_masks, __kmp_affinity_num_masks);
         __kmp_affinity_masks = NULL;
     }
-    if (fullMask != NULL) {
-        KMP_CPU_FREE(fullMask);
-        fullMask = NULL;
+    if (__kmp_affin_fullMask != NULL) {
+        KMP_CPU_FREE(__kmp_affin_fullMask);
+        __kmp_affin_fullMask = NULL;
     }
     __kmp_affinity_num_masks = 0;
 # if OMP_40_ENABLED
     __kmp_affinity_num_places = 0;
 # endif
     if (__kmp_affinity_proclist != NULL) {
         __kmp_free(__kmp_affinity_proclist);
         __kmp_affinity_proclist = NULL;
# endif
     {
         if ((__kmp_affinity_type == affinity_none) || (__kmp_affinity_type == affinity_balanced)
           ) {
 # if KMP_GROUP_AFFINITY
             if (__kmp_num_proc_groups > 1) {
                 return;
             }
 # endif
-            KMP_ASSERT(fullMask != NULL);
+            KMP_ASSERT(__kmp_affin_fullMask != NULL);
             i = KMP_PLACE_ALL;
-            mask = fullMask;
+            mask = __kmp_affin_fullMask;
         }
         else {
             KMP_DEBUG_ASSERT( __kmp_affinity_num_masks > 0 );
             i = (gtid + __kmp_affinity_offset) % __kmp_affinity_num_masks;
             mask = KMP_CPU_INDEX(__kmp_affinity_masks, i);
         }
     }
 # if OMP_40_ENABLED
     else {
         if ((! isa_root)
           || (__kmp_nested_proc_bind.bind_types[0] == proc_bind_false)) {
 #  if KMP_GROUP_AFFINITY
             if (__kmp_num_proc_groups > 1) {
                 return;
             }
 #  endif
-            KMP_ASSERT(fullMask != NULL);
+            KMP_ASSERT(__kmp_affin_fullMask != NULL);
             i = KMP_PLACE_ALL;
-            mask = fullMask;
+            mask = __kmp_affin_fullMask;
         }
         else {
             //
             // int i = some hash function or just a counter that doesn't
             // always start at 0.  Use gtid for now.
             //
             KMP_DEBUG_ASSERT( __kmp_affinity_num_masks > 0 );
             i = (gtid + __kmp_affinity_offset) % __kmp_affinity_num_masks;
if (i == KMP_PLACE_ALL) {
           gtid));
     }
     else {
         KA_TRACE(100, ("__kmp_affinity_set_init_mask: binding T#%d to place %d\n",
           gtid, i));
     }
 # else
     if (i == -1) {
-        KA_TRACE(100, ("__kmp_affinity_set_init_mask: binding T#%d to fullMask\n",
+        KA_TRACE(100, ("__kmp_affinity_set_init_mask: binding T#%d to __kmp_affin_fullMask\n",
           gtid));
     }
     else {
         KA_TRACE(100, ("__kmp_affinity_set_init_mask: binding T#%d to mask %d\n",
           gtid, i));
     }
 # endif /* OMP_40_ENABLED */
 
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, __kmp_affin_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");
__kmp_aux_set_affinity_mask_proc(int proc, void **mask)
 
     if ((proc < 0)
 # if !KMP_USE_HWLOC
          || ((unsigned)proc >= KMP_CPU_SETSIZE)
 # endif
        ) {
         return -1;
     }
-    if (! KMP_CPU_ISSET(proc, fullMask)) {
+    if (! KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
         return -2;
     }
 
     KMP_CPU_SET(proc, (kmp_affin_mask_t *)(*mask));
     return 0;
 }
 
 
__kmp_aux_unset_affinity_mask_proc(int proc, void **mask)
 
     if ((proc < 0)
 # if !KMP_USE_HWLOC
          || ((unsigned)proc >= KMP_CPU_SETSIZE)
 # endif
        ) {
         return -1;
     }
-    if (! KMP_CPU_ISSET(proc, fullMask)) {
+    if (! KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
         return -2;
     }
 
     KMP_CPU_CLR(proc, (kmp_affin_mask_t *)(*mask));
     return 0;
 }
 
 
__kmp_aux_get_affinity_mask_proc(int proc, void **mask)
 
     if ((proc < 0)
 # if !KMP_USE_HWLOC
          || ((unsigned)proc >= KMP_CPU_SETSIZE)
 # endif
        ) {
         return -1;
     }
-    if (! KMP_CPU_ISSET(proc, fullMask)) {
+    if (! KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
         return 0;
     }
 
     return KMP_CPU_ISSET(proc, (kmp_affin_mask_t *)(*mask));
 }
 
 
 // Dynamic affinity settings - Affinity balanced
//   >0 (errno) if an error happened during binding
     }
     if (!KMP_AFFINITY_CAPABLE() || !__kmp_init_middle) {
         KA_TRACE(30, ( "kmp_set_thread_affinity_mask_initial: "
             "affinity not initialized, returning\n"));
         return -1;
     }
     KA_TRACE(30, ( "kmp_set_thread_affinity_mask_initial: "
         "set full mask for thread %d\n", gtid));
-    KMP_DEBUG_ASSERT(fullMask != NULL);
-    return __kmp_set_system_affinity(fullMask, FALSE);
+    KMP_DEBUG_ASSERT(__kmp_affin_fullMask != NULL);
+    return __kmp_set_system_affinity(__kmp_affin_fullMask, FALSE);
 }
 #endif
 
 #endif // KMP_AFFINITY_SUPPORTED

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, __kmp_affin_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, __kmp_affin_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( __kmp_affin_fullMask, TRUE );
     }
 }
 #endif
 
 #if OMP_40_ENABLED && KMP_AFFINITY_SUPPORTED
 
 //
 // __kmp_partition_places() is the heart of the OpenMP 4.0 affinity mechanism.