Merge pull request #9138 from The-OpenROAD-Project-staging/rsz-max-cap-sanity

rsz: add pre-check for max cap sanity

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;
       }