[OpenMP][libomp] Make affinity warnings parameterized

[jlpeyton]

Summary

Separate change for the warnings to depend on the relevant affinity settings verbose and warnings settings.

[jdoerfert]

LG

openmp/runtime/src/kmp_affinity.cpp

 #endif
   }
   return "unknown";
 }
 
 #if KMP_AFFINITY_SUPPORTED
 // If affinity is supported, check the affinity
 // verbose and warning flags before printing warning
-#define KMP_AFF_WARNING(...)                                                   \
-  if (__kmp_affinity.flags.verbose ||                                          \
-      (__kmp_affinity.flags.warnings &&                                        \
-       (__kmp_affinity.type != affinity_none))) {                              \
+#define KMP_AFF_WARNING(s, ...)                                                \
+  if (s.flags.verbose || (s.flags.warnings && (s.type != affinity_none))) {    \
     KMP_WARNING(__VA_ARGS__);                                                  \
   }
 #else
-#define KMP_AFF_WARNING KMP_WARNING
+#define KMP_AFF_WARNING(s, ...) KMP_WARNING(__VA_ARGS__)
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // kmp_hw_thread_t methods
 int kmp_hw_thread_t::compare_ids(const void *a, const void *b) {
   const kmp_hw_thread_t *ahwthread = (const kmp_hw_thread_t *)a;
   const kmp_hw_thread_t *bhwthread = (const kmp_hw_thread_t *)b;
   int depth = __kmp_topology->get_depth();
if (gran_type == KMP_HW_UNKNOWN) {
       for (auto g : gran_types) {
         if (get_equivalent_type(g) != KMP_HW_UNKNOWN) {
           gran_type = g;
           break;
         }
       }
       KMP_ASSERT(gran_type != KMP_HW_UNKNOWN);
       // Warn user what granularity setting will be used instead
-      KMP_AFF_WARNING(AffGranularityBad, env_var,
+      KMP_AFF_WARNING(affinity, AffGranularityBad, env_var,
                       __kmp_hw_get_catalog_string(affinity.gran),
                       __kmp_hw_get_catalog_string(gran_type));
       affinity.gran = gran_type;
     }
 #if KMP_GROUP_AFFINITY
     // If more than one processor group exists, and the level of
     // granularity specified by the user is too coarse, then the
     // granularity must be adjusted "down" to processor group affinity
     // because threads can only exist within one processor group.
     // For example, if a user sets granularity=socket and there are two
     // processor groups that cover a socket, then the runtime must
     // restrict the granularity down to the processor group level.
     if (__kmp_num_proc_groups > 1) {
       int gran_depth = get_level(gran_type);
       int proc_group_depth = get_level(KMP_HW_PROC_GROUP);
       if (gran_depth >= 0 && proc_group_depth >= 0 &&
           gran_depth < proc_group_depth) {
-        KMP_AFF_WARNING(AffGranTooCoarseProcGroup, env_var,
+        KMP_AFF_WARNING(affinity, AffGranTooCoarseProcGroup, env_var,
                         __kmp_hw_get_catalog_string(affinity.gran));
         affinity.gran = gran_type = KMP_HW_PROC_GROUP;
       }
     }
 #endif
     affinity.gran_levels = 0;
     for (int i = depth - 1; i >= 0 && get_type(i) != gran_type; --i)
       affinity.gran_levels++;
for (int i = 0; i < hw_subset_depth; ++i) {
     kmp_hw_t equivalent_type = equivalent[type];
     int level = get_level(type);
     topology_levels[i] = level;
 
     // Check to see if current layer is in detected machine topology
     if (equivalent_type != KMP_HW_UNKNOWN) {
       __kmp_hw_subset->at(i).type = equivalent_type;
     } else {
-      KMP_AFF_WARNING(AffHWSubsetNotExistGeneric,
+      KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetNotExistGeneric,
                       __kmp_hw_get_catalog_string(type));
       return false;
     }
 
     // Check to see if current layer has already been
     // specified either directly or through an equivalent type
     if (specified[equivalent_type] != KMP_HW_UNKNOWN) {
-      KMP_AFF_WARNING(AffHWSubsetEqvLayers, __kmp_hw_get_catalog_string(type),
+      KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetEqvLayers,
+                      __kmp_hw_get_catalog_string(type),
                       __kmp_hw_get_catalog_string(specified[equivalent_type]));
       return false;
     }
     specified[equivalent_type] = type;
 
     // Check to see if each layer's num & offset parameters are valid
     max_count = get_ratio(level);
     if (max_count < 0 ||
         (num != kmp_hw_subset_t::USE_ALL && num + offset > max_count)) {
       bool plural = (num > 1);
-      KMP_AFF_WARNING(AffHWSubsetManyGeneric,
+      KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetManyGeneric,
                       __kmp_hw_get_catalog_string(type, plural));
       return false;
     }
 
     // Check to see if core attributes are consistent
     if (core_level == level) {
       // Determine which core attributes are specified
       for (int j = 0; j < item.num_attrs; ++j) {
         if (item.attr[j].is_core_type_valid())
           using_core_types = true;
         if (item.attr[j].is_core_eff_valid())
           using_core_effs = true;
       }
 
       // Check if using a single core attribute on non-hybrid arch.
       // Do not ignore all of KMP_HW_SUBSET, just ignore the attribute.
       //
       // Check if using multiple core attributes on non-hyrbid arch.
       // Ignore all of KMP_HW_SUBSET if this is the case.
       if ((using_core_effs || using_core_types) && !__kmp_is_hybrid_cpu()) {
         if (item.num_attrs == 1) {
           if (using_core_effs) {
-            KMP_AFF_WARNING(AffHWSubsetIgnoringAttr, "efficiency");
+            KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetIgnoringAttr,
+                            "efficiency");
           } else {
-            KMP_AFF_WARNING(AffHWSubsetIgnoringAttr, "core_type");
+            KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetIgnoringAttr,
+                            "core_type");
           }
           using_core_effs = false;
           using_core_types = false;
         } else {
-          KMP_AFF_WARNING(AffHWSubsetAttrsNonHybrid);
+          KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetAttrsNonHybrid);
           return false;
         }
       }
 
       // Check if using both core types and core efficiencies together
       if (using_core_types && using_core_effs) {
-        KMP_AFF_WARNING(AffHWSubsetIncompat, "core_type", "efficiency");
+        KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetIncompat, "core_type",
+                        "efficiency");
         return false;
       }
 
       // Check that core efficiency values are valid
       if (using_core_effs) {
         for (int j = 0; j < item.num_attrs; ++j) {
           if (item.attr[j].is_core_eff_valid()) {
             int core_eff = item.attr[j].get_core_eff();
if (core_level == level) {
           int offset = item.offset[j];
           int level_above = core_level - 1;
           if (level_above >= 0) {
             max_count = get_ncores_with_attr_per(item.attr[j], level_above);
             if (max_count <= 0 ||
                 (num != kmp_hw_subset_t::USE_ALL && num + offset > max_count)) {
               kmp_str_buf_t buf;
               __kmp_hw_get_catalog_core_string(item.attr[j], &buf, num > 0);
-              KMP_AFF_WARNING(AffHWSubsetManyGeneric, buf.str);
+              KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetManyGeneric, buf.str);
               __kmp_str_buf_free(&buf);
               return false;
             }
           }
         }
       }
 
       if ((using_core_types || using_core_effs) && item.num_attrs > 1) {
         for (int j = 0; j < item.num_attrs; ++j) {
           // Ambiguous use of specific core attribute + generic core
           // e.g., 4c & 3c:intel_core or 4c & 3c:eff1
           if (!item.attr[j]) {
             kmp_hw_attr_t other_attr;
             for (int k = 0; k < item.num_attrs; ++k) {
               if (item.attr[k] != item.attr[j]) {
                 other_attr = item.attr[k];
                 break;
               }
             }
             kmp_str_buf_t buf;
             __kmp_hw_get_catalog_core_string(other_attr, &buf, item.num[j] > 0);
-            KMP_AFF_WARNING(AffHWSubsetIncompat,
+            KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetIncompat,
                             __kmp_hw_get_catalog_string(KMP_HW_CORE), buf.str);
             __kmp_str_buf_free(&buf);
             return false;
           }
           // Allow specifying a specific core type or core eff exactly once
           for (int k = 0; k < j; ++k) {
             if (!item.attr[j] || !item.attr[k])
               continue;
             if (item.attr[k] == item.attr[j]) {
               kmp_str_buf_t buf;
               __kmp_hw_get_catalog_core_string(item.attr[j], &buf,
                                                item.num[j] > 0);
-              KMP_AFF_WARNING(AffHWSubsetAttrRepeat, buf.str);
+              KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetAttrRepeat, buf.str);
               __kmp_str_buf_free(&buf);
               return false;
             }
           }
         }
       }
     }
   }
