odb: add verbose and update tests

Signed-off-by: Peter Gadfort <[email protected]>

Author: gadfort

src/OpenRoad.tcl

@@ -320,14 +320,14 @@ proc cpu_count { } {
   return [ord::cpu_count]
 }
 
-sta::define_cmd_args "global_connect" { [-force] }
+sta::define_cmd_args "global_connect" { [-force] [-verbose] }
 proc global_connect { args } {
   sta::parse_key_args "global_connect" args \
     keys {} \
-    flags {-force}
+    flags {-force -verbose}
 
   sta::check_argc_eq0 "add_global_connection" $args
-  [ord::get_db_block] globalConnect [info exists flags(-force)]
+  [ord::get_db_block] globalConnect [info exists flags(-force)] [info exists flags(-verbose)]
 }
 
 sta::define_cmd_args "clear_global_connect" {}

src/README.md

@@ -263,14 +263,15 @@ add_global_connection -net VSS -pin_pattern {^VSSE$}
 The `global_connect` command is used to connect power and ground pins on design instances to the appropriate supplies.
 
 ```
-global_connect [-force]
+global_connect [-force] [-verbose]
 ```
 
 ##### Options
 
 | Switch Name | Description |
 | ----- | ----- |
 | `-force` | If specified, global connections will overwrite existing connections |
+| `-verbose` | If specified, report the number of connections made and skipped. |
 
 #### Clear global connection rules
 

src/gui/src/globalConnectDialog.cpp

@@ -334,9 +334,9 @@ void GlobalConnectDialog::runRule(odb::dbGlobalConnect* gc, bool force)
   QApplication::processEvents();
   int connections = 0;
   if (gc == nullptr) {
-    connections = block_->globalConnect(force);
+    connections = block_->globalConnect(force, true);
   } else {
-    connections = block_->globalConnect(gc, force);
+    connections = block_->globalConnect(gc, force, true);
   }
   QApplication::restoreOverrideCursor();
   emit connectionsMade(connections);

src/odb/include/odb/db.h

@@ -747,8 +747,8 @@ class dbBlock : public dbObject
   /// and helper functions for global connections
   /// on this block.
   ///
-  int globalConnect(bool force);
-  int globalConnect(dbGlobalConnect* gc, bool force);
+  int globalConnect(bool force, bool verbose);
+  int globalConnect(dbGlobalConnect* gc, bool force, bool verbose);
   int addGlobalConnect(dbRegion* region,
                        const char* instPattern,
                        const char* pinPattern,

src/odb/src/db/dbBlock.cpp

@@ -3347,18 +3347,18 @@ void dbBlock::destroyNetWires()
   }
 }
 
-int dbBlock::globalConnect(bool force)
+int dbBlock::globalConnect(bool force, bool verbose)
 {
   dbSet<dbGlobalConnect> gcs = getGlobalConnects();
   const std::vector<dbGlobalConnect*> connects(gcs.begin(), gcs.end());
   _dbBlock* dbblock = (_dbBlock*) this;
-  return dbblock->globalConnect(connects, force);
+  return dbblock->globalConnect(connects, force, verbose);
 }
 
-int dbBlock::globalConnect(dbGlobalConnect* gc, bool force)
+int dbBlock::globalConnect(dbGlobalConnect* gc, bool force, bool verbose)
 {
   _dbBlock* dbblock = (_dbBlock*) this;
-  return dbblock->globalConnect({gc}, force);
+  return dbblock->globalConnect({gc}, force, verbose);
 }
 
 void dbBlock::clearGlobalConnect()
@@ -3419,13 +3419,14 @@ int dbBlock::addGlobalConnect(dbRegion* region,
       = odb::dbGlobalConnect::create(net, region, instPattern, pinPattern);
 
   if (gc != nullptr && do_connect) {
-    return globalConnect(gc, false);
+    return globalConnect(gc, false, false);
   }
   return 0;
 }
 
 int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects,
-                            bool force)
+                            bool force,
+                            bool verbose)
 {
   _dbBlock* dbblock = (_dbBlock*) this;
   utl::Logger* logger = dbblock->getImpl()->getLogger();
@@ -3440,6 +3441,7 @@ int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects,
   std::vector<_dbGlobalConnect*> region_rules;
 
   std::set<dbITerm*> connected_iterms;
+  std::set<dbITerm*> skipped_iterms;
   // only search for instances once
   std::map<std::string, std::vector<dbInst*>> inst_map;
   std::set<dbInst*> donottouchinsts;
@@ -3473,9 +3475,8 @@ int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects,
 
     inst_map[inst_pattern] = insts;
 
-    _dbGlobalConnect* connect_rule = (_dbGlobalConnect*) connect;
     for (dbInst* inst : remove_insts) {
-      if (connect_rule->needsModification(inst)) {
+      if (gc->needsModification(inst)) {
         donottouchinsts.insert(inst);
       }
     }
@@ -3492,14 +3493,25 @@ int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects,
   }
 
   for (_dbGlobalConnect* connect : non_region_rules) {
-    const auto connections
+    const auto& [connections, skipped]
         = connect->connect(inst_map[connect->inst_pattern_], force);
     connected_iterms.insert(connections.begin(), connections.end());
+    skipped_iterms.insert(skipped.begin(), skipped.end());
   }
   for (_dbGlobalConnect* connect : region_rules) {
-    const auto connections
+    const auto& [connections, skipped]
         = connect->connect(inst_map[connect->inst_pattern_], force);
     connected_iterms.insert(connections.begin(), connections.end());
+    skipped_iterms.insert(skipped.begin(), skipped.end());
+  }
+
+  if (verbose) {
+    logger->info(utl::ODB,
+                 403,
+                 "{} connections made, {} conflicts skipped{}",
+                 connected_iterms.size(),
+                 skipped_iterms.size(),
+                 skipped_iterms.empty() ? "." : ", use -force to connect.");
   }
 
   return connected_iterms.size();

src/odb/src/db/dbBlock.h

@@ -163,7 +163,9 @@ class _dbBlock : public _dbObject
   bool operator==(const _dbBlock& rhs) const;
   bool operator!=(const _dbBlock& rhs) const { return !operator==(rhs); }
 
-  int globalConnect(const std::vector<dbGlobalConnect*>& connects, bool force);
+  int globalConnect(const std::vector<dbGlobalConnect*>& connects,
+                    bool force,
+                    bool verbose);
   _dbTech* getTech();
 
   dbObjectTable* getObjectTable(dbObjectType type);

src/odb/src/db/dbGlobalConnect.cpp

@@ -161,7 +161,7 @@ int dbGlobalConnect::connect(dbInst* inst, bool force)
     return 0;
   }
 
