Merge pull request #8228 from luis201420/grt_suggest_layer_adjustment

GRT: Suggest adjustment value when having congestion problems

Author: eder-matheus

src/grt/include/grt/GlobalRouter.h

@@ -362,6 +362,7 @@ class GlobalRouter
                                 Pin& pin,
                                 odb::Point& pos_on_grid,
                                 bool has_access_points);
+  void suggestAdjustment();
   void findFastRoutePins(Net* net,
                          std::vector<RoutePt>& pins_on_grid,
                          int& root_idx);

src/grt/src/GlobalRouter.cpp

@@ -189,6 +189,8 @@ void GlobalRouter::applyAdjustments(int min_routing_layer,
   computeObstructionsAdjustments();
   std::vector<int> track_space = grid_->getTrackPitches();
   fastroute_->initBlockedIntervals(track_space);
+  // Save global resources before add adjustment by layer
+  fastroute_->saveResourcesBeforeAdjustments();
   computeUserGlobalAdjustments(min_routing_layer, max_routing_layer);
   computeUserLayerAdjustments(max_routing_layer);
 
@@ -368,6 +370,8 @@ void GlobalRouter::globalRoute(bool save_guides,
   }
 
   if (is_congested_) {
+    // Suggest adjustment value
+    suggestAdjustment();
     if (allow_congestion_) {
       logger_->warn(GRT,
                     115,
@@ -382,6 +386,32 @@ void GlobalRouter::globalRoute(bool save_guides,
   }
 }
 
+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;
+  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) {
+      min_adjustment
+          = std::min(min_adjustment, tech_layer->getLayerAdjustment());
+    }
+  }
+  min_adjustment *= 100;
+  // Suggest new adjustment value
+  int suggest_adjustment;
+  bool has_sug_adj = fastroute_->computeSuggestedAdjustment(suggest_adjustment);
+  if (has_sug_adj && min_adjustment > suggest_adjustment) {
+    logger_->warn(GRT,
+                  704,
+                  "Try reduce the layer adjustment from {}% to {}%",
+                  min_adjustment,
+                  suggest_adjustment);
+  }
+}
+
 void GlobalRouter::updateDbCongestion()
 {
   int min_layer, max_layer;
@@ -5116,6 +5146,8 @@ std::vector<Net*> GlobalRouter::updateDirtyRoutes(bool save_guides)
         is_congested_ = true;
         updateDbCongestion();
         saveCongestion();
+        // Suggest adjustment value
+        suggestAdjustment();
         logger_->error(GRT,
                        232,
                        "Routing congestion too high. Check the congestion "

src/grt/src/fastroute/include/DataType.h

@@ -130,6 +130,7 @@ struct Edge  // An Edge is the routing track holder between two adjacent
   uint16_t cap;    // the capacity of the edge
   uint16_t usage;  // the usage of the edge
   uint16_t red;
+  uint16_t real_cap;  // the real capacity without user adjustment
   int16_t last_usage;
   uint16_t ndr_overflow;  // number of NDR nets in congestion
   double est_usage;       // the estimated usage of the edge
@@ -140,9 +141,10 @@ struct Edge  // An Edge is the routing track holder between two adjacent
 
 struct Edge3D
 {
-  uint16_t cap;    // the capacity of the edge
-  uint16_t usage;  // the usage of the edge
-  uint16_t red;    // the reduction of capacity of the edge
+  uint16_t cap;       // the capacity of the edge
+  uint16_t usage;     // the usage of the edge
+  uint16_t red;       // the reduction of capacity of the edge
+  uint16_t real_cap;  // the real capacity without user adjustment
 };
 
 struct TreeNode

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

@@ -153,6 +153,12 @@ class FastRouteCore
       const interval<int>::type& last_tile_reduce_interval,
       const std::vector<int>& track_space,
       bool release = false);
+  void saveResourcesBeforeAdjustments();
+  bool computeSuggestedAdjustment(int& suggested_adjustment);
+  void getPrecisionAdjustment(int x,
+                              int y,
+                              bool is_horizontal,
+                              int& adjustment);
   void initBlockedIntervals(std::vector<int>& track_space);
   void initAuxVar();
   NetRouteMap run();

src/grt/src/fastroute/include/Graph2D.h

@@ -78,6 +78,11 @@ class Graph2D
                                bool stop_decreasing,
                                int& max_adj);
   void str_accu(int rnd);
+  void saveResources(int x, int y, bool is_horizontal);
+  bool computeSuggestedAdjustment(int x,
+                                  int y,
+                                  bool is_horizontal,
+                                  int& adjustment);
 
   void updateEstUsageH(const Interval& xi, int y, FrNet* net, double usage);
   void updateEstUsageH(int x, int y, FrNet* net, double usage);

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

@@ -524,6 +524,28 @@ void FastRouteCore::addAdjustment(int x1,
   }
 }
 
