phv_spec.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PHV_PHV_SPEC_H_
#define BACKENDS_TOFINO_BF_P4C_PHV_PHV_SPEC_H_
 
#include <optional>
#include <vector>
 
#include "bf-p4c/phv/phv.h"
#include "lib/bitvec.h"
#include "lib/json.h"
#include "lib/ordered_map.h"
 
namespace P4 {
class cstring;
}
 
namespace P4 {
namespace IR {
class Annotation;
}  // end namespace IR
}  // end namespace P4
 
using namespace P4;
 
class PhvSpec {
 public:
    // We should reuse the definition from arch/arch.h, however, because of circular includes
    // (arch.h, phv_spec.h, device.h) that is not currently workable
    enum ArchBlockType_t { PARSER, MAU, DEPARSER };
 
    struct RangeSpec {
        unsigned start;
        unsigned blocks;
        unsigned blockSize;
        unsigned incr;
        unsigned shl;
        unsigned shr;
    };
    using AddressSpec = std::map<PHV::Type, RangeSpec>;
 
 protected:
    // All cache fields
    mutable bitvec physical_containers_i;
    mutable std::map<PHV::Size, std::vector<bitvec>> mau_groups_i;
    mutable bitvec ingress_only_containers_i;
    mutable bitvec egress_only_containers_i;
    mutable std::vector<bitvec> tagalong_collections_i;
    mutable bitvec individually_assigned_containers_i;
 
    std::vector<PHV::Type> definedTypes;
    std::set<PHV::Size> definedSizes;
    std::set<PHV::Kind> definedKinds;
 
    ordered_map<PHV::Type, unsigned> typeIdMap;
 
    std::map<PHV::Size, std::set<PHV::Type>> sizeToTypeMap;
 
    struct MauGroupType {
        unsigned numGroups;  // Number of MAU groups
        std::map<PHV::Type, unsigned> types;
        // Type and number of containers in each group
 
        explicit MauGroupType(unsigned n, std::map<PHV::Type, unsigned> t)
            : numGroups(n), types(t) {}
 
        explicit MauGroupType(unsigned n) : numGroups(n) {}
 
        MauGroupType() : numGroups(0) {}
 
        void addType(PHV::Type t, unsigned n) { types.emplace(t, n); }
    };
 
    std::map<PHV::Size, MauGroupType> mauGroupSpec;
 
    unsigned containersPerGroup = 0;
 
    std::map<PHV::Size, std::vector<unsigned>> ingressOnlyMauGroupIds;
 
    std::map<PHV::Size, std::vector<unsigned>> egressOnlyMauGroupIds;
 
    std::map<PHV::Type, unsigned> tagalongCollectionSpec;
 
    unsigned numTagalongCollections = 0;
 
    std::map<PHV::Type, unsigned> deparserGroupSize;
 
    std::map<PHV::Type, std::pair<unsigned, unsigned>> deparserGroupSpec;
 
    unsigned numPovBits = 0;
 
    void addType(PHV::Type t);
 
    unsigned getContainersPerGroup(
        const std::map<PHV::Size, unsigned> &numContainersPerGroup) const;
 
 public:
    const std::vector<PHV::Type> &containerTypes() const;
 
    const std::set<PHV::Size> &containerSizes() const;
 
    const std::set<PHV::Kind> &containerKinds() const;
 
    bool hasContainerKind(PHV::Kind kind) const;
 
    const std::map<PHV::Size, std::set<PHV::Type>> groupsToTypes() const;
 
    unsigned numContainerTypes() const;
 
    unsigned numContainersInGroup() const { return containersPerGroup; }
 
    PHV::Type idToContainerType(unsigned id) const;
 
    unsigned containerTypeToId(PHV::Type type) const;
 
    PHV::Container idToContainer(unsigned id) const;
 
    unsigned containerToId(PHV::Container container) const;
 
    bitvec filterContainerSet(const bitvec &set, PHV::Kind kind) const;
    bitvec filterContainerSet(const bitvec &set, PHV::Type type) const;
 
    cstring containerSetToString(const bitvec &set) const;
 
    virtual bitvec parserGroup(unsigned id) const = 0;
 
    virtual bool hasParserExtractGroups() const = 0;
 
    virtual bitvec parserExtractGroup(unsigned id) const = 0;
 
