parde_spec.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PARDE_PARDE_SPEC_H_
#define BACKENDS_TOFINO_BF_P4C_PARDE_PARDE_SPEC_H_
 
#include <map>
#include <vector>
 
#include "bf-p4c/bf-p4c-options.h"
#include "bf-p4c/ir/bitrange.h"
#include "bf-p4c/parde/match_register.h"
 
using namespace P4::literals;
 
class PardeSpec {
 public:
    size_t byteIngressIntrinsicMetadataSize() const { return 8; }
 
    virtual size_t bytePhase0Size() const = 0;
    size_t bitPhase0Size() const { return bytePhase0Size() * 8; }
 
    size_t bitResubmitTagSize() const { return 8; }
    size_t byteResubmitTagSize() const { return 1; }
 
    size_t bitResubmitSize() const { return bitPhase0Size(); }
    size_t byteResubmitSize() const { return bytePhase0Size(); }
 
    virtual size_t byteIngressPrePacketPaddingSize() const = 0;
    size_t bitIngressPrePacketPaddingSize() const { return byteIngressPrePacketPaddingSize() * 8; }
 
    size_t byteTotalIngressMetadataSize() const {
        return byteIngressIntrinsicMetadataSize() + bytePhase0Size() +
               byteIngressPrePacketPaddingSize();
    }
 
    int byteInputBufferSize() const { return 32; }
 
    nw_byterange byteInputBufferMetadataRange() const { return StartLen(32, 32); }
 
    virtual const std::map<unsigned, unsigned> &extractorSpec() const = 0;
 
    virtual const std::vector<MatchRegister> matchRegisters() const = 0;
 
    virtual const std::vector<MatchRegister> scratchRegisters() const = 0;
 
    // Region in the input buffer where the specified scratch register is located.
    virtual const nw_bitrange bitScratchRegisterRange(const MatchRegister &reg) const = 0;
 
    // Verifies if the provided range is a valid scratch register location.
    virtual bool byteScratchRegisterRangeValid(nw_byterange range) const = 0;
 
    virtual int numParsers() const = 0;
 
    virtual int numTcamRows() const = 0;
 
    virtual unsigned maxClotsPerState() const = 0;
 
    virtual unsigned byteMaxClotSize() const = 0;
 
    virtual unsigned numClotsPerGress() const = 0;
 
    virtual unsigned maxClotsLivePerGress() const = 0;
 
    virtual unsigned byteInterClotGap() const = 0;
 
    virtual unsigned bitMinClotPos(gress_t) const = 0;
 
    virtual unsigned bitMaxClotPos() const = 0;
 
    virtual size_t minParseDepth(gress_t) const { return 0; }
 
    virtual size_t maxParseDepth(gress_t) const { return SIZE_MAX; }
 
    virtual bool parserAllExtractorsSupportSingleByte() const = 0;
 
    // Number of deparser consant bytes available
    virtual unsigned numDeparserConstantBytes() const = 0;
 
    // Number deparser checksum units each gress can support
    virtual unsigned numDeparserChecksumUnits() const = 0;
 
    // Number of deparser checksum units that can invert its output
    virtual unsigned numDeparserInvertChecksumUnits() const = 0;
 
    // Deparser chunk size in bytes
    virtual unsigned deparserChunkSize() const = 0;
 
    // Deparser group size in chunks
    virtual unsigned deparserChunkGroupSize() const = 0;
 
    // Number of chunk groups in deparser
    virtual unsigned numDeparserChunkGroups() const = 0;
 
    // Number of clots in a single chunk group in deparser
    virtual unsigned numClotsPerDeparserGroup() const = 0;
 
    virtual double clkFreq() const = 0;
 
    virtual unsigned lineRate() const = 0;
 
    virtual const std::vector<std::string> &mdpValidVecFields() const = 0;
 
    virtual const std::unordered_set<std::string> &mdpValidVecFieldsSet() const = 0;
};
 
class TofinoPardeSpec : public PardeSpec {
 public:
    size_t bytePhase0Size() const override { return 8; }
    size_t byteIngressPrePacketPaddingSize() const override { return 0; }
 
    const std::map<unsigned, unsigned> &extractorSpec() const override {
        static const std::map<unsigned, unsigned> extractorSpec = {{8, 4}, {16, 4}, {32, 4}};
        return extractorSpec;
    }
 
    const std::vector<MatchRegister> matchRegisters() const override {
        static std::vector<MatchRegister> spec;
 
        if (spec.empty()) {
            spec = {MatchRegister("half"_cs), MatchRegister("byte0"_cs), MatchRegister("byte1"_cs)};
        }
 
        return spec;
    }
 
    const std::vector<MatchRegister> scratchRegisters() const override { return {}; }
 
    const nw_bitrange bitScratchRegisterRange(const MatchRegister &reg) const override {
        // Bug check while silencing unused variable warning.
        BUG("Scratch registers not available in Tofino. Register: %1%", reg.name);
        return nw_bitrange();
    }
 
    bool byteScratchRegisterRangeValid(nw_byterange) const override { return false; }
 
    int numParsers() const override { return 18; }
    int numTcamRows() const override { return 256; }
 
    unsigned maxClotsPerState() const override { BUG("No CLOTs in Tofino"); }
    unsigned byteMaxClotSize() const override { BUG("No CLOTs in Tofino"); }
    unsigned numClotsPerGress() const override { return 0; }
 
