Merge branch 'master' into pdn-check-setup

Author: gadfort

.whitespace

@@ -2449,7 +2449,9 @@ void TritonCTS::adjustLatencies(TreeBuilder* macroBuilder,
   driverOutputTerm->disconnect();
   // hierarchical fix. guarded by network has hierarchy
   if (candidate_hier_net && network_->hasHierarchy()) {
-    driverOutputTerm->connect(orig_flat_net, candidate_hier_net);
+    network_->connectPin((sta::Pin*) driverOutputTerm,
+                         (sta::Net*) orig_flat_net,
+                         (sta::Net*) candidate_hier_net);
   } else {
     driverOutputTerm->connect(outputNet);
   }

src/cts/src/TritonCTS.cpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <set>
+#include <unordered_set>
 
 #include "odb/db.h"
 #include "sta/ConcreteNetwork.hh"
@@ -66,6 +67,7 @@ class dbNetwork : public ConcreteNetwork
   void clear() override;
   CellPortIterator* portIterator(const Cell* cell) const override;
 
+  void AxiomCheck();
   void readLefAfter(dbLib* lib);
   void readDefAfter(dbBlock* block);
   void readDbAfter(dbDatabase* db);
@@ -275,6 +277,7 @@ class dbNetwork : public ConcreteNetwork
   // Net functions
   ObjectId id(const Net* net) const override;
   Net* findNet(const Instance* instance, const char* net_name) const override;
+  Net* findNetAllScopes(const char* net_name) const;
   void findInstNetsMatching(const Instance* instance,
                             const PatternMatch* pattern,
                             // Return value.
@@ -327,6 +330,13 @@ class dbNetwork : public ConcreteNetwork
                               dbNet* new_flat_net,
                               dbNet* orig_flat_net);
 
+  void reassociateFromDbNetView(dbNet* flat_net, dbModNet* mod_net);
+
+  void accumulateFlatLoadPinsOnNet(
+      Net* net,
+      Pin* drvr_pin,
+      std::unordered_set<const Pin*>& accumulated_pins);
+
   int fromIndex(const Port* port) const override;
   int toIndex(const Port* port) const override;
   bool isBus(const Port*) const override;

src/dbSta/include/db_sta/dbNetwork.hh

@@ -957,6 +957,38 @@ bool dbNetwork::isLeaf(const Instance* instance) const
 
 Instance* dbNetwork::findInstance(const char* path_name) const
 {
+  if (hierarchy_) {  // are we in hierarchical mode ?
+    std::string path_name_str = path_name;
+    // search for the last token in the string, which is the leaf instance name
+    size_t last_idx = path_name_str.find_last_of('/');
+    if (last_idx != std::string::npos) {
+      std::string leaf_inst_name = path_name_str.substr(last_idx + 1);
+      // get the parent name, which is the hierarchical prefix in the string
+      std::string parent_name_str = path_name_str.substr(0, last_idx);
+      // get the module instance from the block
+      dbModInst* parent_mod_inst
+          = block()->findModInst(parent_name_str.c_str());
+      if (parent_mod_inst) {
+        // get the module definition
+        //(we are in a uniquified environment so all modules are uniquified).
+        dbModule* module_defn = parent_mod_inst->getMaster();
+        if (module_defn) {
+          // get the leaf instance definition from the module
+          dbInst* ret = module_defn->findDbInst(leaf_inst_name.c_str());
+          if (ret) {
+            return (Instance*) ret;
+          }
+        }
+      }
+    }
+  }
+  // fall through (even in hierarchical mode).
+  // Note: the fall through is the work around so that if the name
+  // is stored in flat form it will be found. TODO: stash the names
+  // hierachically by default for all cases and not flat in the dbBlock.
+  // (currently we,mostly, stash the names flat in the block and that is wrong
+  // in hierachical mode).
+  //
   dbInst* inst = block_->findInst(path_name);
   return dbToSta(inst);
 }
@@ -1021,6 +1053,28 @@ Pin* dbNetwork::findPin(const Instance* instance, const Port* port) const
   return findPin(instance, port_name);
 }
 
+//
+// Catch all see if a net exists anywhere in the design hierarchy
+//
+// TODO: remove this by removing flat net table so that all
+// net names stored in their scope (so dbNet in top dbModule not
+// in block).
+//
+Net* dbNetwork::findNetAllScopes(const char* net_name) const
+{
+  for (auto dbm : block_->getModules()) {
+    dbNet* dnet = block_->findNet(net_name);
+    if (dnet) {
+      return dbToSta(dnet);
+    }
+    dbModNet* modnet = dbm->getModNet(net_name);
+    if (modnet) {
+      return dbToSta(modnet);
+    }
+  }
+  return nullptr;
+}
+
 Net* dbNetwork::findNet(const Instance* instance, const char* net_name) const
 {
   dbModule* scope = nullptr;
@@ -1057,7 +1111,6 @@ Net* dbNetwork::findNet(const Instance* instance, const char* net_name) const
       return dbToSta(modnet);
     }
   }
