phv_logging.h

 
#ifndef BF_P4C_LOGGING_PHV_LOGGING_H_
#define BF_P4C_LOGGING_PHV_LOGGING_H_
 
#include <algorithm>
#include <string>
 
#include "bf-p4c/common/field_defuse.h"
#include "bf-p4c/device.h"
#include "bf-p4c/ir/tofino_write_context.h"
#include "bf-p4c/logging/constrained_fields.h"
#include "bf-p4c/logging/group_constraint_extractor.h"
#include "bf-p4c/logging/logging.h"
#include "bf-p4c/mau/action_analysis.h"
#include "bf-p4c/mau/table_summary.h"
#include "bf-p4c/parde/clot/clot_info.h"
#include "bf-p4c/phv/constraints/constraints.h"
#include "bf-p4c/phv/make_clusters.h"
#include "bf-p4c/phv/phv_fields.h"
#include "bf-p4c/phv/phv_parde_mau_use.h"
#include "bf-p4c/phv/phv_spec.h"
#include "bf-p4c/phv/pragma/phv_pragmas.h"
#include "bf-p4c/phv/utils/utils.h"
#include "ir/ir.h"
#include "phv_schema.h"
 
using Logging::Phv_Schema_Logger;
using namespace P4;
 
struct CollectPhvLoggingInfo : public MauInspector {
    const PhvInfo &phv;
    const PhvUse &uses;
    const ReductionOrInfo &red_info;
 
    ordered_map<cstring, cstring> tableNames;
 
    ordered_map<const IR::MAU::Action *, const IR::MAU::Table *> actionsToTables;
 
    ordered_map<const PHV::FieldSlice, ordered_set<const IR::MAU::Action *>> sliceWriteToActions;
 
    ordered_map<const PHV::FieldSlice, ordered_set<const IR::MAU::Action *>> sliceReadToActions;
 
    ordered_map<const PHV::FieldSlice, ordered_set<cstring>> sliceXbarToTables;
 
    ConstrainedFieldMap fieldConstraints;
 
    const std::list<PHV::SuperCluster *> *superclusters = nullptr;
 
    const PHV::Pragmas *pragmas = nullptr;
 
    ordered_map<cstring, ordered_map<cstring, bool>> noPackConstraints;
 
    MauGroupExtractor *mauGroupConstraints = nullptr;
 
    EquivalentAlignExtractor *equivAlignConstraints = nullptr;
 
    void collectConstraints();
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::MAU::Table *tbl) override;
    bool preorder(const IR::MAU::Action *act) override;
    bool preorder(const IR::MAU::TableKey *read) override;
 
    CollectPhvLoggingInfo(const PhvInfo &p, const PhvUse &u, const ReductionOrInfo &ri)
        : phv(p), uses(u), red_info(ri) {}
 
 private:
    ordered_set<PHV::FieldSlice> getSlices(const IR::Expression *, const IR::MAU::Table *);
};
 
class PhvLogging : public MauInspector {
 public:
    using Phv_Schema_Logger = Logging::Phv_Schema_Logger;
    using Structure = Phv_Schema_Logger::Structure;
    using Container = Phv_Schema_Logger::Container;
    using FieldInfo = Phv_Schema_Logger::FieldInfo;
    using FieldGroupItem = Phv_Schema_Logger::FieldGroupItem;
    using Field = Phv_Schema_Logger::Field;
    using Slice = Phv_Schema_Logger::Slice;
    using FieldSlice = Phv_Schema_Logger::FieldSlice;
    using SourceLocation = Phv_Schema_Logger::SourceLocation;
    using BoolConstraint = Phv_Schema_Logger::BoolConstraint;
    using IntConstraint = Phv_Schema_Logger::IntConstraint;
    using ListConstraint = Phv_Schema_Logger::ListConstraint;
    using Constraint = Phv_Schema_Logger::Constraint;
    using ParserLocation = Phv_Schema_Logger::ParserLocation;
    using DeparserLocation = Phv_Schema_Logger::DeparserLocation;
    using MAULocation = Phv_Schema_Logger::MAULocation;
    using ContainerSlice = Phv_Schema_Logger::ContainerSlice;
    using Access = Phv_Schema_Logger::Access;
    using Resources = Phv_Schema_Logger::Resources;
    struct PardeInfo {
        std::string unit;
        std::string parserState;
 
        bool operator<(PardeInfo other) const {
            if (unit != other.unit) return unit < other.unit;
            return parserState < other.parserState;
        }
 
        bool operator==(PardeInfo other) const {
            return (unit == other.unit && parserState == other.parserState);
        }
 
        explicit PardeInfo(std::string u, std::string name = "") : unit(u), parserState(name) {}
    };
 
    class CollectDefUseInfo : public Visitor {
        const FieldDefUse &defuse;
 
        const IR::Node *apply_visitor(const IR::Node *n, const char *name = 0) override;
 
