meta_live_range.h

 
#ifndef BF_P4C_PHV_ANALYSIS_META_LIVE_RANGE_H_
#define BF_P4C_PHV_ANALYSIS_META_LIVE_RANGE_H_
 
#include "backends/tofino/bf-p4c/common/field_defuse.h"
#include "backends/tofino/bf-p4c/mau/table_dependency_graph.h"
#include "backends/tofino/bf-p4c/phv/mau_backtracker.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "backends/tofino/bf-p4c/phv/phv_parde_mau_use.h"
#include "backends/tofino/bf-p4c/phv/pragma/phv_pragmas.h"
#include "ir/ir.h"
#include "lib/log.h"
#include "lib/symbitmatrix.h"
 
class MetadataLiveRange : public Inspector {
 public:
    // TODO: Should we expose a way of changing the DEP_DIST using a command line flag, as
    // glass does?
    static constexpr int DEP_DIST = 2;
    static constexpr char const *INGRESS_PARSER_ENTRY = "$entry_point.$ingress_tna_entry_point";
    static constexpr char const *EGRESS_PARSER_ENTRY = "$entry_point.$egress_tna_entry_point";
 
    static bool notOverlapping(int minStage1, int maxStage1, int minStage2, int maxStage2,
                               int depDist = DEP_DIST);
 
    static bool notOverlapping(std::pair<int, int> &range1, std::pair<int, int> &range2,
                               int depDist = DEP_DIST);
 
    static const ordered_set<cstring> noInitIntrinsicFields;
 
    enum access_t { READ = 1, WRITE = 2 };
 
    static cstring printAccess(int access);
 
 private:
    PhvInfo &phv;
    const DependencyGraph &dg;
    FieldDefUse &defuse;
    const PragmaNoOverlay &noOverlay;
    const PhvUse &uses;
 
    const ordered_set<const PHV::Field *> &noInitFields;
    const ordered_set<const PHV::Field *> &notParsedFields;
    const ordered_set<const PHV::Field *> &notDeparsedFields;
 
    SymBitMatrix &overlay;
 
    ordered_map<int, std::pair<int, int>> livemap;
    ordered_map<int, std::pair<int, int>> livemapUsage;
 
    ordered_map<int, ordered_set<const IR::MAU::Table *>> minStages;
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::MAU::Table *t) override;
    void end_apply() override;
 
    void printLiveRanges() const;
 
    void setFieldLiveMap(const PHV::Field *f);
 
    void setPaddingFieldLiveMap(const PHV::Field *f);
 
 public:
    const ordered_map<int, std::pair<int, int>> &getMetadataLiveMap() const { return livemap; }
 
    const ordered_map<int, std::pair<int, int>> &getMetadataLiveMapUsage() const {
        return livemapUsage;
    }
 
    const ordered_map<int, ordered_set<const IR::MAU::Table *>> &getMinStageMap() const {
        return minStages;
    }
 
    const ordered_set<const IR::MAU::Table *> getTablesInStage(int stage) const {
        if (!minStages.count(stage))
            BUG("Stage %1% not in the resource-insensitive tabel dependence graph", stage);
        return minStages.at(stage);
    }
 
    bool hasPotentialLiveRangeOverlay(const PHV::Field *f1, const PHV::Field *f2) const {
        return overlay(f1->id, f2->id);
    }
 
    explicit MetadataLiveRange(PhvInfo &p, const DependencyGraph &g, FieldDefUse &f,
                               const PHV::Pragmas &pragmas, const PhvUse &u, const MauBacktracker &)
        : phv(p),
          dg(g),
          defuse(f),
          noOverlay(pragmas.pa_no_overlay()),
          uses(u),
          noInitFields(pragmas.pa_no_init().getFields()),
          notParsedFields(pragmas.pa_deparser_zero().getNotParsedFields()),
          notDeparsedFields(pragmas.pa_deparser_zero().getNotDeparsedFields()),
          overlay(phv.metadata_mutex()) {}
};
 
#endif /* BF_P4C_PHV_ANALYSIS_META_LIVE_RANGE_H_ */