grt: cleaning code, refactoring, adding comments

Signed-off-by: Jonas Gava <[email protected]>

Author: jfgava

src/grt/src/fastroute/src/FastRoute.cpp

@@ -5,6 +5,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdint>
 #include <limits>
 #include <memory>
 #include <unordered_set>
@@ -1101,6 +1102,8 @@ NetRouteMap FastRouteCore::run()
   float logistic_coef = 0;
   int slope;
   int max_adj;
+  const int long_edge_len = 40;
+  const int short_edge_len = 12;
 
   // call FLUTE to generate RSMT and break the nets into segments (2-pin nets)
   via_cost_ = 0;
@@ -1501,8 +1504,8 @@ NetRouteMap FastRouteCore::run()
   via_cost_ = 1;
 
   if (past_cong == 0) {
-    mazeRouteMSMDOrder3D(enlarge_, 0, 40);
-    mazeRouteMSMDOrder3D(enlarge_, 0, 12);
+    mazeRouteMSMDOrder3D(enlarge_, 0, long_edge_len);
+    mazeRouteMSMDOrder3D(enlarge_, 0, short_edge_len);
   }
 
   if (logger_->debugCheck(GRT, "grtSteps", 1)) {

src/grt/src/fastroute/src/graph2d.cpp

@@ -349,24 +349,21 @@ void Graph2D::updateCongList(const std::string& net_name,
   }
 }
 
-// Prints all congested nets.
+// Prints all congested nets (debug).
 void Graph2D::printAllElements()
 {
   if (congestion_nets_.empty()) {
-    std::cout << "No congestion nets.\n";
+    logger_->report("No congestion nets.");
     return;
   }
 
-  std::cout << "Congestion Nets: ";
-  std::cout << congestion_nets_.size();
-  std::cout << " { ";
+  logger_->report("Congestion nets ({}):", congestion_nets_.size());
   for (auto it = congestion_nets_.begin(); it != congestion_nets_.end(); ++it) {
     if (it != congestion_nets_.begin()) {
-      std::cout << ", ";
+      logger_->reportLiteral(", ");
     }
-    std::cout << "\"" << *it << "\"";
+    logger_->reportLiteral(fmt::format("\"{}\"", *it));
   }
-  std::cout << " }\n";
 }
 
 // Updates usage for a horizontal edge, considering NDRs.
