rename congestion_acceptance_rate_trigger to congestion_rlim_trigger_ratio to be more consistent with what it actually does

Author: soheilshahrouz

vpr/src/base/SetupVPR.cpp

@@ -656,7 +656,7 @@ static void SetupPlacerOpts(const t_options& Options, t_placer_opts* PlacerOpts)
 
     PlacerOpts->timing_tradeoff = Options.PlaceTimingTradeoff;
     PlacerOpts->congestion_factor = Options.place_congestion_factor;
-    PlacerOpts->congestion_acceptance_rate_trigger = Options.place_congestion_acceptance_rate_trigger;
+    PlacerOpts->congestion_rlim_trigger_ratio = Options.place_congestion_rlim_trigger_ratio;
     PlacerOpts->congestion_chan_util_threshold = Options.place_congestion_chan_util_threshold;
 
     /* Depends on PlacerOpts->place_algorithm */

vpr/src/base/read_options.cpp

@@ -2494,7 +2494,7 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("0.0")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
-    place_timing_grp.add_argument(args.place_congestion_acceptance_rate_trigger, "--congestion_acceptance_rate_trigger")
+    place_timing_grp.add_argument(args.place_congestion_rlim_trigger_ratio, "--congestion_rlim_trigger_ratio")
         .help("To be written")
         .default_value("0.0")
         .show_in(argparse::ShowIn::HELP_ONLY);

vpr/src/base/read_options.h

