alpm.h

 
#ifndef BF_P4C_MIDEND_ALPM_H_
#define BF_P4C_MIDEND_ALPM_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/externInstance.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
#include "ir/pass_manager.h"
#include "lib/cstring.h"
 
namespace BFN {
 
class CollectAlpmInfo : public Inspector {
 public:
    std::set<cstring> alpm_actions;
    std::set<cstring> alpm_table;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
 
 public:
    CollectAlpmInfo(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {}
 
    void postorder(const IR::P4Table *tbl) override;
};
 
class HasTableApply : public Inspector {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
 
 public:
    const IR::P4Table *table;
    const IR::MethodCallExpression *call;
    HasTableApply(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap), table(nullptr), call(nullptr) {
        CHECK_NULL(refMap);
        CHECK_NULL(typeMap);
        setName("HasTableApply");
    }
    void postorder(const IR::MethodCallExpression *expression) override {
        auto mi = P4::MethodInstance::resolve(expression, refMap, typeMap);
        if (!mi->isApply()) return;
        auto am = mi->to<P4::ApplyMethod>();
        if (!am->object->is<IR::P4Table>()) return;
        BUG_CHECK(table == nullptr, "%1% and %2%: multiple table applications in one expression",
                  table, am->object);
        table = am->object->to<IR::P4Table>();
        call = expression;
        LOG3("Invoked table is " << dbp(table));
    }
    bool preorder(const IR::Member *member) override {
        if (member->member == "hit" || member->member == "miss") return true;
        return false;
    }
};
 
class SplitAlpm : public Transform {
    CollectAlpmInfo *alpm_info;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    static const std::set<unsigned> valid_partition_values;
    std::set<cstring> alpm_tables;
    std::map<cstring, cstring> preclassifier_tables;
 
    const IR::MAU::Table *create_pre_classifier_tcam(IR::MAU::Table *tbl, IR::TempVar *tv,
                                                     IR::TempVar *tk, unsigned partition_index_bits,
                                                     unsigned pre_classifer_number_entries,
                                                     unsigned pre_classifer_number_actions);
    bool values_through_pragmas(const IR::P4Table *tbl, int &number_of_partitions,
                                int &number_subtrees_par_partition);
    bool values_through_impl(const IR::P4Table *tbl, int &number_of_partitions,
                             int &number_subtrees_per_partition, int &atcam_subset_width,
                             int &shift_granularity);
    bool pragma_exclude_msbs(const IR::P4Table *tbl, ordered_map<cstring, int> &fields_to_exclude);
 
    const IR::Node *postorder(IR::P4Table *tbl) override;
    const IR::Node *postorder(IR::MethodCallStatement *) override;
    const IR::Node *postorder(IR::IfStatement *) override;
    const IR::Node *postorder(IR::SwitchStatement *) override;
 
    const IR::IndexedVector<IR::Declaration> *create_temp_var(const IR::P4Table *, unsigned,
                                                              unsigned, unsigned, unsigned,
                                                              const IR::Expression *);
    const IR::IndexedVector<IR::Declaration> *create_preclassifer_actions(const IR::P4Table *,
                                                                          unsigned, unsigned,
                                                                          unsigned, unsigned,
                                                                          unsigned,
                                                                          const IR::Expression *);
    const IR::P4Table *create_preclassifier_table(const IR::P4Table *, unsigned, unsigned, unsigned,
                                                  unsigned);
    const IR::P4Table *create_atcam_table(const IR::P4Table *, unsigned, unsigned, unsigned, int,
                                          int, ordered_map<cstring, int> &fields_to_exclude,
                                          const IR::Expression *);
    void apply_pragma_exclude_msbs(const IR::P4Table *tbl,
                                   const ordered_map<cstring, int> *fields_to_exclude,
                                   IR::Vector<IR::KeyElement> &keys);
    const IR::StatOrDecl *synth_funnel_shift_ops(const IR::P4Table *, const IR::Expression *, int);
    bool use_funnel_shift(int);
 
 public:
    static const cstring ALGORITHMIC_LPM_PARTITIONS;
    static const cstring ALGORITHMIC_LPM_SUBTREES_PER_PARTITION;
    static const cstring ALGORITHMIC_LPM_ATCAM_EXCLUDE_FIELD_MSBS;
 
    SplitAlpm(CollectAlpmInfo *info, P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : alpm_info(info), refMap(refMap), typeMap(typeMap) {}
};
 
class AlpmImplementation : public PassManager {
 public:
    AlpmImplementation(P4::ReferenceMap *refMap, P4::TypeMap *typeMap);
};
 
}  // namespace BFN
 
#endif /* BF_P4C_MIDEND_ALPM_H_ */