mutex_overlay.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PHV_ANALYSIS_MUTEX_OVERLAY_H_
#define BACKENDS_TOFINO_BF_P4C_PHV_ANALYSIS_MUTEX_OVERLAY_H_
 
#include <iostream>
 
#include "bf-p4c/ir/tofino_write_context.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/parde/parde_visitor.h"
#include "bf-p4c/parde/parser_info.h"
#include "bf-p4c/phv/analysis/build_mutex.h"
#include "bf-p4c/phv/analysis/header_mutex.h"
#include "bf-p4c/phv/phv_fields.h"
#include "bf-p4c/phv/pragma/pa_no_pack.h"
#include "ir/ir.h"
#include "ir/visitor.h"
 
namespace PHV {
class Field;
}  // namespace PHV
 
class PhvInfo;
 
/* Produces a SymBitMatrix where keys are PHV::Field ids and values
 * indicate whether two fields are mutually exclusive, based on analyzing the
 * structure of the parse graph to identify fields that can never appear in the
 * same packet.  @see BuildMutex.
 */
class BuildParserOverlay : public BuildMutex {
    static bool ignore_field(const PHV::Field *f) { return !f || f->pov || f->metadata; }
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::MAU::TableSeq *) override { return false; }
    bool preorder(const IR::BFN::Deparser *) override { return false; }
 
 public:
    BuildParserOverlay(PhvInfo &phv, const bitvec &neverOverlay, const PragmaNoOverlay &pragma)
        : BuildMutex(phv, neverOverlay, pragma, ignore_field) {}
    BuildParserOverlay *clone() const override { return new BuildParserOverlay(*this); }
};
 
class ExcludeParserLoopReachableFields : public Visitor {
    PhvInfo &phv;
    const MapFieldToParserStates &fieldToStates;
    const CollectParserInfo &parserInfo;
 
 private:
    const IR::Node *apply_visitor(const IR::Node *root, const char *) override;
 
    bool is_loop_reachable(const ordered_set<const IR::BFN::ParserState *> &k,
                           const ordered_set<const IR::BFN::ParserState *> &v);
 
 public:
    ExcludeParserLoopReachableFields(PhvInfo &phv, const MapFieldToParserStates &fs,
                                     const CollectParserInfo &pi)
        : phv(phv), fieldToStates(fs), parserInfo(pi) {}
};
 
/* Produces a SymBitMatrix where keys are PHV::Field ids and values indicate
 * whether two fields are mutually exclusive, based on analyzing the structure
 * of the MAU pipeline to identify metadata fields that are only used in
 * mutually exclusive tables/actions.  @see BuildMutex.
 */
class BuildMetadataOverlay : public BuildMutex {
 private:
    static bool ignore_field(const PHV::Field *f) { return !f || f->pov || !f->metadata; }
 
    profile_t init_apply(const IR::Node *root) override;
    bool preorder(const IR::BFN::Deparser *) override { return false; }
 
 public:
    BuildMetadataOverlay(PhvInfo &phv, const bitvec &neverOverlay, const PragmaNoOverlay &pragma)
        : BuildMutex(phv, neverOverlay, pragma, ignore_field) {}
    BuildMetadataOverlay *clone() const override { return new BuildMetadataOverlay(*this); }
};
 
class ExcludeAliasedHeaderFields : public Inspector {
    PhvInfo &phv;
    bitvec &neverOverlay;
 
    bool preorder(const IR::BFN::AliasMember *alias) override {
        excludeAliasedField(alias);
        return true;
    }
 
    bool preorder(const IR::BFN::AliasSlice *alias) override {
        excludeAliasedField(alias);
        return true;
    }
 
    void excludeAliasedField(const IR::Expression *alias);
 
 public:
    ExcludeAliasedHeaderFields(PhvInfo &phv, bitvec &neverOverlay)
        : phv(phv), neverOverlay(neverOverlay) {}
};
 
class ExcludeDeparsedIntrinsicMetadata : public Inspector {
    PhvInfo &phv;
    bitvec &neverOverlay;
 
    profile_t init_apply(const IR::Node *root) override {
        profile_t rv = Inspector::init_apply(root);
        neverOverlay.clear();
        return rv;
    }
 
    void end_apply() override;
 
 public:
    ExcludeDeparsedIntrinsicMetadata(PhvInfo &phv, bitvec &neverOverlay)
        : phv(phv), neverOverlay(neverOverlay) {}
};
 
class ExcludePragmaNoOverlayFields : public Inspector {
    bitvec &neverOverlay;
    const PragmaNoOverlay &pragma;
 
    void end_apply() override;
 
 public:
    ExcludePragmaNoOverlayFields(bitvec &neverOverlay, const PragmaNoOverlay &p)
        : neverOverlay(neverOverlay), pragma(p) {}
};
 
class FindAddedHeaderFields : public MauInspector {
 private:
    PhvInfo &phv;
    bitvec rv;
 
