vpr: replace all sort functions with stable sort

Author: amin1377

vpr/src/draw/draw_basic.cpp

@@ -339,7 +339,7 @@ void draw_congestion(ezgl::renderer* g) {
 
         return lhs_cong_ratio < rhs_cong_ratio;
     };
-    std::sort(congested_rr_nodes.begin(), congested_rr_nodes.end(), cmp_ascending_acc_cost);
+    std::stable_sort(congested_rr_nodes.begin(), congested_rr_nodes.end(), cmp_ascending_acc_cost);
 
     if (draw_state->show_congestion == DRAW_CONGESTED_WITH_NETS) {
         auto rr_node_nets = collect_rr_node_nets();

vpr/src/draw/draw_rr.cpp

@@ -816,7 +816,7 @@ void draw_rr_costs(ezgl::renderer* g, const vtr::vector<RRNodeId, float>& rr_cos
         }
         return rr_costs[lhs_node] < rr_costs[rhs_node];
     };
-    std::sort(nodes.begin(), nodes.end(), cmp_ascending_cost);
+    std::stable_sort(nodes.begin(), nodes.end(), cmp_ascending_cost);
 
     for (RRNodeId inode : nodes) {
         float cost = rr_costs[inode];

vpr/src/place/compressed_grid.cpp

@@ -84,10 +84,10 @@ t_compressed_block_grid create_compressed_block_grid(const std::vector<std::vect
             }
 
             //Uniquify x/y locations
-            std::sort(layer_x_locs.begin(), layer_x_locs.end());
+            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::sort(layer_y_locs.begin(), layer_y_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());
 
             //The index of an x-position in x_locs corresponds to it's compressed

vpr/src/place/cut_spreader.cpp

@@ -446,7 +446,7 @@ std::pair<int, int> CutSpreader::cut_region(SpreaderRegion& r, bool dir) {
     }
 
     // sort blks based on raw location
-    std::sort(cut_blks.begin(), cut_blks.end(), [&](const ClusterBlockId a, const ClusterBlockId b) {
+    std::stable_sort(cut_blks.begin(), cut_blks.end(), [&](const ClusterBlockId a, const ClusterBlockId b) {
         return dir ? (ap->blk_locs[a].rawy < ap->blk_locs[b].rawy) : (ap->blk_locs[a].rawx < ap->blk_locs[b].rawx);
     });
 

vpr/src/place/median_move_generator.cpp

@@ -131,8 +131,8 @@ e_create_move MedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved& blocks_
     }
 
     //calculate the median region
-    std::sort(place_move_ctx.X_coord.begin(), place_move_ctx.X_coord.end());
-    std::sort(place_move_ctx.Y_coord.begin(), place_move_ctx.Y_coord.end());
+    std::stable_sort(place_move_ctx.X_coord.begin(), place_move_ctx.X_coord.end());
+    std::stable_sort(place_move_ctx.Y_coord.begin(), place_move_ctx.Y_coord.end());
 
     limit_coords.xmin = place_move_ctx.X_coord[floor((place_move_ctx.X_coord.size() - 1) / 2)];
     limit_coords.xmax = place_move_ctx.X_coord[floor((place_move_ctx.X_coord.size() - 1) / 2) + 1];

vpr/src/place/noc_place_utils.cpp

@@ -880,8 +880,8 @@ void write_noc_placement_file(const std::string& file_name) {
 static std::vector<NocLinkId> find_affected_links_by_flow_reroute(std::vector<NocLinkId>& prev_links,
                                                                   std::vector<NocLinkId>& curr_links) {
     // Sort both link containers
-    std::sort(prev_links.begin(), prev_links.end());
-    std::sort(curr_links.begin(), curr_links.end());
+    std::stable_sort(prev_links.begin(), prev_links.end());
+    std::stable_sort(curr_links.begin(), curr_links.end());
 
     // stores links that appear either in prev_links or curr_links but not both of them
     std::vector<NocLinkId> unique_links;

vpr/src/place/place.cpp

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

vpr/src/place/timing_place_lookup.cpp

@@ -871,7 +871,7 @@ float delay_reduce(std::vector<float>& delays, e_reducer reducer) {
         auto itr = std::max_element(delays.begin(), delays.end());
         delay = *itr;
     } else if (reducer == e_reducer::MEDIAN) {
-        std::sort(delays.begin(), delays.end());
+        std::stable_sort(delays.begin(), delays.end());
         delay = vtr::median(delays.begin(), delays.end());
     } else if (reducer == e_reducer::ARITHMEAN) {
         delay = vtr::arithmean(delays.begin(), delays.end());

vpr/src/place/weighted_median_move_generator.cpp

@@ -95,8 +95,8 @@ e_create_move WeightedMedianMoveGenerator::propose_move(t_pl_blocks_to_be_moved&
     }
 
     //calculate the weighted median region
-    std::sort(place_move_ctx.X_coord.begin(), place_move_ctx.X_coord.end());
-    std::sort(place_move_ctx.Y_coord.begin(), place_move_ctx.Y_coord.end());
+    std::stable_sort(place_move_ctx.X_coord.begin(), place_move_ctx.X_coord.end());
+    std::stable_sort(place_move_ctx.Y_coord.begin(), place_move_ctx.Y_coord.end());
 
     if (place_move_ctx.X_coord.size() == 1) {
         limit_coords.xmin = place_move_ctx.X_coord[0];

vpr/src/route/DecompNetlistRouter.tpp

@@ -128,7 +128,7 @@ void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g
      * nets use their own #fanouts. */
     std::vector<size_t> order(node.nets.size() + node.vnets.size());
     std::iota(order.begin(), order.end(), 0);
-    std::sort(order.begin(), order.end(), [&](size_t i, size_t j) -> bool {
+    std::stable_sort(order.begin(), order.end(), [&](size_t i, size_t j) -> bool {
         ParentNetId id1 = i < node.nets.size() ? node.nets[i] : node.vnets[i - node.nets.size()].net_id;
         ParentNetId id2 = j < node.nets.size() ? node.nets[j] : node.vnets[j - node.nets.size()].net_id;
         return _net_list.net_sinks(id1).size() > _net_list.net_sinks(id2).size();