clot_info.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_INFO_H_
#define BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_INFO_H_
 
#include <algorithm>
 
#include "bf-p4c/lib/assoc.h"
#include "bf-p4c/lib/cmp.h"
#include "bf-p4c/logging/filelog.h"
#include "bf-p4c/parde/clot/pragma/do_not_use_clot.h"
#include "bf-p4c/parde/dump_parser.h"
#include "bf-p4c/parde/parde_visitor.h"
#include "bf-p4c/phv/phv_parde_mau_use.h"
#include "clot.h"
#include "deparse_graph.h"
#include "field_slice_set.h"
#include "lib/ordered_map.h"
#include "pseudoheader.h"
 
class PhvInfo;
 
class FieldSliceExtractInfo;
 
class ClotInfo {
    friend class AllocateClot;
    friend class CollectClotInfo;
    friend class ClotCandidate;
    friend class GreedyClotAllocator;
 
    PhvUse &uses;
 
    ordered_set<const PHV::Field *> do_not_use_clot_fields;
 
    ordered_map<const IR::BFN::ParserState *, std::vector<const PHV::Field *>>
        parser_state_to_fields_;
 
    ordered_map<const IR::BFN::ParserState *, std::vector<const IR::HeaderStack *>>
        parser_state_to_header_stacks_;
 
    ordered_map<std::pair<const IR::BFN::ParserState *, const IR::HeaderStack *>,
                std::set<unsigned>>
        header_stack_elements_;
 
    ordered_map<const PHV::Field *,
                std::unordered_map<const IR::BFN::ParserState *, const IR::BFN::ParserRVal *>>
        field_to_parser_states_;
 
    ordered_map<const IR::BFN::ParserState *, ordered_map<const PHV::Field *, std::set<unsigned>>>
        field_to_byte_idx;
 
    ordered_map<const IR::BFN::ParserState *, std::map<unsigned, ordered_set<const PHV::Field *>>>
        byte_idx_to_field;
 
    std::set<const PHV::Field *> checksum_dests_;
    std::map<const PHV::Field *, std::vector<const IR::BFN::EmitChecksum *>>
        field_to_checksum_updates_;
 
    std::vector<Clot *> clots_;
    std::map<const Clot *, std::pair<gress_t, std::set<cstring>>, Clot::Less>
        clot_to_parser_states_;
    std::map<gress_t, std::map<cstring, std::set<const Clot *>>> parser_state_to_clots_;
 
    std::map<const IR::BFN::ParserState *, ordered_map<const PHV::Field *, nw_bitrange>>
        field_range_;
 
    std::map<const Clot *, std::vector<const IR::BFN::EmitChecksum *>> clot_to_emit_checksum_;
 
    std::map<const PHV::Field *, std::set<const PHV::Field *> *> field_aliases_;
 
    std::set<cstring> headers_added_by_mau_;
 
    std::map<const PHV::Field *, std::set<const Pseudoheader *>> field_to_pseudoheaders_;
 
    std::map<gress_t, DeparseGraph> deparse_graph_;
 
    std::map<const PHV::Field *, PovBitSet> fields_to_pov_bits_;
 
 public:
    explicit ClotInfo(PhvUse &uses) : uses(uses) {}
 
 private:
    unsigned num_clots_allocated(gress_t gress) const { return Clot::tag_count.at(gress); }
 
    std::optional<nw_bitrange> field_range(const IR::BFN::ParserState *state,
                                           const PHV::Field *field) const;
 
    std::optional<unsigned> offset(const IR::BFN::ParserState *state,
                                   const PHV::Field *field) const;
 
 public:
    cstring sanitize_state_name(cstring state_name, gress_t gress) const;
 
    CollectParserInfo parserInfo;
 
    const ordered_map<const IR::BFN::ParserState *, std::vector<const PHV::Field *>> &
    parser_state_to_fields() const {
        return parser_state_to_fields_;
    };
 
    const ordered_map<const IR::BFN::ParserState *, std::vector<const IR::HeaderStack *>> &
    parser_state_to_header_stacks() const {
        return parser_state_to_header_stacks_;
    };
 
    const ordered_map<std::pair<const IR::BFN::ParserState *, const IR::HeaderStack *>,
                      std::set<unsigned>> &
    header_stack_elements() {
        return header_stack_elements_;
    }
 
    std::set<const PHV::Field *> pov_extracted_without_fields;
 
    const std::map<const Clot *, std::pair<gress_t, std::set<cstring>>, Clot::Less> &
    clot_to_parser_states() const {
        return clot_to_parser_states_;
    }
 
    std::map<cstring, std::set<const Clot *>> &parser_state_to_clots(gress_t gress) {
        return parser_state_to_clots_.at(gress);
    }
 