    unsigned maxClotsLivePerGress() const override { BUG("No CLOTs in Tofino"); }
 
    unsigned byteInterClotGap() const override { BUG("No CLOTs in Tofino"); }
 
    unsigned bitMinClotPos(gress_t) const override { BUG("No CLOTs in Tofino"); }
    unsigned bitMaxClotPos() const override { BUG("No CLOTs in Tofino"); }
 
    size_t minParseDepth(gress_t gress) const override { return gress == EGRESS ? 65 : 0; }
 
    size_t maxParseDepth(gress_t gress) const override { return gress == EGRESS ? 160 : SIZE_MAX; }
 
    bool parserAllExtractorsSupportSingleByte() const override { return false; }
 
    unsigned numDeparserConstantBytes() const override { return 0; }
    unsigned numDeparserChecksumUnits() const override { return 6; }
    unsigned numDeparserInvertChecksumUnits() const override { return 0; }
    unsigned deparserChunkSize() const { return 0; }
    unsigned deparserChunkGroupSize() const { return 0; }
    unsigned numDeparserChunkGroups() const { return 0; }
    unsigned numClotsPerDeparserGroup() const { return 0; }
 
    double clkFreq() const override { return 1.22; }
    unsigned lineRate() const override { return 100; }
 
    const std::vector<std::string> &mdpValidVecFields() const override {
        static std::vector<std::string> vldVecFields;
        return vldVecFields;
    }
 
    const std::unordered_set<std::string> &mdpValidVecFieldsSet() const override {
        static std::unordered_set<std::string> vldVecSet;
        return vldVecSet;
    }
};
 
class JBayPardeSpec : public PardeSpec {
 public:
    size_t bytePhase0Size() const override { return 16; }
    size_t byteIngressPrePacketPaddingSize() const override { return 8; }
 
    const std::map<unsigned, unsigned> &extractorSpec() const override {
        static const std::map<unsigned, unsigned> extractorSpec = {{16, 20}};
        return extractorSpec;
    }
 
    const std::vector<MatchRegister> matchRegisters() const override {
        static std::vector<MatchRegister> spec;
 
        if (spec.empty()) {
            spec = {MatchRegister("byte0"_cs), MatchRegister("byte1"_cs), MatchRegister("byte2"_cs),
                    MatchRegister("byte3"_cs)};
        }
 
        return spec;
    }
 
    const std::vector<MatchRegister> scratchRegisters() const override {
        static std::vector<MatchRegister> spec;
 
        if (spec.empty()) {
            matchRegisters();  // make sure the match registers are created first
 
            spec = {MatchRegister("save_byte0"_cs), MatchRegister("save_byte1"_cs),
                    MatchRegister("save_byte2"_cs), MatchRegister("save_byte3"_cs)};
        }
 
        return spec;
    }
 
    const nw_bitrange bitScratchRegisterRange(const MatchRegister &reg) const override {
        if (reg.name == "save_byte0")
            return nw_bitrange(504, 511);
        else if (reg.name == "save_byte1")
            return nw_bitrange(496, 503);
        else if (reg.name == "save_byte2")
            return nw_bitrange(488, 495);
        else if (reg.name == "save_byte3")
            return nw_bitrange(480, 487);
        else
            BUG("Invalid scratch register %1%", reg.name);
        return nw_bitrange();
    }
 
    bool byteScratchRegisterRangeValid(nw_byterange range) const override {
        return (range.lo >= 60) && (range.hi <= 63);
    }
 
    // TBD
    int numParsers() const override { return 36; }
    int numTcamRows() const override { return 256; }
 
    unsigned maxClotsPerState() const override { return 2; }
 
    // Cap max size to 56 as a workaround of TF2LAB-44
    unsigned byteMaxClotSize() const override {
        return BackendOptions().tof2lab44_workaround ? 56 : 64;
    }
 
    unsigned numClotsPerGress() const override { return 64; }
    unsigned maxClotsLivePerGress() const override { return 16; }
    unsigned byteInterClotGap() const override { return 3; }
    unsigned bitMinClotPos(gress_t gress) const override {
        return gress == EGRESS ? 28 * 8 : byteTotalIngressMetadataSize() * 8;
    }
    unsigned bitMaxClotPos() const override { return 384 * 8; /* 384 bytes */ }
    bool parserAllExtractorsSupportSingleByte() const override { return true; }
 
    unsigned numDeparserConstantBytes() const override { return 8; }
    unsigned numDeparserChecksumUnits() const override { return 8; }
    unsigned numDeparserInvertChecksumUnits() const override { return 4; }
    unsigned deparserChunkSize() const { return 8; }
    unsigned deparserChunkGroupSize() const { return 8; }
    unsigned numDeparserChunkGroups() const { return 16; }
    unsigned numClotsPerDeparserGroup() const { return 4; }
 
    // FIXME: adjust to true clock rate
    double clkFreq() const override { return 1.35; }
    unsigned lineRate() const override { return 400; }
 
    const std::vector<std::string> &mdpValidVecFields() const override {
        static std::vector<std::string> vldVecFields;
        return vldVecFields;
    }
 
    const std::unordered_set<std::string> &mdpValidVecFieldsSet() const override {
        static std::unordered_set<std::string> vldVecSet;
        return vldVecSet;
    }
};
 
class JBayA0PardeSpec : public JBayPardeSpec {
 public:
    unsigned numDeparserInvertChecksumUnits() const override { return 0; }
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PARDE_PARDE_SPEC_H_ */