rsz: try to upsize driver when repairing load slew

Buffers created by repairNetWire now have a name dependant on their reason, similar to repairNetJunc

Signed-off-by: Tobias Senti <git@tsenti.li>

Author: TheMightyDuckOfDoom

src/rsz/include/rsz/Resizer.hh

@@ -613,6 +613,7 @@ class Resizer : public sta::dbStaState, public sta::dbNetworkObserver
   bool hasMultipleOutputs(const sta::Instance* inst);
 
   void resizePreamble();
+  void clearSwappableCellsCache();
   sta::LibertyCellSeq getSwappableCells(sta::LibertyCell* source_cell);
   sta::LibertyCellSeq getVTEquivCells(sta::LibertyCell* source_cell);
 

src/rsz/src/RepairDesign.cc

@@ -1075,6 +1075,8 @@ void RepairDesign::repairNet(sta::Net* net,
     estimate_parasitics_->ensureWireParasitic(drvr_pin, net);
     graph_delay_calc_->findDelays(drvr);
 
+    drvr_resized_ = false;
+
     if (check_slew) {
       bool slew_violation = false;
 
@@ -1096,7 +1098,7 @@ void RepairDesign::repairNet(sta::Net* net,
 
         slew_violation = true;
         if (repairDriverSlew(corner1, drvr_pin)) {
-          resize_count_++;
+          drvr_resized_ = true;
           estimate_parasitics_->updateParasitics();
           sta_->findDelays(drvr);
           checkSlew(drvr_pin, slew1, max_slew1, slew_slack1, corner1);
@@ -1181,6 +1183,10 @@ void RepairDesign::repairNet(sta::Net* net,
       }
     }
 
+    if (drvr_resized_) {
+      resize_count_++;
+    }
+
     if (repaired_net) {
       repaired_net_count++;
     }
@@ -1499,6 +1505,7 @@ void RepairDesign::repairNetWire(
     // offset from instance origin to pin and detailed placement movement.
     constexpr double length_margin = .05;
     bool split_wire = false;
+    const char* split_reason = "";
     // Distance from repeater to ref_.
     //              length
     // from----------------------------to/ref
@@ -1518,6 +1525,7 @@ void RepairDesign::repairNetWire(
                  units_->distanceUnit()->asString(dbuToMeters(max_length_), 1));
       split_length = min(max(max_length_ - wire_length_ref, 0), length / 2);
       split_wire = true;
+      split_reason = "wire_length";
     }
     if (wire_cap > 0.0 && load_cap > max_cap_) {
       debugPrint(logger_,
@@ -1532,6 +1540,7 @@ void RepairDesign::repairNetWire(
       split_length = min(split_length,
                          max(metersToDbu((max_cap_ - ref_cap) / wire_cap), 0));
       split_wire = true;
+      split_reason = "wire_cap";
     }
     if (load_slew > max_load_slew_margined) {
       debugPrint(logger_,
@@ -1543,44 +1552,53 @@ void RepairDesign::repairNetWire(
                  level,
                  delayAsString(load_slew, 3, this),
                  delayAsString(max_load_slew_margined, 3, this));
-      // We are inserting a buffer to cut this wire segment short.
-      // The slew at the end of the wire segment is a quadratic polynomial
-      // in terms of the wire segment's length (in Elmore approx.).
-      //
-      // We solve a quadratic eq. to find the maximum conforming length.
-      float a = wire_res * wire_cap / 2;
-      float b = (r_drvr * wire_cap) + (wire_res * ref_cap);
-      float c
-          = (r_drvr * ref_cap) - (max_load_slew_margined / (*slew_rc_factor_));
-      float l = 0.0;
-      if (a > 1e-12) {  // Quadratic case
-        const float discriminant = b * b - 4 * a * c;
-        if (discriminant >= 0.0) {
-          l = (-b + sqrt(discriminant)) / (2 * a);
+
+      // Check if we can upsize the driver to meet the slew requirement without
+      // inserting a buffer. Don't bother if we anyways insert a buffer for
+      // length or capacitance reasons.
+      if (split_wire
+          || !tryUpsizeDriver(
+              level, ref_cap, c_wire, r_wire, max_load_slew_margined)) {
+        // We are inserting a buffer to cut this wire segment short.
+        // The slew at the end of the wire segment is a quadratic polynomial
+        // in terms of the wire segment's length (in Elmore approx.).
+        //
+        // We solve a quadratic eq. to find the maximum conforming length.
+        float a = wire_res * wire_cap / 2;
+        float b = (r_drvr * wire_cap) + (wire_res * ref_cap);
+        float c = (r_drvr * ref_cap)
+                  - (max_load_slew_margined / (*slew_rc_factor_));
+        float l = 0.0;
+        if (a > 1e-12) {  // Quadratic case
+          const float discriminant = b * b - 4 * a * c;
+          if (discriminant >= 0.0) {
+            l = (-b + sqrt(discriminant)) / (2 * a);
+          }
+        } else if (b > 1e-12) {
+          // a * l^2 + b * l + c = 0 becomes
+          // b * l + c = 0 when a is very small
+          l = -c / b;
         }
-      } else if (b > 1e-12) {
-        // a * l^2 + b * l + c = 0 becomes
-        // b * l + c = 0 when a is very small
-        l = -c / b;
-      }
-      if (l >= 0.0) {
-        split_length = min(split_length, metersToDbu(l));
-      } else {
-        split_length = 0;
+        if (l >= 0.0) {
+          split_length = min(split_length, metersToDbu(l));
+        } else {
+          split_length = 0;
+        }
+        split_wire = true;
+        split_reason = "wire_slew";
       }
-      split_wire = true;
     }
 
     if (split_wire) {
-      debugPrint(
-          logger_,
-          RSZ,
-          "repair_net",
-          3,
-          "{:{}s}split length={}",
-          "",
-          level,
-          units_->distanceUnit()->asString(dbuToMeters(split_length), 1));
+      debugPrint(logger_,
+                 RSZ,
+                 "repair_net",
+                 3,
+                 "{:{}s}split length={} reason={}",
+                 "",
+                 level,
+                 units_->distanceUnit()->asString(dbuToMeters(split_length), 1),
+                 split_reason);
       // Distance from to_pt to repeater backward toward from_pt.
       // Note that split_length can be longer than the wire length
       // because it is the maximum value that satisfies max slew/cap.
@@ -1593,7 +1611,7 @@ void RepairDesign::repairNetWire(
       int buf_x = to_x + d * dx;
       int buf_y = to_y + d * dy;
       float repeater_cap, repeater_fanout;
-      if (!makeRepeater("wire",
+      if (!makeRepeater(split_reason,
                         odb::Point(buf_x, buf_y),
                         buffer_cell,
                         /* resize= */ true,
@@ -1656,6 +1674,172 @@ float RepairDesign::maxSlewMargined(float max_slew)
   return max_slew * (1.0 - slew_margin_ / 100.0);
 }
 
+void RepairDesign::clearDriverCellsCache()
+{
+  driver_cells_cache_.clear();
+}
+
+// Returns swappable drivers sorted by drive resistance (low to high)
+sta::LibertyCellSeq RepairDesign::getDriverCells(sta::LibertyCell* driver_cell,
+                                                 std::string driver_port_name)
+{
+  if (driver_cells_cache_.find(driver_cell) != driver_cells_cache_.end()) {
+    if (driver_cells_cache_[driver_cell].find(driver_port_name)
+        != driver_cells_cache_[driver_cell].end()) {
+      return driver_cells_cache_[driver_cell][driver_port_name];
+    }
+  } else {
+    driver_cells_cache_[driver_cell] = {};
+  }
+
+  sta::LibertyCellSeq swappable_cells
+      = resizer_->getSwappableCells(driver_cell);
+
+  std::ranges::sort(
+      swappable_cells,
+      [driver_port_name](sta::LibertyCell* a, sta::LibertyCell* b) {
+        sta::LibertyPort* port_a = a->findLibertyPort(driver_port_name);
+        sta::LibertyPort* port_b = b->findLibertyPort(driver_port_name);
+        return port_a->driveResistance() < port_b->driveResistance();
+      });
+
+  driver_cells_cache_[driver_cell][driver_port_name] = swappable_cells;
+  return swappable_cells;
+}
+
+bool RepairDesign::tryUpsizeDriver(const int level,
+                                   const double ref_cap,
+                                   const double c_wire,
+                                   const double r_wire,
+                                   const float max_load_slew_margined)
+{
+  if (network_->isTopLevelPort(drvr_pin_)) {
+    return false;
+  }
+
+  sta::Instance* driver_inst = network_->instance(drvr_pin_);
+  if (resizer_->dontTouch(driver_inst)) {
+    return false;
+  }
+
+  debugPrint(
+      logger_,
+      RSZ,
+      "repair_net",
+      3,
+      "{:{}s}considering resizing driver {} to meet slew/cap requirement "
+      "without buffering",
+      "",
+      level,
+      network_->pathName(drvr_pin_));
+
+  sta::LibertyCell* driver_cell = network_->libertyCell(driver_inst);
+  std::string driver_port_name = network_->portName(drvr_pin_);
+  sta::LibertyCellSeq swappable_cells
+      = getDriverCells(driver_cell, driver_port_name);
+
+  const float orig_r_drvr = resizer_->driveResistance(drvr_pin_);
+
+  if (!swappable_cells.empty()) {
+    sta::LibertyCell* upsized_driver_cell = nullptr;
+    for (sta::LibertyCell* candidate_cell : swappable_cells) {
+      sta::LibertyPort* candidate_port
+          = candidate_cell->findLibertyPort(driver_port_name);
+
+      const float candidate_r_drvr = candidate_port->driveResistance();
+
+      if (candidate_r_drvr >= orig_r_drvr) {
+        debugPrint(
+            logger_,
+            RSZ,
+            "repair_net",
+            3,
+            "{:{}s}candidate cell {} has drive resistance {} which is not "
+            "lower than current driver resistance {}, stopping search",
+            "",
+            level,
+            candidate_cell->name(),
+            units_->resistanceUnit()->asString(candidate_r_drvr, 3),
+            units_->resistanceUnit()->asString(orig_r_drvr, 3));
+        break;
+      }
+
+      debugPrint(logger_,
+                 RSZ,
+                 "repair_net",
+                 3,
+                 "{:{}s}considering candidate cell {} with drive resistance {}",
+                 "",
+                 level,
+                 candidate_cell->name(),
+                 units_->resistanceUnit()->asString(candidate_r_drvr, 3));
+
+      assert(slew_rc_factor_.has_value());
+      const double candidate_load_slew
+          = (candidate_r_drvr * (c_wire + ref_cap) + r_wire * ref_cap
+             + r_wire * c_wire / 2)
+            * (*slew_rc_factor_);
+
+      // Check that we do not violate the max output slew of the driver.
+      float candidate_max_output_slew = sta::INF;
+      {
+        float max_output_slew = sta::INF;
+        bool exists;
+        candidate_port->slewLimit(max_, max_output_slew, exists);
+        if (exists) {
+          candidate_max_output_slew = maxSlewMargined(max_output_slew);
+        }
+      }
+
+      if (candidate_load_slew > max_load_slew_margined) {
+        // Break as remaining candidates all have higher drive resistance
+        break;
+      }
+
+      if (candidate_load_slew <= candidate_max_output_slew) {
+        debugPrint(
+            logger_,
+            RSZ,
+            "repair_net",
+            3,
+            "{:{}s}resizing driver to {} meets slew requirement with estimated "
+            "load slew {} <= {} and max output slew {} <= {}",
+            "",
+            level,
+            candidate_cell->name(),
+            delayAsString(candidate_load_slew, 3, this),
+            delayAsString(max_load_slew_margined, 3, this),
+            delayAsString(candidate_load_slew, 3, this),
+            delayAsString(candidate_max_output_slew, 3, this));
+        upsized_driver_cell = candidate_cell;
+      }
+    }
+
+    if (upsized_driver_cell) {
+      // We found a candidate cell that can be swapped to that meets the
+      // slew requirement
+      debugPrint(logger_,
+                 RSZ,
+                 "repair_net",
+                 3,
+                 "{:{}s}resizing driver from {} to {} to meet slew requirement "
+                 "without buffering",
+                 "",
+                 level,
+                 driver_cell->name(),
+                 upsized_driver_cell->name());
+      resizer_->replaceCell(driver_inst, upsized_driver_cell, true);
+
+      // Update drvr_pin_ to point to the new cell's output pin
+      drvr_pin_ = network_->findPin(driver_inst, driver_port_name);
+      drvr_resized_ = true;
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void RepairDesign::repairNetJunc(
     const BufferedNetPtr& bnet,
     int level,
@@ -1756,15 +1940,20 @@ void RepairDesign::repairNetJunc(
                level,
                delayAsString(slew_slack_left, 3, this),
                delayAsString(slew_slack_right, 3, this));
-    // Isolate the branch with the smaller slack.
-    if (slew_slack_left < slew_slack_right) {
-      repeater_left = true;
-    } else {
-      repeater_right = true;
+
+    // Check if we can upsize the driver to meet the slew requirement without
+    // inserting a buffer.
+    if (!tryUpsizeDriver(level, load_cap, 0.0, 0.0, max_load_slew_margined)) {
+      // Isolate the branch with the smaller slack.
+      if (slew_slack_left < slew_slack_right) {
+        repeater_left = true;
+      } else {
+        repeater_right = true;
+      }
+      repeater_reason = "load_slew";
     }
-    repeater_reason = "load_slew";
   }
-  bool cap_violation = (cap_left + cap_right) > max_cap_;
+  bool cap_violation = load_cap > max_cap_;
   if (cap_violation) {
     debugPrint(logger_, RSZ, "repair_net", 3, "{:{}s}cap violation", "", level);
     if (cap_left > cap_right) {

src/rsz/src/RepairDesign.hh

@@ -174,6 +174,14 @@ class RepairDesign : sta::dbStaState
                      // Return values.
                      int& wire_length,
                      sta::PinSeq& load_pins);
+  void clearDriverCellsCache();
+  sta::LibertyCellSeq getDriverCells(sta::LibertyCell* driver_cell,
+                                     std::string driver_port_name);
+  bool tryUpsizeDriver(int level,
+                       double ref_cap,
+                       double c_wire,
+                       double r_wire,
+                       float max_load_slew_margined);
   float maxSlewMargined(float max_slew);
   double findSlewLoadCap(sta::LibertyPort* drvr_port,
                          double slew,
@@ -256,8 +264,14 @@ class RepairDesign : sta::dbStaState
   // Gain buffering
   std::vector<sta::LibertyCell*> buffer_sizes_;
 
+  // Swappable driver cells sorted by drive resistance (low to high)
+  std::unordered_map<sta::LibertyCell*,
+                     std::unordered_map<std::string, sta::LibertyCellSeq>>
+      driver_cells_cache_;
+
   // Implicit arguments to repairNet bnet recursion.
   const sta::Pin* drvr_pin_ = nullptr;
+  bool drvr_resized_ = false;
   float max_cap_ = 0;
   int max_length_ = 0;
   double slew_margin_ = 0;