Merge pull request The-OpenROAD-Project#7464 from The-OpenROAD-Project-staging/rsz-cbk-parasitics

rsz: Rely on odb callback for all parasitics invalidation

Author: maliberty

src/rsz/include/rsz/Resizer.hh

@@ -118,6 +118,7 @@ class SizeDownMove;
 class SizeUpMove;
 class SwapPinsMove;
 class UnbufferMove;
+class RegisterOdbCallbackGuard;
 
 class NetHash
 {
@@ -409,7 +410,7 @@ class Resizer : public dbStaState, public dbNetworkObserver
 
   dbNetwork* getDbNetwork() { return db_network_; }
   ParasiticsSrc getParasiticsSrc() { return parasitics_src_; }
-  void setParasiticsSrc(ParasiticsSrc src) { parasitics_src_ = src; }
+  void setParasiticsSrc(ParasiticsSrc src);
   dbBlock* getDbBlock() { return block_; };
   double dbuToMeters(int dist) const;
   int metersToDbu(double dist) const;
@@ -421,7 +422,6 @@ class Resizer : public dbStaState, public dbNetworkObserver
   void journalBeginTest();
   void journalRestoreTest();
   Logger* logger() const { return logger_; }
-  void invalidateParasitics(const Pin* pin, const Net* net);
   void eraseParasitics(const Net* net);
   void eliminateDeadLogic(bool clean_nets);
   std::optional<float> cellLeakage(LibertyCell* cell);
@@ -728,6 +728,7 @@ class Resizer : public dbStaState, public dbNetworkObserver
 
   ParasiticsSrc parasitics_src_ = ParasiticsSrc::none;
   UnorderedSet<const Net*, NetHash> parasitics_invalid_;
+  bool incremental_parasitics_enabled_ = false;
 
   double design_area_ = 0.0;
   const MinMax* min_ = MinMax::min();
@@ -783,9 +784,6 @@ class Resizer : public dbStaState, public dbNetworkObserver
   sta::UnorderedMap<LibertyPort*, InputSlews> input_slew_map_;
 
   std::unique_ptr<OdbCallBack> db_cbk_;
-  bool is_callback_registered_ = false;
-  bool isCallBackRegistered() { return is_callback_registered_; }
-  void setCallBackRegistered(bool val) { is_callback_registered_ = val; }
 
   // Restrict default sizing such that one sizing move cannot increase area or
   // leakage by more than 4X.  Subsequent sizing moves can exceed the 4X limit.
@@ -837,6 +835,18 @@ class Resizer : public dbStaState, public dbNetworkObserver
   friend class CloneMove;
   friend class SwapPinsMove;
   friend class UnbufferMove;
+  friend class IncrementalParasiticsGuard;
+};
+
+class IncrementalParasiticsGuard
+{
+ public:
+  IncrementalParasiticsGuard(Resizer* resizer);
+  ~IncrementalParasiticsGuard();
+
+ private:
+  Resizer* resizer_;
+  bool need_unregister_;
 };
 
 }  // namespace rsz

src/rsz/src/BaseMove.cc

@@ -678,20 +678,6 @@ bool BaseMove::replaceCell(Instance* inst, const LibertyCell* replacement)
         || resizer_->getParasiticsSrc() == ParasiticsSrc::detailed_routing) {
       opendp_->legalCellPos(db_network_->staToDb(inst));
     }
-    if (resizer_->haveEstimatedParasitics()) {
-      auto pin_iter
-          = std::unique_ptr<InstancePinIterator>(network_->pinIterator(inst));
-      while (pin_iter->hasNext()) {
-        const Pin* pin = pin_iter->next();
-        const Net* net = network_->net(pin);
-        odb::dbNet* db_net = nullptr;
-        odb::dbModNet* db_modnet = nullptr;
-        db_network_->staToDb(net, db_net, db_modnet);
-        // only work on dbnets
-        resizer_->invalidateParasitics(pin, db_network_->dbToSta(db_net));
-        //        invalidateParasitics(pin, net);
-      }
-    }
 
     return true;
   }

