clot.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_H_
#define BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_H_
 
#include <map>
#include <set>
#include <vector>
 
#include "bf-p4c/ir/gress.h"
#include "bf-p4c/lib/cmp.h"
#include "lib/exceptions.h"
#include "lib/ordered_map.h"
 
using namespace P4;
 
namespace P4 {
namespace IR {
namespace BFN {
class ParserState;
class FieldLVal;
}  // namespace BFN
}  // namespace IR
}  // namespace P4
 
namespace PHV {
class Field;
class FieldSlice;
}  // namespace PHV
 
namespace P4 {
class cstring;
class JSONGenerator;
class JSONLoader;
}  // namespace P4
 
class PhvInfo;
 
using namespace P4;
 
class Clot final : public LiftCompare<Clot> {
    friend class ClotInfo;
    friend class GreedyClotAllocator;
 
 public:
    Clot() : tag(0), gress(INGRESS) {}
 
    explicit Clot(gress_t gress) : tag(tag_count[gress]++), gress(gress) {
        BUG_CHECK(gress != GHOST, "Cannot assign CLOTs to ghost gress.");
    }
 
    explicit Clot(gress_t gress, unsigned tag) : tag(tag), gress(gress) {
        BUG_CHECK(gress != GHOST, "Cannot assign CLOTs to ghost gress.");
    }
 
    explicit Clot(cstring);
 
    cstring toString() const;
 
    bool operator==(const Clot &clot) const { return tag == clot.tag && gress == clot.gress; }
 
    bool operator<(const Clot &clot) const {
        if (gress != clot.gress) return gress < clot.gress;
        return tag < clot.tag;
    }
 
    void toJSON(JSONGenerator &json) const;
    static Clot *fromJSON(JSONLoader &json);
 
    unsigned tag;
 
    gress_t gress;
 
    const IR::BFN::FieldLVal *pov_bit = nullptr;
 
    std::optional<unsigned> stack_depth = std::nullopt;
 
    std::optional<unsigned> stack_inc = std::nullopt;
 
    unsigned length_in_bytes(cstring parser_state) const;
 
    unsigned bit_offset(cstring parser_state, const PHV::FieldSlice *slice) const;
 
    unsigned byte_offset(cstring parser_state, const PHV::FieldSlice *slice) const;
 
    bool is_phv_field(const PHV::Field *field) const;
 
    bool is_checksum_field(const PHV::Field *field) const;
 
    bool has_slice(const PHV::FieldSlice *slice) const;
 
    bool is_first_field_in_clot(const PHV::Field *field) const;
 
    std::optional<unsigned> csum_unit;
 
 private:
    void set_slices(cstring parser_state, const std::vector<const PHV::FieldSlice *> &slices);
 
    enum FieldKind {
        // Designates a modified field.
        MODIFIED,
 
        // Designates an unmodified field with a PHV allocation.
        READONLY,
 
        // Designates a field that is replaced with a checksum when deparsed.
        CHECKSUM,
 
        UNUSED
    };
 
    void add_slice(cstring parser_state, FieldKind kind, const PHV::FieldSlice *slice);
 
    std::map<cstring, std::vector<const PHV::FieldSlice *>> parser_state_to_slices_;
 
    std::map<const PHV::FieldSlice *, cstring> slice_to_parser_state_;
 
    ordered_map<const PHV::Field *, const PHV::FieldSlice *> fields_to_slices_;
 
    std::set<const PHV::Field *> phv_fields_;
 
    std::set<const PHV::Field *> checksum_fields_;
 
 public:
    const std::map<cstring, std::vector<const PHV::FieldSlice *>> &parser_state_to_slices() const {
        return parser_state_to_slices_;
    }
 
    const ordered_map<const PHV::Field *, const PHV::FieldSlice *> &fields_to_slices() const {
        return fields_to_slices_;
    }
 
    const std::set<const PHV::Field *> &checksum_fields() const { return checksum_fields_; }
 
    std::map<const PHV::Field *, unsigned> checksum_field_to_checksum_id;
 
    static std::map<gress_t, int> tag_count;
};
 
std::ostream &operator<<(std::ostream &out, const Clot &clot);
std::ostream &operator<<(std::ostream &out, const Clot *clot);
P4::JSONGenerator &operator<<(P4::JSONGenerator &out, const Clot &clot);
P4::JSONGenerator &operator<<(P4::JSONGenerator &out, const Clot *clot);
 
#endif /* BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_H_ */