     public:
        void replace_parser_state_name(cstring old_name, cstring new_name);
        ordered_map<int, ordered_set<cstring>> parser_defs;
        ordered_map<int, ordered_set<cstring>> deparser_uses;
 
        explicit CollectDefUseInfo(const FieldDefUse &du) : defuse(du) {}
    };
 
    enum class ConstraintReason : std::size_t {
        SolitaryAlu = 0,
        SolitaryIntrinsic,
        SolitaryChecksum,
        SolitaryLastByte,
        SolitaryMirror,
        SolitaryContainerSize,
        SolitaryPragma,
        SolitaryExceptSameDigest,
        DifferentContainer,
        MAUGroup,
        NoSplit,
        ContainerSize,
        Alignment,
        NoOverlay,
        ExactContainer,
        EquivalentAlignment,
        NoHoles,
        SameContainerGroup
    };
 
 private:
    const PhvInfo &phv;
    const ClotInfo &clot;
    const CollectPhvLoggingInfo &info;
    const CollectDefUseInfo &defuseInfo;
    const ordered_map<cstring, ordered_set<int>> &tableAlloc;
    const TableSummary &tableSummary;
 
    ordered_set<PHV::FieldSlice> unallocatedSlices;
 
    Phv_Schema_Logger logger;
 
    profile_t init_apply(const IR::Node *root) override {
        unallocatedSlices.clear();
        return Inspector::init_apply(root);
    }
 
    void end_apply(const IR::Node *root) override;
 
    void populateContainerGroups(cstring groupType);
 
 
    const char *containerType(const PHV::Container c) const;
 
    const char *getFieldType(const PHV::Field *f) const;
 
    const char *getGress(const PHV::Field *f) const;
 
    const char *getDeparserAccessType(const PHV::Field *f) const;
 
    // @returns the name with the prefix '.' stripped out
    std::string stripDotPrefix(const cstring name) const;
 
    void getAllParserDefs(const PHV::Field *f, ordered_set<PardeInfo> &rv) const;
    void getAllDeparserUses(const PHV::Field *f, ordered_set<PardeInfo> &rv) const;
 
    void addPardeReadsAndWrites(const PHV::Field *f, ordered_set<PardeInfo> &rv,
                                ContainerSlice *cs) const;
    void addTableKeys(const PHV::FieldSlice &sl, ContainerSlice *cs) const;
    void addVLIWReads(const PHV::FieldSlice &sl, ContainerSlice *cs) const;
    void addVLIWWrites(const PHV::FieldSlice &sl, ContainerSlice *cs) const;
    void addMutexFields(const PHV::AllocSlice &sl, ContainerSlice *cs) const;
 
    PHV::Field::AllocState getAllocatedState(const PHV::Field *f);
 
    ordered_map<cstring, ordered_set<const PHV::Field *>> getFields();
 
    ordered_map<const PHV::Field *, const PHV::Field *> getFieldAliases();
 
    FieldInfo *getFieldInfo(const PHV::Field *f) const;
 
    SourceLocation *getSourceLoc(const PHV::Field *f) const;
 
    FieldSlice *logFieldSlice(const PHV::Field *f, bool use_alias);
 
    FieldSlice *logFieldSlice(const PHV::AllocSlice &sl, bool use_alias);
 
    ContainerSlice *logContainerSlice(const PHV::AllocSlice &sl, bool use_alias);
 
    void logHeaders();
 
    void logFields();
 
    void logContainers();
 
    // Add database of constraint reasons
    void logConstraintReasons();
 
    // Add field constraint information to the logger object
    void logFieldConstraints(const cstring &fieldName, Field *logger);
 
    void logSolitaryConstraints(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logNoPackConstraint(ConstrainedField &field, const FieldInfo *fieldInfo,
                             const SourceLocation *srcLoc);
 
    void logGroupConstraint(ConstrainedField &field, ListConstraint *c,
                            std::vector<ConstrainedSlice> &group);
 
    void logMauGroupConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logNoSplitConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logContainerSizeConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logAlignmentConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logNoOverlayConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logExactContainerConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logEquivalentAlignConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logNoHolesConstraint(ConstrainedField &field, const SourceLocation *srcLoc);
 
    void logSameContainerGroup(ConstrainedField &field, const SourceLocation *srcLoc);
 
    // Looks up item in db. If item is not there, it is added.
    // Index of the item is then returned.
    // This template is supposed to be used with FieldGroupItem
    // and FieldGroups
    template <typename T>
    int getDatabaseIndex(std::vector<T> &db, T item);
 
 public:
    explicit PhvLogging(const char *filename, const PhvInfo &p, const ClotInfo &ci,
                        const CollectPhvLoggingInfo &c, const CollectDefUseInfo &cdu,
                        const ordered_map<cstring, ordered_set<int>> &t, const TableSummary &ts);
};
 
#endif /* BF_P4C_LOGGING_PHV_LOGGING_H_ */