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.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  ;
 
        std::vector<char> serialize() const;
 
        static Msg deserialize(std::vector<char>::const_iterator& it);
 
        static Msg deserialize(std::vector<char>::const_iterator&& it);
    };
 
    struct MsgWithCounter
    {
        Msg msg      ;
        std::int64_t counter  ;
 
        std::vector<char> serialize() const;
 
        static MsgWithCounter deserialize(std::vector<char>::const_iterator& it);
 
        static MsgWithCounter deserialize(std::vector<char>::const_iterator&& it);
    };
 
    struct MsgWithCounterAndRanks
    {
        MsgWithCounter msg_with_counter ;
        bool all_ranks                  ;
        std::vector<int> ranks          ;
 
        std::vector<char> serialize() const;
 
        static MsgWithCounterAndRanks deserialize(std::vector<char>::const_iterator& it);
 
        static MsgWithCounterAndRanks deserialize(std::vector<char>::const_iterator&& it);
    };
 
    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(Msg msg);
 
        std::vector<Msg> get_msgs() const;
 
        std::vector<MsgWithCounter> get_msgs_with_counter() const;
 
        std::vector<MsgWithCounterAndRanks>
        collective_gather_msgs_with_counter_and_ranks() const;
 
        private:
 
        std::vector<MsgWithCounterAndRanks>
        one_rank_gather_msgs_with_counter_and_ranks() const;
 
#ifdef AMREX_USE_MPI
        std::pair<int, int> find_gather_rank_and_its_msgs(
            int how_many_msgs) const;
 
        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,
            const int gather_rank
        ) const;
 
 
        void
        swap_with_io_rank(
        std::vector<MsgWithCounterAndRanks>& msgs_with_counter_and_ranks,
        int gather_rank) const;
 
#endif
 
        const int m_rank       ;
        const int m_num_procs  ;
        const int m_io_rank    ;
 
        std::map<Msg, std::int64_t> m_messages ;
    };
}
 
#endif //ABLASTR_MSG_LOGGER_H_