    virtual unsigned parserGroupId(const PHV::Container &c) const = 0;
 
    bitvec deparserGroup(unsigned id) const;
 
    virtual unsigned deparserGroupId(const PHV::Container &c) const = 0;
 
    bitvec range(PHV::Type t, unsigned start, unsigned length) const;
 
    bitvec ingressOrEgressOnlyContainers(
        const std::map<PHV::Size, std::vector<unsigned>> &gressOnlyMauGroupIds) const;
 
    const bitvec &ingressOnly() const;
 
    const bitvec &egressOnly() const;
 
    const std::vector<bitvec> &mauGroups(PHV::Size sz) const;
 
    const std::map<PHV::Size, std::vector<bitvec>> &mauGroups() const;
 
    bitvec mauGroup(unsigned container_id) const;
 
    virtual unsigned mauGroupId(const PHV::Container &c) const = 0;
 
    const std::pair<int, int> mauGroupNumAndSize(const PHV::Type t) const;
 
    const std::pair<int, int> deparserGroupNumAndSize(const PHV::Type t) const;
 
    unsigned getTagalongCollectionId(PHV::Container c) const;
 
    const std::map<PHV::Type, unsigned> getTagalongCollectionSpec() const {
        return tagalongCollectionSpec;
    }
 
    unsigned getNumTagalongCollections() const { return numTagalongCollections; }
 
    const std::vector<bitvec> &tagalongCollections() const;
 
    bitvec tagalongCollection(unsigned container_id) const;
 
    unsigned getNumPovBits() const { return numPovBits; }
 
    virtual const bitvec &individuallyAssignedContainers() const = 0;
 
    const bitvec &physicalContainers() const;
 
    virtual unsigned physicalAddress(unsigned container_id, ArchBlockType_t interface) const = 0;
 
    unsigned physicalAddress(const PHV::Container &c, ArchBlockType_t interface) const;
 
    virtual AddressSpec &physicalAddressSpec(ArchBlockType_t interface) const = 0;
 
    std::optional<PHV::Container> physicalAddressToContainer(unsigned address,
                                                             ArchBlockType_t interface) const;
 
    void applyGlobalPragmas(const std::vector<const IR::Annotation *> &global_pragmas) const;
};
 
class TofinoPhvSpec : public PhvSpec {
 public:
    TofinoPhvSpec();
 
    bitvec parserGroup(unsigned id) const override;
 
    bool hasParserExtractGroups() const override;
 
    bitvec parserExtractGroup(unsigned id) const override;
 
    unsigned parserGroupId(const PHV::Container &c) const override;
 
    unsigned mauGroupId(const PHV::Container &c) const override;
 
    unsigned deparserGroupId(const PHV::Container &c) const override;
 
    const bitvec &individuallyAssignedContainers() const override;
 
    unsigned physicalAddress(unsigned container_id, ArchBlockType_t /*interface*/) const override;
 
    AddressSpec &physicalAddressSpec(ArchBlockType_t /* interface */) const override {
        return _physicalAddresses;
    }
 
 private:
    static AddressSpec _physicalAddresses;
};
 
class JBayPhvSpec : public PhvSpec {
 public:
    JBayPhvSpec();
 
    bitvec parserGroup(unsigned id) const override;
 
    bool hasParserExtractGroups() const override;
 
    bitvec parserExtractGroup(unsigned id) const override;
 
    unsigned parserGroupId(const PHV::Container &c) const override;
 
    unsigned mauGroupId(const PHV::Container &c) const override;
 
    unsigned deparserGroupId(const PHV::Container &c) const override;
 
    const bitvec &individuallyAssignedContainers() const override;
 
    unsigned physicalAddress(unsigned container_id, ArchBlockType_t interface) const override;
 
    AddressSpec &physicalAddressSpec(ArchBlockType_t interface) const override {
        switch (interface) {
            case PhvSpec::MAU:
                return _physicalMauAddresses;
            case PhvSpec::PARSER:
                return _physicalParserAddresses;
            case PhvSpec::DEPARSER:
                return _physicalDeparserAddresses;
            default:
                BUG("Invalid interface");
        }
    }
 
 private:
    static AddressSpec _physicalMauAddresses;
    static AddressSpec _physicalParserAddresses;
    static AddressSpec _physicalDeparserAddresses;
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PHV_PHV_SPEC_H_ */