[OpenMP][libomp] Add use-all syntax to KMP_HW_SUBSET

[jlpeyton]

Summary

This patch allows the user to request all resources of a particular
layer (or core-attribute). The syntax of KMP_HW_SUBSET is modified
so the number of units requested is optional or can be replaced with an * character.

Examples:
KMP_HW_SUBSET=c:intel_atom@3 will use all the cores after offset 3
KMP_HW_SUBSET=*c:intel_core will use all the big cores
KMP_HW_SUBSET=*s,*c,1t will use all the sockets, all cores per each socket and 1 thread per core.

[AndreyChurbanov]

LGTM

openmp/docs/design/Runtimes.rst

 or a limiting process affinity mask. You can also specify an offset value to set
 which resources to use. When available, you can specify attributes to select
 different subsets of resources.
 
 An extended syntax is available when ``KMP_TOPOLOGY_METHOD=hwloc``. Depending on what
 resources are detected, you may be able to specify additional resources, such as
 NUMA domains and groups of hardware resources that share certain cache levels.
 
-**Basic syntax:** ``num_unitsID[@offset][:attribute] [,num_unitsID[@offset][:attribute]...]``
+**Basic syntax:** ``[num_units|*]ID[@offset][:attribute] [,[num_units|*]ID[@offset][:attribute]...]``
 
 Supported unit IDs are not case-insensitive.
 
 | ``S`` - socket
 | ``num_units`` specifies the requested number of sockets.
 
 | ``D`` - die
 | ``num_units`` specifies the requested number of dies per socket.
 
 | ``C`` - core
 | ``num_units`` specifies the requested number of cores per die - if any - otherwise, per socket.
 
 | ``T`` - thread
 | ``num_units`` specifies the requested number of HW threads per core.
 
+.. note::
+    ``num_units`` can be left out or explicitly specified as ``*`` instead of a positive integer
+    meaning use all specified resources at that level.
+    e.g., ``1s,*c`` means use 1 socket and all the cores on that socket
+
 ``offset`` - (Optional) The number of units to skip.
 
 ``attribute`` - (Optional) An attribute differentiating resources at a particular level. The attributes available to users are:
 
 * **Core type** - On Intel architectures, this can be ``intel_atom`` or ``intel_core``
 * **Core efficiency** - This is specified as ``eff``:emphasis:`num` where :emphasis:`num` is a number from 0
   to the number of core efficiencies detected in the machine topology minus one.
   E.g., ``eff0``. The greater the efficiency number the more performant the core. There may be

 * ``2c:eff0@1,3c:eff1``: Use all available sockets, skip the first core with efficiency 0
   and use the next 2 cores with efficiency 0 and 3 cores with efficiency 1 per socket.
 * ``1s, 1c, 1t``: Use 1 socket, 1 core, 1 thread. This may result in using
   single thread on a 3-layer topology architecture, or multiple threads on
   4-layer or 5-layer architecture. Result may even be different on the same
   architecture, depending on ``KMP_TOPOLOGY_METHOD`` specified, as hwloc can
   often detect more topology layers than the default method used by the OpenMP
   run-time library.
