field_slice_extract_info.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_FIELD_SLICE_EXTRACT_INFO_H_
#define BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_FIELD_SLICE_EXTRACT_INFO_H_
 
#include "bf-p4c/parde/parser_info.h"
#include "bf-p4c/phv/phv_fields.h"
#include "clot_candidate.h"
#include "lib/ordered_map.h"
 
using StatePair = std::pair<const IR::BFN::ParserState *, const IR::BFN::ParserState *>;
using StatePairSet = ordered_set<StatePair>;
 
class FieldSliceExtractInfo {
    friend class GreedyClotAllocator;
 
    // Invariant: all offsets here are congruent, modulo 8.
    ordered_map<const IR::BFN::ParserState *, unsigned> state_bit_offsets_;
 
    // Invariant: all offsets here are congruent, modulo 8.
    std::map<unsigned, ordered_map<const IR::BFN::ParserState *, unsigned>>
        stack_offset_state_bit_offsets_;
 
    int min_packet_bit_offset_;
 
    int max_packet_bit_offset_;
 
    const PHV::FieldSlice *slice_;
 
 public:
    FieldSliceExtractInfo(
        const ordered_map<const IR::BFN::ParserState *, unsigned> &state_bit_offsets,
        const std::map<unsigned, ordered_map<const IR::BFN::ParserState *, unsigned>>
            &stack_offset_state_bit_offsets,
        int min_packet_bit_offset, int max_packet_bit_offset, const PHV::Field *field)
        : FieldSliceExtractInfo(state_bit_offsets, stack_offset_state_bit_offsets,
                                min_packet_bit_offset, max_packet_bit_offset,
                                new PHV::FieldSlice(field)) {}
 
    FieldSliceExtractInfo(
        const ordered_map<const IR::BFN::ParserState *, unsigned> &state_bit_offsets,
        const std::map<unsigned, ordered_map<const IR::BFN::ParserState *, unsigned>>
            &stack_offset_state_bit_offsets,
        int min_packet_bit_offset, int max_packet_bit_offset, const PHV::FieldSlice *slice)
        : state_bit_offsets_(state_bit_offsets),
          stack_offset_state_bit_offsets_(stack_offset_state_bit_offsets),
          min_packet_bit_offset_(min_packet_bit_offset),
          max_packet_bit_offset_(max_packet_bit_offset),
          slice_(slice) {}
 
    void update(const IR::BFN::ParserState *state, unsigned stack_offset, unsigned state_bit_offset,
                int min_packet_bit_offset, int max_packet_bit_offset);
 
    ordered_set<const IR::BFN::ParserState *> states() const;
 
    int min_packet_bit_offset() const { return min_packet_bit_offset_; }
 
    int max_packet_bit_offset() const { return max_packet_bit_offset_; }
 
    const ordered_map<const IR::BFN::ParserState *, unsigned> &state_bit_offsets() const {
        return state_bit_offsets_;
    }
 
    unsigned state_bit_offset(const IR::BFN::ParserState *state) const {
        return state_bit_offsets_.at(state);
    }
 
    unsigned bit_in_byte_offset() const {
        auto offset = *Values(state_bit_offsets_).begin();
        return offset % 8;
    }
 
    const PHV::FieldSlice *slice() const { return slice_; }
 
    const FieldSliceExtractInfo *trim_head_to_byte() const;
 
    const FieldSliceExtractInfo *trim_head_to_min_clot_pos() const;
 
    const FieldSliceExtractInfo *trim_tail_to_byte() const;
 
    const FieldSliceExtractInfo *trim_tail_to_max_clot_pos() const;
 
 private:
    const FieldSliceExtractInfo *trim_tail_bits(int size) const;
 
 public:
    const FieldSliceExtractInfo *trim(int lo_idx, int bits) const;
 
    std::vector<const FieldSliceExtractInfo *> *remove_conflicts(
        const CollectParserInfo &parserInfo, int preGapBits, const ClotCandidate *candidate,
        int postGapBits) const;
 
    const std::map<unsigned, StatePairSet> byte_gaps(const CollectParserInfo &parserInfo,
                                                     const FieldSliceExtractInfo *other) const;
 
