copacker.h

 
#ifndef BF_P4C_PHV_V2_COPACKER_H_
#define BF_P4C_PHV_V2_COPACKER_H_
 
#include "backends/tofino/bf-p4c/phv/action_source_tracker.h"
#include "backends/tofino/bf-p4c/phv/utils/utils.h"
#include "backends/tofino/bf-p4c/phv/v2/utils_v2.h"
 
namespace PHV {
namespace v2 {
 
struct SrcPackVec {
    std::optional<PHV::Container> container = std::nullopt;
 
    FieldSliceAllocStartMap fs_starts = {};
 
    // bool left_shiftable = false;
 
    bool empty() const { return fs_starts.empty(); }
 
    size_t size() const { return fs_starts.size(); }
};
std::ostream &operator<<(std::ostream &, const SrcPackVec &);
std::ostream &operator<<(std::ostream &, const SrcPackVec *);
 
struct CoPackHint {
    std::vector<SrcPackVec *> pack_sources;
    bool required = false;
    cstring reason = ""_cs;
};
std::ostream &operator<<(std::ostream &, const CoPackHint &);
std::ostream &operator<<(std::ostream &, const CoPackHint *);
 
using ActionSourceCoPackMap = ordered_map<const IR::MAU::Action *, std::vector<const CoPackHint *>>;
std::ostream &operator<<(std::ostream &, const ActionSourceCoPackMap &);
std::ostream &operator<<(std::ostream &, const ActionSourceCoPackMap *);
 
struct CoPackResult {
    ActionSourceCoPackMap action_hints;
    const AllocError *err = nullptr;
    bool ok() const { return err == nullptr; }
};
 
class CoPacker {
    const ActionSourceTracker &sources_i;
    const SuperCluster *sc_i;
    const ScAllocAlignment *alignment_i;
    ordered_map<FieldSlice, const SuperCluster::SliceList *> fs_to_sl;
 
    using DestSrcsMap = ordered_map<AllocSlice, safe_vector<SourceOp>>;
    using DestSrcsKv = std::pair<AllocSlice, safe_vector<SourceOp>>;
 
    struct CoPackHintOrErr {
        const AllocError *err = nullptr;
        const CoPackHint *hint = nullptr;
        bool ok() const { return err == nullptr; }
        explicit CoPackHintOrErr(const AllocError *err) : err(err) {}
        explicit CoPackHintOrErr(const CoPackHint *c) : hint(c) {}
    };
 
    std::optional<int> get_decided_start_index(const FieldSlice &fs) const;
 
    bool ok_to_pack(const FieldSliceAllocStartMap &existing, const FieldSlice &new_fs,
                    const int new_fs_start_index, const Container &c) const;
 
    bool skip_source_packing(const FieldSlice &fs) const;
 
    const CoPackHint *gen_bitwise_copack(const Allocation &allocated_tx,
                                         const IR::MAU::Action *action, const DestSrcsMap &writes,
                                         const Container &c) const;
 
    CoPackHintOrErr gen_whole_container_set_copack(const Allocation &allocated_tx,
                                                   const IR::MAU::Action *action,
                                                   const DestSrcsMap &writes,
                                                   const Container &c) const;
 
    // The algorithm is
    CoPackHintOrErr gen_move_copack(const Allocation &allocated_tx, const IR::MAU::Action *action,
                                    const DestSrcsMap &writes, const Container &c) const;
 
 public:
    CoPacker(const ActionSourceTracker &sources, const SuperCluster *sc,
             const ScAllocAlignment *alignment);
 
    CoPackResult gen_copack_hints(const Allocation &allocated_tx,
                                  const std::vector<AllocSlice> &slices, const Container &c) const;
};
 
}  // namespace v2
}  // namespace PHV
 
#endif /* BF_P4C_PHV_V2_COPACKER_H_ */