collect_pipelines.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_MIDEND_COLLECT_PIPELINES_H_
#define BACKENDS_TOFINO_BF_P4C_MIDEND_COLLECT_PIPELINES_H_
 
#include <set>
#include <unordered_map>
#include <vector>
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "ir/ir.h"
 
namespace BFN {
 
class CollectPipelines : public Inspector {
    // Checks the "main"
    bool preorder(const IR::Declaration_Instance *) override;
 
 public:
    struct FullGress {
        const IR::BFN::TnaParser *parser = nullptr;
        const IR::BFN::TnaControl *control = nullptr;
        const IR::BFN::TnaDeparser *deparser = nullptr;
 
        bool operator==(const FullGress &) const;
    };
 
    class Pipe {
        friend class CollectPipelines;
        void set(unsigned count, unsigned idx, const IR::IDeclaration *ty);
 
     public:
        FullGress ingress, egress;
        const IR::BFN::TnaControl *ghost = nullptr;
        const IR::Declaration_Instance *dec = nullptr;
 
        bool operator==(const Pipe &) const;
 
        bool operator<(const Pipe &) const;
    };
 
    using PipeSet = std::set<Pipe>;
 
    class Pipelines {
        friend class CollectPipelines;
        std::vector<Pipe> pipes;
        std::map<const IR::Type_Declaration *, std::unordered_set<int>,
                 ByNameLess<const IR::Type_Declaration>>
            declarationToPipe;
 
        PipeSet _get(const IR::Type_Declaration *dec) const {
            auto it = declarationToPipe.find(dec);
            BUG_CHECK(it != declarationToPipe.end(), "Declaration %1% not found in pipes", dec);
            PipeSet out;
            for (int idx : it->second) out.insert(pipes[idx]);
            return out;
        }
 
     public:
        std::vector<Pipe>::const_iterator begin() const { return pipes.begin(); }
        std::vector<Pipe>::const_iterator end() const { return pipes.end(); }
 
        PipeSet get(const IR::BFN::TnaParser *p) const { return _get(p); }
        PipeSet get(const IR::BFN::TnaDeparser *d) const { return _get(d); }
        PipeSet get(const IR::BFN::TnaControl *c) const { return _get(c); }
    };
 
 private:
    P4::ReferenceMap *refMap;
    Pipelines *pipelines;
    std::unordered_map<const IR::IDeclaration *, Pipe> pipesByDec;
 
 public:
    explicit CollectPipelines(P4::ReferenceMap *refMap, Pipelines *pipelines)
        : refMap(refMap), pipelines(pipelines) {}
};
 
}  // namespace BFN
 
#endif  // BACKENDS_TOFINO_BF_P4C_MIDEND_COLLECT_PIPELINES_H_