+* ``*c:eff1@3``: Use all available sockets, skip the first three cores of
+  efficiency 1, and then use the rest of the available cores of efficiency 1.
 
 To see the result of the setting, you can specify ``verbose`` modifier in
 ``KMP_AFFINITY`` environment variable. The OpenMP run-time library will output
 to ``stderr`` the information about the discovered hardware topology before and
 after the ``KMP_HW_SUBSET`` setting was applied.
 
 KMP_INHERIT_FP_CONTROL
 """"""""""""""""""""""

openmp/runtime/src/kmp_affinity.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef KMP_AFFINITY_H
 #define KMP_AFFINITY_H
 
 #include "kmp.h"
 #include "kmp_os.h"
+#include <limits>
 
 #if KMP_AFFINITY_SUPPORTED
 #if KMP_USE_HWLOC
 class KMPHwlocAffinity : public KMPAffinity {
 public:
   class Mask : public KMPAffinity::Mask {
     hwloc_cpuset_t mask;
 
public:
   // Describe a machine topology item in KMP_HW_SUBSET
   struct item_t {
     kmp_hw_t type;
     int num_attrs;
     int num[MAX_ATTRS];
     int offset[MAX_ATTRS];
     kmp_hw_attr_t attr[MAX_ATTRS];
   };
+  // Put parenthesis around max to avoid accidental use of Windows max macro.
+  const static int USE_ALL = (std::numeric_limits<int>::max)();
 
 private:
   int depth;
   int capacity;
   item_t *items;
   kmp_uint64 set;
   bool absolute;
   // The set must be able to handle up to KMP_HW_LAST number of layers

openmp/runtime/src/kmp_affinity.cpp

if (specified[equivalent_type] != KMP_HW_UNKNOWN) {
       KMP_WARNING(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 + offset > max_count) {
+    if (max_count < 0 ||
+        (num != kmp_hw_subset_t::USE_ALL && num + offset > max_count)) {
       bool plural = (num > 1);
       KMP_WARNING(AffHWSubsetManyGeneric,
                   __kmp_hw_get_catalog_string(type, plural));
       return false;
     }
 
     // Check to see if core attributes are consistent
     if (core_level == level) {
if (core_level == level) {
       // Check that the number of requested cores with attributes is valid
       if (using_core_types || using_core_effs) {
         for (int j = 0; j < item.num_attrs; ++j) {
           int num = item.num[j];
           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 + offset > max_count) {
+            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_WARNING(AffHWSubsetManyGeneric, buf.str);
               __kmp_str_buf_free(&buf);
               return false;
             }
           }
         }
for (int hw_subset_index = 0; hw_subset_index < hw_subset_depth;
         }
         int sub_id;
         int num = hw_subset_item.num[attr_idx];
         int offset = hw_subset_item.offset[attr_idx];
         if (using_core_types)
           sub_id = core_type_sub_ids.get_sub_id(hw_thread);
         else
           sub_id = core_eff_sub_ids.get_sub_id(hw_thread);
-        if (sub_id < offset || sub_id >= offset + num) {
+        if (sub_id < offset ||
+            (num != kmp_hw_subset_t::USE_ALL && sub_id >= offset + num)) {
           should_be_filtered = true;
           break;
         }
       } else {
         int num = hw_subset_item.num[0];
         int offset = hw_subset_item.offset[0];
         if (hw_thread.sub_ids[level] < offset ||
-            hw_thread.sub_ids[level] >= offset + num) {
+            (num != kmp_hw_subset_t::USE_ALL &&
+             hw_thread.sub_ids[level] >= offset + num)) {
           should_be_filtered = true;
           break;
         }
       }
     }
     // Collect filtering information
     filtered[i] = should_be_filtered;
     if (should_be_filtered)

openmp/runtime/src/kmp_settings.cpp

while ((pos = strchr(pos, '&'))) {
       core_components[core_level++] = ++pos; // expect something after '&'
     }
 
     for (int j = 0; j < core_level; ++j) {
       char *offset_ptr;
       char *attr_ptr;
       int offset = 0;
       kmp_hw_attr_t attr;
-      int num =
-          atoi(core_components[j]); // each component should start with a number
+      int num;
+      // components may begin with an optional count of the number of resources
+      if (isdigit(*core_components[j])) {
+        num = atoi(core_components[j]);
         if (num <= 0) {
           goto err; // only positive integers are valid for count
         }
+        pos = core_components[j] + strspn(core_components[j], digits);
+      } else if (*core_components[j] == '*') {
+        num = kmp_hw_subset_t::USE_ALL;
+        pos = core_components[j] + 1;
+      } else {
+        num = kmp_hw_subset_t::USE_ALL;
+        pos = core_components[j];
+      }
 
       offset_ptr = strchr(core_components[j], '@');
       attr_ptr = strchr(core_components[j], ':');
 
       if (offset_ptr) {
         offset = atoi(offset_ptr + 1); // save offset
         *offset_ptr = '\0'; // cut the offset from the component
       }
#endif
           }
           int efficiency = atoi(number);
           attr.set_core_eff(efficiency);
         } else {
           goto err;
         }
         *attr_ptr = '\0'; // cut the attribute from the component
       }
-      pos = core_components[j] + strspn(core_components[j], digits);
-      if (pos == core_components[j]) {
-        goto err;
-      }
       // detect the component type
       kmp_hw_t type = __kmp_stg_parse_hw_subset_name(pos);
       if (type == KMP_HW_UNKNOWN) {
         goto err;
       }
       // Only the core type can have attributes
       if (attr && type != KMP_HW_CORE)
         goto err;