Comm.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef COMM_HPP_INCLUDE
#define COMM_HPP_INCLUDE
 
#include <memory>
#include <vector>
#include <string>
#include <list>
 
#include "geopm/PluginFactory.hpp"
 
namespace geopm
{
    class Comm
    {
        public:
            enum m_comm_split_type_e {
                M_COMM_SPLIT_TYPE_PPN1,
                M_COMM_SPLIT_TYPE_SHARED,
                M_NUM_COMM_SPLIT_TYPE
            };
 
            enum m_split_color_e {
                M_SPLIT_COLOR_UNDEFINED = -16,
            };
 
            Comm() = default;
            Comm(const Comm &other) = default;
            Comm &operator=(const Comm &other) = default;
            virtual ~Comm() = default;
            static std::vector<std::string> comm_names(void);
            static std::unique_ptr<Comm> make_unique(const std::string &comm_name);
            static std::unique_ptr<Comm> make_unique(void);
            virtual std::shared_ptr<Comm> split() const = 0;
            virtual std::shared_ptr<Comm> split(int color, int key) const = 0;
            virtual std::shared_ptr<Comm> split(const std::string &tag, int split_type) const = 0;
            virtual std::shared_ptr<Comm> split(std::vector<int> dimensions, std::vector<int> periods, bool is_reorder) const = 0;
            virtual std::shared_ptr<Comm> split_cart(std::vector<int> dimensions) const = 0;
 
            virtual bool comm_supported(const std::string &description) const = 0;
 
            // Introspection
            virtual int cart_rank(const std::vector<int> &coords) const = 0;
            virtual int rank(void) const = 0;
            virtual int num_rank(void) const = 0;
            virtual void dimension_create(int num_ranks, std::vector<int> &dimension) const = 0;
            virtual void free_mem(void *base) = 0;
            virtual void alloc_mem(size_t size, void **base) = 0;
            virtual size_t window_create(size_t size, void *base) = 0;
            virtual void window_destroy(size_t window_id) = 0;
            virtual void window_lock(size_t window_id, bool is_exclusive, int rank, int assert) const = 0;
            virtual void window_unlock(size_t window_id, int rank) const = 0;
            virtual void coordinate(int rank, std::vector<int> &coord) const = 0;
            virtual std::vector<int> coordinate(int rank) const = 0;
            // Collective communication
            virtual void barrier(void) const = 0;
            virtual void broadcast(void *buffer, size_t size, int root) const = 0;
            virtual bool test(bool is_true) const = 0;
            virtual void reduce_max(double *send_buf, double *recv_buf, size_t count, int root) const = 0;
            virtual void gather(const void *send_buf, size_t send_size, void *recv_buf,
                                size_t recv_size, int root) const = 0;
            virtual void gatherv(const void *send_buf, size_t send_size, void *recv_buf,
                                 const std::vector<size_t> &recv_sizes, const std::vector<off_t> &rank_offset, int root) const = 0;
            virtual void window_put(const void *send_buf, size_t send_size, int rank, off_t disp, size_t window_id) const = 0;
            virtual void tear_down(void) = 0;
            static const std::string M_PLUGIN_PREFIX;
    };
 
    class CommFactory : public PluginFactory<Comm>
    {
        public:
            CommFactory();
            virtual ~CommFactory() = default;
    };
 
    CommFactory &comm_factory(void);
 
 
    class NullComm : public Comm
    {
        public:
            NullComm();
            virtual ~NullComm() = default;
            std::shared_ptr<Comm> split() const override;
            std::shared_ptr<Comm> split(int color, int key) const override;
            std::shared_ptr<Comm> split(const std::string &tag, int split_type) const override;
            std::shared_ptr<Comm> split(std::vector<int> dimensions, std::vector<int> periods, bool is_reorder) const override;
            std::shared_ptr<Comm> split_cart(std::vector<int> dimensions) const override;
 
            bool comm_supported(const std::string &description) const override;
            int cart_rank(const std::vector<int> &coords) const override;
            int rank(void) const override;
            int num_rank(void) const override;
            void dimension_create(int num_ranks, std::vector<int> &dimension) const override;
            void free_mem(void *base) override;
            void alloc_mem(size_t size, void **base) override;
            size_t window_create(size_t size, void *base) override;
            void window_destroy(size_t window_id) override;
            void window_lock(size_t window_id, bool is_exclusive, int rank, int assert) const override;
            void window_unlock(size_t window_id, int rank) const override;
            void coordinate(int rank, std::vector<int> &coord) const override;
            std::vector<int> coordinate(int rank) const override;
            void barrier(void) const override;
            void broadcast(void *buffer, size_t size, int root) const override;
            bool test(bool is_true) const override;
            void reduce_max(double *send_buf, double *recv_buf, size_t count, int root) const override;
            void gather(const void *send_buf, size_t send_size, void *recv_buf,
                                size_t recv_size, int root) const override;
            void gatherv(const void *send_buf, size_t send_size, void *recv_buf,
                                 const std::vector<size_t> &recv_sizes, const std::vector<off_t> &rank_offset, int root) const override;
            void window_put(const void *send_buf, size_t send_size, int rank, off_t disp, size_t window_id) const override;
            void tear_down(void) override;
            static std::string plugin_name(void);
            static std::unique_ptr<Comm> make_plugin();
        private:
            mutable std::vector<std::vector<char> > m_window_buffers;
            std::map<char *, int> m_window_buffers_map;
    };
}
 
#endif