multiple_apply.h

 
#ifndef BF_P4C_COMMON_MULTIPLE_APPLY_H_
#define BF_P4C_COMMON_MULTIPLE_APPLY_H_
 
#include <set>
 
#include "bf-p4c/ir/thread_visitor.h"
#include "bf-p4c/lib/union_find.hpp"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/mau/table_mutex.h"
#include "lib/ordered_map.h"
#include "lib/ordered_set.h"
 
using namespace P4;
 
class BFN_Options;
 
class MultipleApply : public PassManager {
    // gtest requirements
    std::set<cstring> mutex_errors;
    std::set<cstring> topological_errors;
    std::set<cstring> default_next_errors;
 
    const BFN_Options &options;
 
    bool longBranchDisabled = false;
 
    TablesMutuallyExclusive mutex;
 
    class MutuallyExclusiveApplies : public MauInspector {
        TablesMutuallyExclusive &mutex;
 
        std::set<cstring> &errors;
 
        ordered_map<const IR::P4Table *, ordered_set<const IR::MAU::Table *>> mutex_apply;
 
        Visitor::profile_t init_apply(const IR::Node *root) override;
        void postorder(const IR::MAU::Table *) override;
 
     public:
        explicit MutuallyExclusiveApplies(TablesMutuallyExclusive &m, std::set<cstring> &e)
            : mutex(m), errors(e) {}
    };
 
    UnionFind<const IR::MAU::Table *> duplicate_tables;
 
    class CheckStaticNextTable : public MauInspector {
        MultipleApply &self;
 
        ordered_map<const IR::P4Table *, const IR::MAU::Table *> canon_table;
 
        ordered_set<const IR::MAU::Table *> all_gateways;
 
        bool check_equiv(const IR::MAU::Table *table1, const IR::MAU::Table *table2,
                         bool makeUnion = true);
 
        bool check_equiv(const IR::MAU::TableSeq *seq1, const IR::MAU::TableSeq *seq2,
                         bool makeUnion = true);
 
        bool equiv_gateway(const IR::Expression *expr1, const IR::Expression *expr2);
 
        Visitor::profile_t init_apply(const IR::Node *root) override;
 
        void check_all_gws(const IR::MAU::Table *);
        void postorder(const IR::MAU::Table *) override;
 
     public:
        explicit CheckStaticNextTable(MultipleApply &s) : self(s) {}
    };
 
    class DeduplicateTables : public MauTransform {
        MultipleApply &self;
 
        std::optional<gress_t> gress;
 
        std::map<gress_t, std::map<const IR::MAU::Table *, const IR::MAU::Table *>> replacements;
 
        std::map<gress_t, std::vector<const IR::MAU::TableSeq *>> table_seqs_seen;
 
        gress_t getGress() const { return gress ? *gress : VisitingThread(this); }
 
        Visitor::profile_t init_apply(const IR::Node *root) override;
        const IR::Node *postorder(IR::MAU::Table *tbl) override;
        const IR::Node *postorder(IR::MAU::TableSeq *seq) override;
 
     public:
        explicit DeduplicateTables(MultipleApply &s, std::optional<gress_t> gress = std::nullopt)
            : self(s), gress(gress) {}
    };
 
    class CheckTopologicalTables : public MauInspector {
        std::set<cstring> &errors;
 
        bool preorder(const IR::MAU::TableSeq *) override;
 
     public:
        explicit CheckTopologicalTables(std::set<cstring> &errors) : errors(errors) {}
    };
 
    Visitor::profile_t init_apply(const IR::Node *root) override;
 
 public:
    bool mutex_error(cstring name) { return mutex_errors.count(name); }
 
    unsigned num_mutex_errors() { return mutex_errors.size(); }
 
    bool topological_error(cstring name) { return topological_errors.count(name); }
 
    unsigned num_topological_errors() { return topological_errors.size(); }
 
    bool default_next_error(cstring name) {
        return default_next_errors.find(name) != default_next_errors.end();
    }
 
    unsigned num_default_next_errors() { return default_next_errors.size(); }
 
    // For gtests, allow doing just the passes for de-duplicating tables and allow specifying which
    // gress is being visited.
    MultipleApply(const BFN_Options &options, std::optional<gress_t> gress = std::nullopt,
                  bool dedup_only = false, bool run_default_next = true);
};
 
#endif /* BF_P4C_COMMON_MULTIPLE_APPLY_H_ */