:github_url: https://github.com/svenevs/exhale-companion


.. _program_listing_file_ckpttncpp_FMKWayGainCalc.hpp:

Program Listing for File FMKWayGainCalc.hpp
===========================================

|exhale_lsh| :ref:`Return to documentation for file <file_ckpttncpp_FMKWayGainCalc.hpp>` (``ckpttncpp/FMKWayGainCalc.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include "FMPmrConfig.hpp"
   #include "dllist.hpp"  // import dllink
   #include "netlist.hpp" // import Netlist
   #include "robin.hpp"   // import robin
   #include <gsl/span>
   
   // class FMKWayGainMgr;
   
   class FMKWayGainCalc
   {
       friend class FMKWayGainMgr;
       using node_t = typename SimpleNetlist::node_t;
       using Item = dllink<std::pair<node_t, uint32_t>>;
   
     private:
       const SimpleNetlist& H;
       std::uint8_t K;
       robin<std::uint8_t> RR;
       // size_t num_modules;
       int totalcost {0};
       std::byte StackBuf[20000];
       FMPmr::monotonic_buffer_resource rsrc;
       std::vector<std::vector<Item>> vertex_list;
       FMPmr::vector<int> deltaGainV;
   
     public:
       FMPmr::vector<int> deltaGainW;
       FMPmr::vector<node_t> IdVec;
       bool special_handle_2pin_nets {true}; // @TODO should be template parameter
   
       FMKWayGainCalc(const SimpleNetlist& H, std::uint8_t K)
           : H {H}
           , K {K}
           , RR {K}
           , rsrc(StackBuf, sizeof StackBuf)
           , vertex_list {}
           , deltaGainV(K, 0, &rsrc)
           , deltaGainW(K, 0, &rsrc)
           , IdVec(&rsrc)
       {
           for (auto k = 0U; k != this->K; ++k)
           {
               auto vec = std::vector<Item>{};
               vec.reserve(H.number_of_modules());
               for (const auto& v : this->H)
               {
                   vec.emplace_back(Item(std::pair {v, uint32_t(0)}));
               }
               this->vertex_list.emplace_back(std::move(vec));
           }
       }
   
       // /*!
       //  * @brief
       //  *
       //  * @param[in] toPart
       //  * @return dllink*
       //  */
       // auto start_ptr(uint8_t toPart) -> dllink<std::pair<node_t, int32_t>>*
       // {
       //     return &this->vertex_list[toPart][0];
       // }
   
       auto init(gsl::span<const std::uint8_t> part) -> int
       {
           this->totalcost = 0;
           for (auto& vec : this->vertex_list)
           {
               for (auto& vlink : vec)
               {
                   vlink.data.second = 0U;
               }
           }
           for (const auto& net : this->H.nets)
           {
               this->_init_gain(net, part);
           }
           return this->totalcost;
       }
   
       auto update_move_init() -> void
       {
           std::fill(this->deltaGainV.begin(), this->deltaGainV.end(), 0);
       }
   
       auto update_move_2pin_net(gsl::span<const std::uint8_t> part,
           const MoveInfo<node_t>& move_info) -> node_t;
   
       void init_IdVec(const node_t& v, const node_t& net);
   
       using ret_info = std::vector<std::vector<int>>;
   
       auto update_move_3pin_net(gsl::span<const std::uint8_t> part,
           const MoveInfo<node_t>& move_info) -> ret_info;
   
       auto update_move_general_net(gsl::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, unsigned int weight) -> void
       {
           for (const auto& k : this->RR.exclude(part_v))
           {
               this->vertex_list[k][v].data.second += weight;
           }
       }
   
       template <typename... Ts>
       auto _modify_vertex_va(unsigned int weight, std::uint8_t k, Ts... v) -> void
       {
           ((this->vertex_list[k][v].data.second += weight), ...);
       }
   
       // /**
       //  * @brief
       //  *
       //  * @tparam Ts
       //  * @param weight
       //  * @param part_v
       //  * @param v
       //  */
       // auto _modify_vertex_va(unsigned int weight, std::uint8_t k, const node_t& v1) ->
       // void
       // {
       //     this->vertex_list[k][v1].data.second += weight;
       // }
   
       // /**
       //  * @brief
       //  *
       //  * @tparam Ts
       //  * @param weight
       //  * @param part_v
       //  * @param v
       //  */
       // auto _modify_vertex_va(
       //     unsigned int weight, std::uint8_t k, const node_t& v1, const node_t& v2) ->
       //     void
       // {
       //     this->vertex_list[k][v1].data.second += weight;
       //     this->vertex_list[k][v2].data.second += weight;
       // }
   
       // /**
       //  * @brief
       //  *
       //  * @tparam Ts
       //  * @param weight
       //  * @param part_v
       //  * @param v
       //  */
       // auto _modify_vertex_va(unsigned int weight, std::uint8_t k, const node_t& v1,
       //     const node_t& v2, const node_t& v3) -> void
       // {
       //     this->vertex_list[k][v1].data.second += weight;
       //     this->vertex_list[k][v2].data.second += weight;
       //     this->vertex_list[k][v3].data.second += weight;
       // }
   
       template <typename... Ts>
       auto _modify_gain_va(unsigned int weight, std::uint8_t part_v, Ts... v) -> void
       {
           for (const auto& k : this->RR.exclude(part_v))
           {
               _modify_vertex_va(weight, k, v...);
           }
       }
   
       auto _init_gain(const node_t& net, gsl::span<const std::uint8_t> part)
           -> void;
   
       auto _init_gain_2pin_net(
           const node_t& net, gsl::span<const std::uint8_t> part) -> void;
   
       auto _init_gain_3pin_net(
           const node_t& net, gsl::span<const std::uint8_t> part) -> void;
   
       auto _init_gain_general_net(
           const node_t& net, gsl::span<const std::uint8_t> part) -> void;
   };