topologyManager.hpp

Go to the documentation of this file.

/*
 *   Copyright 2025 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include "hwloc.h"
#include <hicr/backends/hwloc/device.hpp>
#include <hicr/backends/hwloc/computeResource.hpp>
#include <hicr/backends/hwloc/memorySpace.hpp>
#include <hicr/core/topology.hpp>
#include <hicr/core/topologyManager.hpp>
 
namespace HiCR::backend::hwloc
{
 
constexpr size_t _HWLOC_MAX_MEMSPACE_SIZE = 1024;
 
class TopologyManager final : public HiCR::TopologyManager
{
  public:
 
  TopologyManager(hwloc_topology_t *topology)
    : HiCR::TopologyManager(),
      _topology(topology)
  {}
 
  ~TopologyManager() override = default;
 
  __INLINE__ HiCR::Topology queryTopology() override
  {
    // Disable filters in order to detect instr. caches
    hwloc_topology_set_icache_types_filter(*_topology, HWLOC_TYPE_FILTER_KEEP_ALL);
 
    // Loading HWLoc topology object
    hwloc_topology_load(*_topology);
 
    // Storage for the new HICR topology
    HiCR::Topology t;
 
    // Ask hwloc about number of NUMA nodes and add as many devices as NUMA domains
    auto n = hwloc_get_nbobjs_by_type(*_topology, HWLOC_OBJ_NUMANODE);
    for (int i = 0; i < n; i++)
    {
      // Creating new device for the current NUMA domain
      auto d = std::make_shared<hwloc::Device>(i, queryComputeResources(i), queryMemorySpaces(i));
 
      // Inserting new device into the list
      t.addDevice(d);
    }
 
    // Returning the created topology
    return t;
  }
 
  __INLINE__ static HiCR::Topology deserializeTopology(const nlohmann::json &topology)
  {
    // Verifying input's syntax
    HiCR::Topology::verify(topology);
 
    // New topology to create
    HiCR::Topology t;
 
    // Iterating over the device list entries in the serialized input
    for (const auto &device : topology["Devices"])
    {
      // Getting device type
      const auto type = device["Type"].get<std::string>();
 
      // If the device type is recognized, add it to the new topology
      if (type == "NUMA Domain") t.addDevice(std::make_shared<hwloc::Device>(device));
    }
 
    // Returning new topology
    return t;
  }
 
  [[nodiscard]] __INLINE__ HiCR::Topology _deserializeTopology(const nlohmann::json &topology) const override { return deserializeTopology(topology); }
 
  __INLINE__ static std::unique_ptr<HiCR::TopologyManager> createDefault()
  {
    // Creating HWloc topology object
    auto topology = new hwloc_topology_t;
 
    // Reserving memory for hwloc
    hwloc_topology_init(topology);
 
    // Initializing HWLoc-based topology manager
    return std::make_unique<HiCR::backend::hwloc::TopologyManager>(topology);
  }
 
  private:
 
  __INLINE__ HiCR::Device::computeResourceList_t queryComputeResources(const hwloc::Device::NUMADomainID_t numaDomainId)
  {
    // New compute resource list to return
    HiCR::Device::computeResourceList_t computeResourceList;
 
    // Creating compute resource list, based on the  processing units (hyperthreads) observed by HWLoc
    std::vector<HiCR::backend::hwloc::ComputeResource::logicalProcessorId_t> logicalProcessorIds;
    HiCR::backend::hwloc::ComputeResource::detectThreadPUs(*_topology, hwloc_get_root_obj(*_topology), 0, logicalProcessorIds);
 
    // Adding detected PUs as long they belong to this numa domain
    for (const auto id : logicalProcessorIds)
      if (ComputeResource::getCpuNumaAffinity(*_topology, id) == numaDomainId)
      {
        // Creating new compute resource class (of CPU core/processor type)
        auto processor = std::make_shared<HiCR::backend::hwloc::ComputeResource>(*_topology, id);
 
        // Adding new resource to the list
        computeResourceList.push_back(processor);
      }
 
    // Returning new compute resource list
    return computeResourceList;
  }
 
  __INLINE__ HiCR::Device::memorySpaceList_t queryMemorySpaces(const hwloc::Device::NUMADomainID_t numaDomainId)
  {
    // New memory space list to return
    HiCR::Device::memorySpaceList_t memorySpaceList;
 
    // Getting HWLoc object related to this NUMA domain
    auto hwlocObj = hwloc_get_obj_by_type(*_topology, HWLOC_OBJ_NUMANODE, numaDomainId);
 
    // Checking whther bound memory allocation and freeing is supported
    auto   bindingSupport = LocalMemorySlot::binding_type::strict_non_binding;
    size_t size           = _HWLOC_MAX_MEMSPACE_SIZE;
    auto   ptr            = hwloc_alloc_membind(*_topology, size, hwlocObj->nodeset, HWLOC_MEMBIND_DEFAULT, HWLOC_MEMBIND_BYNODESET | HWLOC_MEMBIND_STRICT);
    if (ptr != nullptr)
    {
      // Attempting to free with hwloc
      auto status = hwloc_free(*_topology, ptr, size);
 
      // Freeing was successful, then strict binding is supported
      if (status == 0) bindingSupport = LocalMemorySlot::binding_type::strict_binding;
    }
 
    // Getting memory space size
    auto memSpaceSize = hwlocObj->attr->cache.size;
 
    // Creating new memory space object
    auto memorySpace = std::make_shared<hwloc::MemorySpace>(memSpaceSize, hwlocObj, bindingSupport);
 
    // Storing new memory space
    memorySpaceList.push_back(memorySpace);
 
    // Returning new memory space list
    return memorySpaceList;
  }
 
  hwloc_topology_t *const _topology;
};
 
} // namespace HiCR::backend::hwloc