for (int i = 0; i < num_hw_threads; ++i) {
     // Collect filtering information
     filtered[i] = should_be_filtered;
     if (should_be_filtered)
       num_filtered++;
   }
 
   // One last check that we shouldn't allow filtering entire machine
   if (num_filtered == num_hw_threads) {
-    KMP_AFF_WARNING(AffHWSubsetAllFiltered);
+    KMP_AFF_WARNING(__kmp_affinity, AffHWSubsetAllFiltered);
     __kmp_free(filtered);
     return false;
   }
 
   // Apply the filter
   int new_index = 0;
   for (int i = 0; i < num_hw_threads; ++i) {
     if (!filtered[i]) {
static void __kmp_create_os_id_masks(unsigned *numUnique,
   }
   affinity.num_os_id_masks = maxOsId + 1;
   KMP_CPU_ALLOC_ARRAY(affinity.os_id_masks, affinity.num_os_id_masks);
   KMP_ASSERT(affinity.gran_levels >= 0);
   if (affinity.flags.verbose && (affinity.gran_levels > 0)) {
     KMP_INFORM(ThreadsMigrate, env_var, affinity.gran_levels);
   }
   if (affinity.gran_levels >= (int)depth) {
-    KMP_AFF_WARNING(AffThreadsMayMigrate);
+    KMP_AFF_WARNING(affinity, AffThreadsMayMigrate);
   }
 
   // Run through the table, forming the masks for all threads on each core.
   // Threads on the same core will have identical kmp_hw_thread_t objects, not
   // considering the last level, which must be the thread id. All threads on a
   // core will appear consecutively.
   int unique = 0;
   int j = 0; // index of 1st thread on core
#define ADD_MASK(_mask)                                                        \
     KMP_CPU_COPY(KMP_CPU_INDEX(newMasks, nextNewMask), (_mask));               \
     nextNewMask++;                                                             \
   }
 
 #define ADD_MASK_OSID(_osId, _osId2Mask, _maxOsId)                             \
   {                                                                            \
     if (((_osId) > _maxOsId) ||                                                \
         (!KMP_CPU_ISSET((_osId), KMP_CPU_INDEX((_osId2Mask), (_osId))))) {     \
-      KMP_AFF_WARNING(AffIgnoreInvalidProcID, _osId);                          \
+      KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, _osId);                \
     } else {                                                                   \
       ADD_MASK(KMP_CPU_INDEX(_osId2Mask, (_osId)));                            \
     }                                                                          \
   }
 
 // Re-parse the proclist (for the explicit affinity type), and form the list
 // of affinity newMasks indexed by gtid.
 static void __kmp_affinity_process_proclist(kmp_affinity_t &affinity) {
if (*next == '{') {
       KMP_ASSERT2((*next >= '0') && (*next <= '9'), "bad proclist");
       SKIP_DIGITS(next);
       num = __kmp_str_to_int(scan, *next);
       KMP_ASSERT2(num >= 0, "bad explicit proc list");
 
       // Copy the mask for that osId to the sum (union) mask.
       if ((num > maxOsId) ||
           (!KMP_CPU_ISSET(num, KMP_CPU_INDEX(osId2Mask, num)))) {
-        KMP_AFF_WARNING(AffIgnoreInvalidProcID, num);
+        KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, num);
         KMP_CPU_ZERO(sumMask);
       } else {
         KMP_CPU_COPY(sumMask, KMP_CPU_INDEX(osId2Mask, num));
         setSize = 1;
       }
 
       for (;;) {
         // Check for end of set.
if (*next == '{') {
 
         SKIP_DIGITS(next);
         num = __kmp_str_to_int(scan, *next);
         KMP_ASSERT2(num >= 0, "bad explicit proc list");
 
         // Add the mask for that osId to the sum mask.
         if ((num > maxOsId) ||
             (!KMP_CPU_ISSET(num, KMP_CPU_INDEX(osId2Mask, num)))) {
-          KMP_AFF_WARNING(AffIgnoreInvalidProcID, num);
+          KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, num);
         } else {
           KMP_CPU_UNION(sumMask, KMP_CPU_INDEX(osId2Mask, num));
           setSize++;
         }
       }
       if (setSize > 0) {
         ADD_MASK(sumMask);
       }
for (;;) {
     KMP_ASSERT(start >= 0);
     *scan = next;
 
     // valid follow sets are ',' ':' and '}'
     SKIP_WS(*scan);
     if (**scan == '}' || **scan == ',') {
       if ((start > maxOsId) ||
           (!KMP_CPU_ISSET(start, KMP_CPU_INDEX(osId2Mask, start)))) {
-        KMP_AFF_WARNING(AffIgnoreInvalidProcID, start);
+        KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, start);
       } else {
         KMP_CPU_UNION(tempMask, KMP_CPU_INDEX(osId2Mask, start));
         (*setSize)++;
       }
       if (**scan == '}') {
         break;
       }
       (*scan)++; // skip ','
for (;;) {
     *scan = next;
 
     // valid follow sets are ',' ':' and '}'
     SKIP_WS(*scan);
     if (**scan == '}' || **scan == ',') {
       for (i = 0; i < count; i++) {
         if ((start > maxOsId) ||
             (!KMP_CPU_ISSET(start, KMP_CPU_INDEX(osId2Mask, start)))) {
-          KMP_AFF_WARNING(AffIgnoreInvalidProcID, start);
+          KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, start);
           break; // don't proliferate warnings for large count
         } else {
           KMP_CPU_UNION(tempMask, KMP_CPU_INDEX(osId2Mask, start));
           start++;
           (*setSize)++;
         }
       }
       if (**scan == '}') {
for (;;) {
     stride *= sign;
 
     // valid follow sets are ',' and '}'
     SKIP_WS(*scan);
     if (**scan == '}' || **scan == ',') {
       for (i = 0; i < count; i++) {
         if ((start > maxOsId) ||
             (!KMP_CPU_ISSET(start, KMP_CPU_INDEX(osId2Mask, start)))) {
-          KMP_AFF_WARNING(AffIgnoreInvalidProcID, start);
+          KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, start);
           break; // don't proliferate warnings for large count
         } else {
           KMP_CPU_UNION(tempMask, KMP_CPU_INDEX(osId2Mask, start));
           start += stride;
           (*setSize)++;
         }
       }
       if (**scan == '}') {
if (**scan == '{') {
     KMP_CPU_COMPLEMENT(maxOsId, tempMask);
   } else if ((**scan >= '0') && (**scan <= '9')) {
     next = *scan;
     SKIP_DIGITS(next);
     int num = __kmp_str_to_int(*scan, *next);
     KMP_ASSERT(num >= 0);
     if ((num > maxOsId) ||
         (!KMP_CPU_ISSET(num, KMP_CPU_INDEX(osId2Mask, num)))) {
-      KMP_AFF_WARNING(AffIgnoreInvalidProcID, num);
+      KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, num);
     } else {
       KMP_CPU_UNION(tempMask, KMP_CPU_INDEX(osId2Mask, num));
       (*setSize)++;
     }
     *scan = next; // skip num
   } else {
     KMP_ASSERT2(0, "bad explicit places list");
   }
for (i = 0; i < count; i++) {
         if (!KMP_CPU_ISSET(j, previousMask)) {
           continue;
         }
         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 (i < count - 1) {
-            KMP_AFF_WARNING(AffIgnoreInvalidProcID, j + stride);
+            KMP_AFF_WARNING(affinity, AffIgnoreInvalidProcID, j + stride);
           }
           continue;
         }
         KMP_CPU_SET(j + stride, tempMask);
         setSize++;
       }
     }
     KMP_CPU_ZERO(tempMask);
if (affinity.flags.respect) {
       __kmp_avail_proc = 0;
       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) {
-        KMP_AFF_WARNING(ErrorInitializeAffinity);
+        KMP_AFF_WARNING(affinity, ErrorInitializeAffinity);
         affinity.type = affinity_none;
         KMP_AFFINITY_DISABLE();
         return;
       }
 
       if (verbose) {
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
else if (__kmp_affinity_top_method == affinity_top_method_flat) {
     success = __kmp_affinity_create_flat_map(&msg_id);
     // should not fail
     KMP_ASSERT(success);
   }
 
   // Early exit if topology could not be created
   if (!__kmp_topology) {
     if (KMP_AFFINITY_CAPABLE()) {
-      KMP_AFF_WARNING(ErrorInitializeAffinity);
+      KMP_AFF_WARNING(affinity, ErrorInitializeAffinity);
     }
     if (nPackages > 0 && nCoresPerPkg > 0 && __kmp_nThreadsPerCore > 0 &&
         __kmp_ncores > 0) {
       __kmp_topology = kmp_topology_t::allocate(0, 0, NULL);
       __kmp_topology->canonicalize(nPackages, nCoresPerPkg,
                                    __kmp_nThreadsPerCore, __kmp_ncores);
       if (verbose) {
         __kmp_topology->print(env_var);
#endif
   case affinity_explicit:
     KMP_DEBUG_ASSERT(affinity.proclist != NULL);
     if (__kmp_nested_proc_bind.bind_types[0] == proc_bind_intel) {
       __kmp_affinity_process_proclist(affinity);
     } else {
       __kmp_affinity_process_placelist(affinity);
     }
     if (affinity.num_masks == 0) {
-      KMP_AFF_WARNING(AffNoValidProcID);
+      KMP_AFF_WARNING(affinity, AffNoValidProcID);
       affinity.type = affinity_none;
       __kmp_create_affinity_none_places(affinity);
       affinity.flags.initialized = TRUE;
       return;
     }
     break;
 
   // The other affinity types rely on sorting the hardware threads according to
#endif
   case affinity_compact:
     if (affinity.compact >= depth) {
       affinity.compact = depth - 1;
     }
     goto sortTopology;
 
   case affinity_balanced:
     if (depth <= 1) {
-      KMP_AFF_WARNING(AffBalancedNotAvail, env_var);
+      KMP_AFF_WARNING(affinity, AffBalancedNotAvail, env_var);
       affinity.type = affinity_none;
       __kmp_create_affinity_none_places(affinity);
       affinity.flags.initialized = TRUE;
       return;
     } else if (!__kmp_topology->is_uniform()) {
       // Save the depth for further usage
       __kmp_aff_depth = depth;
 
       int core_level =
           __kmp_affinity_find_core_level(__kmp_avail_proc, depth - 1);
       int ncores = __kmp_affinity_compute_ncores(__kmp_avail_proc, depth - 1,
                                                  core_level);
       int maxprocpercore = __kmp_affinity_max_proc_per_core(
           __kmp_avail_proc, depth - 1, core_level);
 
       int nproc = ncores * maxprocpercore;
       if ((nproc < 2) || (nproc < __kmp_avail_proc)) {
-        KMP_AFF_WARNING(AffBalancedNotAvail, env_var);
+        KMP_AFF_WARNING(affinity, AffBalancedNotAvail, env_var);
         affinity.type = affinity_none;
         affinity.flags.initialized = TRUE;
         return;
       }
 
       procarr = (int *)__kmp_allocate(sizeof(int) * nproc);
       for (int i = 0; i < nproc; i++) {
         procarr[i] = -1;