add a private const t_placer_opts& placer_opts_ to NetCostHandler

Author: soheilshahrouz

vpr/src/place/move_transactions.h

@@ -30,7 +30,7 @@ struct t_pl_moved_block {
  * placement.                                                   *
  * Store the information on the blocks to be moved in a swap during     *
  * placement, in the form of array of structs instead of struct with    *
- * arrays for cache effifiency                                          *
+ * arrays for cache efficiency                                          *
  *
  * moved blocks: a list of moved blocks data structure with     *
  *               information on the move.                       *

vpr/src/place/net_cost_handler.cpp

@@ -129,9 +129,13 @@ static double wirelength_crossing_count(size_t fanout);
 /******************************* End of Function definitions ************************************/
 
 
-NetCostHandler::NetCostHandler(PlacerContext& placer_ctx, size_t num_nets, bool cube_bb, float place_cost_exp)
+NetCostHandler::NetCostHandler(const t_placer_opts& placer_opts,
+                               PlacerContext& placer_ctx,
+                               size_t num_nets,
+                               bool cube_bb)
     : cube_bb_(cube_bb)
-    , placer_ctx_(placer_ctx) {
+    , placer_ctx_(placer_ctx)
+    , placer_opts_(placer_opts) {
     const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
 
     // Either 3D BB or per layer BB data structure are used, not both.
@@ -159,7 +163,7 @@ NetCostHandler::NetCostHandler(PlacerContext& placer_ctx, size_t num_nets, bool
      * been recomputed. */
     bb_update_status_.resize(num_nets, NetUpdateState::NOT_UPDATED_YET);
 
-    alloc_and_load_chan_w_factors_for_place_cost_(place_cost_exp);
+    alloc_and_load_chan_w_factors_for_place_cost_(placer_opts_.place_cost_exp);
 }
 
 void NetCostHandler::alloc_and_load_chan_w_factors_for_place_cost_(float place_cost_exp) {
@@ -1500,24 +1504,20 @@ double NetCostHandler::get_net_cost_(ClusterNetId net_id, const t_bb& bb) {
 double NetCostHandler::get_net_layer_bb_wire_cost_(ClusterNetId /* net_id */,
                                                    const std::vector<t_2D_bb>& bb,
                                                    const vtr::NdMatrixProxy<int, 1> layer_pin_sink_count) {
-    /* Finds the cost due to one net by looking at its coordinate bounding  *
-     * box.                                                                 */
+    // Finds the cost due to one net by looking at its coordinate bounding box.
 
     double ncost = 0.;
-    double crossing = 0.;
     int num_layers = g_vpr_ctx.device().grid.get_num_layers();
 
     for (int layer_num = 0; layer_num < num_layers; layer_num++) {
         VTR_ASSERT(layer_pin_sink_count[layer_num] != OPEN);
         if (layer_pin_sink_count[layer_num] == 0) {
             continue;
         }
-        /*
-        adjust the bounding box half perimeter by the wirelength correction
-        factor based on terminal count, which is 1 for the source + the number
-        of sinks on this layer.
-        */
-        crossing = wirelength_crossing_count(layer_pin_sink_count[layer_num] + 1);
+        /* Adjust the bounding box half perimeter by the wirelength correction
+         * factor based on terminal count, which is 1 for the source + the number
+         * of sinks on this layer. */
+        double crossing = wirelength_crossing_count(layer_pin_sink_count[layer_num] + 1);
 
         /* Could insert a check for xmin == xmax.  In that case, assume  *
          * connection will be made with no bends and hence no x-cost.    *
@@ -1533,7 +1533,7 @@ double NetCostHandler::get_net_layer_bb_wire_cost_(ClusterNetId /* net_id */,
                  * chany_place_cost_fac_[bb[layer_num].xmax][bb[layer_num].xmin - 1];
     }
 
-    return (ncost);
+    return ncost;
 }
 
 static double get_net_wirelength_estimate(ClusterNetId net_id, const t_bb& bb) {
@@ -1562,15 +1562,14 @@ static double get_net_wirelength_from_layer_bb(ClusterNetId /* net_id */,
      * its coordinate bounding box.                                         */
 
     double ncost = 0.;
-    double crossing = 0.;
-    int num_layers = g_vpr_ctx.device().grid.get_num_layers();
+    const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
 
     for (int layer_num = 0; layer_num < num_layers; layer_num++) {
         VTR_ASSERT_SAFE(layer_pin_sink_count[layer_num] != OPEN);
         if (layer_pin_sink_count[layer_num] == 0) {
             continue;
         }
-        crossing = wirelength_crossing_count(layer_pin_sink_count[layer_num] + 1);
+        double crossing = wirelength_crossing_count(layer_pin_sink_count[layer_num] + 1);
 
         /* Could insert a check for xmin == xmax.  In that case, assume  *
          * connection will be made with no bends and hence no x-cost.    *
@@ -1580,11 +1579,10 @@ static double get_net_wirelength_from_layer_bb(ClusterNetId /* net_id */,
          * channel capacity.   Do this for x, then y direction and add.  */
 
         ncost += (bb[layer_num].xmax - bb[layer_num].xmin + 1) * crossing;
-
         ncost += (bb[layer_num].ymax - bb[layer_num].ymin + 1) * crossing;
     }
 
-    return (ncost);
+    return ncost;
 }
 
 double NetCostHandler::recompute_bb_cost_() {
@@ -1636,10 +1634,9 @@ void NetCostHandler::find_affected_nets_and_update_costs(const t_place_algorithm
     ts_nets_to_update_.resize(0);
 
     /* Go through all the blocks moved. */
-    for (const auto& block : blocks_affected.moved_blocks) {
-        const auto& moving_block_inf = block;
+    for (const t_pl_moved_block& moving_block : blocks_affected.moved_blocks) {
         auto& affected_pins = blocks_affected.affected_pins;
-        ClusterBlockId blk = block.block_num;
+        ClusterBlockId blk = moving_block.block_num;
 
         /* Go through all the pins in the moved block. */
         for (ClusterPinId blk_pin : clb_nlist.block_pins(blk)) {
@@ -1653,7 +1650,7 @@ void NetCostHandler::find_affected_nets_and_update_costs(const t_place_algorithm
                                          criticalities,
                                          blk,
                                          blk_pin,
-                                         moving_block_inf,
+                                         moving_block,
                                          affected_pins,
                                          timing_delta_c,
                                          is_src_moving);

vpr/src/place/net_cost_handler.h

@@ -44,7 +44,7 @@ class NetCostHandler {
      * @param cube_bb True if the 3D bounding box should be used, false otherwise.
      * @param place_cost_exp It is an exponent to which you take the average inverse channel
      */
-    NetCostHandler(PlacerContext& placer_ctx, size_t num_nets, bool cube_bb, float place_cost_exp);
+    NetCostHandler(const t_placer_opts& placer_opts, PlacerContext& placer_ctx, size_t num_nets, bool cube_bb);
 
     /**
      * @brief Finds the bb cost from scratch.
@@ -120,6 +120,7 @@ class NetCostHandler {
   private:
     bool cube_bb_ = false;
     PlacerContext& placer_ctx_;
+    const t_placer_opts& placer_opts_;
 
     std::function<double(e_cost_methods method)> comp_bb_cost_functor_;
 

vpr/src/place/place.cpp

@@ -1912,7 +1912,7 @@ static NetCostHandler alloc_and_load_placement_structs(const t_placer_opts& plac
 
     place_ctx.compressed_block_grids = create_compressed_block_grids();
 
-    return {placer_ctx, num_nets, place_ctx.cube_bb, placer_opts.place_cost_exp};
+    return {placer_opts, placer_ctx, num_nets, place_ctx.cube_bb};
 }
 
 /* Frees the major structures needed by the placer (and not needed       *