FMKWayGainCalc.hpp

Go to the documentation of this file.

 
#pragma once
 
// #include <algorithm>   // for fill
#include <cstdint>             // for uint8_t
#include <mywheel/dllist.hpp>  // for Dllink
#include <mywheel/robin.hpp>   // for fun::Robin<>...
#include <span>                // for span
#include <utility>             // for pair
#include <vector>              // for vector
 
#include "FMPmrConfig.hpp"  // for FMPmr::monotonic_buffer_resource, FMPmr::vector
 
// forward declare
template <typename Gnl> class FMKWayGainMgr;
template <typename Node> struct MoveInfo;
template <typename Node> struct MoveInfoV;
 
template <typename Gnl> class FMKWayGainCalc {
    friend class FMKWayGainMgr<Gnl>;
    using node_t = typename Gnl::node_t;
    using Item = Dllink<std::pair<node_t, uint32_t>>;
 
  private:
    const Gnl& hyprgraph;
    std::uint8_t num_parts;
    fun::Robin<std::uint8_t> rr;
    // size_t num_modules;
    int total_cost{0};
    static constexpr size_t stack_buf_size = 65536;
    uint8_t stack_buf[stack_buf_size];
    FMPmr::monotonic_buffer_resource rsrc;
    std::vector<std::vector<Item>> vertex_list{};
    std::vector<std::vector<int>> init_gain_list;
    FMPmr::vector<int> delta_gain_v;
 
  public:
    FMPmr::vector<int> delta_gain_w;
    FMPmr::vector<node_t> idx_vec;
    bool special_handle_2pin_nets{true};  // @TODO should be template parameter
 
    FMKWayGainCalc(const Gnl& hyprgraph, std::uint8_t num_parts)
        : hyprgraph{hyprgraph},
          num_parts{num_parts},
          rr{num_parts},
          rsrc(stack_buf, sizeof stack_buf),
          init_gain_list(num_parts, std::vector<int>(hyprgraph.number_of_modules(), 0)),
          delta_gain_v(num_parts, 0, &rsrc),
          delta_gain_w(num_parts, 0, &rsrc),
          idx_vec(&rsrc) {
        for (auto part_idx = 0U; part_idx != this->num_parts; ++part_idx) {
            auto vec = std::vector<Item>{};
            vec.reserve(hyprgraph.number_of_modules());
            for (const auto& v : this->hyprgraph) {
                vec.emplace_back(Item(std::make_pair(v, 0)));
            }
            this->vertex_list.emplace_back(std::move(vec));
        }
    }
 
    auto init(std::span<const std::uint8_t> part) -> int {
        this->total_cost = 0;
        for (auto& vec : this->vertex_list) {
            for (auto& vlink : vec) {
                vlink.data.second = 0U;
            }
        }
        for (auto& vec : this->init_gain_list) {
            for (auto& elem : vec) {
                elem = 0;
            }
        }
        for (const auto& net : this->hyprgraph.nets) {
            this->_init_gain(net, part);
        }
        return this->total_cost;
    }
 
    auto update_move_init() -> void;
 
    auto update_move_2pin_net(std::span<const std::uint8_t> part, const MoveInfo<node_t>& move_info)
        -> node_t;
 
    void init_idx_vec(const node_t& v, const node_t& net);
 
    using ret_info = std::vector<std::vector<int>>;
 
    auto update_move_3pin_net(std::span<const std::uint8_t> part, const MoveInfo<node_t>& move_info)
        -> ret_info;
 
    auto update_move_general_net(std::span<const std::uint8_t> part,
                                 const MoveInfo<node_t>& move_info) -> ret_info;
 
  private:
    auto _modify_gain(const node_t& v, std::uint8_t part_v, int weight) -> void {
        for (const auto& k : this->rr.exclude(part_v)) {
            // this->vertex_list[k][v].data.second += weight;
            this->init_gain_list[k][v] += weight;
        }
    }
 
    auto _increase_gain(const node_t& v, std::uint8_t part_v, uint32_t weight) -> void {
        for (const auto& k : this->rr.exclude(part_v)) {
            // this->vertex_list[k][v].data.second += weight;
            this->init_gain_list[k][v] += weight;
        }
    }
 
    auto _decrease_gain(const node_t& v, std::uint8_t part_v, uint32_t weight) -> void {
        for (const auto& k : this->rr.exclude(part_v)) {
            // this->vertex_list[k][v].data.second += weight;
            this->init_gain_list[k][v] -= 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;
};