-
   return nullptr;
 }
 
@@ -3459,7 +3512,6 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
         dbNet* dest_flat_net = flatNet((Pin*) dest_pin);
         disconnectPin((Pin*) dest_pin);
         connectPin((Pin*) dest_pin, (Net*) dest_flat_net, (Net*) dest_mod_net);
-        //        dest_pin->connect(dest_mod_net);
         return;
       }
     }
@@ -3471,54 +3523,69 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
     std::vector<dbModule*> dest_parent_tree;
     getParentHierarchy(source_db_module, source_parent_tree);
     getParentHierarchy(dest_db_module, dest_parent_tree);
+
     dbModule* highest_common_module
         = findHighestCommonModule(source_parent_tree, dest_parent_tree);
     dbModNet* top_net = source_db_mod_net;
     dbModITerm* top_mod_dest = nullptr;
 
     // make source hierarchy (bottom to top).
     dbModule* cur_module = source_db_module;
+    int level = 0;
+
     while (cur_module != highest_common_module) {
       std::string connection_name_o
           = std::string(connection_name) + std::string("_o");
       dbModBTerm* mod_bterm
           = dbModBTerm::create(cur_module, connection_name_o.c_str());
-      if (!source_db_mod_net) {
-        source_db_mod_net
-            = dbModNet::create(source_db_module, connection_name_o.c_str());
-      }
-      source_pin->connect(source_db_mod_net);
+      source_db_mod_net
+          = dbModNet::create(source_db_module, connection_name_o.c_str());
+
       mod_bterm->connect(source_db_mod_net);
       mod_bterm->setIoType(dbIoType::OUTPUT);
       mod_bterm->setSigType(dbSigType::SIGNAL);
+
+      // at leaf level make connection
+      if (level == 0) {
+        dbModNet* source_pin_mod_net = hierNet((Pin*) source_pin);
+        if (source_pin_mod_net) {
+          disconnectPin((Pin*) source_pin, (Net*) source_pin_mod_net);
+        }
+        connectPin((Pin*) source_pin, (Net*) source_db_mod_net);
+      }
+
       dbModInst* parent_inst = cur_module->getModInst();
       cur_module = parent_inst->getParent();
       dbModITerm* mod_iterm = dbModITerm::create(
           parent_inst, connection_name_o.c_str(), mod_bterm);
       source_db_mod_net = dbModNet::create(cur_module, connection_name);
       mod_iterm->connect(source_db_mod_net);
       top_net = source_db_mod_net;
+      level = level + 1;
     }
 
     // make dest hierarchy
