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


.. _program_listing_file_ckpttncpp_netlist.hpp:

Program Listing for File netlist.hpp
====================================

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

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

.. code-block:: cpp

   #pragma once
   
   // import networkx as nx
   // #include <algorithm>
   #include <gsl/span>
   #include <iterator>
   #include <py2cpp/py2cpp.hpp>
   #include <utility>
   #include <vector>
   #include <xnetwork/classes/graph.hpp>
   
   // using node_t = int;
   
   // struct PartInfo
   // {
   //     std::vector<std::uint8_t> part;
   //     py::set<node_t> extern_nets;
   // };
   
   template <typename graph_t>
   struct Netlist
   {
       using nodeview_t = typename graph_t::nodeview_t;
       using node_t = typename graph_t::node_t;
       using index_t = typename nodeview_t::key_type;
       // using graph_t = xn::Graph<graph_t>;
   
       graph_t G;
       nodeview_t modules;
       nodeview_t nets;
       size_t num_modules {};
       size_t num_nets {};
       size_t num_pads = 0U;
       size_t max_degree {};
       size_t max_net_degree {};
       // std::uint8_t cost_model = 0;
       std::vector<unsigned int> module_weight;
       bool has_fixed_modules {};
       py::set<node_t> module_fixed;
   
     public:
       Netlist(graph_t G, const nodeview_t& modules, const nodeview_t& nets);
   
       Netlist(graph_t G, uint32_t numModules, uint32_t numNets);
   
       auto begin() const
       {
           return this->modules.begin();
       }
   
       auto end() const
       {
           return this->modules.end();
       }
   
       [[nodiscard]] auto number_of_modules() const -> size_t
       {
           return this->num_modules;
       }
   
       [[nodiscard]] auto number_of_nets() const -> size_t
       {
           return this->num_nets;
       }
   
       [[nodiscard]] auto number_of_nodes() const -> size_t
       {
           return this->G.number_of_nodes();
       }
   
       // /*!
       //  * @brief
       //  *
       //  * @return index_t
       //  */
       // auto number_of_pins() const -> index_t { return
       // this->G.number_of_edges(); }
   
       [[nodiscard]] auto get_max_degree() const -> size_t
       {
           return this->max_degree;
       }
   
       [[nodiscard]] auto get_max_net_degree() const -> size_t
       {
           return this->max_net_degree;
       }
   
       auto get_module_weight(const node_t& v) const -> unsigned int
       {
           return this->module_weight.empty() ? 1U : this->module_weight[v];
       }
   
       auto get_net_weight(const node_t& /*net*/) const -> int
       {
           // return this->net_weight.is_empty() ? 1
           //                                 :
           //                                 this->net_weight[this->net_map[net]];
           return 1;
       }
   };
   
   template <typename graph_t>
   Netlist<graph_t>::Netlist(
       graph_t G, const nodeview_t& modules, const nodeview_t& nets)
       : G {std::move(G)}
       , modules {modules}
       , nets {nets}
       , num_modules(modules.size())
       , num_nets(nets.size())
   {
       this->has_fixed_modules = (!this->module_fixed.empty());
   
       // Some compilers does not accept py::range()->iterator as a forward
       // iterator auto deg_cmp = [this](const node_t& v, const node_t& w) ->
       // index_t {
       //     return this->G.degree(v) < this->G.degree(w);
       // };
       // const auto result1 =
       //     std::max_element(this->modules.begin(), this->modules.end(),
       //     deg_cmp);
       // this->max_degree = this->G.degree(*result1);
       // const auto result2 =
       //     std::max_element(this->nets.begin(), this->nets.end(), deg_cmp);
       // this->max_net_degree = this->G.degree(*result2);
   
       this->max_degree = 0U;
       for (const auto& v : this->modules)
       {
           if (this->max_degree < this->G.degree(v))
           {
               this->max_degree = this->G.degree(v);
           }
       }
   
       this->max_net_degree = 0U;
       for (const auto& net : this->nets)
       {
           if (this->max_net_degree < this->G.degree(net))
           {
               this->max_net_degree = this->G.degree(net);
           }
       }
   }
   
   template <typename graph_t>
   Netlist<graph_t>::Netlist(graph_t G, uint32_t numModules, uint32_t numNets)
       : Netlist {std::move(G), py::range(numModules),
             py::range(numModules, numModules + numNets)}
   {
   }
   
   // using RngIter = decltype(py::range(1));
   using graph_t = xn::SimpleGraph;
   using index_t = uint32_t;
   using SimpleNetlist = Netlist<graph_t>;
   
   template <typename Node>
   struct MoveInfo
   {
       Node net;
       Node v;
       std::uint8_t fromPart;
       std::uint8_t toPart;
   };
   
   template <typename Node>
   struct MoveInfoV
   {
       Node v;
       std::uint8_t fromPart;
       std::uint8_t toPart;
       // node_t v;
   };
   
   template <typename Node>
   struct Snapshot
   {
       py::set<Node> extern_nets;
       py::dict<index_t, std::uint8_t> extern_modules;
   };