src/rsz/src/CloneMove.cc

@@ -229,7 +229,6 @@ bool CloneMove::doMove(const Path* drvr_path,
       if (modnet) {
         iterm->connect(modnet);
       }
-      resizer_->parasiticsInvalid(db_network_->dbToSta(dbnet));
     }
   }
 
@@ -284,8 +283,6 @@ bool CloneMove::doMove(const Path* drvr_path,
       }
     }
   }
-  resizer_->parasiticsInvalid(out_net);
-  resizer_->parasiticsInvalid(network_->net(drvr_pin));
   return true;
 }
 

src/rsz/src/EstimateWireParasitics.cc

@@ -279,43 +279,15 @@ bool Resizer::haveEstimatedParasitics() const
   return parasitics_src_ != ParasiticsSrc::none;
 }
 
-void Resizer::incrementalParasiticsBegin()
-{
-  switch (parasitics_src_) {
-    case ParasiticsSrc::placement:
-      break;
-    case ParasiticsSrc::global_routing:
-    case ParasiticsSrc::detailed_routing:
-      // TODO: add IncrementalDRoute
-      incr_groute_ = new IncrementalGRoute(global_router_, block_);
-      // Don't print verbose messages for incremental routing
-      global_router_->setVerbose(false);
-      break;
-    case ParasiticsSrc::none:
-      break;
-  }
-  parasitics_invalid_.clear();
-}
-
-void Resizer::incrementalParasiticsEnd()
+void Resizer::updateParasitics(bool save_guides)
 {
-  switch (parasitics_src_) {
-    case ParasiticsSrc::placement:
-      break;
-    case ParasiticsSrc::global_routing:
-    case ParasiticsSrc::detailed_routing:
-      // TODO: add IncrementalDRoute
-      delete incr_groute_;
-      incr_groute_ = nullptr;
-      break;
-    case ParasiticsSrc::none:
-      break;
+  if (!incremental_parasitics_enabled_) {
+    logger_->error(
+        RSZ,
+        109,
+        "updateParasitics() called with incremental parasitics disabled");
   }
-  parasitics_invalid_.clear();
-}
 
-void Resizer::updateParasitics(bool save_guides)
-{
   switch (parasitics_src_) {
     case ParasiticsSrc::placement:
       for (const Net* net : parasitics_invalid_) {
@@ -327,7 +299,6 @@ void Resizer::updateParasitics(bool save_guides)
         }
         estimateWireParasitic(net);
       }
-      parasitics_invalid_.clear();
       break;
     case ParasiticsSrc::global_routing:
     case ParasiticsSrc::detailed_routing: {
@@ -336,12 +307,13 @@ void Resizer::updateParasitics(bool save_guides)
       for (const Net* net : parasitics_invalid_) {
         global_router_->estimateRC(db_network_->staToDb(net));
       }
-      parasitics_invalid_.clear();
       break;
     }
     case ParasiticsSrc::none:
       break;
   }
+
+  parasitics_invalid_.clear();
 }
 
 bool Resizer::parasiticsValid() const

src/rsz/src/OdbCallBack.cc

@@ -17,6 +17,8 @@
 #include <memory>
 
 #include "rsz/Resizer.hh"
+#include "sta/Liberty.hh"
+#include "sta/PortDirection.hh"
 
 namespace rsz {
 
@@ -115,14 +117,22 @@ void OdbCallBack::inDbInstSwapMasterAfter(dbInst* inst)
              "inDbInstSwapMasterAfter {}",
              inst->getName());
   Instance* sta_inst = db_network_->dbToSta(inst);
