greedy_allocator.h

 
#ifndef BF_P4C_PHV_V2_GREEDY_ALLOCATOR_H_
#define BF_P4C_PHV_V2_GREEDY_ALLOCATOR_H_
 
#include "bf-p4c/phv/utils/utils.h"
#include "bf-p4c/phv/v2/allocator_base.h"
#include "bf-p4c/phv/v2/kind_size_indexed_map.h"
#include "bf-p4c/phv/v2/phv_kit.h"
#include "bf-p4c/phv/v2/utils_v2.h"
 
namespace PHV {
namespace v2 {
 
class GreedyAllocator : public AllocatorBase {
    // const PhvKit& kit_i;
    PhvInfo &phv_i;
    const int pipe_id_i;
    const int max_slicing_tries_i = 256;
 
 private:
    ContainerGroupsBySize make_container_groups_by_size() const;
 
    struct PreSliceResult {
        std::list<SuperCluster *> clusters;
        ordered_map<const SuperCluster *, KindSizeIndexedMap> baseline_cont_req;
    };
 
    PreSliceResult pre_slice_all(const Allocation &empty_alloc,
                                 const std::list<SuperCluster *> &clusters,
                                 ordered_set<const SuperCluster *> &invalid_clusters,
                                 AllocatorMetrics &alloc_metrics) const;
 
    struct RefinedSuperClusterSet {
        std::list<PHV::SuperCluster *> normal;
        std::list<PHV::SuperCluster *> deparser_zero;
        std::list<PHV::SuperCluster *> strided;
 
        std::deque<std::pair<int, const PHV::SuperCluster *>> normal_sc_que() const;
    };
 
    void sort_normal_clusters(std::list<PHV::SuperCluster *> &clusters) const;
 
    RefinedSuperClusterSet prepare_refined_set(const std::list<SuperCluster *> &clusters) const;
 
    struct AllocResultWithSlicingDetails {
        AllocResult rst;
        TxScore *best_score = nullptr;
        std::list<PHV::SuperCluster *> best_slicing;
        int best_slicing_idx = 0;  // valid index starts from 1.
        ordered_map<const PHV::SuperCluster *, TxContStatus> *sliced_tx = nullptr;
        explicit AllocResultWithSlicingDetails(const Transaction &tx) : rst(tx) {}
        explicit AllocResultWithSlicingDetails(AllocError *err) : rst(err) {}
    };
    friend std::ostream &operator<<(std::ostream &, const AllocResultWithSlicingDetails &);
 
    AllocResultWithSlicingDetails slice_and_allocate_sc(
        const ScoreContext &ctx, const Allocation &alloc, const PHV::SuperCluster *sc,
        const ContainerGroupsBySize &container_groups, AllocatorMetrics &alloc_metrics,
        const int max_slicings = 128) const;
 
 public:
    GreedyAllocator(const PhvKit &kit, PhvInfo &phv, int pipe_id)
        : AllocatorBase(kit), phv_i(phv), pipe_id_i(pipe_id){};
 
    bool allocate(std::list<SuperCluster *> clusters, AllocatorMetrics &alloc_metrics);
};
 
std::ostream &operator<<(std::ostream &, const GreedyAllocator::AllocResultWithSlicingDetails &);
 
}  // namespace v2
}  // namespace PHV
 
#endif /* BF_P4C_PHV_V2_GREEDY_ALLOCATOR_H_ */