std::ranges + declaratio and assignment, const ref

Author: soheilshahrouz

vpr/src/place/annealer.cpp

@@ -76,9 +76,9 @@ static float analyze_setup_slack_cost(const PlacerSetupSlacks* setup_slacks,
         proposed_setup_slacks.push_back(setup_slacks->setup_slack(net_id, ipin));
     }
 
-    //Sort in ascending order, from the worse slack value to the best
-    std::stable_sort(original_setup_slacks.begin(), original_setup_slacks.end());
-    std::stable_sort(proposed_setup_slacks.begin(), proposed_setup_slacks.end());
+    // Sort in ascending order, from the worse slack value to the best
+    std::ranges::stable_sort(original_setup_slacks);
+    std::ranges::stable_sort(proposed_setup_slacks);
 
     //Check the first pair of slack values that are different
     //If found, return their difference

vpr/src/place/compressed_grid.cpp

@@ -111,11 +111,11 @@ static t_compressed_block_grid create_compressed_block_grid(const std::vector<st
             }
 
             //Uniquify x/y locations
-            std::stable_sort(layer_x_locs.begin(), layer_x_locs.end());
-            layer_x_locs.erase(unique(layer_x_locs.begin(), layer_x_locs.end()), layer_x_locs.end());
+            std::ranges::stable_sort(layer_x_locs);
+            layer_x_locs.erase(std::ranges::unique(layer_x_locs).begin(), layer_x_locs.end());
 
-            std::stable_sort(layer_y_locs.begin(), layer_y_locs.end());
-            layer_y_locs.erase(unique(layer_y_locs.begin(), layer_y_locs.end()), layer_y_locs.end());
+            std::ranges::stable_sort(layer_y_locs);
+            layer_y_locs.erase(std::ranges::unique(layer_y_locs).begin(), layer_y_locs.end());
 
             //The index of an x-position in x_locs corresponds to it's compressed
             //x-coordinate (similarly for y)
