rsz: add pre-check for max cap sanity

The max cap on any driver should be at least as much as the minimum
input cap on an buffer or inverter.  If not repair is impossible.

Fixes #9133

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

src/rsz/src/PreChecks.cc

@@ -4,11 +4,15 @@
 #include "PreChecks.hh"
 
 #include <algorithm>
+#include <memory>
 
 #include "db_sta/dbNetwork.hh"
+#include "db_sta/dbSta.hh"
 #include "rsz/Resizer.hh"
 #include "sta/Corner.hh"
 #include "sta/LibertyClass.hh"
+#include "sta/MinMax.hh"
+#include "sta/NetworkClass.hh"
 #include "sta/Units.hh"
 #include "utl/Logger.h"
 
@@ -59,4 +63,66 @@ void PreChecks::checkSlewLimit(float ref_cap, float max_load_slew)
                    cap_unit->scaleAbbreviation());
   }
 }
+
+void PreChecks::checkCapLimit(const Pin* drvr_pin)
+{
+  if (!min_cap_load_computed_) {
+    min_cap_load_computed_ = true;
+    // Find the smallest buffer/inverter input cap
+    min_cap_load_ = sta::INF;
+    dbNetwork* network = resizer_->getDbNetwork();
+    std::unique_ptr<sta::LibertyLibraryIterator> lib_iter{
+        network->libertyLibraryIterator()};
+
+    auto update_min_cap = [&](const auto& cells) {
+      for (sta::LibertyCell* cell : cells) {
+        sta::LibertyPort* input;
+        sta::LibertyPort* output;
+        cell->bufferPorts(input, output);
+        min_cap_load_ = std::min(min_cap_load_, input->capacitance());
+      }
+    };
+
+    while (lib_iter->hasNext()) {
+      sta::LibertyLibrary* lib = lib_iter->next();
+      update_min_cap(*lib->buffers());
+      update_min_cap(*lib->inverters());
+    }
+  }
+
+  float cap1, max_cap1, cap_slack1;
+  const Corner* corner1;
+  const RiseFall* tr1;
+  sta_->checkCapacitance(drvr_pin,
+                         nullptr,
+                         sta::MinMax::max(),
+                         corner1,
+                         tr1,
+                         cap1,
+                         max_cap1,
+                         cap_slack1);
+  if (max_cap1 > 0 && max_cap1 < min_cap_load_) {
+    dbNetwork* network = resizer_->getDbNetwork();
+    const sta::Unit* cap_unit = sta_->units()->capacitanceUnit();
+    std::string master_name = "-";
+    if (sta::Instance* inst = network->instance(drvr_pin)) {
+      sta::Cell* cell = network->cell(inst);
+      if (cell) {
+        master_name = network->name(cell);
+      }
+    }
+    logger_->error(
+        RSZ,
+        169,
+        "Max cap for driver {} of type {} is unreasonably small {}{}F. "
+        "Min buffer or inverter input cap is {}{}F",
+        network->name(drvr_pin),
+        master_name,
+        cap_unit->asString(max_cap1),
+        cap_unit->scaleAbbreviation(),
+        cap_unit->asString(min_cap_load_),
+        cap_unit->scaleAbbreviation());
+  }
+}
+
 }  // namespace rsz

src/rsz/src/PreChecks.hh

@@ -15,6 +15,7 @@ class PreChecks
  public:
   PreChecks(Resizer* resizer);
   void checkSlewLimit(float ref_cap, float max_load_slew);
+  void checkCapLimit(const sta::Pin* drvr_pin);
 
  private:
   Logger* logger_ = nullptr;
@@ -25,6 +26,12 @@ class PreChecks
   float best_case_slew_ = -1.0;
   float best_case_slew_load_ = -1.0;
   bool best_case_slew_computed_ = false;
+
+  // smallest buffer/inv cap to ensure the max_cap in Liberty/SDC is reasonable
+  float min_cap_load_ = default_min_cap_load;
+  bool min_cap_load_computed_ = false;
+
+  static constexpr float default_min_cap_load = 1e-18;  // 1aF
 };
 
 }  // namespace rsz

src/rsz/src/RepairDesign.cc

@@ -1177,6 +1177,8 @@ void RepairDesign::repairNet(Net* net,
     }
 
     if (check_cap && !resizer_->isTristateDriver(drvr_pin)) {
+      // Check that the max cap limit specified is within the bounds of reason.
+      pre_checks_->checkCapLimit(drvr_pin);
       if (needRepairCap(drvr_pin, cap_violations, max_cap, corner)) {
         repair_cap = true;
       }