phv_spec.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_SPECS_PHV_SPEC_H_
#define BACKENDS_TOFINO_BF_P4C_SPECS_PHV_SPEC_H_
 
#include <optional>
#include <vector>
 
#include "backends/tofino/bf-p4c/specs/phv.h"
#include "lib/bitvec.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>;
 
    // All cache fields
    struct PhVCache {
        bitvec physical_containers_i;
        std::map<PHV::Size, std::vector<bitvec>> mau_groups_i;
        bitvec ingress_only_containers_i;
        bitvec egress_only_containers_i;
        std::vector<bitvec> tagalong_collections_i;
        bitvec individually_assigned_containers_i;
    };
 
 protected:
    // All cache fields
    mutable PhVCache cache_;

    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:
    PhVCache &mutablePhvCache() const { return cache_; }
 
    const ordered_map<PHV::Type, unsigned> &typeIdMap() const { return typeIdMap_; }

    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;
};
 
class TofinoPhvSpec : public PhvSpec {
 public:
    TofinoPhvSpec(float phv_scale_factor, bool no_tagalong);

    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:
    explicit JBayPhvSpec(float phv_scale_factor);

    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_SPECS_PHV_SPEC_H_ */