Merge pull request #10542 from The-OpenROAD-Project-staging/rsz-repair-design-reroute

RSZ: repair design reroute for slew fix

Author: jfgava

src/grt/include/grt/GlobalRouter.h

@@ -317,7 +317,7 @@ class GlobalRouter
   float getLayerResistance(int layer, int length, odb::dbNet* net);
   float getViaResistance(int from_layer, int to_layer);
   float getFRNetResistance(odb::dbNet* db_net);
-  float getFRNetResistanceOnMinClockLayer(odb::dbNet* db_net);
+  float getFRNetResistanceOnMinResistanceLayer(odb::dbNet* db_net);
   double dbuToMicrons(int dbu);
   float estimatePathResistance(odb::dbObject* pin1,
                                odb::dbObject* pin2,

src/grt/src/GlobalRouter.cpp

@@ -3829,12 +3829,28 @@ float GlobalRouter::getFRNetResistance(odb::dbNet* db_net)
   return fastroute_->getNetResistance(db_net);
 }
 
-float GlobalRouter::getFRNetResistanceOnMinClockLayer(odb::dbNet* db_net)
-{
-  int min_layer = getMinLayerForClock() > 0 ? getMinLayerForClock()
-                                            : getMinRoutingLayer();
+float GlobalRouter::getFRNetResistanceOnMinResistanceLayer(odb::dbNet* db_net)
+{
+  const int min_routing_layer = getMinRoutingLayer();
+  const int max_routing_layer = getMaxRoutingLayer();
+  int min_res_layer = min_routing_layer;
+  float min_res_per_width = std::numeric_limits<float>::max();
+  for (const auto& [layer_idx, tech_layer] : routing_layers_) {
+    if (layer_idx < min_routing_layer || layer_idx > max_routing_layer) {
+      continue;
+    }
+    const float width = static_cast<float>(tech_layer->getWidth());
+    const float resistance = static_cast<float>(tech_layer->getResistance());
+    if (width > 0 && resistance > 0) {
+      const float res_per_width = resistance / width;
+      if (res_per_width < min_res_per_width) {
+        min_res_per_width = res_per_width;
+        min_res_layer = layer_idx;
+      }
+    }
+  }
   // FastRouteCore uses 0-based layer indices; routing layer numbers are 1-based
-  return fastroute_->getNetResistanceOnLayer(db_net, min_layer - 1);
+  return fastroute_->getNetResistanceOnLayer(db_net, min_res_layer - 1);
 }
 
 float GlobalRouter::estimatePathResistance(odb::dbObject* pin1,

src/rsz/README.md

@@ -149,6 +149,7 @@ repair_design
     [-pre_placement]
     [-buffer_gain float_value] (deprecated)
     [-match_cell_footprint]
+    [-reroute]
     [-verbose]
 ```
 
@@ -163,6 +164,7 @@ repair_design
 | `-pre_placement` | Enables performing an initial pre-placement sizing and buffering round. |
 | `-buffer_gain` | Deprecated alias for `-pre_placement`. The passed value is ignored. |
 | `-match_cell_footprint` | Obey the Liberty cell footprint when swapping gates. |
+| `-reroute` | Enable resistance-aware wire rerouting to fix slew violations post-GRT (experimental). |
 | `-verbose` | Enable verbose logging on progress of the repair. |
 
 #### Instance Name Prefixes

src/rsz/include/rsz/Resizer.hh

@@ -427,8 +427,15 @@ class Resizer : public sta::dbStaState, public sta::dbNetworkObserver
       double cap_margin,       // 0.0-1.0
       double buffer_gain,
       bool match_cell_footprint,
+      bool reroute,
       bool verbose);
   int repairDesignBufferCount() const;
+  // Try to reroute the net driven by drvr_pin to a lower-resistance layer.
+  // Returns true if the reroute was accepted (net marked dirty for incremental
+  // global re-routing and parasitics invalidated).  Returns false if the net
+  // was already rerouted, doesn't exist, or the expected resistance reduction
+  // is below the threshold.
+  bool tryRerouteNet(const sta::Pin* drvr_pin);
   // for debugging
   void repairNet(sta::Net* net,
                  double max_wire_length,  // meters
@@ -760,6 +767,7 @@ class Resizer : public sta::dbStaState, public sta::dbNetworkObserver
                      // Return values.
                      sta::Delay& delay,
                      sta::Slew& slew);
+  float getRerouteResistanceReduction();
 
  protected:
   void makeWireParasitic(sta::Net* net,
@@ -1048,6 +1056,9 @@ class Resizer : public sta::dbStaState, public sta::dbNetworkObserver
 
   std::shared_ptr<ResizerObserver> graphics_;
 
+  // Reroute
+  const float kMinResistanceReduction = 0.50f;
+
   int accepted_move_count_ = 0;
   int rejected_move_count_ = 0;
 

src/rsz/src/RepairDesign.cc

@@ -135,6 +135,11 @@ void RepairDesign::computeSlewRCFactor()
   slew_rc_factor_ = factor * (1 + pessimism);
 }
 
+bool RepairDesign::rerouteEnabled() const
+{
+  return reroute_;
+}
+
 // Repair long wires, max slew, max capacitance, max fanout violations
 // The whole enchilada.
 // max_wire_length zero for none (meters)
@@ -301,6 +306,7 @@ void RepairDesign::repairDesign(
   repaired_net_count = 0;
   inserted_buffer_count_ = 0;
   resize_count_ = 0;
+  rerouted_nets_ = 0;
   resizer_->resized_multi_output_insts_.clear();
 
   sta_->checkSlewsPreamble();
@@ -1100,21 +1106,44 @@ void RepairDesign::repairNet(sta::Net* net,
                    delayAsString(max_slew1, 3, this));
 
         slew_violation = true;
-        if (repairDriverSlew(corner1, drvr_pin)) {
-          resize_count_++;
+
+        // Try rerouting to a lower-resistance layer first. If the reroute
+        // reduces wire resistance enough, it may fix the slew violation
+        // without requiring driver resizing or buffer insertion.
+        if (rerouteEnabled() && resizer_->tryRerouteNet(drvr_pin)) {
+          rerouted_nets_++;
           estimate_parasitics_->updateParasitics();
           sta_->findDelays(drvr);
           checkSlew(drvr_pin, slew1, max_slew1, slew_slack1, corner1);
+          debugPrint(logger_,
+                     RSZ,
+                     "repair_net",
+                     2,
+                     "after reroute: drvr slew pin={} slew={} max_slew={}",
+                     network_->name(drvr_pin),
+                     delayAsString(slew1, 3, this),
+                     delayAsString(max_slew1, 3, this));
         }
 
-        // sta::Slew violation persists after resizing the driver, derive
-        // the max cap we need to apply to remove the slew violation
+        // If slew violation persists after reroute, fall back to driver
+        // resizing and, if still needed, buffer insertion.
         if (slew_slack1 < 0.0f) {
-          sta::LibertyPort* drvr_port = network_->libertyPort(drvr_pin);
-          if (drvr_port) {
-            max_cap = findSlewLoadCap(drvr_port, max_slew1, corner1);
-            corner = corner1;
-            repair_cap = true;
+          if (repairDriverSlew(corner1, drvr_pin)) {
+            resize_count_++;
+            estimate_parasitics_->updateParasitics();
+            sta_->findDelays(drvr);
+            checkSlew(drvr_pin, slew1, max_slew1, slew_slack1, corner1);
+          }
+
+          // sta::Slew violation persists after resizing the driver, derive
+          // the max cap we need to apply to remove the slew violation
+          if (slew_slack1 < 0.0f) {
+            sta::LibertyPort* drvr_port = network_->libertyPort(drvr_pin);
+            if (drvr_port) {
+              max_cap = findSlewLoadCap(drvr_port, max_slew1, corner1);
+              corner = corner1;
+              repair_cap = true;
+            }
           }
         }
       }
@@ -1133,6 +1162,7 @@ void RepairDesign::repairNet(sta::Net* net,
                      network_->name(drvr_pin),
                      delayAsString(slew1, 3, this),
                      delayAsString(max_slew1, 3, this));
+
           slew_violation = true;
           repair_load_slew = true;
           // If repair_cap is true, corner is already set to correspond
@@ -1141,8 +1171,24 @@ void RepairDesign::repairNet(sta::Net* net,
             corner = corner1;
           }
         } else if (corner_w_load_slew_viol) {
-          // There's a violation hidden by an annotation. Repair still
+          // There's a violation hidden by an annotation. The forward pass
+          // clamped the load pin slew to the limit, so checkLoadSlews above
+          // saw slack==0 and didn't fire. Try rerouting before falling back
+          // to buffer insertion. Even though we can't re-verify the slew here
+          // (the annotation is still active), an improved parasitic from
+          // rerouting will reduce how many buffers are needed.
           slew_violation = true;
+          if (rerouteEnabled() && resizer_->tryRerouteNet(drvr_pin)) {
+            rerouted_nets_++;
+            estimate_parasitics_->updateParasitics();
+            sta_->findDelays(drvr);
+            debugPrint(logger_,
+                       RSZ,
+                       "repair_net",
+                       2,
+                       "rerouted annotated-slew net {}",
+                       network_->name(drvr_pin));
+          }
           repair_load_slew = true;
           if (!repair_cap) {
             corner = corner_w_load_slew_viol;
@@ -2407,6 +2453,9 @@ void RepairDesign::reportViolationCounters(bool invalidate_driver_vertices,
   if (resize_count_ > 0) {
     logger_->info(utl::RSZ, 39, "Resized {} instances.", resize_count_);
   }
+  if (rerouted_nets_ > 0) {
+    logger_->info(utl::RSZ, 44, "Rerouted {} nets.", rerouted_nets_);
+  }
   if (inserted_buffer_count_ > 0) {
     logger_->info(utl::RSZ,
                   invalidate_driver_vertices ? 55 : 38,

src/rsz/src/RepairDesign.hh

@@ -66,6 +66,7 @@ class RepairDesign : sta::dbStaState
                     int& cap_violations,
                     int& fanout_violations,
                     int& length_violations);
+  bool rerouteEnabled() const;
   int insertedBufferCount() const { return inserted_buffer_count_; }
   void repairNet(sta::Net* net,
                  double max_wire_length,
@@ -266,6 +267,9 @@ class RepairDesign : sta::dbStaState
   double cap_margin_ = 0;
   const sta::Scene* corner_ = nullptr;
 
+  bool reroute_ = false;
+  int rerouted_nets_ = 0;
+
   int resize_count_ = 0;
   int inserted_buffer_count_ = 0;
   const sta::MinMax* min_ = sta::MinMax::min();

src/rsz/src/Resizer.cc

@@ -44,6 +44,7 @@
 #include "boost/multi_array.hpp"
 #include "db_sta/dbSta.hh"
 #include "est/EstimateParasitics.h"
+#include "grt/GRoute.h"
 #include "grt/GlobalRouter.h"
 #include "odb/PtrSetMap.h"
 #include "odb/db.h"
@@ -4810,6 +4811,7 @@ void Resizer::repairDesign(double max_wire_length,
                            double cap_margin,
                            double buffer_gain,
                            bool match_cell_footprint,
+                           bool reroute,
                            bool verbose)
 {
   utl::Timer timer;
@@ -4822,6 +4824,7 @@ void Resizer::repairDesign(double max_wire_length,
              == est::ParasiticsSrc::kDetailedRouting) {
     opendp_->initMacrosAndGrid();
   }
+  utl::SetAndRestore set_reroute(repair_design_->reroute_, reroute);
   repair_design_->repairDesign(
       max_wire_length, slew_margin, cap_margin, buffer_gain, verbose);
   logger_->info(RSZ, 504, "Runtime: {:.2f}s", timer.elapsed());
@@ -4832,6 +4835,90 @@ int Resizer::repairDesignBufferCount() const
   return repair_design_->insertedBufferCount();
 }
 
+float Resizer::getRerouteResistanceReduction()
+{
+  return kMinResistanceReduction;
+}
+
+bool Resizer::tryRerouteNet(const sta::Pin* drvr_pin)
+{
+  // Res-aware rerouting only makes sense with global-routing parasitics.
+  if (estimate_parasitics_->getParasiticsSrc()
+      != est::ParasiticsSrc::kGlobalRouting) {
+    return false;
+  }
+
+  sta::Net* net = network_->net(drvr_pin);
+  if (net == nullptr || dontTouch(drvr_pin)) {
+    return false;
+  }
+
+  odb::dbNet* db_net = db_network_->flatNet(net);
+  if (db_net == nullptr || db_net->isSpecial()) {
+    return false;
+  }
+
+  // Already scheduled for res-aware routing in a prior iteration.
+  if (global_router_->isNetResAware(db_net)) {
+    return false;
+  }
+
+  // Unconstrained nets have no timing path; res-aware routing will waste
+  // valuable resources.
+  const sta::Slack slack = sta_->slack(graph_->pinDrvrVertex(drvr_pin), max_);
+  if (slack == sta::INF) {
+    return false;
+  }
+
+  // Short nets (<=3 gcells) have negligible resistance; skip the reroute.
+  const int kShortNetGCellThreshold = 3;
+  const int tile_size = global_router_->getTileSize();
+  if (tile_size > 0) {
+    const grt::NetRouteMap& routes = global_router_->getRoutes();
+    auto it = routes.find(db_net);
+    if (it != routes.end()) {
+      int gcell_length = 0;
+      for (const grt::GSegment& seg : it->second) {
+        if (!seg.isVia()) {
+          gcell_length += seg.length() / tile_size;
+        }
+      }
+      if (gcell_length <= kShortNetGCellThreshold) {
+        return false;
+      }
+    }
+  }
+
+  // Only reroute if moving to the lowest-resistance layer saves enough
+  // resistance to justify the disruption.
+  const float resistance = global_router_->getFRNetResistance(db_net);
+  const float estimated_resistance
+      = global_router_->getFRNetResistanceOnMinResistanceLayer(db_net);
+  float reduction_ratio = 0.0f;
+  if (resistance > 0.0f) {
+    reduction_ratio = (resistance - estimated_resistance) / resistance;
+  }
+
+  if (reduction_ratio < kMinResistanceReduction) {
+    return false;
+  }
+
+  global_router_->setResistanceAware(true);
+  global_router_->addDirtyNet(db_net);
+  global_router_->setNetIsResAware(db_net, true);
+  estimate_parasitics_->parasiticsInvalid(db_net);
+
+  debugPrint(logger_,
+             utl::RSZ,
+             "reroute",
+             1,
+             "RepairDesign rerouting net {} (resistance {} -> {} estimated)",
+             db_net->getName(),
+             resistance,
+             estimated_resistance);
+  return true;
+}
+
 void Resizer::repairNet(sta::Net* net,
                         double max_wire_length,
                         double slew_margin,

src/rsz/src/Resizer.i

@@ -309,6 +309,7 @@ repair_design_cmd(double max_length,
                   double cap_margin,
                   bool pre_placement,
                   bool match_cell_footprint,
+                  bool reroute,
                   bool verbose)
 {
   ensureLinked();
@@ -318,6 +319,7 @@ repair_design_cmd(double max_length,
                         cap_margin,
                         pre_placement,
                         match_cell_footprint,
+                        reroute,
                         verbose);
 }
 

src/rsz/src/Resizer.tcl

@@ -148,12 +148,13 @@ sta::define_cmd_args "repair_design" {[-max_wire_length max_wire_length] \
                                       [-buffer_gain gain] \
                                       [-pre_placement] \
                                       [-match_cell_footprint] \
+                                      [-reroute] \
                                       [-verbose]}
 
 proc repair_design { args } {
   sta::parse_key_args "repair_design" args \
     keys {-max_wire_length -max_utilization -slew_margin -cap_margin -buffer_gain} \
-    flags {-match_cell_footprint -verbose -pre_placement}
+    flags {-match_cell_footprint -verbose -pre_placement -reroute}
 
   set max_wire_length [rsz::parse_max_wire_length keys]
   set slew_margin [rsz::parse_percent_margin_arg "-slew_margin" keys]
@@ -171,8 +172,9 @@ proc repair_design { args } {
   set max_wire_length [rsz::check_max_wire_length $max_wire_length false]
   set match_cell_footprint [info exists flags(-match_cell_footprint)]
   set verbose [info exists flags(-verbose)]
+  set reroute [info exists flags(-reroute)]
   rsz::repair_design_cmd $max_wire_length $slew_margin $cap_margin \
-    $pre_placement $match_cell_footprint $verbose
+    $pre_placement $match_cell_footprint $reroute $verbose
 }
 
 sta::define_cmd_args "repair_clock_nets" {[-max_wire_length max_wire_length]}