clot_candidate.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_CANDIDATE_H_
#define BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_CANDIDATE_H_
 
#include "backends/tofino/bf-p4c/lib/cmp.h"
#include "clot_info.h"
#include "pseudoheader.h"
 
using StatePair = std::pair<const IR::BFN::ParserState *, const IR::BFN::ParserState *>;
using StatePairSet = ordered_set<StatePair>;
 
class FieldSliceExtractInfo;
 
class ClotCandidate : public LiftLess<ClotCandidate> {
 public:
    const Pseudoheader *pseudoheader;
    PovBitSet pov_bits;
 
 private:
    // Invariant: field slices are extracted in the same set of parser states.
    const std::vector<const FieldSliceExtractInfo *> extract_infos;
 
    std::vector<unsigned> can_start_indices_;
 
    std::vector<unsigned> can_end_indices_;
 
    std::map<const IR::BFN::ParserState *, bitvec> parser_state_to_checksum_bits;
    std::set<const PHV::FieldSlice *> checksum_slices;
    unsigned checksum_bits;
 
    std::map<const IR::BFN::ParserState *, bitvec> parser_state_to_modified_bits;
    std::set<const PHV::FieldSlice *> modified_slices;
    unsigned modified_bits;
 
    std::map<const IR::BFN::ParserState *, bitvec> parser_state_to_readonly_bits;
    std::set<const PHV::FieldSlice *> readonly_slices;
    unsigned readonly_bits;
 
    std::map<const IR::BFN::ParserState *, bitvec> parser_state_to_unused_bits;
    std::set<const PHV::FieldSlice *> unused_slices;
    unsigned unused_bits;
 
    std::map<const IR::BFN::ParserState *, unsigned> parser_state_to_size_in_bits;
 
    static unsigned nextId;
 
 public:
    const unsigned id;
 
    unsigned max_size_in_bits() const;
 
    unsigned size_in_bits(const IR::BFN::ParserState *parser_state) const;
 
    bool afterAllocatedClot;
 
    bool beforeAllocatedClot;
 
    ClotCandidate(const ClotInfo &clotInfo, const Pseudoheader *pseudoheader,
                  const std::vector<const FieldSliceExtractInfo *> &extract_infos,
                  bool afterAllocatedClot = false, bool beforeAllocatedClot = false);
 
    ordered_set<const IR::BFN::ParserState *> states() const;
 
    gress_t thread() const;
 
    const ordered_map<const IR::BFN::ParserState *, unsigned> &state_bit_offsets() const;
 
    unsigned bit_in_byte_offset() const;
 
    const std::vector<const FieldSliceExtractInfo *> &extracts() const;
 
    const std::vector<unsigned> &can_start_indices() const;
 
    const std::vector<unsigned> &can_end_indices() const;
 
    const std::map<unsigned, StatePairSet> byte_gaps(const CollectParserInfo &parserInfo,
                                                     const ClotCandidate *other) const;
 
    const ClotCandidate *mark_adjacencies(bool afterAllocatedClot, bool beforeAllocatedClot) const;
 
    bool operator<(const ClotCandidate &other) const;
 
    std::string print() const;
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_CANDIDATE_H_ */