FMBiGainCalc.hpp

Go to the documentation of this file.

 
#pragma once
 
// #include <cstddef>   // for byte
#include <cstdint>             // for uint8_t
#include <mywheel/dllist.hpp>  // for Dllink
#include <span>                // for span
#include <utility>             // for pair
#include <vector>              // for vector
 
#include "FMPmrConfig.hpp"
// #include "moveinfo.hpp"  // for MoveInfo
 
// forward declare
template <typename Gnl> class FMBiGainMgr;
template <typename Node> struct MoveInfo;
template <typename Node> struct MoveInfoV;
 
template <typename Gnl> class FMBiGainCalc {
    friend class FMBiGainMgr<Gnl>;
 
  public:
    using node_t = typename Gnl::node_t;
    using Item = Dllink<std::pair<node_t, uint32_t>>;
 
  private:
    const Gnl& hyprgraph;
    std::vector<Item> vertex_list;
    std::vector<int> init_gain_list;
    std::vector<int> delta_gain_buf;
    int total_cost{0};
    static constexpr size_t stack_buf_size = 32768;
    uint8_t stack_buf[stack_buf_size];
    FMPmr::monotonic_buffer_resource rsrc;
 
  public:
    int delta_gain_w{};
    FMPmr::vector<node_t> idx_vec;
    bool special_handle_2pin_nets{true};
 
    const auto& get_init_gain_list() const { return this->init_gain_list; }
 
    explicit FMBiGainCalc(const Gnl& hyprgraph, std::uint8_t /*num_parts*/)
        : hyprgraph{hyprgraph},
          vertex_list(hyprgraph.number_of_modules()),
          init_gain_list(hyprgraph.number_of_modules(), 0),
          rsrc(stack_buf, sizeof stack_buf),
          idx_vec(&rsrc) {
        for (const auto& v : this->hyprgraph) {
            this->vertex_list[v].data = std::make_pair(v, uint32_t(0));
        }
    }
 
    auto init(std::span<const std::uint8_t> part) -> int {
        this->total_cost = 0;
        for (auto& vlink : this->vertex_list) {
            vlink.data.second = 0U;
        }
        for (auto& elem : this->init_gain_list) {
            elem = 0;
        }
        for (const auto& net : this->hyprgraph.nets) {
            this->_init_gain(net, part);
        }
        return this->total_cost;
    }
 
    auto update_move_init() -> void {
        // nothing to do in 2-way partitioning
    }
 
    void init_idx_vec(const node_t& module, const node_t& net);
 
    auto update_move_2pin_net(std::span<const std::uint8_t> part, const MoveInfo<node_t>& move_info)
        -> node_t;
 
    auto update_move_3pin_net(std::span<const std::uint8_t> part, const MoveInfo<node_t>& move_info)
        -> std::span<const int>;
 
    auto update_move_general_net(std::span<const std::uint8_t> part,
                                 const MoveInfo<node_t>& move_info) -> std::span<const int>;
 
  private:
    auto _modify_gain(const node_t& w, int weight) -> void {
        // this->vertex_list[node_w].data.second += weight;
        this->init_gain_list[w] += weight;
    }
 
    auto _increase_gain(const node_t& w, uint32_t weight) -> void {
        // this->vertex_list[w].data.second += weight;
        this->init_gain_list[w] += weight;
    }
 
    auto _decrease_gain(const node_t& w, uint32_t weight) -> void {
        // this->vertex_list[w].data.second += weight;
        this->init_gain_list[w] -= weight;
    }
 
    auto _init_gain(const node_t& net, std::span<const std::uint8_t> part) -> void;
 
    auto _init_gain_2pin_net(const node_t& net, std::span<const std::uint8_t> part) -> void;
 
    auto _init_gain_3pin_net(const node_t& net, std::span<const std::uint8_t> part) -> void;
 
    auto _init_gain_general_net(const node_t& net, std::span<const std::uint8_t> part) -> void;
};