remove std::max calls

Author: soheilshahrouz

vpr/src/place/net_cost_handler.cpp

@@ -36,7 +36,6 @@
 
 #include <array>
 
-using std::max;
 using std::min;
 
 
@@ -572,12 +571,12 @@ void NetCostHandler::get_non_updatable_cube_bb_(ClusterNetId net_id, bool use_ts
      * clip to 1 in both directions as well (since minimum channel index *
      * is 0).  See route_common.cpp for a channel diagram.               */
 
-    bb_coord_new.xmin = max(min<int>(xmin, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    bb_coord_new.ymin = max(min<int>(ymin, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-    bb_coord_new.layer_min = max(min<int>(layer_min, device_ctx.grid.get_num_layers() - 1), 0);
-    bb_coord_new.xmax = max(min<int>(xmax, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    bb_coord_new.ymax = max(min<int>(ymax, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-    bb_coord_new.layer_max = max(min<int>(layer_max, device_ctx.grid.get_num_layers() - 1), 0);
+    bb_coord_new.xmin = min<int>(xmin, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    bb_coord_new.ymin = min<int>(ymin, device_ctx.grid.height() - 2); //-2 for no perim channels
+    bb_coord_new.layer_min = layer_min;
+    bb_coord_new.xmax = min<int>(xmax, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    bb_coord_new.ymax = min<int>(ymax, device_ctx.grid.height() - 2); //-2 for no perim channels
+    bb_coord_new.layer_max = layer_max;
 }
 
 void NetCostHandler::get_non_updatable_per_layer_bb_(ClusterNetId net_id, bool use_ts) {
@@ -637,10 +636,10 @@ void NetCostHandler::get_non_updatable_per_layer_bb_(ClusterNetId net_id, bool u
      * is 0).  See route_common.cpp for a channel diagram.               */
     for (int layer_num = 0; layer_num < num_layers; layer_num++) {
         bb_coord_new[layer_num].layer_num = layer_num;
-        bb_coord_new[layer_num].xmin = max(min<int>(bb_coord_new[layer_num].xmin, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-        bb_coord_new[layer_num].ymin = max(min<int>(bb_coord_new[layer_num].ymin, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-        bb_coord_new[layer_num].xmax = max(min<int>(bb_coord_new[layer_num].xmax, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-        bb_coord_new[layer_num].ymax = max(min<int>(bb_coord_new[layer_num].ymax, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+        bb_coord_new[layer_num].xmin = min<int>(bb_coord_new[layer_num].xmin, device_ctx.grid.width() - 2);  //-2 for no perim channels
+        bb_coord_new[layer_num].ymin = min<int>(bb_coord_new[layer_num].ymin, device_ctx.grid.height() - 2); //-2 for no perim channels
+        bb_coord_new[layer_num].xmax = min<int>(bb_coord_new[layer_num].xmax, device_ctx.grid.width() - 2);  //-2 for no perim channels
+        bb_coord_new[layer_num].ymax = min<int>(bb_coord_new[layer_num].ymax, device_ctx.grid.height() - 2); //-2 for no perim channels
     }
 }
 
@@ -663,12 +662,12 @@ void NetCostHandler::update_bb_(ClusterNetId net_id,
     // Number of sinks of the given net on each layer
     vtr::NdMatrixProxy<int, 1> num_sink_pin_layer_new = ts_layer_sink_pin_count_[size_t(net_id)];
 
-    pin_new_loc.x = max(min<int>(pin_new_loc.x, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    pin_new_loc.y = max(min<int>(pin_new_loc.y, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-    pin_new_loc.layer_num = max(min<int>(pin_new_loc.layer_num, device_ctx.grid.get_num_layers() - 1), 0);
-    pin_old_loc.x = max(min<int>(pin_old_loc.x, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    pin_old_loc.y = max(min<int>(pin_old_loc.y, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-    pin_old_loc.layer_num = max(min<int>(pin_old_loc.layer_num, device_ctx.grid.get_num_layers() - 1), 0);
+    pin_new_loc.x = min<int>(pin_new_loc.x, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    pin_new_loc.y = min<int>(pin_new_loc.y, device_ctx.grid.height() - 2); //-2 for no perim channels
+    pin_new_loc.layer_num = pin_new_loc.layer_num;
+    pin_old_loc.x = min<int>(pin_old_loc.x, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    pin_old_loc.y = min<int>(pin_old_loc.y, device_ctx.grid.height() - 2); //-2 for no perim channels
+    pin_old_loc.layer_num = pin_old_loc.layer_num;
 
     /* Check if the net had been updated before. */
     if (bb_update_status_[net_id] == NetUpdateState::GOT_FROM_SCRATCH) {
@@ -927,10 +926,10 @@ void NetCostHandler::update_layer_bb_(ClusterNetId net_id,
     auto& device_ctx = g_vpr_ctx.device();
     auto& place_move_ctx = placer_state_.move();
 
-    pin_new_loc.x = max(min<int>(pin_new_loc.x, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    pin_new_loc.y = max(min<int>(pin_new_loc.y, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
-    pin_old_loc.x = max(min<int>(pin_old_loc.x, device_ctx.grid.width() - 2), 1);  //-2 for no perim channels
-    pin_old_loc.y = max(min<int>(pin_old_loc.y, device_ctx.grid.height() - 2), 1); //-2 for no perim channels
+    pin_new_loc.x = min<int>(pin_new_loc.x, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    pin_new_loc.y = min<int>(pin_new_loc.y, device_ctx.grid.height() - 2); //-2 for no perim channels
+    pin_old_loc.x = min<int>(pin_old_loc.x, device_ctx.grid.width() - 2);  //-2 for no perim channels
+    pin_old_loc.y = min<int>(pin_old_loc.y, device_ctx.grid.height() - 2); //-2 for no perim channels
 
     std::vector<t_2D_bb>& bb_edge_new = layer_ts_bb_edge_new_[net_id];
     std::vector<t_2D_bb>& bb_coord_new = layer_ts_bb_coord_new_[net_id];
@@ -1285,9 +1284,9 @@ void NetCostHandler::get_bb_from_scratch_(ClusterNetId net_id,
     int y = block_loc.y + physical_tile_type(block_loc)->pin_height_offset[pnum];
     int pin_layer = block_loc.layer;
 
-    x = max(min<int>(x, grid.width() - 2), 1);
-    y = max(min<int>(y, grid.height() - 2), 1);
-    pin_layer = max(min<int>(pin_layer, grid.get_num_layers() - 1), 0);
+    x = min<int>(x, grid.width() - 2);
+    y = min<int>(y, grid.height() - 2);
+    pin_layer = min<int>(pin_layer, grid.get_num_layers() - 1);
 
     int xmin = x;
     int ymin = y;
@@ -1322,9 +1321,9 @@ void NetCostHandler::get_bb_from_scratch_(ClusterNetId net_id,
          * the which channels are included within the bounding box, and it         *
          * simplifies the code a lot.                                              */
 
-        x = max(min<int>(x, grid.width() - 2), 1);  //-2 for no perim channels
-        y = max(min<int>(y, grid.height() - 2), 1); //-2 for no perim channels
-        pin_layer = max(min<int>(pin_layer, grid.get_num_layers() - 1), 0);
+        x = min<int>(x, grid.width() - 2);  //-2 for no perim channels
+        y = min<int>(y, grid.height() - 2); //-2 for no perim channels
+        pin_layer = min<int>(pin_layer, grid.get_num_layers() - 1);
 
         if (x == xmin) {
             xmin_edge++;
@@ -1406,8 +1405,8 @@ void NetCostHandler::get_layer_bb_from_scratch_(ClusterNetId net_id,
     int x_src = block_loc.x + physical_tile_type(block_loc)->pin_width_offset[pnum_src];
     int y_src = block_loc.y + physical_tile_type(block_loc)->pin_height_offset[pnum_src];
 
-    x_src = max(min<int>(x_src, grid.width() - 2), 1);
-    y_src = max(min<int>(y_src, grid.height() - 2), 1);
+    x_src = min<int>(x_src, grid.width() - 2);
+    y_src = min<int>(y_src, grid.height() - 2);
 
     // TODO: Currently we are assuming that crossing can only happen from OPIN. Because of that,
     // when per-layer bounding box is used, we want the bounding box on each layer to also include
@@ -1435,8 +1434,8 @@ void NetCostHandler::get_layer_bb_from_scratch_(ClusterNetId net_id,
          * the which channels are included within the bounding box, and it         *
          * simplifies the code a lot.                                              */
 
-        x = max(min<int>(x, grid.width() - 2), 1);  //-2 for no perim channels
-        y = max(min<int>(y, grid.height() - 2), 1); //-2 for no perim channels
+        x = min<int>(x, grid.width() - 2);  //-2 for no perim channels
+        y = min<int>(y, grid.height() - 2); //-2 for no perim channels
 
         if (x == coords[layer].xmin) {
             num_on_edges[layer].xmin++;