    profile_t init_apply(const IR::Node *root) override {
        rv.clear();
        return Inspector::init_apply(root);
    }
    bool preorder(const IR::MAU::Primitive *prim) override;
    void markFields(const IR::HeaderRef *hr);
 
 public:
    explicit FindAddedHeaderFields(PhvInfo &phv) : phv(phv) {}
    bool isAddedInMAU(const PHV::Field *field) const { return rv[field->id]; }
};
 
class ExcludeMAUOverlays : public MauInspector {
 public:
    using ActionToFieldsMap = ordered_map<const IR::MAU::Action *, ordered_set<const PHV::Field *>>;
 
 private:
    PhvInfo &phv;
    const FindAddedHeaderFields &addedFields;
 
    ActionToFieldsMap actionToWrites;
    ActionToFieldsMap actionToReads;
 
    profile_t init_apply(const IR::Node *root) override {
        actionToWrites.clear();
        actionToReads.clear();
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::MAU::Table *tbl) override;
    bool preorder(const IR::MAU::Instruction *inst) override;
    void end_apply() override;
 
    void markNonMutex(const ActionToFieldsMap &arg);
 
 public:
    explicit ExcludeMAUOverlays(PhvInfo &p, const FindAddedHeaderFields &a)
        : phv(p), addedFields(a) {}
};
 
class ExcludeDeparserOverlays : public Inspector {
 private:
    PhvInfo &phv;
    ordered_map<const PHV::Field *, ordered_set<const PHV::Field *>> povToFieldsMap;
 
    profile_t init_apply(const IR::Node *root) override {
        povToFieldsMap.clear();
        return Inspector::init_apply(root);
    }
 
    bool preorder(const IR::BFN::EmitField *emit) override;
    void end_apply() override;
 
 public:
    explicit ExcludeDeparserOverlays(PhvInfo &p) : phv(p) {}
};
 
class ExcludeCsumOverlays : public Inspector {
 private:
    PhvInfo &phv;
    const FindAddedHeaderFields &addedFields;
    const PhvUse &use;
    bool preorder(const IR::BFN::EmitChecksum *emitChecksum) override;
 
 public:
    explicit ExcludeCsumOverlays(PhvInfo &p, const FindAddedHeaderFields &a, const PhvUse &u)
        : phv(p), addedFields(a), use(u) {}
};
 
class ExcludeCsumOverlaysPOV : public Inspector {
 private:
    PhvInfo &phv;
    const FindAddedHeaderFields &addedFields;
    const PhvUse &use;
    bool preorder(const IR::BFN::EmitChecksum *emitChecksum) override;
 
 public:
    explicit ExcludeCsumOverlaysPOV(PhvInfo &p, const FindAddedHeaderFields &a, const PhvUse &u)
        : phv(p), addedFields(a), use(u) {}
};
 
class MarkMutexPragmaFields : public Inspector {
 private:
    PhvInfo &phv;
    const PragmaMutuallyExclusive &pragma;
 
    profile_t init_apply(const IR::Node *root) override;
 
 public:
    explicit MarkMutexPragmaFields(PhvInfo &p, const PragmaMutuallyExclusive &pr)
        : phv(p), pragma(pr) {}
};
 
class MutexOverlay : public PassManager {
 private:
    bitvec neverOverlay;
    FindAddedHeaderFields addedFields;
    CollectParserInfo parserInfo;
    MapFieldToParserStates fieldToParserStates;
 
 public:
    MutexOverlay(PhvInfo &phv, const PHV::Pragmas &pragmas, const PhvUse &use)
        : addedFields(phv), fieldToParserStates(phv) {
        Visitor *exclude_csum_overlays = nullptr;
        if (Device::currentDevice() == Device::TOFINO) {
            exclude_csum_overlays = new ExcludeCsumOverlays(phv, addedFields, use);
        } else if (Device::currentDevice() == Device::JBAY) {
            exclude_csum_overlays = new ExcludeCsumOverlaysPOV(phv, addedFields, use);
        }
 
        addPasses({new ExcludeDeparsedIntrinsicMetadata(phv, neverOverlay),
                   new ExcludePragmaNoOverlayFields(neverOverlay, pragmas.pa_no_overlay()),
                   &addedFields, new ExcludeAliasedHeaderFields(phv, neverOverlay),
                   new BuildParserOverlay(phv, neverOverlay, pragmas.pa_no_overlay()),
                   new BuildMetadataOverlay(phv, neverOverlay, pragmas.pa_no_overlay()),
                   &parserInfo, &fieldToParserStates,
                   new ExcludeParserLoopReachableFields(phv, fieldToParserStates, parserInfo),
                   exclude_csum_overlays, new ExcludeMAUOverlays(phv, addedFields),
                   new ExcludeDeparserOverlays(phv), new HeaderMutex(phv, neverOverlay, pragmas),
                   new MarkMutexPragmaFields(phv, pragmas.pa_mutually_exclusive())});
    }
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PHV_ANALYSIS_MUTEX_OVERLAY_H_  */