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_