    const std::map<cstring, std::set<const Clot *>> &parser_state_to_clots(gress_t gress) const {
        return parser_state_to_clots_.at(gress);
    }
 
    const std::set<const Clot *> parser_state_to_clots(
        const IR::BFN::LoweredParserState *state) const;
 
    const Clot *parser_state_to_clot(const IR::BFN::LoweredParserState *state, unsigned tag) const;
 
    const std::vector<Clot *> &clots() { return clots_; }
 
    const std::map<const PHV::Field *, std::vector<const IR::BFN::EmitChecksum *>> &
    field_to_checksum_updates() {
        return field_to_checksum_updates_;
    }
 
    std::map<int, PHV::Container> get_overwrite_containers(const Clot *clot,
                                                           const PhvInfo &phv) const;
 
    std::map<int, const PHV::Field *> get_csum_fields(const Clot *clot) const;
 
    std::map<const Clot *, std::vector<const IR::BFN::EmitChecksum *>> &clot_to_emit_checksum() {
        return clot_to_emit_checksum_;
    }
 
    const std::map<const Clot *, std::vector<const IR::BFN::EmitChecksum *>> &
    clot_to_emit_checksum() const {
        return clot_to_emit_checksum_;
    }
 
    void merge_parser_states(gress_t gress, cstring dst_state_name, cstring src_state_name);
 
 private:
    void add_field(const PHV::Field *f, const IR::BFN::ParserRVal *source,
                   const IR::BFN::ParserState *state);
 
    void add_stack(const IR::HeaderStack *hs, const IR::BFN::ParserState *state, int index = -1);
 
    void compute_byte_maps();
 
    void add_clot(Clot *clot, ordered_set<const IR::BFN::ParserState *> states);
 
    const ordered_set<const IR::BFN::ParserState *> *find_full_states(
        const IR::BFN::ParserGraph *graph) const;
 
    // A field may participate in multiple checksum updates, e.g. IPv4 fields
    // may be included in both IPv4 and TCP checksum updates. In such cases,
    // we require the IPv4 fields in both updates to be identical sets in order
    // to be allocated to a CLOT (each CLOT can only compute one checksum)
    bool is_used_in_multiple_checksum_update_sets(const PHV::Field *field) const;
 
    bool is_extracted_in_multiple_non_mutex_states(const PHV::Field *f) const;
 
    bool extracted_with_pov(const PHV::Field *field) const;
 
    bool has_consistent_bit_in_byte_offset(const PHV::Field *field) const;
 
    bool can_be_in_clot(const PHV::Field *field) const;
 
    bool can_start_clot(const FieldSliceExtractInfo *extract_info) const;
 
    bool can_end_clot(const FieldSliceExtractInfo *extract_info) const;
 
    bool extracts_full_width(const PHV::Field *field) const;
 
    mutable std::map<const PHV::Field *, bool> is_modified_;
 
 public:
    bool is_checksum(const PHV::Field *field) const;
    bool is_checksum(const PHV::FieldSlice *slice) const;
 
    bool is_modified(const PHV::Field *field) const;
    bool is_modified(const PHV::FieldSlice *slice) const;
 
    bool is_readonly(const PHV::Field *field) const;
    bool is_readonly(const PHV::FieldSlice *slice) const;
 
    bool is_unused(const PHV::Field *field) const;
    bool is_unused(const PHV::FieldSlice *slice) const;
 
    const std::set<const PHV::Field *> *clot_eligible_fields() const;
 
    assoc::map<const PHV::FieldSlice *, Clot *, PHV::FieldSlice::Greater> *allocated_slices(
        const PHV::Field *field) const {
        return is_unused(field) ? slice_clots(field) : nullptr;
    }
 
    bool is_slice_below_min_offset(const PHV::FieldSlice *slice, int max_packet_bit_offset) const;
 
    //
    // If we had more precise slice-level usage information, we could instead return a non-null
    // result if the given slice were unused.
    assoc::map<const PHV::FieldSlice *, Clot *, PHV::FieldSlice::Greater> *allocated_slices(
        const PHV::FieldSlice *slice) const {
        return is_unused(slice->field()) ? slice_clots(slice) : nullptr;
    }
 
    const Clot *fully_allocated(const PHV::Field *field) const {
        return is_unused(field) ? whole_field_clot(field) : nullptr;
    }
 
    //
    // If we had more precise slice-level usage information, we could instead return a non-null
    // result if the given slice were unused.
    std::set<const Clot *, Clot::Less> *fully_allocated(const PHV::FieldSlice &slice) const {
        return fully_allocated(&slice);
    }
 
