manifest.h

 
#ifndef _BACKENDS_TOFINO_BF_P4C_LOGGING_MANIFEST_H_
#define _BACKENDS_TOFINO_BF_P4C_LOGGING_MANIFEST_H_
 
#include <rapidjson/document.h>
#include <rapidjson/prettywriter.h>
 
#include <cstdarg>
#include <fstream>
#include <map>
#include <set>
#include <string>
#include <utility>
 
#include "backends/tofino/bf-p4c/arch/arch.h"
#include "backends/tofino/bf-p4c/bf-p4c-options.h"
#include "backends/tofino/bf-p4c/ir/gress.h"
#include "lib/cstring.h"
 
namespace Logging {
 
class Manifest : public Inspector {
    using Writer = rapidjson::PrettyWriter<rapidjson::StringBuffer>;
    using PathAndType = std::pair<cstring, cstring>;
 
    // to use PathAndType as std::set
    struct PathCmp {
        bool operator()(const PathAndType &lhs, const PathAndType &rhs) const;
    };
 
 private:
    struct InputFiles {
        cstring m_rootPath;
        cstring m_sourceInfo;  // path to source.json relative to manifest.json
        std::set<cstring> m_includePaths;
        std::set<cstring> m_defines;
 
        explicit InputFiles(const BFN_Options &);
        void serialize(Writer &) const;
    };
 
    struct GraphOutput {
        cstring m_path;
        gress_t m_gress;
        cstring m_type;
        cstring m_format;
        GraphOutput(const cstring path_in, const gress_t gress_in, const cstring type_in,
                    const cstring format_in = ".dot"_cs)
            : m_path(path_in), m_gress(gress_in), m_type(type_in), m_format(format_in) {}
 
        void serialize(Writer &) const;
 
        cstring getHash() const { return m_path + toString(m_gress) + m_type + m_format; }
    };
 
    struct GraphOutputCmp {
        bool operator()(const GraphOutput &lhs, const GraphOutput &rhs) const {
            return std::less<const char *>()(lhs.getHash().c_str(), rhs.getHash().c_str());
        }
    };
 
    struct OutputFiles {
        cstring m_context;  // path to the context file
        cstring m_binary;   // path to the binary file
        // pairs of path and resource type
        std::set<PathAndType, PathCmp> m_resources;
        // pairs of path and log type
        std::set<PathAndType, PathCmp> m_logs;
        std::set<GraphOutput, GraphOutputCmp> m_graphs;
 
        void serialize(Writer &) const;
    };
 
    const BFN_Options &m_options;
    // pairs of <pipe_id, pipe_name>
    std::map<unsigned int, cstring> m_pipes;
    std::map<unsigned int, OutputFiles *> m_pipeOutputs;
    InputFiles m_programInputs;
    cstring m_eventLogPath, m_frontendIrLogPath;
    BFN::ProgramPipelines m_pipelines;
    int m_pipeId = -1;  
    P4::ReferenceMap *m_refMap = nullptr;
    std::ofstream m_manifestStream;
    bool m_success = false;
 
 private:
    Manifest();
    ~Manifest();
 
    OutputFiles *getPipeOutputs(unsigned int pipe);
 
 public:
    static Manifest &getManifest();  //  singleton
 
    void postorder(const IR::BFN::TnaParser *parser) override;
    void postorder(const IR::BFN::TnaControl *control) override;
    void setRefMap(/* intentionally no "const" here */ P4::ReferenceMap *const refMap_in) {
        m_refMap = refMap_in;
    }
 
    void setPipe(int pipe_ID, const cstring pipe_name);
 
    void setSuccess(const bool success) { m_success = success; }
 
    void addContext(const int pipe, const cstring path) { getPipeOutputs(pipe)->m_context = path; }
    void addResources(const int pipe, const cstring path, const cstring type = "resources"_cs) {
        getPipeOutputs(pipe)->m_resources.insert(PathAndType(path, type));
    }
    void addGraph(int pipe, const cstring graphType, const cstring graphName, const gress_t gress,
                  const cstring extension_including_the_leading_period = ".dot"_cs);
    void addLog(int pipe, const cstring logType, const cstring logName);
    void addArchitecture(const BFN::ProgramPipelines &pipelines_in) { m_pipelines = pipelines_in; }
    void setSourceInfo(const cstring sourceInfo_in) {
        BUG_CHECK(m_programInputs.m_sourceInfo.size() == 0,
                  "Trying to redefine path to source info!");
        m_programInputs.m_sourceInfo = sourceInfo_in;
    }
    void setEventLog(const cstring eventLogPath_in) {
        BUG_CHECK(m_eventLogPath.size() == 0, "Trying to redefine path to source info!");
        m_eventLogPath = eventLogPath_in;
    }
    void setFrontendIrLog(const cstring frontendIrLogPath_in) {
        BUG_CHECK(m_frontendIrLogPath.size() == 0, "Trying to redefine path to frontend IR!");
        m_frontendIrLogPath = frontendIrLogPath_in;
    }
 
    virtual void serialize();
 
 private:
    void serialize_target_data(Writer &);
 
    void serializePipes(Writer &);
 
    void sendTo(Writer &, int pipe, gress_t);
};
}  // end namespace Logging
 
#endif /* _BACKENDS_TOFINO_BF_P4C_LOGGING_MANIFEST_H_ */