trivial_allocator.h

 
#ifndef BF_P4C_PHV_V2_TRIVIAL_ALLOCATOR_H_
#define BF_P4C_PHV_V2_TRIVIAL_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 TrivialAllocator : public AllocatorBase {
 public:
    class PhvStatus {
        std::unordered_map<PHV::Size, int> next_container_idx;
 
     public:
        PhvStatus();
        PHV::Container next_container(PHV::Size) const;
        void inc_next_container(PHV::Size);
    };
 
    struct PartialAllocResult {
        const AllocError *err = nullptr;
        std::vector<AllocSlice> alloc_slices;
        PhvStatus phv_status;
        bool ok() const { return err == nullptr; };
        PartialAllocResult(const std::vector<AllocSlice> &alloc_slices, PhvStatus phv_status)
            : alloc_slices(alloc_slices), phv_status(phv_status) {}
        explicit PartialAllocResult(const AllocError *err) : err(err) {}
    };
 
 private:
    // const PhvKit& kit_i;
    PhvInfo &phv_i;
    const int pipe_id_i;  
 
    ContainerGroupsBySize make_container_groups_merged_by_size() const;
 
    std::vector<PHV::AllocSlice> gen_alloc_slices_from_tx(const PHV::Transaction &tx,
                                                          PhvStatus &phv_status) const;
 
    void bind_alloc_slices(const std::vector<PHV::AllocSlice> &slices);
 
    const AllocError *diagnose_invalid_cluster(const Allocation &empty_alloc,
                                               const PHV::SuperCluster *sc,
                                               const ContainerGroupsBySize &container_groups,
                                               AllocatorMetrics &alloc_metrics) const;
 
    cstring make_error_msg(const SuperCluster *sc, const AllocError *err) const;
 
 public:
    TrivialAllocator(const PhvKit &kit, PhvInfo &phv, int pipe_id);
 
    const PartialAllocResult *slice_and_allocate_sc(
        const Allocation &empty_alloc, const PHV::SuperCluster *sc, PhvStatus phv_status,
        const ContainerGroupsBySize &container_groups, AllocatorMetrics &alloc_metrics,
        bool homogeneous_sizes = false, bool minimal_packing_slicing = true,
        const int max_slicings = 128, std::ostream *history = nullptr) const;
 
    bool allocate(const std::list<PHV::SuperCluster *> &clusters, AllocatorMetrics &alloc_metrics);
 
    bool can_be_allocated(const Allocation &empty_alloc, const PHV::SuperCluster *sc,
                          AllocatorMetrics &alloc_metrics, const int max_slicings = 128) const;
 
    struct PreSlicingResult {
        std::list<SuperCluster *> sliced;
        const SuperCluster *invalid = nullptr;
        ordered_map<SuperCluster *, KindSizeIndexedMap> baseline_cont_req;
    };
 
    PreSlicingResult pre_slice(const Allocation &empty_alloc, SuperCluster *sc,
                               AllocatorMetrics &alloc_metrics, const int n_max_slicing = 128,
                               bool baseline_mode = false) const;
};
 
}  // namespace v2
}  // namespace PHV
 
#endif /* BF_P4C_PHV_V2_TRIVIAL_ALLOCATOR_H_ */