    //
    // If we had more precise slice-level usage information, we could instead return a non-null
    // result if the given slice were unused.
    std::set<const Clot *, Clot::Less> *fully_allocated(const PHV::FieldSlice *slice) const;
 
    bool allocated_unmodified_undigested(const PHV::Field *field) const {
        return whole_field_clot(field) && (is_readonly(field) || is_unused(field)) &&
               !field->is_digest();
    }
 
    void adjust_clots(const PhvInfo &phv);
 
 private:
    bool adjust(const PhvInfo &phv, Clot *clot);
 
    void crop(Clot *clot, cstring parser_state, unsigned start_bits, unsigned end_bits);
 
    void crop(Clot *clot, cstring parser_state, unsigned num_bits, bool from_start);
 
 public:
    bool slice_overwritten(const PhvInfo &phvInfo, const Clot *clot,
                           const PHV::FieldSlice *f) const;
 
    bool slice_overwritten_by_phv(const PhvInfo &phvInfo, const Clot *clot,
                                  const PHV::FieldSlice *f) const;
 
 private:
    template <Endian Order = Endian::Network>
    bitvec bits_overwritten(const PhvInfo &phvInfo, const Clot *clot,
                            const PHV::FieldSlice *f) const;
 
    template <Endian Order = Endian::Network>
    bitvec bits_overwritten_by_phv(const PhvInfo &phvInfo, const Clot *clot,
                                   const PHV::FieldSlice *f) const;
 
 public:
    bool is_added_by_mau(cstring h) const;
 
    assoc::map<const PHV::FieldSlice *, Clot *, PHV::FieldSlice::Greater> *slice_clots(
        const PHV::FieldSlice *slice) const;
 
    assoc::map<const PHV::FieldSlice *, Clot *, PHV::FieldSlice::Greater> *slice_clots(
        const PHV::Field *field) const {
        return slice_clots(new PHV::FieldSlice(field));
    }
 
    Clot *whole_field_clot(const PHV::Field *field) const;
 
    bool clot_covers_slice(const Clot *clot, const PHV::FieldSlice *slice) const;
 
    std::string print(const PhvInfo *phvInfo = nullptr) const;
 
 private:
    void add_alias(const PHV::Field *f1, const PHV::Field *f2);
 
    void clear();
 
    //
    // DANGER: This function assumes the parser graph is a DAG.
    std::pair<unsigned, ordered_set<const IR::BFN::ParserState *> *> *find_largest_paths(
        const std::map<cstring, std::set<const Clot *>> &parser_state_to_clots,
        const IR::BFN::ParserGraph *graph, const IR::BFN::ParserState *state,
        std::map<const IR::BFN::ParserState *,
                 std::pair<unsigned, ordered_set<const IR::BFN::ParserState *> *> *> *memo =
            nullptr) const;
};
 
class CollectClotInfo : public Inspector {
    const PhvInfo &phv;
    ClotInfo &clotInfo;
    const PragmaDoNotUseClot &pragmaDoNotUseClot;
    Logging::FileLog *log = nullptr;
 
 public:
    explicit CollectClotInfo(const PhvInfo &phv, ClotInfo &clotInfo,
                             const PragmaDoNotUseClot &pragmaDoNotUseClot)
        : phv(phv), clotInfo(clotInfo), pragmaDoNotUseClot(pragmaDoNotUseClot) {}
 
 private:
    Visitor::profile_t init_apply(const IR::Node *root) override;
 
    bool preorder(const IR::BFN::Extract *extract) override;
    bool preorder(const IR::BFN::ParserZeroInit *zero_init) override;
 
    bool preorder(const IR::HeaderStackItemRef *hs) override;
 
    bool preorder(const IR::BFN::EmitField *emit) override;
 
    bool preorder(const IR::BFN::EmitChecksum *emit) override;
 
    void postorder(const IR::BFN::Deparser *deparser) override;
 
    void add_pseudoheader(
        const PovBitSet pov_bits, const std::vector<const PHV::Field *> fields,
        std::map<std::pair<const PovBitSet, const std::vector<const PHV::Field *>>,
                 const Pseudoheader *> &allocated);
 
    bool preorder(const IR::BFN::AliasMember *alias) override {
        add_alias_field(alias);
        return true;
    }
 
    bool preorder(const IR::BFN::AliasSlice *alias) override {
        add_alias_field(alias);
        return true;
    }
 
    void add_alias_field(const IR::Expression *alias);
 
    bool preorder(const IR::MAU::Instruction *instruction) override;
 
    void end_apply(const IR::Node *root) override;
};
 
#endif /* BACKENDS_TOFINO_BF_P4C_PARDE_CLOT_CLOT_INFO_H_ */