numa.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_NUMA_H
#define DISMEC_NUMA_H
 
#include <memory>
#include <vector>
#include <functional>
#include <any>
#include "spdlog/spdlog.h"
#include "thread_id.h"
 
namespace dismec::parallel {
 
    void pin_to_data(const void* data);
 
    class NUMAReplicatorBase {
    public:
        [[nodiscard]] bool has_numa() const { return m_HasNUMA; }
        [[nodiscard]] int num_numa() const { return m_Copies.size(); }
 
    protected:
        NUMAReplicatorBase();
        virtual ~NUMAReplicatorBase() = default;
 
        void make_copies();
 
        [[nodiscard]] const std::any& access_local() const;
 
    private:
        bool m_HasNUMA = false;     
 
        std::vector<std::any> m_Copies;
 
        [[nodiscard]] virtual std::any get_clone() const = 0;
    };
 
    template<class T>
    class NUMAReplicator : public NUMAReplicatorBase {
        using ptr_t = std::shared_ptr<const T>;
    public:
        explicit NUMAReplicator(std::shared_ptr<const T> data) : m_Data(std::move(data)) {
            make_copies();
        }
 
        std::shared_ptr<const T> get_local() const {
            const std::any& data = access_local();
            if(data.has_value()) {
                return std::any_cast<ptr_t>(data);
            }
            return m_Data;
        }
    private:
        ptr_t m_Data;
 
        [[nodiscard]] std::any get_clone() const override {
            return std::make_shared<const T>(*m_Data);
        }
    };
 
 
    class ThreadDistributor {
    public:
        ThreadDistributor(long num_threads, std::shared_ptr<spdlog::logger> = {});
        void pin_this_thread(thread_id_t thread_id);
    private:
        std::vector<cpu_id_t> m_TargetCPUs;       
 
        std::shared_ptr<spdlog::logger> m_Logger;
    };
}
 
#endif //DISMEC_NUMA_H