MsgLogger.H

Go to the documentation of this file.

/* Copyright 2021 Luca Fedeli
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
 
#ifndef ABLASTR_MSG_LOGGER_H_
#define ABLASTR_MSG_LOGGER_H_
 
#include <AMReX_Config.H>
 
#include <cstdint>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace ablastr::utils::msg_logger
{
    enum class Priority
    {
        low,
        medium,
        high
    };

    std::string PriorityToString(const Priority& priority);

    Priority StringToPriority(const std::string& priority_string);

    struct Msg
    {
        std::string topic  ;
        std::string text   ;
        Priority priority  ;

        [[nodiscard]] std::vector<char> serialize() const;

        static Msg deserialize(std::vector<char>::const_iterator& it);

        static Msg deserialize(std::vector<char>::const_iterator&& rit);
    };

    struct MsgWithCounter
    {
        Msg msg      ;
        std::int64_t counter  ;

        [[nodiscard]] std::vector<char> serialize() const;

        static MsgWithCounter deserialize(std::vector<char>::const_iterator& it);

        static MsgWithCounter deserialize(std::vector<char>::const_iterator&& rit);
    };

    struct MsgWithCounterAndRanks
    {
        MsgWithCounter msg_with_counter ;
        bool all_ranks                  ;
        std::vector<int> ranks          ;

        [[nodiscard]] std::vector<char> serialize() const;

        static MsgWithCounterAndRanks deserialize(std::vector<char>::const_iterator& it);

        static MsgWithCounterAndRanks deserialize(std::vector<char>::const_iterator&& rit);
    };

    constexpr bool operator<(const Msg& l, const Msg& r)
    {
        return
            (l.priority > r.priority) ||
            ((l.priority == r.priority) && (l.topic < r.topic)) ||
            ((l.priority == r.priority) && (l.topic == r.topic) && (l.text < r.text));
    }

    class Logger
    {
        public:

        Logger();

        void record_msg(const Msg& msg);

        [[nodiscard]] std::vector<Msg> get_msgs() const;

        [[nodiscard]] std::vector<MsgWithCounter>
        get_msgs_with_counter() const;

        [[nodiscard]] std::vector<MsgWithCounterAndRanks>
        collective_gather_msgs_with_counter_and_ranks() const;
 
        private:

        [[nodiscard]] std::vector<MsgWithCounterAndRanks>
        one_rank_gather_msgs_with_counter_and_ranks() const;
 
#ifdef AMREX_USE_MPI
        [[nodiscard]] std::pair<int, int>
        find_gather_rank_and_its_msgs(int how_many_msgs) const;

        [[nodiscard]] std::vector<MsgWithCounterAndRanks>
        compute_msgs_with_counter_and_ranks(
            const std::map<Msg,std::int64_t>& my_msg_map,
            const std::vector<char>& all_data,
            const std::vector<int>& displacements,
            int gather_rank
        ) const;
 

        void
        swap_with_io_rank(
        std::vector<MsgWithCounterAndRanks>& msgs_with_counter_and_ranks,
        int gather_rank) const;
 
#endif
 
        int m_rank       ;
        int m_num_procs  ;
        int m_io_rank    ;
 
        std::map<Msg, std::int64_t> m_messages ;
    };
}
 
#endif //ABLASTR_MSG_LOGGER_H_