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

grt: resistance aware enhancements

Author: maliberty

src/est/src/EstimateParasitics.cpp

@@ -526,7 +526,13 @@ void EstimateParasitics::estimateGlobalRouteParasitics(odb::dbNet* net,
   initBlock();
   MakeWireParasitics builder(
       logger_, this, sta_, db_->getTech(), block_, global_router_);
-  builder.estimateParasitics(net, route);
+
+  // Check if we are estimating parasitics after layer assignment
+  if (route.at(0).is3DRoute()) {
+    builder.estimateParasitics(net, route, nullptr);
+  } else {
+    builder.estimateParasitics(net, route);
+  }
 }
 
 void EstimateParasitics::clearParasitics()

src/grt/include/grt/GRoute.h

@@ -26,10 +26,13 @@ struct GSegment
   int final_y;
   int final_layer;
   bool is_jumper;
+  bool is_3d_route = false;
   GSegment() = default;
   GSegment(int x0, int y0, int l0, int x1, int y1, int l1, bool jumper = false);
   bool isVia() const { return (init_x == final_x && init_y == final_y); }
   bool isJumper() const { return is_jumper; }
+  bool is3DRoute() const { return is_3d_route; }
+  void setIs3DRoute(bool is_3d) { is_3d_route = is_3d; }
   int length() const
   {
     return std::abs(init_x - final_x) + std::abs(init_y - final_y);

src/grt/include/grt/GlobalRouter.h

@@ -486,7 +486,7 @@ class GlobalRouter
   std::vector<RoutingTracks> routing_tracks_;
 
   // Flow variables
-  bool is_incremental;
+  bool is_incremental_;
   float adjustment_;
   int layer_for_guide_dimension_;
   int congestion_iterations_{50};

src/grt/src/GlobalRouter.cpp

@@ -217,7 +217,7 @@ NetRouteMap GlobalRouter::getPartialRoutes()
 {
   NetRouteMap net_routes;
   // TODO: still need to fix this during incremental grt
-  if (is_incremental) {
+  if (is_incremental_) {
     for (const auto& [db_net, net] : db_net_map_) {
       if (routes_[db_net].empty()) {
         GRoute route;
@@ -304,7 +304,7 @@ void GlobalRouter::globalRoute(bool save_guides,
                                bool end_incremental)
 {
   bool has_routable_nets = false;
-  is_incremental = (start_incremental || end_incremental);
+  is_incremental_ = (start_incremental || end_incremental);
 
   for (auto net : db_->getChip()->getBlock()->getNets()) {
     if (net->getITerms().size() + net->getBTerms().size() > 1) {

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

@@ -246,6 +246,7 @@ struct OrderNetPin
   int ndr_priority;      // NDR nets are assigned first
   int res_aware;
   float slack;
+  int clock;
 };
 
 struct OrderTree

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

@@ -271,6 +271,7 @@ class FastRouteCore
 
   NetRouteMap getPlanarRoutes();
   void getPlanarRoute(odb::dbNet* db_net, GRoute& route);
+  void get3DRoute(odb::dbNet* db_net, GRoute& route);
 
  private:
   int getEdgeCapacity(FrNet* net, int x1, int y1, EdgeDirection direction);
@@ -280,7 +281,7 @@ class FastRouteCore
   double dbuToMicrons(int dbu);
   odb::Rect globalRoutingToBox(const GSegment& route);
   NetRouteMap getRoutes();
-  void updateSlacks(float percentage = 0.7);
+  void updateSlacks(float percentage = 1);
   void preProcessTechLayers();
   odb::dbTechLayer* getTechLayer(int layer, bool is_via);
 
@@ -609,9 +610,10 @@ class FastRouteCore
   int x_range_;
   int y_range_;
 
-  bool estimate_parasitics_ = false;
+  bool en_estimate_parasitics_ = false;
   bool resistance_aware_ = false;
   bool enable_resistance_aware_ = false;
+  bool is_3d_step_ = false;
   int num_adjust_;
   int v_capacity_;
   int h_capacity_;

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

@@ -1011,16 +1011,155 @@ void FastRouteCore::getPlanarRoute(odb::dbNet* db_net, GRoute& route)
   }
 }
 
+void FastRouteCore::get3DRoute(odb::dbNet* db_net, GRoute& route)
+{
+  int netID;
+  bool exists;
+  getNetId(db_net, netID, exists);
+
+  std::unordered_set<GSegment, GSegmentHash> net_segs;
+
+  const auto& treeedges = sttrees_[netID].edges;
+  const int num_edges = sttrees_[netID].num_edges();
+
+  for (int edgeID = 0; edgeID < num_edges; edgeID++) {
+    const TreeEdge* treeedge = &(treeedges[edgeID]);
+    if (treeedge->len > 0) {
+      int routeLen = treeedge->route.routelen;
+      const std::vector<GPoint3D>& grids = treeedge->route.grids;
+      const int num_terminals = sttrees_[netID].num_terminals;
+      const auto& treenodes = sttrees_[netID].nodes;
+      int node1_alias = treeedge->n1a;
+      int node2_alias = treeedge->n2a;
+
+      std::vector<GPoint3D> filled_grids;
+
+      // Handle vias for node1_alias (start node)
+      if (treenodes[node1_alias].hID == edgeID
+          || (edgeID == treenodes[node1_alias].lID
+              && treenodes[node1_alias].hID == BIG_INT
+              && node1_alias < num_terminals)) {
+        int16_t bottom_layer = treenodes[node1_alias].botL;
+        int16_t top_layer = treenodes[node1_alias].topL;
+        int16_t edge_init_layer = grids[0].layer;
+
+        if (node1_alias < num_terminals) {
+          int16_t pin_botL, pin_topL;
+          getViaStackRange(netID, node1_alias, pin_botL, pin_topL);
+          bottom_layer = std::min(pin_botL, bottom_layer);
+          top_layer = std::max(pin_topL, top_layer);
+
+          for (int16_t l = bottom_layer; l < top_layer; l++) {
+            filled_grids.push_back({grids[0].x, grids[0].y, l});
+          }
+
+          for (int16_t l = top_layer; l > edge_init_layer; l--) {
+            filled_grids.push_back({grids[0].x, grids[0].y, l});
+          }
+        } else {
+          for (int16_t l = bottom_layer; l < edge_init_layer; l++) {
+            filled_grids.push_back({grids[0].x, grids[0].y, l});
+          }
+        }
+      }
+
+      for (int j = 0; j <= routeLen; j++) {
+        filled_grids.emplace_back(grids[j]);
+      }
+
+      // Handle vias for node2_alias (end node)
+      if (treenodes[node2_alias].hID == edgeID
+          || (edgeID == treenodes[node2_alias].lID
+              && treenodes[node2_alias].hID == BIG_INT
+              && node2_alias < num_terminals)) {
+        int16_t bottom_layer = treenodes[node2_alias].botL;
+        int16_t top_layer = treenodes[node2_alias].topL;
+        if (node2_alias < num_terminals) {
+          int16_t pin_botL, pin_topL;
+          getViaStackRange(netID, node2_alias, pin_botL, pin_topL);
+          bottom_layer = std::min(pin_botL, bottom_layer);
+          top_layer = std::max(pin_topL, top_layer);
+
+          // Adjust bottom_layer if it's the same as the last filled grid layer
+          if (bottom_layer == filled_grids.back().layer) {
+            bottom_layer++;
+          }
+
+          // Ensure the loop for descending vias is correct
+          for (int16_t l = filled_grids.back().layer - 1; l > bottom_layer;
+               l--) {
+            filled_grids.push_back(
+                {filled_grids.back().x, filled_grids.back().y, l});
+          }
+
+          for (int16_t l = bottom_layer; l <= top_layer; l++) {
+            filled_grids.push_back(
+                {filled_grids.back().x, filled_grids.back().y, l});
+          }
+        } else {
+          for (int16_t l = top_layer - 1; l >= bottom_layer; l--) {
+            filled_grids.push_back(
+                {filled_grids.back().x, filled_grids.back().y, l});
+          }
+        }
+      }
+
+      int lastX = (tile_size_ * (filled_grids[0].x + 0.5)) + x_corner_;
+      int lastY = (tile_size_ * (filled_grids[0].y + 0.5)) + y_corner_;
+      int lastL = filled_grids[0].layer;
+
+      for (int i = 1; i < filled_grids.size(); i++) {
+        const int xreal = (tile_size_ * (filled_grids[i].x + 0.5)) + x_corner_;
+        const int yreal = (tile_size_ * (filled_grids[i].y + 0.5)) + y_corner_;
+        const int currentL = filled_grids[i].layer;
+
+        // Prevent adding segments that are effectively zero-length vias on the
+        // same layer
+        if (lastX == xreal && lastY == yreal && lastL == currentL) {
+          // Skip this segment as it's a redundant via on the same layer
+          lastX = xreal;
+          lastY = yreal;
+          lastL = currentL;
+          continue;
+        }
+
+        GSegment segment
+            = GSegment(lastX, lastY, lastL + 1, xreal, yreal, currentL + 1);
+        segment.setIs3DRoute(true);
+
+        // Only add segment if it's not a duplicate
+        if (net_segs.find(segment) == net_segs.end()) {
+          net_segs.insert(segment);
+          route.push_back(segment);
+        }
+
+        lastX = xreal;
+        lastY = yreal;
+        lastL = currentL;
+      }
+    }
+  }
+}
+
 NetRouteMap FastRouteCore::getPlanarRoutes()
 {
   NetRouteMap routes;
 
   // Get routes before layer assignment
-  for (const int& netID : net_ids_) {
-    auto fr_net = nets_[netID];
-    odb::dbNet* db_net = fr_net->getDbNet();
-    GRoute& route = routes[db_net];
-    getPlanarRoute(db_net, route);
+  if (!is_3d_step_) {
+    for (const int& netID : net_ids_) {
+      auto fr_net = nets_[netID];
+      odb::dbNet* db_net = fr_net->getDbNet();
+      GRoute& route = routes[db_net];
+      getPlanarRoute(db_net, route);
+    }
+  } else {
+    for (const int& netID : net_ids_) {
+      auto fr_net = nets_[netID];
+      odb::dbNet* db_net = fr_net->getDbNet();
+      GRoute& route = routes[db_net];
+      get3DRoute(db_net, route);
+    }
   }
 
   return routes;
@@ -1643,13 +1782,18 @@ NetRouteMap FastRouteCore::run()
   via_cost_ = 1;
 
   if (past_cong == 0) {
+    // Increase ripup threshold if res-aware is enabled
+    if (enable_resistance_aware_) {
+      long_edge_len = BIG_INT;
+    }
+
     mazeRouteMSMDOrder3D(enlarge_, 0, long_edge_len);
     mazeRouteMSMDOrder3D(enlarge_, 0, short_edge_len);
   }
 
   // Disable estimate parasitics for grt incremental steps with resistance-aware
   // strategy to prevent issues during repair design and repair timing
-  estimate_parasitics_ = false;
+  en_estimate_parasitics_ = false;
 
   if (logger_->debugCheck(GRT, "grtSteps", 1)) {
     getOverflow3D();
@@ -1819,7 +1963,7 @@ void FastRouteCore::setCongestionReportIterStep(int congestion_report_iter_step)
 void FastRouteCore::setResistanceAware(bool resistance_aware)
 {
   enable_resistance_aware_ = resistance_aware;
-  estimate_parasitics_ = true;
+  en_estimate_parasitics_ = true;
 }
 
 void FastRouteCore::setCongestionReportFile(const char* congestion_file_name)

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

@@ -695,6 +695,11 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
     }
   }
 
+  if (enable_resistance_aware_) {
+    updateSlacks(.8);
+    netpinOrderInc();
+  }
+
   const int endIND = tree_order_pv_.size() * 0.9;
 
   for (int orderIndex = 0; orderIndex < endIND; orderIndex++) {
@@ -720,6 +725,16 @@ void FastRouteCore::mazeRouteMSMDOrder3D(int expand,
       if (treeedge->len >= ripupTHub || treeedge->len <= ripupTHlb) {
         continue;
       }
+
+      // Force resistance-aware if edge length > 100
+      if (enable_resistance_aware_) {
+        if (treeedge->len > 100) {
+          resistance_aware_ = true;
+        } else {
+          resistance_aware_ = net->isResAware();
+        }
+      }
+
       int n1 = treeedge->n1;
       int n2 = treeedge->n2;
       const int n1x = treenodes[n1].x;