@@ -188,7 +188,7 @@ struct t_options {
     /* Timing-driven placement options only */
     argparse::ArgValue<float> PlaceTimingTradeoff;
     argparse::ArgValue<float> place_congestion_factor;
-    argparse::ArgValue<float> place_congestion_acceptance_rate_trigger;
+    argparse::ArgValue<float> place_congestion_rlim_trigger_ratio;
     argparse::ArgValue<float> place_congestion_chan_util_threshold;
 
     argparse::ArgValue<int> RecomputeCritIter;

vpr/src/base/vpr_types.h

@@ -1014,7 +1014,7 @@ struct t_placer_opts {
     t_annealing_sched anneal_sched; ///<Placement option annealing schedule
     float timing_tradeoff;
     float congestion_factor;
-    float congestion_acceptance_rate_trigger;
+    float congestion_rlim_trigger_ratio;
     float congestion_chan_util_threshold;
     int place_chan_width;
     enum e_pad_loc_type pad_loc_type;

vpr/src/place/annealer.cpp

@@ -139,7 +139,7 @@ bool t_annealing_state::outer_loop_update(float success_rate,
     }
 
     // Automatically determine exit temperature.
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
     float t_exit = 0.005 * costs.cost / cluster_ctx.clb_nlist.nets().size();
 
     VTR_ASSERT_SAFE(placer_opts.anneal_sched.type == e_sched_type::AUTO_SCHED);
@@ -377,15 +377,13 @@ e_move_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
 
     MoveOutcomeStats move_outcome_stats;
 
-    /* I'm using negative values of proposed_net_cost as a flag,
-     * so DO NOT use cost functions that can go negative. */
-    double delta_c = 0.;        //Change in cost due to this swap.
-    double bb_delta_c = 0.;     //Change in the bounding box (wiring) cost.
-    double timing_delta_c = 0.; //Change in the timing cost (delay * criticality).
-    double congestion_delta_c = 0.;
+    double delta_c = 0.;            // Change in cost due to this swap.
+    double bb_delta_c = 0.;         // Change in the bounding box (wiring) cost.
+    double timing_delta_c = 0.;     // Change in the timing cost (delay * criticality).
+    double congestion_delta_c = 0.; // Change in the congestion cost
 
-    /* Allow some fraction of moves to not be restricted by rlim,
-     * in the hopes of better escaping local minima. */
+    // Allow some fraction of moves to not be restricted by rlim,
+    // in the hopes of better escaping local minima.
     float rlim;
     if (placer_opts_.rlim_escape_fraction > 0. && rng_.frand() < placer_opts_.rlim_escape_fraction) {
         rlim = std::numeric_limits<float>::infinity();
@@ -401,19 +399,19 @@ e_move_result PlacementAnnealer::try_swap_(MoveGenerator& move_generator,
         router_block_move = check_for_router_swap(noc_opts_.noc_swap_percentage, rng_);
     }
 
-    //When manual move toggle button is active, the manual move window asks the user for input.
+    // When manual move toggle button is active, the manual move window asks the user for input.
     if (manual_move_enabled) {
 #ifndef NO_GRAPHICS
         create_move_outcome = manual_move_display_and_propose(manual_move_generator_, blocks_affected_,
                                                               proposed_action.move_type, rlim,
                                                               placer_opts_, criticalities_);
-#endif //NO_GRAPHICS
+#endif // NO_GRAPHICS
     } else if (router_block_move) {
         // generate a move where two random router blocks are swapped
         create_move_outcome = propose_router_swap(blocks_affected_, rlim, blk_loc_registry, place_macros_, rng_);
         proposed_action.move_type = e_move_type::UNIFORM;
     } else {
-        //Generate a new move (perturbation) used to explore the space of possible placements
+        // Generate a new move (perturbation) used to explore the space of possible placements
         create_move_outcome = move_generator.propose_move(blocks_affected_, proposed_action, rlim, placer_opts_, criticalities_);
     }
 
@@ -681,7 +679,7 @@ void PlacementAnnealer::outer_loop_update_timing_info() {
     }
 
     if (congestion_modeling_started_
-        || (annealing_state_.rlim / MoveGenerator::first_rlim) < placer_opts_.congestion_acceptance_rate_trigger) {
+        || (annealing_state_.rlim / MoveGenerator::first_rlim) < placer_opts_.congestion_rlim_trigger_ratio) {
         costs_.congestion_cost = net_cost_handler_.estimate_routing_chan_util();
 
         if (!congestion_modeling_started_) {

vpr/src/place/net_cost_handler.cpp

@@ -1421,7 +1421,7 @@ double NetCostHandler::get_net_cube_cong_cost_(ClusterNetId net_id, bool use_ts)
     VTR_ASSERT_SAFE(congestion_modeling_started_);
     const auto [x_chan_util, y_chan_util] = use_ts ? ts_avg_chann_util_new_[net_id] : avg_chann_util_[net_id];
 
-    const t_bb& bb = use_ts ? ts_bb_coord_new_[net_id] : bb_coords_[net_id];
+    //    const t_bb& bb = use_ts ? ts_bb_coord_new_[net_id] : bb_coords_[net_id];
 
     //    int distance_x = bb.xmax - bb.xmin + 1;
     //    int distance_y = bb.ymax - bb.ymin + 1;
@@ -1802,6 +1802,7 @@ double NetCostHandler::estimate_routing_chan_util() {
         }
     }
 
+    // Channel width is computed only once and reused in later calls.
     if (chanx_width_.empty()) {
         VTR_ASSERT(chany_width_.empty());
         std::tie(chanx_width_, chany_width_) = calculate_channel_width();
@@ -1811,9 +1812,9 @@ double NetCostHandler::estimate_routing_chan_util() {
     VTR_ASSERT(chanx_util_.size() == chanx_width_.size());
     VTR_ASSERT(chany_util_.size() == chany_width_.size());
 
-    for (size_t layer = 0; layer < chanx_util_.dim_size(0); ++layer) {
-        for (size_t x = 0; x < chanx_util_.dim_size(1); ++x) {
-            for (size_t y = 0; y < chanx_util_.dim_size(2); ++y) {
+    for (size_t layer = 0; layer < num_layers; ++layer) {
+        for (size_t x = 0; x < grid_width; ++x) {
+            for (size_t y = 0; y < grid_height; ++y) {
                 if (chanx_width_[layer][x][y] > 0) {
                     chanx_util_[layer][x][y] /= chanx_width_[layer][x][y];
                 } else {

vpr/src/place/place_util.cpp

@@ -11,7 +11,7 @@
 #include "noc_place_utils.h"
 
 void t_placer_costs::update_norm_factors() {
-    const auto& clustered_nlist = g_vpr_ctx.clustering().clb_nlist;
+    const ClusteredNetlist& clustered_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     bb_cost_norm = 1 / bb_cost;
 
@@ -76,7 +76,7 @@ int get_place_inner_loop_num_move(const t_placer_opts& placer_opts, const t_anne
         move_lim = int(annealing_sched.inner_num * pow(device_size, 2. / 3.) * pow(num_blocks, 2. / 3.));
     }
 
-    /* Avoid having a non-positive move_lim */
+    // Avoid having a non-positive move_lim
     move_lim = std::max(move_lim, 1);
 
     return move_lim;