utils_v2.h

 
#ifndef BF_P4C_PHV_V2_UTILS_V2_H_
#define BF_P4C_PHV_V2_UTILS_V2_H_
 
#include <iterator>
#include <optional>
#include <ostream>
#include <sstream>
#include <vector>
 
#include "bf-p4c/phv/phv.h"
#include "bf-p4c/phv/phv_fields.h"
#include "bf-p4c/phv/utils/utils.h"
#include "bf-p4c/phv/v2/tx_score.h"
#include "bf-p4c/phv/v2/types.h"
#include "lib/cstring.h"
#include "lib/exceptions.h"
 
namespace PHV {
namespace v2 {
 
enum class ErrorCode {
    NOT_ENOUGH_SPACE,
    ACTION_CANNOT_BE_SYNTHESIZED,
    CONTAINER_TYPE_MISMATCH,
    CONTAINER_GRESS_MISMATCH,
    CONTAINER_PARSER_WRITE_MODE_MISMATCH,
    CONTAINER_PARSER_PACKING_INVALID,
    FIELD_MAX_CONTAINER_BYTES_EXCEEDED,
    ALIGNED_CLUSTER_NO_VALID_START,
    ALIGNED_CLUSTER_CANNOT_BE_ALLOCATED,
    NO_VALID_CONTAINER_SIZE,
    NO_VALID_SC_ALLOC_ALIGNMENT,
    WIDE_ARITH_ALLOC_FAILED,
    NO_SLICING_FOUND,
    INVALID_ALLOC_FOUND_BY_COPACKER,
    CANNOT_APPLY_REQUIRED_COPACK_HINTS,
};
 
cstring to_str(const ErrorCode &e);
 
struct AllocError {
    ErrorCode code;
    cstring msg;
    const std::vector<AllocSlice> *invalid_packing = nullptr;
    const ordered_set<const SuperCluster::SliceList *> *reslice_required = nullptr;
    explicit AllocError(ErrorCode code) : code(code), msg(cstring::empty) {}
    AllocError(ErrorCode code, cstring msg) : code(code), msg(msg) {}
    std::string str() const;
};
 
template <class T>
AllocError &operator<<(AllocError &e, const T &v) {
    std::stringstream ss;
    ss << v;
    e.msg += ss.str();
    return e;
}
 
std::ostream &operator<<(std::ostream &out, const AllocError &e);
 
struct AllocResult {
    const AllocError *err = nullptr;
    std::optional<PHV::Transaction> tx;
    explicit AllocResult(const AllocError *err) : err(err) {}
    explicit AllocResult(const Transaction &tx) : tx(tx) {}
    bool ok() const { return err == nullptr; }
    std::string err_str() const;
    std::string tx_str(cstring prefix = ""_cs) const;
    static std::string pretty_print_tx(const PHV::Transaction &tx, cstring prefix = cstring::empty);
    bool operator==(const AllocResult &other) const;
};
 
struct ScAllocAlignment {
    ordered_map<const AlignedCluster *, int> cluster_starts;
    std::optional<ScAllocAlignment> merge(const ScAllocAlignment &other) const;
    cstring pretty_print(cstring prefix, const SuperCluster *sc) const;
    bool ok(const AlignedCluster *aligned, int start) const {
        return !cluster_starts.count(aligned) || cluster_starts.at(aligned) == start;
    }
    bool empty() const { return cluster_starts.empty(); }
};
 
std::vector<ScAllocAlignment> make_sc_alloc_alignment(
    const SuperCluster *sc, const PHV::Size width, const int max_n,
    const std::list<const SuperCluster::SliceList *> *sl_order = nullptr);
 
struct SearchConfig {
    int n_dfs_steps_sc_alloc = 256;
 
    int n_best_of_sc_alloc = 1;
 
    bool stop_first_succ_empty_normal_container = false;
 
    bool try_byte_aligned_starts_first_for_table_keys = false;
};
 
class ScoreContext {
    const SuperCluster *sc_i = nullptr;
 
    const ContainerGroup *cont_group_i = nullptr;
 
    const std::vector<const SuperCluster::SliceList *> *alloc_order_i = {};
 
    const ScAllocAlignment *alloc_alignment_i = nullptr;
 
    const TxScoreMaker *score_i = nullptr;
 
    int t_i = 0;
 
    const SearchConfig *search_config_i = new SearchConfig();
 
    std::ostream *tracer = nullptr;
 
 private:
    static constexpr const char *tab_table[] = {
        "", " ", "  ", "   ", "    ", "     ", "      ", "       ", "        ",
    };
    static constexpr int max_log_level = sizeof(tab_table) / sizeof(tab_table[0]) - 1;
 
 public:
    ScoreContext() {}
 
    const SuperCluster *sc() const {
        BUG_CHECK(sc_i, "sc not added in ctx.");
        return sc_i;
    }
    ScoreContext with_sc(const SuperCluster *sc) const {
        auto cloned = *this;
        cloned.sc_i = sc;
        return cloned;
    }
 
    const ContainerGroup *cont_group() const {
        BUG_CHECK(cont_group_i, "container group not added in ctx.");
        return cont_group_i;
    }
    ScoreContext with_cont_group(const ContainerGroup *cont_group) const {
        auto cloned = *this;
        cloned.cont_group_i = cont_group;
        return cloned;
    }
 
    const std::vector<const SuperCluster::SliceList *> *alloc_order() const {
        BUG_CHECK(alloc_order_i, "sl alloc order not added in ctx.");
        return alloc_order_i;
    }
    ScoreContext with_alloc_order(const std::vector<const SuperCluster::SliceList *> *order) const {
        auto cloned = *this;
        cloned.alloc_order_i = order;
        return cloned;
    }
 
    const ScAllocAlignment *alloc_alignment() const {
        BUG_CHECK(alloc_alignment_i, "alloc alignment not added in ctx.");
        return alloc_alignment_i;
    }
    ScoreContext with_alloc_alignment(const ScAllocAlignment *alignment) const {
        auto cloned = *this;
        cloned.alloc_alignment_i = alignment;
        return cloned;
    }
 
    const TxScoreMaker *score() const {
        BUG_CHECK(score_i, "score not added in ctx.");
        return score_i;
    }
    ScoreContext with_score(const TxScoreMaker *score) const {
        auto cloned = *this;
        cloned.score_i = score;
        return cloned;
    }
 
    int t() const { return t_i; }
    std::string t_tabs() const { return tab_table[t_i]; }
    ScoreContext with_t(int t) const {
        if (t > max_log_level) t = max_log_level;
        auto cloned = *this;
        cloned.t_i = t;
        return cloned;
    }
 
    const SearchConfig *search_config() const { return search_config_i; }
    ScoreContext with_search_config(const SearchConfig *c) const {
        auto cloned = *this;
        cloned.search_config_i = c;
        return cloned;
    }
};
 
}  // namespace v2
}  // namespace PHV
 
#endif /* BF_P4C_PHV_V2_UTILS_V2_H_ */