-  const auto connections = obj->connect({inst}, force);
+  const auto& [connections, skipped] = obj->connect({inst}, force);
   return connections.size();
 }
 
@@ -283,25 +283,28 @@ std::set<dbMTerm*> _dbGlobalConnect::getMTermMapping(
   return mterms;
 }
 
-std::set<dbITerm*> _dbGlobalConnect::connect(const std::vector<dbInst*>& insts,
-                                             bool force)
+std::pair<std::set<dbITerm*>, std::set<dbITerm*>> _dbGlobalConnect::connect(
+    const std::vector<dbInst*>& insts,
+    bool force)
 {
   utl::Logger* logger = getImpl()->getLogger();
   dbBlock* block = (dbBlock*) getImpl()->getOwner();
   dbNet* net = odb::dbNet::getNet(block, net_);
 
+  std::set<dbITerm*> iterms;
+  std::set<dbITerm*> iterms_skipped;
+
   if (net->isDoNotTouch()) {
     logger->warn(
         utl::ODB,
         379,
         "{} is marked do not touch, will be skipped for global connections",
         net->getName());
-    return {};
+    return {iterms, iterms_skipped};
   }
 
   const auto mterm_map = getMTermMapping();
 
-  std::set<dbITerm*> iterms;
   for (dbInst* inst : insts) {
     _dbInst* dbinst = (_dbInst*) inst;
     if (region_ != 0 && region_ != dbinst->region_) {
@@ -319,21 +322,25 @@ std::set<dbITerm*> _dbGlobalConnect::connect(const std::vector<dbInst*>& insts,
       auto* iterm = inst->getITerm(mterm);
 
       auto* current_net = iterm->getNet();
-      if (current_net != nullptr && !force) {
-        // Already connected, so dont update unless force
+      if (current_net == net) {
+        // Already connected, nothing to do
         continue;
       }
       if (current_net != nullptr && current_net->isDoNotTouch()) {
-        logger->warn(utl::ODB,
-                     380,
-                     "{}/{} is connected to {} which is marked do not touch, "
-                     "this connection will not be modified.",
-                     inst->getName(),
-                     mterm->getName(),
-                     current_net->getName());
+        // Connected, but current net is marked do not touch, nothing to do
+        if (force) {
+          logger->warn(utl::ODB,
+                       380,
+                       "{} is connected to {} which is marked do not touch, "
+                       "this connection will not be modified.",
+                       iterm->getName(),
+                       current_net->getName());
+        }
         continue;
       }
-      if (current_net == net) {
+      if (current_net != nullptr && !force) {
+        // Already connected, so dont update unless force
+        iterms_skipped.insert(iterm);
         continue;
       }
       iterm->connect(net);
@@ -343,7 +350,7 @@ std::set<dbITerm*> _dbGlobalConnect::connect(const std::vector<dbInst*>& insts,
       iterms.insert(iterm);
     }
   }
-  return iterms;
+  return {iterms, iterms_skipped};
 }
 
 bool _dbGlobalConnect::appliesTo(dbInst* inst) const

src/odb/src/db/dbGlobalConnect.h

@@ -54,7 +54,9 @@ class _dbGlobalConnect : public _dbObject
   std::map<dbMaster*, std::set<dbMTerm*>> getMTermMapping();
   std::set<dbMTerm*> getMTermMapping(dbMaster* master,
                                      const std::regex& pin_regex) const;
-  std::set<dbITerm*> connect(const std::vector<dbInst*>& insts, bool force);
+  std::pair<std::set<dbITerm*>, std::set<dbITerm*>> connect(
+      const std::vector<dbInst*>& insts,
+      bool force);
   bool appliesTo(dbInst* inst) const;
   bool needsModification(dbInst* inst) const;
   // User Code End Methods

src/pdn/test/global_connect_with_dont_touch.tcl

@@ -9,4 +9,5 @@ add_global_connection -net VDD -pin_pattern VDD
 add_global_connection -net VSS -pin_pattern VSS -ground
 
 set_dont_touch *
-global_connect
+
+global_connect -force