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/src/RepairDesign.cc

@@ -881,8 +881,8 @@ void RepairDesign::checkDriverArcSlew(const sta::Scene* corner,
     float in_slew
         = use_ideal_clk_slew
               ? sta_->cmdMode()->clkNetwork()->idealClkSlew(in_pin, in_rf, max_)
-              : float(graph_->slew(
-                    graph_->pinLoadVertex(in_pin), in_rf, dcalc_ap));
+              : float(
+                  graph_->slew(graph_->pinLoadVertex(in_pin), in_rf, dcalc_ap));
     const sta::Pvt* pvt = corner->sdc()->pvt(inst, max_);
     if (pvt == nullptr) {
       pvt = corner->sdc()->operatingConditions(max_);
@@ -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,54 @@ 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);
-        }
-      } 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));
+
+      // 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, load_cap, max_load_slew_margined)) {
+        r_drvr = resizer_->driveResistance(drvr_pin_);
       } else {
-        split_length = 0;
+        // 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;
+        }
+        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 +1612,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 +1675,138 @@ float RepairDesign::maxSlewMargined(float max_slew)
   return max_slew * (1.0 - slew_margin_ / 100.0);
 }
 
+bool RepairDesign::tryUpsizeDriver(const int level,
+                                   const float load_cap,
+                                   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);
+  sta::LibertyCellSeq swappable_cells
+      = resizer_->getSwappableCells(driver_cell);
+
+  std::string driver_port_name = network_->portName(drvr_pin_);
+  const float orig_r_drvr = resizer_->driveResistance(drvr_pin_);
+
+  if (!swappable_cells.empty()) {
+    std::ranges::sort(
+        swappable_cells,
+        [this, 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();
+        });
+
+    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));
+
+      const float candidate_load_slew
+          = candidate_r_drvr * load_cap * (*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
+          && 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 +1907,23 @@ void RepairDesign::repairNetJunc(
                level,
                delayAsString(slew_slack_left, 3, this),
                delayAsString(slew_slack_right, 3, this));
+
+    // Check if we can upsize the driver to meet the slew requirement without
+    // inserting a buffer.
+    bool fixed_by_resize
+        = tryUpsizeDriver(level, load_cap, 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;
+    if (!fixed_by_resize) {
+      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,9 @@ class RepairDesign : sta::dbStaState
                      // Return values.
                      int& wire_length,
                      sta::PinSeq& load_pins);
+  bool tryUpsizeDriver(const int level,
+                       const float load_cap,
+                       const float max_load_slew_margined);
   float maxSlewMargined(float max_slew);
   double findSlewLoadCap(sta::LibertyPort* drvr_port,
                          double slew,
@@ -258,6 +261,7 @@ class RepairDesign : sta::dbStaState
 
   // 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;