+    level = 0;
     cur_module = dest_db_module;
     while (cur_module != highest_common_module) {
       std::string connection_name_i
           = std::string(connection_name) + std::string("_i");
       dbModBTerm* mod_bterm
           = dbModBTerm::create(cur_module, connection_name_i.c_str());
-      // We may have a destination mod net (see first part), but check to make
-      // sure it is in this module. If not, create one and hook it to the
-      // destination pin also hook up the modbterm to it.
-      if ((dest_db_mod_net == nullptr)
-          || (dest_db_mod_net->getParent() != cur_module)) {
-        dest_db_mod_net
-            = dbModNet::create(cur_module, connection_name_i.c_str());
-      }
-      dest_pin->connect(dest_db_mod_net);
+      dest_db_mod_net = dbModNet::create(cur_module, connection_name_i.c_str());
+
       mod_bterm->connect(dest_db_mod_net);
       mod_bterm->setIoType(dbIoType::INPUT);
       mod_bterm->setSigType(dbSigType::SIGNAL);
+
+      if (level == 0) {
+        dbModNet* dest_pin_mod_net = hierNet((Pin*) dest_pin);
+        if (dest_pin_mod_net) {
+          disconnectPin((Pin*) dest_pin, (Net*) dest_pin_mod_net);
+        }
+        connectPin((Pin*) dest_pin, (Net*) dest_db_mod_net);
+      }
+
       dbModInst* parent_inst = cur_module->getModInst();
       cur_module = parent_inst->getParent();
       dbModITerm* mod_iterm = dbModITerm::create(
@@ -3553,6 +3620,34 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
       dest_pin->connect(top_net);
     }
 
+    // What we are doing here is making sure that the
+    // hierarchical nets at the source and the destination
+    // are correctly associated. In the above code
+    // we are wiring/unwiring modnets without regard to the
+    // flat net association. We clean that up here.
+    // Note we cannot reassociate until after we have built
+    // the hiearchy tree
+
+    // reassociate the dest pin
+
+    dbModNet* dest_pin_mod_net = hierNet((Pin*) dest_pin);
+    if (dest_pin_mod_net) {
+      dbNet* dest_pin_flat_net = flatNet((Pin*) dest_pin);
+      dest_pin->disconnect();
+      connectPin(
+          (Pin*) dest_pin, (Net*) dest_pin_flat_net, (Net*) dest_pin_mod_net);
+    }
+
+    // reassociate the source pin
+    dbModNet* source_pin_mod_net = hierNet((Pin*) source_pin);
+    if (source_pin_mod_net) {
+      dbNet* source_pin_flat_net = flatNet((Pin*) source_pin);
+      source_pin->disconnect();
+      connectPin((Pin*) source_pin,
+                 (Net*) source_pin_flat_net,
+                 (Net*) source_pin_mod_net);
+    }
+
     // During the addition of new ports and new wiring we may
     // leave orphaned pins, clean them up.
     std::set<dbModInst*> cleaned_up;
@@ -3793,6 +3888,13 @@ void dbNetwork::reassociateHierFlatNet(dbModNet* mod_net,
   visitConnectedPins(dbToSta(new_flat_net), visitordb, visited_dbnets);
 }
 
+void dbNetwork::reassociateFromDbNetView(dbNet* flat_net, dbModNet* mod_net)
+{
+  DbModNetAssociation visitordb(this, mod_net);
+  NetSet visited_dbnets(this);
+  visitConnectedPins(dbToSta(flat_net), visitordb, visited_dbnets);
+}
+
 void dbNetwork::replaceHierModule(dbModInst* mod_inst, dbModule* module)
 {
   (void) mod_inst->swapMaster(module);
@@ -3880,6 +3982,22 @@ void PinModDbNetConnection::operator()(const Pin* pin)
                 ->getOwningInstanceParent(const_cast<Pin*>(pin));
       (void) owning_instance;
       if (dbnet_ != nullptr && dbnet_ != candidate_flat_net) {
+        /*
+          //How to debug in orfs:
+          //uncomment this code
+          //then use gdb -p pid on the openroad process
+          //to see stack trace.
+        printf("Axiom check fail\n");
+        printf("Flat nets are %s %s for modnet %s\n",
+               db_network_->name(db_network_->dbToSta(dbnet_)),
+               db_network_->name(db_network_->dbToSta(candidate_flat_net)),
+               db_network_->name(search_net_));
+        printf("Suspending, access from gdb to debug\n");
+        fflush(stdout);
+        int forever_loop=1;
+        while(forever_loop);
+        */
+
         logger_->error(
             ORD,
             2030,
@@ -3991,4 +4109,54 @@ bool dbNetwork::hasHierarchicalElements() const
   return false;
 }
 
+class AccumulateNetFlatLoadPins : public PinVisitor
+{
+ public:
+  AccumulateNetFlatLoadPins(dbNetwork* nwk,
+                            Pin* drvr_pin,
+                            std::unordered_set<const Pin*>& accumulated_pins)
+      : nwk_(nwk), drvr_pin_(drvr_pin), flat_load_pinset_(accumulated_pins)
+  {
+  }
+  void operator()(const Pin* pin) override;
+
+ private:
+  dbNetwork* nwk_;
+  Pin* drvr_pin_;
+  std::unordered_set<const sta::Pin*>& flat_load_pinset_;
+};
+
+void AccumulateNetFlatLoadPins::operator()(const Pin* pin)
+{
+  if (pin != drvr_pin_) {
+    dbITerm* iterm = nullptr;
+    dbBTerm* bterm = nullptr;
+    dbModITerm* moditerm = nullptr;
+    // only stash the flat loads on instances (iterms)
+    nwk_->staToDb(pin, iterm, bterm, moditerm);
+    if (iterm /*|| bterm */) {
+      flat_load_pinset_.insert(pin);
+    }
+  }
+}
+
+void dbNetwork::accumulateFlatLoadPinsOnNet(
+    Net* net,
+    Pin* drvr_pin,
+    std::unordered_set<const Pin*>& accumulated_pins)
+{
+  NetSet visited_nets(this);
+  // just the flat load pins
+  AccumulateNetFlatLoadPins rp(this, drvr_pin, accumulated_pins);
+  visitConnectedPins(net, rp, visited_nets);
+}
+
+void dbNetwork::AxiomCheck()
+{
+  dbSet<dbModNet> mod_nets = block()->getModNets();
+  for (auto mod_net : mod_nets) {
+    findRelatedDbNet(mod_net);
+  }
+}
+
 }  // namespace sta