@@ -150,10 +150,10 @@ static t_compressed_block_grid create_compressed_block_grid(const std::vector<st
         //it efficient to find the non-empty blocks in the y dimension
         for (auto point : locations[layer_num]) {
             //Determine the compressed indices in the x & y dimensions
-            auto x_itr = std::lower_bound(layer_compressed_x_locs.begin(), layer_compressed_x_locs.end(), point.x());
+            auto x_itr = std::ranges::lower_bound(layer_compressed_x_locs, point.x());
             int cx = std::distance(layer_compressed_x_locs.begin(), x_itr);
 
-            auto y_itr = std::lower_bound(layer_compressed_y_locs.begin(), layer_compressed_y_locs.end(), point.y());
+            auto y_itr = std::ranges::lower_bound(layer_compressed_y_locs, point.y());
             int cy = std::distance(layer_compressed_y_locs.begin(), y_itr);
 
             VTR_ASSERT(cx >= 0 && cx < (int)layer_compressed_x_locs.size());
@@ -173,8 +173,7 @@ static t_compressed_block_grid create_compressed_block_grid(const std::vector<st
 
 /*Print the contents of the compressed grids to an echo file*/
 void echo_compressed_grids(const char* filename, const std::vector<t_compressed_block_grid>& comp_grids) {
-    FILE* fp;
-    fp = vtr::fopen(filename, "w");
+    FILE* fp = vtr::fopen(filename, "w");
 
     auto& device_ctx = g_vpr_ctx.device();
     int num_layers = device_ctx.grid.get_num_layers();

vpr/src/place/compressed_grid.h

@@ -45,11 +45,11 @@ struct t_compressed_block_grid {
         int cy = UNDEFINED;
         int layer_num = grid_loc.layer_num;
 
-        auto itr_x = std::lower_bound(compressed_to_grid_x[layer_num].begin(), compressed_to_grid_x[layer_num].end(), grid_loc.x);
+        auto itr_x = std::ranges::lower_bound(compressed_to_grid_x[layer_num], grid_loc.x);
         VTR_ASSERT(*itr_x == grid_loc.x);
         cx = std::distance(compressed_to_grid_x[layer_num].begin(), itr_x);
 
-        auto itr_y = std::lower_bound(compressed_to_grid_y[layer_num].begin(), compressed_to_grid_y[layer_num].end(), grid_loc.y);
+        auto itr_y = std::ranges::lower_bound(compressed_to_grid_y[layer_num], grid_loc.y);
         VTR_ASSERT(*itr_y == grid_loc.y);
         cy = std::distance(compressed_to_grid_y[layer_num].begin(), itr_y);
 
@@ -69,7 +69,7 @@ struct t_compressed_block_grid {
     inline t_physical_tile_loc grid_loc_to_compressed_loc_approx_round_up(t_physical_tile_loc grid_loc) const {
         auto find_compressed_index = [](const std::vector<int>& compressed, int value) -> int {
             // Get the first element that is not less than the value
-            auto itr = std::lower_bound(compressed.begin(), compressed.end(), value);
+            auto itr = std::ranges::lower_bound(compressed, value);
             if (itr == compressed.end()) {
                 // If all the compressed locations are less than the grid location, return the last compressed location
                 return compressed.size() - 1;
@@ -99,7 +99,7 @@ struct t_compressed_block_grid {
     inline t_physical_tile_loc grid_loc_to_compressed_loc_approx_round_down(t_physical_tile_loc grid_loc) const {
         auto find_compressed_index = [](const std::vector<int>& compressed, int value) -> int {
             // Get the first element that is strictly bigger than the value
-            auto itr = std::upper_bound(compressed.begin(), compressed.end(), value);
+            auto itr = std::ranges::upper_bound(compressed, value);
             if (itr == compressed.begin()) {
                 // If all the compressed locations are bigger than the grid location, return the first compressed location
                 return 0;
@@ -135,7 +135,7 @@ struct t_compressed_block_grid {
             }
 
             // Find the first element not less than loc
-            auto itr = std::lower_bound(compressed_grid_dim.begin(), compressed_grid_dim.end(), loc);
+            auto itr = std::ranges::lower_bound(compressed_grid_dim, loc);
 
             if (itr == compressed_grid_dim.begin()) {
                 // If all the compressed locations are bigger that or equal to loc, return the first compressed location

vpr/src/place/delay_model/compute_delta_delays_utils.cpp

@@ -215,7 +215,7 @@ static vtr::NdMatrix<float, 4> compute_delta_delays(RouterDelayProfiler& route_p
 
                     if (type != device_ctx.EMPTY_PHYSICAL_TILE_TYPE) {
                         // check if the tile type is among the allowed types
-                        if (!allowed_types.empty() && allowed_types.find(type->name) == allowed_types.end()) {
+                        if (!allowed_types.empty() && !allowed_types.contains(type->name)) {
                             continue;
                         }
                         src_type = type;
@@ -250,7 +250,7 @@ static vtr::NdMatrix<float, 4> compute_delta_delays(RouterDelayProfiler& route_p
 
                     if (type != device_ctx.EMPTY_PHYSICAL_TILE_TYPE) {
                         // check if the tile type is among the allowed types
-                        if (!allowed_types.empty() && allowed_types.find(type->name) == allowed_types.end()) {
+                        if (!allowed_types.empty() && !allowed_types.contains(type->name)) {
                             continue;
                         }
                         src_type = type;
@@ -441,7 +441,7 @@ static void generic_compute_matrix_iterative_astar(RouterDelayProfiler& route_pr
             bool src_or_target_empty = (src_type == device_ctx.EMPTY_PHYSICAL_TILE_TYPE
                                         || sink_type == device_ctx.EMPTY_PHYSICAL_TILE_TYPE);
 
-            bool is_allowed_type = allowed_types.empty() || allowed_types.find(src_type->name) != allowed_types.end();
+            bool is_allowed_type = allowed_types.empty() || allowed_types.contains(src_type->name);
 
             if (src_or_target_empty || !is_allowed_type) {
                 if (matrix[delta_x][delta_y].empty()) {
@@ -503,7 +503,7 @@ static void generic_compute_matrix_dijkstra_expansion(RouterDelayProfiler& /*rou
     const auto& device_ctx = g_vpr_ctx.device();
 
     t_physical_tile_type_ptr src_type = device_ctx.grid.get_physical_type({source_x, source_y, from_layer_num});
-    bool is_allowed_type = allowed_types.empty() || allowed_types.find(src_type->name) != allowed_types.end();
+    bool is_allowed_type = allowed_types.empty() || allowed_types.contains(src_type->name);
     if (src_type == device_ctx.EMPTY_PHYSICAL_TILE_TYPE || !is_allowed_type) {
         for (int sink_x = start_x; sink_x <= end_x; sink_x++) {
             for (int sink_y = start_y; sink_y <= end_y; sink_y++) {
@@ -703,13 +703,13 @@ static float delay_reduce(std::vector<float>& delays, e_reducer reducer) {
     float delay;
 
     if (reducer == e_reducer::MIN) {
-        auto itr = std::min_element(delays.begin(), delays.end());
+        auto itr = std::ranges::min_element(delays);
         delay = *itr;
     } else if (reducer == e_reducer::MAX) {
-        auto itr = std::max_element(delays.begin(), delays.end());
+        auto itr = std::ranges::max_element(delays);
         delay = *itr;
     } else if (reducer == e_reducer::MEDIAN) {
-        std::sort(delays.begin(), delays.end());
+        std::ranges::sort(delays);
         delay = vtr::median_presorted<float>(delays.begin(), delays.end());
     } else if (reducer == e_reducer::ARITHMEAN) {
         delay = vtr::arithmean(delays.begin(), delays.end());
@@ -945,7 +945,7 @@ std::vector<int> get_best_classes(enum e_pin_type pintype, t_physical_tile_type_
                 int pin = type->class_inf[i].pinlist[ipin];
                 //If the pin isn't ignored, and has a non-zero Fc to some general
                 //routing the class is suitable for delay profiling
-                if (!type->is_ignored_pin[pin] && non_zero_fc_pins.count(pin)) {
+                if (!type->is_ignored_pin[pin] && non_zero_fc_pins.contains(pin)) {
                     any_pins_connect_to_general_routing = true;
                     break;
                 }
@@ -964,7 +964,7 @@ std::vector<int> get_best_classes(enum e_pin_type pintype, t_physical_tile_type_
         return type->class_inf[lhs].num_pins > type->class_inf[rhs].num_pins;
     };
 
-    std::stable_sort(best_classes.begin(), best_classes.end(), cmp_class);
+    std::ranges::stable_sort(best_classes, cmp_class);
 
     return best_classes;
 }

vpr/src/place/delay_model/override_delay_model.cpp

@@ -75,9 +75,8 @@ void OverrideDelayModel::compute_override_delay_model_(RouterDelayProfiler& rout
             int to_pin_class = to_type->find_pin_class(to_port.port_name(), to_port.port_low_index() + iconn, e_pin_type::RECEIVER);
             VTR_ASSERT(to_pin_class != UNDEFINED);
 
-            bool found_sample_points;
             RRNodeId src_rr, sink_rr;
-            found_sample_points = find_direct_connect_sample_locations(direct, from_type, from_pin, from_pin_class, to_type, to_pin, to_pin_class, src_rr, sink_rr);
+            bool found_sample_points = find_direct_connect_sample_locations(direct, from_type, from_pin, from_pin_class, to_type, to_pin, to_pin_class, src_rr, sink_rr);
 
             if (!found_sample_points) {
                 ++missing_instances;
@@ -86,7 +85,7 @@ void OverrideDelayModel::compute_override_delay_model_(RouterDelayProfiler& rout
 
             //If some of the source/sink ports are logically equivalent we may have already
             //sampled the associated source/sink pair and don't need to do so again
-            if (sampled_rr_pairs.count({src_rr, sink_rr})) continue;
+            if (sampled_rr_pairs.contains({src_rr, sink_rr})) continue;
 
             float direct_connect_delay = std::numeric_limits<float>::quiet_NaN();
             bool found_routing_path = route_profiler.calculate_delay(src_rr, sink_rr, router_opts2, &direct_connect_delay);

vpr/src/place/move_transactions.cpp

@@ -46,7 +46,7 @@ e_block_move_result t_pl_blocks_to_be_moved::record_block_move(ClusterBlockId bl
 }
 
 //Examines the currently proposed move and determine any empty locations
-std::set<t_pl_loc> t_pl_blocks_to_be_moved::determine_locations_emptied_by_move() {
+std::set<t_pl_loc> t_pl_blocks_to_be_moved::determine_locations_emptied_by_move() const {
     std::set<t_pl_loc> moved_from_set;
     std::set<t_pl_loc> moved_to_set;
 

vpr/src/place/move_transactions.h

@@ -83,7 +83,7 @@ struct t_pl_blocks_to_be_moved {
                                           t_pl_loc to,
                                           const BlkLocRegistry& blk_loc_registry);
 
-    std::set<t_pl_loc> determine_locations_emptied_by_move();
+    std::set<t_pl_loc> determine_locations_emptied_by_move() const;
 
     std::vector<t_pl_moved_block> moved_blocks;
     std::unordered_set<t_pl_loc> moved_from;

vpr/src/place/move_utils.cpp

@@ -26,7 +26,6 @@ static bool f_placer_breakpoint_reached = false;
  * @param to_layer_num The layer that the block is moving to
  * @param is_range_fixed Whether the search range is fixed (e.g., in case of placement constraints)
  * @param search_range The search range to adjust
- * 
  */
 static void adjust_search_range(t_logical_block_type_ptr block_type,
                                 const int compressed_column_num,
@@ -405,7 +404,7 @@ e_block_move_result identify_macro_self_swap_affected_macros(std::vector<int>& m
         int imacro_to = place_macros.get_imacro_from_iblk(blk_to);
 
         if (imacro_to != -1) {
-            auto itr = std::find(macros.begin(), macros.end(), imacro_to);
+            auto itr = std::ranges::find(macros, imacro_to);
             if (itr == macros.end()) {
                 macros.push_back(imacro_to);
                 outcome = identify_macro_self_swap_affected_macros(macros, imacro_to, swap_offset, blk_loc_registry, place_macros, move_abortion_logger);
@@ -432,7 +431,7 @@ e_block_move_result record_macro_self_swaps(t_pl_blocks_to_be_moved& blocks_affe
     }
 
     //Remove any duplicate macros
-    affected_macros.resize(std::distance(affected_macros.begin(), std::unique(affected_macros.begin(), affected_macros.end())));
+    affected_macros.resize(std::distance(affected_macros.begin(), std::ranges::unique(affected_macros).begin()));
 
     std::vector<ClusterBlockId> displaced_blocks;
 
@@ -448,14 +447,14 @@ e_block_move_result record_macro_self_swaps(t_pl_blocks_to_be_moved& blocks_affe
     auto is_non_macro_block = [&](ClusterBlockId blk) {
         int imacro_blk = place_macros.get_imacro_from_iblk(blk);
 
-        if (std::find(affected_macros.begin(), affected_macros.end(), imacro_blk) != affected_macros.end()) {
+        if (std::ranges::find(affected_macros, imacro_blk) != affected_macros.end()) {
             return false;
         }
         return true;
     };
 
     std::vector<ClusterBlockId> non_macro_displaced_blocks;
-    std::copy_if(displaced_blocks.begin(), displaced_blocks.end(), std::back_inserter(non_macro_displaced_blocks), is_non_macro_block);
+    std::ranges::copy_if(displaced_blocks, std::back_inserter(non_macro_displaced_blocks), is_non_macro_block);
 
     //Based on the currently queued block moves, find the empty 'holes' left behind
     auto empty_locs = blocks_affected.determine_locations_emptied_by_move();
@@ -863,7 +862,6 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
     }
 
     //Determine the valid compressed grid location ranges
-    int delta_cx;
     t_bb search_range;
 
     // If we are early in the anneal and the range limit still big enough --> search around the center location that the move proposed
@@ -878,7 +876,7 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
                                                                 compressed_loc_on_layer,
                                                                 std::min<float>(range_limiters.original_rlim, range_limiters.dm_rlim));
     }
-    delta_cx = search_range.xmax - search_range.xmin;
+    int delta_cx = search_range.xmax - search_range.xmin;
 
     bool block_constrained = is_cluster_constrained(b_from);
 
@@ -1141,7 +1139,6 @@ t_bb get_compressed_grid_bounded_search_range(const t_compressed_block_grid& com
                                               const t_physical_tile_loc& from_compressed_loc,
                                               const t_physical_tile_loc& target_compressed_loc,
                                               float rlim) {
-    t_bb search_range;
 
     int min_cx, max_cx, min_cy, max_cy;
 
@@ -1174,7 +1171,7 @@ t_bb get_compressed_grid_bounded_search_range(const t_compressed_block_grid& com
         max_cy = std::min<int>(compressed_block_grid.get_num_rows(layer_num) - 1, cy_from + rlim_y_max_range);
     }
 
-    search_range = t_bb(min_cx, max_cx, min_cy, max_cy, layer_num, layer_num);
+    t_bb search_range = t_bb(min_cx, max_cx, min_cy, max_cy, layer_num, layer_num);
 
     return search_range;
 }

vpr/src/place/net_cost_handler.cpp

@@ -228,7 +228,7 @@ void NetCostHandler::alloc_and_load_for_fast_vertical_cost_update_() {
                                                          });
 }
 
-std::pair<double, double> NetCostHandler::comp_bb_cost(e_cost_methods method) {
+std::pair<double, double> NetCostHandler::comp_bb_cost(e_cost_methods method) const {
     return comp_bb_cost_functor_(method);
 }
 

vpr/src/place/net_cost_handler.h

@@ -68,7 +68,7 @@ class NetCostHandler {
      *
      * @note The returned estimated wirelength is valid only when method == CHECK
      */
-    std::pair<double, double> comp_bb_cost(e_cost_methods method);
+    std::pair<double, double> comp_bb_cost(e_cost_methods method) const;
 
     /**
      * @brief Find all the nets and pins affected by this swap and update costs.