Merge pull request #8523 from The-OpenROAD-Project-staging/grt-resistance-aware

GRT: resistance-aware layer assignment and 3D routing

Author: eder-matheus

src/grt/README.md

@@ -29,6 +29,7 @@ global_route
     [-start_incremental]
     [-end_incremental]
     [-use_cugr]
+    [-resistance_aware]
 ```
 
 #### Options
@@ -46,6 +47,7 @@ global_route
 | `-start_incremental` | This flag initializes the GRT listener to get the net modified. The default is false. |
 | `-end_incremental` | This flag run incremental GRT with the nets modified. The default is false. |
 | `-use_cugr` | This flag run GRT using CUGR as the router solver. NOTE: this is not ready for production. |
+| `-resistance_aware` | This flag enables resistance-aware layer assignment and 3D routing. NOTE: this is not ready for production. |
 
 ### Set Routing Layers
 

src/grt/include/grt/GlobalRouter.h

@@ -151,6 +151,7 @@ class GlobalRouter
   void setCongestionReportFile(const char* file_name);
   void setGridOrigin(int x, int y);
   void setAllowCongestion(bool allow_congestion);
+  void setResistanceAware(bool resistance_aware);
   void setMacroExtension(int macro_extension);
   void setUseCUGR(bool use_cugr) { use_cugr_ = use_cugr; };
 
@@ -484,6 +485,7 @@ class GlobalRouter
   int congestion_iterations_{50};
   int congestion_report_iter_step_;
   bool allow_congestion_;
+  bool resistance_aware_{false};
   std::vector<int> vertical_capacities_;
   std::vector<int> horizontal_capacities_;
   int macro_extension_;

src/grt/src/GlobalRouter.cpp

@@ -2058,6 +2058,11 @@ void GlobalRouter::setAllowCongestion(bool allow_congestion)
   allow_congestion_ = allow_congestion;
 }
 
+void GlobalRouter::setResistanceAware(bool resistance_aware)
+{
+  resistance_aware_ = resistance_aware;
+}
+
 void GlobalRouter::setMacroExtension(int macro_extension)
 {
   macro_extension_ = macro_extension;
@@ -2159,6 +2164,7 @@ void GlobalRouter::configFastRoute()
   fastroute_->setVerbose(verbose_);
   fastroute_->setOverflowIterations(congestion_iterations_);
   fastroute_->setCongestionReportIterStep(congestion_report_iter_step_);
+  fastroute_->setResistanceAware(resistance_aware_);
 
   if (congestion_file_name_ != nullptr) {
     fastroute_->setCongestionReportFile(congestion_file_name_);

src/grt/src/GlobalRouter.i

@@ -104,6 +104,12 @@ set_allow_congestion(bool allowCongestion)
   getGlobalRouter()->setAllowCongestion(allowCongestion);
 }
 
+void
+set_resistance_aware(bool resistance_aware)
+{
+  getGlobalRouter()->setResistanceAware(resistance_aware);
+}
+
 void
 set_critical_nets_percentage(float criticalNetsPercentage)
 {

src/grt/src/GlobalRouter.tcl

@@ -150,15 +150,17 @@ sta::define_cmd_args "global_route" {[-guide_file out_file] \
                                   [-verbose] \
                                   [-start_incremental] \
                                   [-end_incremental] \
-                                  [-use_cugr]
+                                  [-use_cugr] \
+                                  [-resistance_aware]
 }
 
 proc global_route { args } {
   sta::parse_key_args "global_route" args \
     keys {-guide_file -congestion_iterations -congestion_report_file \
           -grid_origin -critical_nets_percentage -congestion_report_iter_step
          } \
-    flags {-allow_congestion -verbose -start_incremental -end_incremental -use_cugr}
+    flags {-allow_congestion -resistance_aware -verbose -start_incremental -end_incremental \
+          -use_cugr}
 
   sta::check_argc_eq0 "global_route" $args
 
@@ -215,6 +217,9 @@ proc global_route { args } {
   set allow_congestion [info exists flags(-allow_congestion)]
   grt::set_allow_congestion $allow_congestion
 
+  set resistance_aware [info exists flags(-resistance_aware)]
+  grt::set_resistance_aware $resistance_aware
+
   set start_incremental [info exists flags(-start_incremental)]
   set end_incremental [info exists flags(-end_incremental)]
 

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

@@ -238,6 +238,7 @@ struct OrderNetPin
   int minX;
   float length_per_pin;  // net length over pin count
   int ndr_priority;      // NDR nets are assigned first
+  float slack;
 };
 
 struct OrderTree

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

@@ -103,6 +103,7 @@ class FastRouteCore
   void addHCapacity(short horizontalCapacity, int layer);
   void setLowerLeft(int x, int y);
   void setTileSize(int size);
+  void setResistanceAware(bool resistance_aware);
   void addLayerDirection(int layer_idx, const odb::dbTechLayerDir& direction);
   FrNet* addNet(odb::dbNet* db_net,
                 bool is_clock,
@@ -354,6 +355,14 @@ class FastRouteCore
   void reInitTree(int netID);
 
   // maze3D functions
+  float getMazeRouteCost3D(int net_id,
+                           int from_layer,
+                           int to_layer,
+                           int from_x,
+                           int from_y,
+                           int to_x,
+                           int to_y,
+                           bool is_via);
   void mazeRouteMSMDOrder3D(int expand, int ripupTHlb, int ripupTHub);
   void addNeighborPoints(int netID,
                          int n1,
@@ -513,6 +522,8 @@ class FastRouteCore
                          int& best_cost,
                          multi_array<int, 2>& layer_grid);
   void assignEdge(int netID, int edgeID, bool processDIR);
+  int getLayerResistance(int layer, int length, FrNet* net);
+  int getViaResistance(int from_layer, int to_layer);
   void recoverEdge(int netID, int edgeID);
   void layerAssignmentV4();
   void netpinOrderInc();
@@ -589,6 +600,7 @@ class FastRouteCore
   int x_range_;
   int y_range_;
 
+  bool resistance_aware_ = false;
   int num_adjust_;
   int v_capacity_;
   int h_capacity_;

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

@@ -1802,6 +1802,11 @@ void FastRouteCore::setCongestionReportIterStep(int congestion_report_iter_step)
   congestion_report_iter_step_ = congestion_report_iter_step;
 }
 
+void FastRouteCore::setResistanceAware(bool resistance_aware)
+{
+  resistance_aware_ = resistance_aware;
+}
+
 void FastRouteCore::setCongestionReportFile(const char* congestion_file_name)
 {
   congestion_file_name_ = congestion_file_name;

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

@@ -652,6 +652,57 @@ void FastRouteCore::updateRouteType23D(int netID,
   }
 }
 
+// Resistance-aware cost calculation
+float FastRouteCore::getMazeRouteCost3D(const int net_id,
+                                        const int from_layer,
+                                        const int to_layer,
+                                        const int from_x,
+                                        const int from_y,
+                                        const int to_x,
+                                        const int to_y,
+                                        const bool is_via)
+{
+  FrNet* net = nets_[net_id];
+  float base_cost = 1.0;
+
+  if (is_via) {
+    // Via transition cost
+    base_cost = via_cost_;
+    const int via_resistance = getViaResistance(from_layer, to_layer);
+
+    return base_cost + via_resistance;
+  }
+
+  // Wire segment cost
+  const float length = abs(to_x - from_x) + abs(to_y - from_y);
+  const float wire_resistance
+      = getLayerResistance(from_layer, length * tile_size_, net);
+
+  // Check congestion
+  bool congested = false;
+  if (from_x == to_x) {  // vertical
+    int min_y = std::min(from_y, to_y);
+    if (v_edges_3D_[from_layer][min_y][from_x].usage
+            + net->getLayerEdgeCost(from_layer)
+        > v_edges_3D_[from_layer][min_y][from_x].cap) {
+      congested = true;
+    }
+  } else {  // horizontal
+    int min_x = std::min(from_x, to_x);
+    if (h_edges_3D_[from_layer][from_y][min_x].usage
+            + net->getLayerEdgeCost(from_layer)
+        > h_edges_3D_[from_layer][from_y][min_x].cap) {
+      congested = true;
+    }
+  }
+
+  if (congested) {
+    base_cost = BIG_INT;  // Heavy penalty for congestion
+  }
+
+  return base_cost + wire_resistance;
+}
+
 void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
                                          int ripupTHlb,
                                          int ripupTHub)
@@ -766,7 +817,9 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
           // left
           if (curX > regionX1
               && directions_3D_[curL][curY][curX] != Direction::East) {
-            const float tmp = d1_3D_[curL][curY][curX] + 1;
+            const float cost = getMazeRouteCost3D(
+                netID, curL, curL, curX, curY, curX - 1, curY, false);
+            const float tmp = d1_3D_[curL][curY][curX] + cost;
             if (h_edges_3D_[curL][curY][curX - 1].usage + edge_cost
                     <= h_edges_3D_[curL][curY][curX - 1].cap
                 && net->getMinLayer() <= curL && curL <= net->getMaxLayer()) {
@@ -811,7 +864,9 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
           // right
           if (Horizontal && curX < regionX2
               && directions_3D_[curL][curY][curX] != Direction::West) {
-            const float tmp = d1_3D_[curL][curY][curX] + 1;
+            const float cost = getMazeRouteCost3D(
+                netID, curL, curL, curX, curY, curX + 1, curY, false);
+            const float tmp = d1_3D_[curL][curY][curX] + cost;
             const int tmpX = curX + 1;  // the right neighbor
 
             if (h_edges_3D_[curL][curY][curX].usage + edge_cost
@@ -857,7 +912,9 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
           // bottom
           if (!Horizontal && curY > regionY1
               && directions_3D_[curL][curY][curX] != Direction::South) {
-            const float tmp = d1_3D_[curL][curY][curX] + 1;
+            const float cost = getMazeRouteCost3D(
+                netID, curL, curL, curX, curY, curX, curY - 1, false);
+            const float tmp = d1_3D_[curL][curY][curX] + cost;
             const int tmpY = curY - 1;  // the bottom neighbor
             if (v_edges_3D_[curL][curY - 1][curX].usage + edge_cost
                     <= v_edges_3D_[curL][curY - 1][curX].cap
@@ -901,7 +958,9 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
           // top
           if (!Horizontal && curY < regionY2
               && directions_3D_[curL][curY][curX] != Direction::North) {
-            const float tmp = d1_3D_[curL][curY][curX] + 1;
+            const float cost = getMazeRouteCost3D(
+                netID, curL, curL, curX, curY, curX, curY + 1, false);
+            const float tmp = d1_3D_[curL][curY][curX] + cost;
             const int tmpY = curY + 1;  // the top neighbor
             if (v_edges_3D_[curL][curY][curX].usage + edge_cost
                     <= v_edges_3D_[curL][curY][curX].cap
@@ -945,7 +1004,10 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
 
         // down
         if (curL > 0 && directions_3D_[curL][curY][curX] != Direction::Up) {
-          const float tmp = d1_3D_[curL][curY][curX] + via_cost_;
+          // Via cost
+          const float cost = getMazeRouteCost3D(
+              netID, curL, curL - 1, curX, curY, curX, curY, true);
+          const float tmp = d1_3D_[curL][curY][curX] + cost;
           const int tmpL = curL - 1;  // the bottom neighbor
 
           if (d1_3D_[tmpL][curY][curX]
@@ -986,7 +1048,10 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
         // up
         if (curL < num_layers_ - 1
             && directions_3D_[curL][curY][curX] != Direction::Down) {
-          const float tmp = d1_3D_[curL][curY][curX] + via_cost_;
+          // Via cost
+          const float cost = getMazeRouteCost3D(
+              netID, curL, curL + 1, curX, curY, curX, curY, true);
+          const float tmp = d1_3D_[curL][curY][curX] + cost;
           const int tmpL = curL + 1;  // the bottom neighbor
           if (d1_3D_[tmpL][curY][curX]
               >= BIG_INT)  // bottom neighbor not been put into src_heap_3D