greedy_tx_score.h

 
#ifndef BF_P4C_PHV_V2_GREEDY_TX_SCORE_H_
#define BF_P4C_PHV_V2_GREEDY_TX_SCORE_H_
 
#include "backends/tofino/bf-p4c/phv/v2/kind_size_indexed_map.h"
#include "backends/tofino/bf-p4c/phv/v2/phv_kit.h"
#include "backends/tofino/bf-p4c/phv/v2/tx_score.h"
 
namespace PHV {
namespace v2 {
 
using ContainerByte = std::pair<Container, int>;
using TableIxbarContBytesMap = ordered_map<const IR::MAU::Table *, ordered_set<ContainerByte>>;
using StageIxbarContBytesMap = ordered_map<int, ordered_set<ContainerByte>>;
 
struct Vision {
    enum class ContGress {
        ingress,
        egress,
        unassigned,
    };
 
    ordered_map<const SuperCluster *, KindSizeIndexedMap> sc_cont_required;
    ordered_map<gress_t, KindSizeIndexedMap> cont_required;
    ordered_map<ContGress, KindSizeIndexedMap> cont_available;
 
    // TODO: maybe a good idea to add learning quanta and pov bits limit here?
    // ordered_map<gress_t, int> pov_bits_used;
    // ordered_map<gress_t, int> pov_bits_unallocated;
 
    // The direction of dataflow for table matching is
    // phv-bytes ======> ixbar (groups)  =======> search bus ========> SRAM/TCAM table.
    //             (1)                     (2)
    // (1) Constraints are:
    //     + 32-bit container bytes must be mapped to same mod-4 bytes.
    //     + 16-bit container bytes must be mapped to same mod-2 bytes.
    //     + 8-bit container byte can be mapped to any bytes.
    // (2) Constraints are:
    //     + search bus read from one of 8 (exact) or 12 (ternary) ixbar group.
    //     + For ternary, a group is of 5 + 1 (4bit of mid-byte) bytes group.
    //     + For sram, a group has 16 bytes.
 
    TableIxbarContBytesMap table_ixbar_cont_bytes;
    StageIxbarContBytesMap stage_sram_ixbar_cont_bytes;
    StageIxbarContBytesMap stage_tcam_ixbar_cont_bytes;
 
    int bits_demand(const PHV::Kind &k) const;
    int bits_supply(const PHV::Kind &k) const;
    bool has_more_than_enough(const PHV::Kind &k) const {
        return bits_supply(k) >= bits_demand(k);
    };
};
 
std::ostream &operator<<(std::ostream &, const ContainerByte &);
std::ostream &operator<<(std::ostream &, const Vision &);
 
class GreedyTxScoreMaker : public TxScoreMaker {
 private:
    const PhvKit &kit_i;
 
    Vision vision_i;
    std::set<const Field *> table_key_with_ranges;
 
    friend class GreedyTxScore;
    friend std::ostream &operator<<(std::ostream &, const Vision &);
 
 public:
    GreedyTxScoreMaker(const PhvKit &utils, const std::list<ContainerGroup *> &container_groups,
                       const std::list<SuperCluster *> &sorted_clusters,
                       const ordered_map<const SuperCluster *, KindSizeIndexedMap> &baseline);
 
    TxScore *make(const Transaction &tx) const override;
 
    void record_commit(const Transaction &tx, const SuperCluster *presliced_sc);
 
    KindSizeIndexedMap record_deallocation(const SuperCluster *sc,
                                           const ConcreteAllocation &curr_alloc,
                                           const ordered_set<AllocSlice> &slices);
 
    cstring status() const;
 
    // algorithms
 public:
    static int ixbar_imbalanced_alignment(const ordered_set<ContainerByte> &cont_bytes);
};
 
class GreedyTxScore : public TxScore {
 private:
    const GreedyTxScoreMaker *maker_i = nullptr;
    const Vision *vision_i;
 
    int used_L1_bits() const;
 
    int used_L2_bits() const;
 
    friend class GreedyTxScoreMaker;
 
 private:
    KindSizeIndexedMap used_bits;
 
    KindSizeIndexedMap used_containers;
 
    KindSizeIndexedMap n_set_gress;
    KindSizeIndexedMap n_set_parser_gress;
    KindSizeIndexedMap n_set_deparser_gress;
    KindSizeIndexedMap n_mismatched_deparser_gress;
    // TODO
    // {n_mismatched_deparser_gress, weighted_delta[n_mismatched_deparser_gress], false},
 
    ordered_map<int, int> ixbar_bytes;
 
    int n_size_overflow = 0;
 
    int n_max_overflowed = 0;
 
    int n_tphv_on_phv_bits = 0;
 
    int n_inc_used_tphv_collection = 0;
 
    int n_pov_deparser_read_bits = 0;
 
    int n_deparser_read_learning_bytes = 0;
 
    int n_table_new_ixbar_bytes = 0;
 
    int n_stage_new_ixbar_bytes = 0;
 
    // sum of the imbalanced alignment for all tables involved in this tx.
    int n_table_ixbar_imbalanced_alignments = 0;
 
    // sum of the imbalanced alignment of ixbar bytes,
    // for all stages that are (1) involved in this tx and (2) the remaining bytes of the stage
    // are less than threshold.
    int n_overloaded_stage_ixbar_imbalanced_alignments = 0;
 
    // For TCAM table match keys, amount of nibbles occupied, i.e. the width of the span
    // between first and last nibble occupied.
    int n_range_match_nibbles_occupied = 0;
 
 public:
    explicit GreedyTxScore(const Vision *vision) : vision_i(vision) {}
 
    bool better_than(const TxScore *other) const override;
 
    std::string str() const override;
 
    bool has_mismatch_gress() const;
};
 
}  // namespace v2
}  // namespace PHV
 
#endif /* BF_P4C_PHV_V2_GREEDY_TX_SCORE_H_ */