    const std::map<unsigned, StatePairSet> bit_gaps(const CollectParserInfo &parserInfo,
                                                    const FieldSliceExtractInfo *other) const;
 
    friend bool operator==(const FieldSliceExtractInfo &, const FieldSliceExtractInfo &);
 
 private:
    friend std::ostream &operator<<(std::ostream &, const FieldSliceExtractInfo &);
    friend std::ostream &operator<<(std::ostream &, const FieldSliceExtractInfo *);
};
 
class FieldExtractInfo {
 public:
    typedef std::map<const Pseudoheader *, ordered_map<const PHV::Field *, FieldSliceExtractInfo *>,
                     Pseudoheader::Less>
        PseudoheaderMap;
    typedef ordered_map<const PHV::Field *, FieldSliceExtractInfo *> FieldMap;
    typedef std::map<cstring, std::map<const IR::BFN::ParserState *, std::set<unsigned>>>
        HeaderStackMap;
 
    PseudoheaderMap pseudoheaderMap;
 
    FieldMap fieldMap;
 
    // FIXME: Don't need to make sure that all or none of the indices extracted in a state
    // are covered by CLOTs. If multiple are extracted in a single iteration, then potentionally
    // only those at the same offset across all iterationsd need to be CLOTed/not CLOTed.
    // e.g., if a state extracts 0 & 1, or 2 & 3, then it's probably okay if only 0 and 2 are
    // CLOTed because they are both the first offset in the state being processed.
    HeaderStackMap headerStackMap;
 
    void updateFieldMap(const PHV::Field *field, const IR::BFN::ParserState *state,
                        unsigned stack_offset, unsigned state_bit_offset, int min_packet_bit_offset,
                        int max_packet_bit_offset) {
        if (fieldMap.count(field)) {
            fieldMap.at(field)->update(state, stack_offset, state_bit_offset, min_packet_bit_offset,
                                       max_packet_bit_offset);
        } else {
            ordered_map<const IR::BFN::ParserState *, unsigned> state_bit_offsets;
            state_bit_offsets[state] = state_bit_offset;
            std::map<unsigned, ordered_map<const IR::BFN::ParserState *, unsigned>>
                stack_offset_state_bit_offsets;
            stack_offset_state_bit_offsets[stack_offset][state] = state_bit_offset;
            fieldMap[field] =
                new FieldSliceExtractInfo(state_bit_offsets, stack_offset_state_bit_offsets,
                                          min_packet_bit_offset, max_packet_bit_offset, field);
        }
    }
 
    void updatePseudoheaderMap(const Pseudoheader *pseudoheader, const PHV::Field *field,
                               const IR::BFN::ParserState *state, unsigned stack_offset,
                               unsigned state_bit_offset, int min_packet_bit_offset,
                               int max_packet_bit_offset) {
        if (pseudoheaderMap.count(pseudoheader) && pseudoheaderMap.at(pseudoheader).count(field)) {
            auto *fei = pseudoheaderMap.at(pseudoheader).at(field);
            fei->update(state, stack_offset, state_bit_offset, min_packet_bit_offset,
                        max_packet_bit_offset);
        } else {
            ordered_map<const IR::BFN::ParserState *, unsigned> state_bit_offsets;
            state_bit_offsets[state] = state_bit_offset;
            std::map<unsigned, ordered_map<const IR::BFN::ParserState *, unsigned>>
                stack_offset_state_bit_offsets;
            stack_offset_state_bit_offsets[stack_offset][state] = state_bit_offset;
            auto fei =
                new FieldSliceExtractInfo(state_bit_offsets, stack_offset_state_bit_offsets,
                                          min_packet_bit_offset, max_packet_bit_offset, field);
 
            pseudoheaderMap[pseudoheader][field] = fei;
        }
    }
 
    void updateHeaderStackMap(cstring header_stack, const IR::BFN::ParserState *state,
                              const std::set<unsigned> indices) {
        headerStackMap[header_stack][state].insert(indices.begin(), indices.end());
    }
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_FIELD_SLICE_EXTRACT_INFO_H_ */