machine_topology.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_MACHINE_TOPOLOGY_HPP_
#define GKO_PUBLIC_CORE_BASE_MACHINE_TOPOLOGY_HPP_
 
 
#include <cassert>
#include <cstddef>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <type_traits>
#include <vector>
 
#include <ginkgo/config.hpp>
#include <ginkgo/core/base/exception.hpp>
#include <ginkgo/core/base/exception_helpers.hpp>
 
 
#if GKO_HAVE_HWLOC
 
#include <hwloc.h>
 
#else
 
struct hwloc_obj_type_t {};
struct hwloc_obj_t {};
 
#endif
 
 
struct hwloc_topology;
struct hwloc_bitmap_s;
 
 
namespace gko {
 
 
class machine_topology {
    template <typename T>
    using hwloc_manager = std::unique_ptr<T, std::function<void(T*)>>;
 
    struct normal_obj_info {
        hwloc_obj_t obj;
 
        size_type logical_id;
 
        size_type os_id;
 
        size_type gp_id;
 
        int numa;
 
        size_type memory_size;
    };
 
 
    struct io_obj_info {
        hwloc_obj_t obj;
 
        size_type logical_id;
 
        size_type os_id;
 
        size_type gp_id;
 
        int closest_numa;
 
        hwloc_obj_t non_io_ancestor;
 
        int ancestor_local_id;
 
        std::string ancestor_type;
 
        std::vector<int> closest_pu_ids;
 
        std::string pci_bus_id;
    };
 
public:
    static machine_topology* get_instance()
    {
        static machine_topology instance;
        return &instance;
    }
 
    void bind_to_cores(const std::vector<int>& ids,
                       const bool singlify = true) const
    {
        hwloc_binding_helper(this->cores_, ids, singlify);
    }
 
    void bind_to_core(const int& id) const
    {
        machine_topology::get_instance()->bind_to_cores(std::vector<int>{id});
    }
 
    void bind_to_pus(const std::vector<int>& ids,
                     const bool singlify = true) const
    {
        hwloc_binding_helper(this->pus_, ids, singlify);
    }
 
    void bind_to_pu(const int& id) const
    {
        machine_topology::get_instance()->bind_to_pus(std::vector<int>{id});
    }
 
    const normal_obj_info* get_pu(size_type id) const
    {
        GKO_ENSURE_IN_BOUNDS(id, this->pus_.size());
        return &this->pus_[id];
    }
 
    const normal_obj_info* get_core(size_type id) const
    {
        GKO_ENSURE_IN_BOUNDS(id, this->cores_.size());
        return &this->cores_[id];
    }
 
    const io_obj_info* get_pci_device(size_type id) const
    {
        GKO_ENSURE_IN_BOUNDS(id, this->pci_devices_.size());
        return &this->pci_devices_[id];
    }
 
    const io_obj_info* get_pci_device(const std::string& pci_bus_id) const;
 
    size_type get_num_pus() const { return this->pus_.size(); }
 
    size_type get_num_cores() const { return this->cores_.size(); }
 
    size_type get_num_pci_devices() const { return this->pci_devices_.size(); }
 
    size_type get_num_numas() const { return this->num_numas_; }
 
    void hwloc_binding_helper(
        const std::vector<machine_topology::normal_obj_info>& obj,
        const std::vector<int>& ids, const bool singlify = true) const;
 
    void load_objects(hwloc_obj_type_t type,
                      std::vector<normal_obj_info>& objects) const;
 
    void load_objects(hwloc_obj_type_t type,
                      std::vector<io_obj_info>& vector) const;
 
    int get_obj_id_by_os_index(const std::vector<normal_obj_info>& objects,
                               size_type os_index) const;
 
    int get_obj_id_by_gp_index(const std::vector<normal_obj_info>& objects,
                               size_type gp_index) const;
 
private:
    machine_topology();
    machine_topology(machine_topology&) = delete;
    machine_topology(machine_topology&&) = delete;
    machine_topology& operator=(machine_topology&) = delete;
    machine_topology& operator=(machine_topology&&) = delete;
    ~machine_topology() = default;
 
    std::vector<normal_obj_info> pus_;
    std::vector<normal_obj_info> cores_;
    std::vector<normal_obj_info> packages_;
    std::vector<normal_obj_info> numa_nodes_;
    std::vector<io_obj_info> pci_devices_;
    size_type num_numas_;
 
    hwloc_manager<hwloc_topology> topo_;
};
 
 
using MachineTopology GKO_DEPRECATED("please use machine_topology") =
    machine_topology;
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_MACHINE_TOPOLOGY_HPP_