Merge pull request #8656 from The-OpenROAD-Project-staging/grt_congestion_issue_fix

GRT: Fix congestion issue on hercules design

Author: eder-matheus

src/grt/src/GlobalRouter.cpp

@@ -384,7 +384,7 @@ void GlobalRouter::suggestAdjustment()
   // Get min adjustment apply to layers
   int min_routing_layer, max_routing_layer;
   getMinMaxLayer(min_routing_layer, max_routing_layer);
-  float min_adjustment = 100;
+  float min_adjustment = 1.0;
   for (int l = min_routing_layer; l <= max_routing_layer; l++) {
     odb::dbTechLayer* tech_layer = db_->getTech()->findRoutingLayer(l);
     if (tech_layer->getLayerAdjustment() != 0.0) {
@@ -5132,6 +5132,7 @@ std::vector<Net*> GlobalRouter::updateDirtyRoutes(bool save_guides)
 {
   callback_handler_->triggerOnPinAccessUpdateRequired();
   std::vector<Net*> dirty_nets;
+
   if (!dirty_nets_.empty()) {
     fastroute_->setVerbose(false);
     fastroute_->clearNetsToRoute();

src/grt/src/fastroute/include/FastRoute.h

@@ -520,7 +520,8 @@ class FastRouteCore
                          int l,
                          bool horizontal,
                          int& best_cost,
-                         multi_array<int, 2>& layer_grid);
+                         multi_array<int, 2>& layer_grid,
+                         int net_cost);
   void assignEdge(int netID, int edgeID, bool processDIR);
   int getLayerResistance(int layer, int length, FrNet* net);
   int getViaResistance(int from_layer, int to_layer);

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

@@ -371,18 +371,19 @@ void FastRouteCore::fixEdgeAssignment(int& net_layer,
                                       const int l,
                                       const bool vertical,
                                       int& best_cost,
-                                      multi_array<int, 2>& layer_grid)
+                                      multi_array<int, 2>& layer_grid,
+                                      const int net_cost)
 {
   const bool is_vertical
       = layer_directions_[l] == odb::dbTechLayerDir::VERTICAL;
   // if layer direction doesn't match edge direction or
   // if already found a layer for the edge, ignores the remaining layers
-  if (is_vertical != vertical || best_cost > 0) {
+  if (is_vertical != vertical || best_cost >= net_cost) {
     layer_grid[l][k] = std::numeric_limits<int>::min();
   } else {
     layer_grid[l][k] = edges_3D[l][y][x].cap - edges_3D[l][y][x].usage;
     best_cost = std::max(best_cost, layer_grid[l][k]);
-    if (best_cost > 0) {
+    if (best_cost >= net_cost) {
       // set the new min/max routing layer for the net to avoid
       // errors during mazeRouteMSMDOrder3D
       net_layer = l;
@@ -458,6 +459,7 @@ void FastRouteCore::assignEdge(const int netID,
   int endLayer = 0;
 
   FrNet* net = nets_[netID];
+  const int8_t net_cost = net->getEdgeCost();
   auto& treeedges = sttrees_[netID].edges;
   auto& treenodes = sttrees_[netID].nodes;
   TreeEdge* treeedge = &(treeedges[edgeID]);
@@ -488,25 +490,31 @@ void FastRouteCore::assignEdge(const int netID,
 
   for (k = 0; k < routelen; k++) {
     int best_cost = std::numeric_limits<int>::min();
+    bool has_available_resources = false;
     if (grids[k].x == grids[k + 1].x) {
       const int min_y = std::min(grids[k].y, grids[k + 1].y);
       for (int l = net->getMinLayer(); l <= net->getMaxLayer(); l++) {
         // check if the current layer is vertical to match the edge orientation
         bool is_vertical
             = layer_directions_[l] == odb::dbTechLayerDir::VERTICAL;
         if (is_vertical) {
-          layer_grid[l][k] = v_edges_3D_[l][min_y][grids[k].x].cap
-                             - v_edges_3D_[l][min_y][grids[k].x].usage;
+          const int available_resources
+              = v_edges_3D_[l][min_y][grids[k].x].cap
+                - v_edges_3D_[l][min_y][grids[k].x].usage;
+          layer_grid[l][k] = available_resources;
           best_cost = std::max(best_cost, layer_grid[l][k]);
+          // Check if any layer has enough resources to route
+          has_available_resources
+              |= (available_resources >= net->getLayerEdgeCost(l));
         } else {
           layer_grid[l][k] = std::numeric_limits<int>::min();
         }
       }
 
-      // assigning the edge to the layer range would cause overflow try to
+      // if no layer has sufficient resources in the range of layers try to
       // assign the edge to the closest layer below the min routing layer.
       // if design has 2D overflow, accept the congestion in layer assignment
-      if (best_cost <= 0 && !has_2D_overflow_) {
+      if (!has_available_resources && !has_2D_overflow_) {
         int min_layer = net->getMinLayer();
         for (int l = net->getMinLayer() - 1; l >= 0; l--) {
           fixEdgeAssignment(min_layer,
@@ -517,7 +525,8 @@ void FastRouteCore::assignEdge(const int netID,
                             l,
                             true,
                             best_cost,
-                            layer_grid);
+                            layer_grid,
+                            net_cost);
         }
         net->setMinLayer(min_layer);
         // try to assign the edge to the closest layer above the max routing
@@ -532,7 +541,8 @@ void FastRouteCore::assignEdge(const int netID,
                             l,
                             true,
                             best_cost,
-                            layer_grid);
+                            layer_grid,
+                            net_cost);
         }
         net->setMaxLayer(max_layer);
       } else {  // the edge was assigned to a layer without causing overflow
@@ -550,18 +560,23 @@ void FastRouteCore::assignEdge(const int netID,
         bool is_horizontal
             = layer_directions_[l] == odb::dbTechLayerDir::HORIZONTAL;
         if (is_horizontal) {
-          layer_grid[l][k] = h_edges_3D_[l][grids[k].y][min_x].cap
-                             - h_edges_3D_[l][grids[k].y][min_x].usage;
+          const int available_resources
+              = h_edges_3D_[l][grids[k].y][min_x].cap
+                - h_edges_3D_[l][grids[k].y][min_x].usage;
+          layer_grid[l][k] = available_resources;
           best_cost = std::max(best_cost, layer_grid[l][k]);
+          // Check if any layer has enough resources to route
+          has_available_resources
+              |= (available_resources >= net->getLayerEdgeCost(l));
         } else {
           layer_grid[l][k] = std::numeric_limits<int>::min();
         }
       }
 
-      // assigning the edge to the layer range would cause overflow try to
+      // if no layer has sufficient resources in the range of layers try to
       // assign the edge to the closest layer below the min routing layer.
       // if design has 2D overflow, accept the congestion in layer assignment
-      if (best_cost <= 0 && !has_2D_overflow_) {
+      if (!has_available_resources && !has_2D_overflow_) {
         int min_layer = net->getMinLayer();
         for (int l = net->getMinLayer() - 1; l >= 0; l--) {
           fixEdgeAssignment(min_layer,
@@ -572,7 +587,8 @@ void FastRouteCore::assignEdge(const int netID,
                             l,
                             false,
                             best_cost,
-                            layer_grid);
+                            layer_grid,
+                            net_cost);
         }
         net->setMinLayer(min_layer);
         // try to assign the edge to the closest layer above the max routing
@@ -587,7 +603,8 @@ void FastRouteCore::assignEdge(const int netID,
                             l,
                             false,
                             best_cost,
-                            layer_grid);
+                            layer_grid,
+                            net_cost);
         }
         net->setMaxLayer(max_layer);
       } else {  // the edge was assigned to a layer without causing overflow
@@ -1069,7 +1086,6 @@ void FastRouteCore::layerAssignment()
   }
 
   layerAssignmentV4();
-
   ConvertToFull3DType2();
 }