table_phv_constraints.h

 
#ifndef BF_P4C_PHV_TABLE_PHV_CONSTRAINTS_H_
#define BF_P4C_PHV_TABLE_PHV_CONSTRAINTS_H_
 
#include "backends/tofino/bf-p4c/mau/mau_visitor.h"
#include "backends/tofino/bf-p4c/phv/action_phv_constraints.h"
#include "backends/tofino/bf-p4c/phv/analysis/pack_conflicts.h"
#include "backends/tofino/bf-p4c/phv/phv_fields.h"
#include "backends/tofino/bf-p4c/phv/pragma/pa_container_size.h"
#include "backends/tofino/bf-p4c/phv/utils/slice_alloc.h"
#include "ir/ir.h"
 
class TernaryMatchKeyConstraints : public MauModifier {
 private:
    static constexpr unsigned BITS_IN_BYTE = 8;
    static constexpr unsigned TERNARY_MATCH_KEY_BITS_THRESHOLD = 64;
    static constexpr unsigned MAX_EXACT_MATCH_KEY_BYTES = 128;
    static constexpr size_t MAX_TERNARY_MATCH_KEY_BITS = (44 * 12) - 4;
 
    PhvInfo &phv;
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(IR::MAU::Table *tbl) override;
    void end_apply() override;
 
    bool isATCAM(IR::MAU::Table *tbl) const;
    bool isTernary(IR::MAU::Table *tbl) const;
 
    void calculateTernaryMatchKeyConstraints(const IR::MAU::Table *tbl) const;
 
 public:
    explicit TernaryMatchKeyConstraints(PhvInfo &p) : phv(p) {}
};
 
class CollectForceImmediateFields : public MauInspector {
 private:
    PhvInfo &phv;
    const ActionPhvConstraints &actions;
    PackConflicts &pack;
 
    bool preorder(const IR::MAU::Action *action) override;
 
 public:
    explicit CollectForceImmediateFields(PhvInfo &p, const ActionPhvConstraints &a,
                                         PackConflicts &c)
        : phv(p), actions(a), pack(c) {}
};
 
class TablePhvConstraints : public PassManager {
 public:
    explicit TablePhvConstraints(PhvInfo &p, const ActionPhvConstraints &a, PackConflicts &c) {
        addPasses({new TernaryMatchKeyConstraints(p), new CollectForceImmediateFields(p, a, c)});
    }
};
class TableFieldPackOptimization : public MauInspector {
 private:
    const PhvInfo &phv;
    ordered_map<PHV::FieldSlice, ordered_map<PHV::FieldSlice, int>> candidate;
    ordered_map<const PHV::Field *, ordered_set<PHV::FieldSlice>> f_to_fs;
 
    profile_t init_apply(const IR::Node *root) override;
    void end_apply() override;
    bool preorder(const IR::MAU::Table *tbl) override;
    int getNumberOfEntriesInTable(const IR::MAU::Table *tbl);
    int getFieldSlicePackScore(const PHV::AllocSlice &slice, const PHV::AllocSlice &slice2) const;
 
 public:
    explicit TableFieldPackOptimization(PhvInfo &p) : phv(p) {}
 
    int getPackScore(const ordered_set<PHV::AllocSlice> &parent,
                     const ordered_set<PHV::AllocSlice> &slices) const;
    std::list<PHV::FieldSlice> getPackCandidate(const PHV::FieldSlice &fs) const;
};
 
#endif /* BF_P4C_PHV_TABLE_PHV_CONSTRAINTS_H_ */