+
+  // Invalidate estimated parasitics on all instance pins.
   std::unique_ptr<InstancePinIterator> pin_iter{
       network_->pinIterator(sta_inst)};
   while (pin_iter->hasNext()) {
     Pin* pin = pin_iter->next();
     Net* net = network_->net(pin);
-    // we can only update parasitics for flat net
-    odb::dbNet* db_net = db_network_->flatNet(net);
-    resizer_->parasiticsInvalid(db_network_->dbToSta(db_net));
+
+    const LibertyPort* port = network_->libertyPort(pin);
+    // Tristate nets have multiple drivers and this is drivers^2 if
+    // the parasitics are updated for each resize.
+    if (!port || !port->direction()->isAnyTristate()) {
+      // we can only update parasitics for flat net
+      odb::dbNet* db_net = db_network_->flatNet(net);
+      resizer_->parasiticsInvalid(db_network_->dbToSta(db_net));
+    }
   }
 }
 

src/rsz/src/Rebuffer.cc

@@ -735,11 +735,8 @@ Slack BufferMove::slackAtDriverPin(const BufferedNetPtr& bnet,
 void BufferMove::rebufferNet(const Pin* drvr_pin)
 {
   init();
-  resizer_->incrementalParasiticsBegin();
+  IncrementalParasiticsGuard guard(resizer_);
   int inserted_buffer_count_ = rebuffer(drvr_pin);
-  // Leave the parasitics up to date.
-  resizer_->updateParasitics();
-  resizer_->incrementalParasiticsEnd();
   logger_->report("Inserted {} buffers.", inserted_buffer_count_);
 }
 
@@ -1004,15 +1001,6 @@ int BufferMove::rebufferTopDown(const BufferedNetPtr& choice,
       const int buffer_count = rebufferTopDown(
           choice->ref(), net2, level + 1, parent, buffer_op_iterm, mod_net_in);
 
-      // ip_net
-      odb::dbNet* db_net = nullptr;
-      odb::dbModNet* db_modnet = nullptr;
-      db_network_->staToDb(net, db_net, db_modnet);
-      resizer_->parasiticsInvalid(db_network_->dbToSta(db_net));
-
-      db_network_->staToDb(net2, db_net, db_modnet);
-      resizer_->parasiticsInvalid(db_network_->dbToSta(db_net));
-
       return buffer_count + 1;
     }
 
@@ -1116,8 +1104,6 @@ int BufferMove::rebufferTopDown(const BufferedNetPtr& choice,
           }
 
           // sta_->connectPin(load_inst, load_port, net);
-          resizer_->parasiticsInvalid(db_network_->dbToSta(db_net));
-          // resizer_->parasiticsInvalid(load_net);
         }
         return 0;
       }

src/rsz/src/RecoverPower.cc

@@ -98,6 +98,7 @@ bool RecoverPower::recoverPower(const float recover_power_percent, bool verbose)
 
   int end_index = 0;
   int failed_move_threshold = 0;
+  IncrementalParasiticsGuard guard(resizer_);
   for (Vertex* end : ends_with_slack) {
     resizer_->journalBegin();
     const Slack end_slack_before = sta_->vertexSlack(end, max_);
@@ -218,11 +219,12 @@ Vertex* RecoverPower::recoverPower(const Pin* end_pin)
   Vertex* vertex = graph_->pinLoadVertex(end_pin);
   const Slack slack = sta_->vertexSlack(vertex, max_);
   const Path* path = sta_->vertexWorstSlackPath(vertex, max_);
-  resizer_->incrementalParasiticsBegin();
-  Vertex* drvr_vertex = recoverPower(path, slack);
-  // Leave the parasitices up to date.
-  resizer_->updateParasitics();
-  resizer_->incrementalParasiticsEnd();
+  Vertex* drvr_vertex;
+
+  {
+    IncrementalParasiticsGuard guard(resizer_);
+    drvr_vertex = recoverPower(path, slack);
+  }
 
   if (resize_count_ > 0) {
     logger_->info(RSZ, 3111, "Resized {} instances.", resize_count_);