event_logger.h

 
#ifndef _BACKENDS_TOFINO_BF_P4C_LOGGING_EVENT_LOGGER_H_
#define _BACKENDS_TOFINO_BF_P4C_LOGGING_EVENT_LOGGER_H_
 
#include <ctime>
#include <functional>
#include <map>
#include <string>
#include <vector>
 
#include "lib/error_message.h"
#include "lib/log.h"
 
namespace P4 {
 
namespace IR {
class Node;  // Forward declare IR::Node for debug hook
}
 
namespace Util {
class SourceInfo;  // Forward declare Util::SourceInfo for errors/warnings
}
 
// Copy typedef of DebugHook so we don't have to depend on ir/ir.h
typedef std::function<void(const char *, unsigned, const char *, const IR::Node *)> DebugHook;
 
}  // namespace P4
 
using namespace P4;
 
class EventLogger {
 protected:
    const time_t BEGIN_TIME = std::time(nullptr);
 
    bool enabled = false;
    bool initialized = false;
 
    // Used for deduplicating passChange messages
    std::string lastManager = "";
    std::string lastPass = "";
    unsigned lastSeq = 0;
 
    // Used to form JSON mapping of names to ids and back
    // Used from pass change event
    int managerId = 0;
    std::map<std::string, int> managerNameToIds;
    std::vector<std::string> managerNames;
 
    // Used to form JSON mapping of filenames to ids and back
    // Used from debug and decision events
    int fileId = 0;
    std::map<std::string, int> fileNameToIds;
    std::vector<std::string> fileNames;
 
    EventLogger();
    EventLogger(EventLogger &&other) = delete;
    EventLogger(const EventLogger &other) = delete;
    EventLogger &operator=(const EventLogger &other) = delete;
    ~EventLogger();
 
    void nullInit();
 
    int getManagerId(const std::string &name);
 
    int getFileNameId(const std::string &name);
 
    virtual int getTimeDifference() const;
 
    virtual std::string getStartTimestamp() const;
 
    virtual std::ostream &getDebugStream(unsigned level, const std::string &file) const;
 
    template <typename T>
    void logSink(const T *obj);
 
    void logProperties();
 
    void passChange(const std::string &manager, const std::string &pass, unsigned seq);
 
 public:
    enum class AllocPhase { PhvAllocation, TablePlacement };
 
    static EventLogger &get();
 
    void init(const std::string &outdir, const std::string &filename);
 
    void enable() { enabled = true; }
 
    void deinit();
 
    void parserError(const P4::ParserErrorMessage &msg);
 
    void error(const P4::ErrorMessage &msg);
 
    void warning(const P4::ErrorMessage &msg);
 
    void debug(unsigned level, const std::string &file, const std::string &message);
 
    void decision(unsigned level, const std::string &file, const std::string &description,
                  const std::string &what, const std::string &why);
 
    void iterationChange(unsigned iteration, AllocPhase phase);
 
    void pipeChange(int pipeId);
 
    static P4::DebugHook getDebugHook() {
        return [](const char *m, unsigned s, const char *p, const IR::Node *) {
            get().passChange(m, p, s);
        };
    }
};
 
#define TAB1 "  "_cs
#define TAB2 TAB1 TAB1
#define TAB3 TAB1 TAB2
#define TAB4 TAB2 TAB2
#define TAB5 TAB1 TAB4
#define TAB6 TAB3 TAB3
#define TAB7 TAB1 TAB6
 
#define LOG_DEBUG(level, message)                             \
    if (LOGGING(level)) {                                     \
        std::stringstream out;                                \
        out << message;                                       \
        EventLogger::get().debug(level, __FILE__, out.str()); \
    }
#define LOG_DEBUG1(message) LOG_DEBUG(1, message)
#define LOG_DEBUG2(message) LOG_DEBUG(2, message)
#define LOG_DEBUG3(message) LOG_DEBUG(3, message)
#define LOG_DEBUG4(message) LOG_DEBUG(4, message)
#define LOG_DEBUG5(message) LOG_DEBUG(5, message)
#define LOG_DEBUG6(message) LOG_DEBUG(6, message)
#define LOG_DEBUG7(message) LOG_DEBUG(7, message)
#define LOG_DEBUG8(message) LOG_DEBUG(8, message)
#define LOG_DEBUG9(message) LOG_DEBUG(9, message)
 
#define LOG_DECISION(level, description, chosen, why) \
    EventLogger::get().decision(level, __FILE__, description, chosen, why);
#define LOG_DECISION1(description, chosen, why) LOG_DECISION(1, description, chosen, why);
#define LOG_DECISION2(description, chosen, why) LOG_DECISION(2, description, chosen, why);
#define LOG_DECISION3(description, chosen, why) LOG_DECISION(3, description, chosen, why);
#define LOG_DECISION4(description, chosen, why) LOG_DECISION(4, description, chosen, why);
#define LOG_DECISION5(description, chosen, why) LOG_DECISION(5, description, chosen, why);
#define LOG_DECISION6(description, chosen, why) LOG_DECISION(6, description, chosen, why);
#define LOG_DECISION7(description, chosen, why) LOG_DECISION(7, description, chosen, why);
#define LOG_DECISION8(description, chosen, why) LOG_DECISION(8, description, chosen, why);
#define LOG_DECISION9(description, chosen, why) LOG_DECISION(9, description, chosen, why);
 
#endif /* _BACKENDS_TOFINO_BF_P4C_LOGGING_EVENT_LOGGER_H_ */