@@ -552,29 +549,28 @@ void Graph2D::printEdgeCapPerLayer()
 bool Graph2D::hasNDRCapacity(FrNet* net, int x, int y, EdgeDirection direction)
 {
   const int8_t edgeCost = net->getEdgeCost();
-  double max_single_layer_cap = 0;
-
-  if (edgeCost > 1) {
-    // For nets with high cost, we need at least one layer with sufficient
-    // capacity
-    for (int l = net->getMinLayer(); l <= net->getMaxLayer(); l++) {
-      double layer_cap = 0;
-      if (direction == EdgeDirection::Horizontal) {
-        layer_cap = h_cap_3D_[l][x][y].cap_ndr;
-      } else {
-        layer_cap = v_cap_3D_[l][x][y].cap_ndr;
-      }
-      max_single_layer_cap = std::max(max_single_layer_cap, layer_cap);
-      if (layer_cap >= edgeCost) {
-        return true;
-      }
+
+  if (edgeCost == 1) {
+    return true;
+  }
+
+  // For nets with high cost, we need at least one layer with sufficient
+  // capacity
+  for (int l = net->getMinLayer(); l <= net->getMaxLayer(); l++) {
+    double layer_cap = 0;
+    if (direction == EdgeDirection::Horizontal) {
+      layer_cap = h_cap_3D_[l][x][y].cap_ndr;
+    } else {
+      layer_cap = v_cap_3D_[l][x][y].cap_ndr;
     }
 
-    // No single layer can accommodate this NDR net
-    return false;
+    if (layer_cap >= edgeCost) {
+      return true;
+    }
   }
 
-  return true;
+  // No single layer can accommodate this NDR net
+  return false;
 }
 
 // Calculates the cost of an edge, considering NDRs.
@@ -603,9 +599,15 @@ double Graph2D::getCostNDRAware(FrNet* net,
   bool is_net_present = ndr_nets.find(net_name) != ndr_nets.end();
   double final_edge_cost = 0;
 
-  if (edge_cost < 0) {     // Rip-up: remove resource
-    if (is_net_present) {  // Remove only one time for L route
+  if (edge_cost < 0) {  // Rip-up: remove resource
+    // If the net is in the list, remove it and compute the edge cost.
+    // If the net is not in the list, it probably means that we are removing
+    // half the edge cost a second time in the initial routing steps. But we
+    // only need to count once to avoid problems when managing 3D capacity
+    if (is_net_present) {
       ndr_nets.erase(net_name);
+      // If the edge already has an overflow caused by NDR net we need to remove
+      // the big edge cost value
       if (edge.ndr_overflow > 0) {
         edge.ndr_overflow--;
         final_edge_cost = -OVERFLOW_COST_MULTIPLIER * edgeCost;
@@ -615,7 +617,14 @@ double Graph2D::getCostNDRAware(FrNet* net,
       updateNDRCapLayer(x, y, net, direction, edge_cost);
     }
   } else {  // Routing: add resource
+    // If the net is not in the list, add it and compute the edge cost.
+    // If the net is in the list, it probably means that we are in the
+    // initial routing steps adding two times half the edge cost. But we
+    // only need to count once to avoid problems when managing 3D capacity
     if (!is_net_present) {
+      // If the edge already has an overflow caused by NDR net or it will have
+      // an overflow due to lack of capacity in a single layer, we need to add
+      // the big edge cost value
       if (edge.ndr_overflow > 0 || !hasNDRCapacity(net, x, y, direction)) {
         edge.ndr_overflow++;
         final_edge_cost = OVERFLOW_COST_MULTIPLIER * edgeCost;
@@ -661,19 +670,24 @@ void Graph2D::updateNDRCapLayer(const int x,
   for (int l = net->getMinLayer(); l <= net->getMaxLayer(); l++) {
     auto& layer_cap = cap_3D[l][x][y];
     if (edge_cost < 0) {  // Reducing edge usage
+      // If we already have a NDR net in this layer, increase the NDR capacity
+      // available again
       if (layer_cap.cap - layer_cap.cap_ndr >= edgeCost) {
         layer_cap.cap_ndr += edgeCost;
         return;
       }
     } else {  // Increasing edge usage
+      // If there is NDR capacity available, reduce the capacity value
       if (layer_cap.cap_ndr >= edgeCost) {
         layer_cap.cap_ndr -= edgeCost;
         return;
       }
     }
   }
 
-  // Overflow (need to update cap_ndr even with congestion)
+  // If the edge is already with congestion and there is no capacity available
+  // in any layer, reduce the capacity available of the first layer.
+  // When rippin-up, it will be the first to be released
   if (edge_cost > 0) {
     cap_3D[net->getMinLayer()][x][y].cap_ndr -= edgeCost;
   }

src/grt/src/fastroute/src/maze.cpp

@@ -1955,7 +1955,7 @@ int FastRouteCore::getOverflow2Dmaze(int* maxOverflow, int* tUsage)
   total_overflow_ = H_overflow + V_overflow;
   *maxOverflow = max_overflow;
 
-  if (logger_->debugCheck(GRT, "congestion", 1)) {
+  if (logger_->debugCheck(GRT, "congestion2D", 1)) {
     logger_->report("Overflow report:");
     logger_->report("Total usage          : {}", total_usage);
     logger_->report("Max H overflow       : {}", max_H_overflow);
@@ -2038,7 +2038,7 @@ int FastRouteCore::getOverflow2D(int* maxOverflow)
     ahth_ = 20;
   }
 
-  if (logger_->debugCheck(GRT, "congestion", 1)) {
+  if (logger_->debugCheck(GRT, "congestion2D", 1)) {
     logger_->report("Overflow report.");
     logger_->report("Total hCap               : {}", hCap);
     logger_->report("Total vCap               : {}", vCap);

src/grt/src/fastroute/src/maze3D.cpp

@@ -1432,7 +1432,7 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
             graph2d_.updateUsageV(grids[i].x, min_y, net, net->getEdgeCost());
             v_edges_3D_[grids[i].layer][min_y][grids[i].x].usage
                 += net->getLayerEdgeCost(grids[i].layer);
-          } else  /// if(grids[i].y==grids[i+1].y)// a horizontal edge
+          } else  // a horizontal edge
           {
             const int min_x = std::min(grids[i].x, grids[i + 1].x);
             graph2d_.updateUsageH(min_x, grids[i].y, net, net->getEdgeCost());

src/grt/src/fastroute/src/utility.cpp

@@ -96,15 +96,9 @@ void FastRouteCore::ConvertToFull3DType2()
 
 static bool compareNetPins(const OrderNetPin& a, const OrderNetPin& b)
 {
-  // First priority: NDR nets (lower is better, so NDR nets with priority 0 come
-  // first)
-  if (a.ndr_priority != b.ndr_priority) {
-    return a.ndr_priority < b.ndr_priority;
-  }
-
-  // Second priority: original sorting by length_per_pin, minX, and treeIndex
-  return std::tie(a.length_per_pin, a.minX, a.treeIndex)
-         < std::tie(b.length_per_pin, b.minX, b.treeIndex);
+  // Sorting by ndr_priority, length_per_pin, minX, and treeIndex
+  return std::tie(a.ndr_priority, a.length_per_pin, a.minX, a.treeIndex)
+         < std::tie(b.ndr_priority, b.length_per_pin, b.minX, b.treeIndex);
 }
 
 void FastRouteCore::netpinOrderInc()