[OpenMP][libomp] Insert correct HWLOC version guards

[jlpeyton]

Summary

Put needed HWLOC version guards around relevant HWLOC API.
Tested OpenMP host runtime build with HWLOC 1.11.13, 2.0-2.9.

Patch by Gilles Gouaillardet

Fix #54951

[tianshilei1992]

LGTM, thanks for the fix.

openmp/runtime/src/kmp_affinity.cpp

case HWLOC_OBJ_PACKAGE:
     return KMP_HW_SOCKET;
   case HWLOC_OBJ_NUMANODE:
     return KMP_HW_NUMA;
   case HWLOC_OBJ_CORE:
     return KMP_HW_CORE;
   case HWLOC_OBJ_PU:
     return KMP_HW_THREAD;
   case HWLOC_OBJ_GROUP:
+#if HWLOC_API_VERSION >= 0x00020000
     if (obj->attr->group.kind == HWLOC_GROUP_KIND_INTEL_DIE)
       return KMP_HW_DIE;
     else if (obj->attr->group.kind == HWLOC_GROUP_KIND_INTEL_TILE)
       return KMP_HW_TILE;
     else if (obj->attr->group.kind == HWLOC_GROUP_KIND_INTEL_MODULE)
       return KMP_HW_MODULE;
     else if (obj->attr->group.kind == HWLOC_GROUP_KIND_WINDOWS_PROCESSOR_GROUP)
       return KMP_HW_PROC_GROUP;
+#endif
     return KMP_HW_UNKNOWN;
 #if HWLOC_API_VERSION >= 0x00020100
   case HWLOC_OBJ_DIE:
     return KMP_HW_DIE;
 #endif
   }
   return KMP_HW_UNKNOWN;
 }
else
       __kmp_nThreadsPerCore = 1; // no CORE found
     __kmp_ncores = __kmp_xproc / __kmp_nThreadsPerCore;
     if (nCoresPerPkg == 0)
       nCoresPerPkg = 1; // to prevent possible division by 0
     nPackages = (__kmp_xproc + nCoresPerPkg - 1) / nCoresPerPkg;
     return true;
   }
 
+#if HWLOC_API_VERSION >= 0x00020400
   // Handle multiple types of cores if they exist on the system
   int nr_cpu_kinds = hwloc_cpukinds_get_nr(tp, 0);
 
   typedef struct kmp_hwloc_cpukinds_info_t {
     int efficiency;
     kmp_hw_core_type_t core_type;
     hwloc_bitmap_t mask;
   } kmp_hwloc_cpukinds_info_t;
#if KMP_ARCH_X86 || KMP_ARCH_X86_64
               break;
             }
 #endif
           }
         }
       }
     }
   }
+#endif
 
   root = hwloc_get_root_obj(tp);
 
   // Figure out the depth and types in the topology
   depth = 0;
   pu = hwloc_get_pu_obj_by_os_index(tp, __kmp_affin_fullMask->begin());
   KMP_ASSERT(pu);
   obj = pu;
while ((pu = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, pu))) {
     int index = depth - 1;
     bool included = KMP_CPU_ISSET(pu->os_index, __kmp_affin_fullMask);
     kmp_hw_thread_t &hw_thread = __kmp_topology->at(hw_thread_index);
     if (included) {
       hw_thread.clear();
       hw_thread.ids[index] = pu->logical_index;
       hw_thread.os_id = pu->os_index;
       // If multiple core types, then set that attribute for the hardware thread
+#if HWLOC_API_VERSION >= 0x00020400
       if (cpukinds) {
         int cpukind_index = -1;
         for (int i = 0; i < nr_cpu_kinds; ++i) {
           if (hwloc_bitmap_isset(cpukinds[i].mask, hw_thread.os_id)) {
             cpukind_index = i;
             break;
           }
         }
         if (cpukind_index >= 0) {
           hw_thread.attrs.set_core_type(cpukinds[cpukind_index].core_type);
           hw_thread.attrs.set_core_eff(cpukinds[cpukind_index].efficiency);
         }
       }
+#endif
       index--;
     }
     obj = pu;
     prev = obj;
     while (obj != root && obj != NULL) {
       obj = obj->parent;
 #if HWLOC_API_VERSION >= 0x00020000
       // NUMA Nodes are handled differently since they are not within the
#endif
         }
         prev = obj;
       }
     }
     if (included)
       hw_thread_index++;
   }
 
+#if HWLOC_API_VERSION >= 0x00020400
   // Free the core types information
   if (cpukinds) {
     for (int idx = 0; idx < nr_cpu_kinds; ++idx)
       hwloc_bitmap_free(cpukinds[idx].mask);
     __kmp_free(cpukinds);
   }
+#endif
   __kmp_topology->sort_ids();
   return true;
 }
 #endif // KMP_USE_HWLOC
 
 // If we don't know how to retrieve the machine's processor topology, or
 // encounter an error in doing so, this routine is called to form a "flat"
 // mapping of os thread id's <-> processor id's.