+void FastRouteCore::saveResourcesBeforeAdjustments()
+{
+  // Save real horizontal resources
+  for (int x = 0; x < x_grid_ - 1; x++) {
+    for (int y = 0; y < y_grid_; y++) {
+      graph2d_.saveResources(x, y, true);
+      for (int l = 0; l < num_layers_; l++) {
+        h_edges_3D_[l][y][x].real_cap = h_edges_3D_[l][y][x].cap;
+      }
+    }
+  }
+  // Save real vertical resources
+  for (int x = 0; x < x_grid_; x++) {
+    for (int y = 0; y < y_grid_ - 1; y++) {
+      graph2d_.saveResources(x, y, false);
+      for (int l = 0; l < num_layers_; l++) {
+        v_edges_3D_[l][y][x].real_cap = v_edges_3D_[l][y][x].cap;
+      }
+    }
+  }
+}
+
 void FastRouteCore::releaseResourcesOnInterval(
     int x,
     int y,

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

@@ -456,6 +456,35 @@ void Graph2D::foreachEdge(const std::function<void(Edge&)>& func)
   inner(v_edges_);
 }
 
+void Graph2D::saveResources(const int x, const int y, bool is_horizontal)
+{
+  if (is_horizontal) {
+    h_edges_[x][y].real_cap = h_edges_[x][y].cap;
+  } else {
+    v_edges_[x][y].real_cap = v_edges_[x][y].cap;
+  }
+}
+
+bool Graph2D::computeSuggestedAdjustment(const int x,
+                                         const int y,
+                                         bool is_horizontal,
+                                         int& adjustment)
+{
+  float real_capacity, usage;
+  if (is_horizontal) {
+    real_capacity = h_edges_[x][y].real_cap;
+    usage = h_edges_[x][y].usage;
+  } else {
+    real_capacity = v_edges_[x][y].real_cap;
+    usage = v_edges_[x][y].usage;
+  }
+  if (real_capacity >= usage) {
+    adjustment = (1.0 - (usage / real_capacity)) * 100;
+    return true;
+  }
+  return false;
+}
+
 // Initializes the 3D capacity of the graph.
 void Graph2D::initCap3D()
 {

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

@@ -1889,6 +1889,81 @@ void FastRouteCore::getOverflowPositions(
   }
 }
 
+// Search in range of 5 the correct adjustment to fix the overflow
+void FastRouteCore::getPrecisionAdjustment(const int x,
+                                           const int y,
+                                           bool is_horizontal,
+                                           int& adjustment)
+{
+  int new_2D_cap, usage_2D, range = 5;
+  if (is_horizontal) {
+    usage_2D = graph2d_.getUsageH(x, y);
+  } else {
+    usage_2D = graph2d_.getUsageV(x, y);
+  }
+
+  new_2D_cap = 0;
+  while (range > 0 && new_2D_cap < usage_2D) {
+    // calculate new capacity with adjustment
+    for (int l = 0; l < num_layers_; l++) {
+      if (is_horizontal) {
+        new_2D_cap
+            += (1.0 - (adjustment / 100.0)) * h_edges_3D_[l][y][x].real_cap;
+      } else {
+        new_2D_cap
+            += (1.0 - (adjustment / 100.0)) * v_edges_3D_[l][y][x].real_cap;
+      }
+    }
+    // Reduce adjustment to increase capacity
+    if (usage_2D > new_2D_cap) {
+      adjustment--;
+      new_2D_cap = 0;
+    }
+    range--;
+  }
+}
+
+// For each edge with overflow, calculate the ideal adjustment
+// Return the minimum value of all or -1 if no value can be found
+bool FastRouteCore::computeSuggestedAdjustment(int& suggested_adjustment)
+{
+  int horizontal_suggest = 100, local_suggest;
+  bool has_new_adj;
+  // Find horizontal ggrids with congestion
+  for (const auto& [x, y] : graph2d_.getUsedGridsH()) {
+    const int overflow = graph2d_.getOverflowH(x, y);
+    if (overflow > 0) {
+      has_new_adj
+          = graph2d_.computeSuggestedAdjustment(x, y, true, local_suggest);
+      if (has_new_adj) {
+        // modify the value to resolve the congestion at the position
+        getPrecisionAdjustment(x, y, true, local_suggest);
+        horizontal_suggest = std::min(horizontal_suggest, local_suggest);
+      } else {
+        return false;
+      }
+    }
+  }
+  int vertical_suggest = 100;
+  // Find vertical ggrids with congestion
+  for (const auto& [x, y] : graph2d_.getUsedGridsV()) {
+    const int overflow = graph2d_.getOverflowV(x, y);
+    if (overflow > 0) {
+      has_new_adj
+          = graph2d_.computeSuggestedAdjustment(x, y, false, local_suggest);
+      if (has_new_adj) {
+        // modify the value to resolve the congestion at the position
+        getPrecisionAdjustment(x, y, false, local_suggest);
+        vertical_suggest = std::min(vertical_suggest, local_suggest);
+      } else {
+        return false;
+      }
+    }
+  }
+  suggested_adjustment = std::min(horizontal_suggest, vertical_suggest);
+  return true;
+}
+
 // The function will add the new nets to the congestion_nets set
 void FastRouteCore::getCongestionNets(std::set<odb::dbNet*>& congestion_nets)
 {

test/helpers.py

@@ -72,4 +72,7 @@ def make_design(tech):
     # suppress ord message with number of threads
     logger.suppressMessage(utl.ORD, 30)
 
+    # suppress grt message with the suggested adjustment
+    logger.suppressMessage(utl.GRT, 704)
+
     return design

test/helpers.tcl

@@ -210,3 +210,6 @@ suppress_message PAR 38
 
 # suppress ord message with number of threads
 suppress_message ORD 30
+
+# suppress grt message with the suggested adjustment
+suppress_message GRT 704