mau/table_mutex.h

 
#ifndef BF_P4C_MAU_TABLE_MUTEX_H_
#define BF_P4C_MAU_TABLE_MUTEX_H_
 
#include <map>
 
#include "bf-p4c/mau/action_mutex.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/mau/resource.h"
#include "bf-p4c/mau/table_layout.h"
#include "lib/ordered_map.h"
#include "lib/safe_vector.h"
#include "lib/symbitmatrix.h"
 
using namespace P4;
 
class IgnoreTableDeps : public MauTableInspector {
    using TablePair = std::pair<const IR::MAU::Table *, const IR::MAU::Table *>;
 
    ordered_map<const IR::MAU::Table *, ordered_set<const IR::MAU::Table *>> ignore_dep_map;
 
    // Auxiliary data structures for end_apply().
    std::map<cstring, const IR::MAU::Table *> internal_name_to_table;
    std::map<cstring, const IR::MAU::Table *> external_name_to_table;
 
    ordered_map<const IR::MAU::Table *, std::set<cstring>> table_to_pragmas;
 
    profile_t init_apply(const IR::Node *node) override {
        auto rv = MauTableInspector::init_apply(node);
        ignore_dep_map.clear();
        internal_name_to_table.clear();
        external_name_to_table.clear();
        table_to_pragmas.clear();
        return rv;
    }
 
    bool preorder(const IR::MAU::Table *) override;
 
    void end_apply() override;
 
 public:
    IgnoreTableDeps() {}
 
    bool ignore_deps(const IR::MAU::Table *t1, const IR::MAU::Table *t2) const;
 
    safe_vector<TablePair> pairwise_deps_to_ignore() const;
};
 
class TablesMutuallyExclusive : public MauTableInspector {
    ordered_map<const IR::MAU::Table *, int> table_ids;
    std::map<int, const IR::MAU::Table *> rev_table_ids;
 
 public:
    // public for gtests
    std::map<cstring, const IR::MAU::Table *> name_to_tables;
 
 private:
    ordered_map<const IR::MAU::Table *, bitvec> table_succ;
 
    SymBitMatrix non_mutex;
 
    // If a table is present as an key, it means that one of its sucessor is an exit table.
    // The bit vec represents the exit table and tables before the exit table in a tableSeq
    ordered_map<const IR::MAU::Table *, bitvec> exit_succ;
 
    void postorder(const IR::MAU::Table *tbl) override;
    void postorder(const IR::MAU::TableSeq *seq) override;
    bool miss_mutex_action_chain(const IR::MAU::Table *tbl, const IR::MAU::Action *default_act,
                                 cstring &name);
 
    profile_t init_apply(const IR::Node *root) override {
        profile_t rv = MauTableInspector::init_apply(root);
 
        table_ids.clear();
        rev_table_ids.clear();
        non_mutex.clear();
        name_to_tables.clear();
 
        // Populate auxiliary data structures.
        forAllMatching<IR::MAU::Table>(root, [this](const IR::MAU::Table *t) {
            assert(!table_ids.count(t));
            rev_table_ids.emplace(table_ids.size(), t);
            table_ids.emplace(t, table_ids.size());
            name_to_tables.emplace(t->externalName(), t);
        });
        return rv;
    }
 
 public:
    bool operator()(const IR::MAU::Table *a, const IR::MAU::Table *b) const;
};
 
class SharedIndirectAttachedAnalysis : public MauInspector {
    ordered_map<const IR::MAU::AttachedMemory *, safe_vector<const IR::MAU::Table *>> backend_users;
    ordered_map<const IR::MAU::Table *, ordered_set<const IR::MAU::Table *>> table_sharing_attached;
    const TablesMutuallyExclusive &mutex;
    const IgnoreTableDeps &ignore;
    const ActionMutuallyExclusive &action_mutex;
    LayoutChoices &lc;
    SymBitMatrix _mutex_through_ignore;
 
    std::map<const IR::MAU::Table *, int> table_ids;
    std::map<int, const IR::MAU::Table *> rev_table_ids;
 
    profile_t init_apply(const IR::Node *root) override {
        profile_t rv = MauInspector::init_apply(root);
        backend_users.clear();
        table_sharing_attached.clear();
        table_ids.clear();
        rev_table_ids.clear();
        _mutex_through_ignore.clear();
        forAllMatching<IR::MAU::Table>(root, [this](const IR::MAU::Table *t) {
            assert(!table_ids.count(t));
            rev_table_ids.emplace(table_ids.size(), t);
            table_ids.emplace(t, table_ids.size());
        });
        return rv;
    }
    bool preorder(const IR::MAU::AttachedMemory *) override;
    bool check_if_can_share(const IR::MAU::Table *a, const IR::MAU::Table *b,
                            const IR::MAU::AttachedMemory *am);
    std::vector<const IR::MAU::Action *> get_indirect_actions(const IR::MAU::Table *a,
                                                              const IR::MAU::AttachedMemory *am);
 
 public:
    bool mutex_through_ignore(const IR::MAU::Table *a, const IR::MAU::Table *b) const;
    // for gtest
    bool if_table_share_attach(const IR::MAU::Table *a, const IR::MAU::Table *b) const;
    explicit SharedIndirectAttachedAnalysis(const TablesMutuallyExclusive &m,
                                            const IgnoreTableDeps &i,
                                            const ActionMutuallyExclusive &a, LayoutChoices &lc)
        : mutex(m), ignore(i), action_mutex(a), lc(lc) {}
};
#endif /* BF_P4C_MAU_TABLE_MUTEX_H_ */