Merge pull request #9084 from gadfort/global-connect-force

odb: add force/verbose to global_connect

Author: maliberty

src/OpenRoad.tcl

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

src/README.md

@@ -263,9 +263,16 @@ 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
+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
 
 The `clear_global_connect` command is used remove all defined global connection rules.

src/gui/resources/google_icons/resume.png

@@ -17,5 +17,6 @@
   <file alias="cancel.png">google_icons/round_cancel_black_36dp.png</file>
   <file alias="expand_more.png">google_icons/round_unfold_more_black_36dp.png</file>
   <file alias="expand_less.png">google_icons/round_unfold_less_black_36dp.png</file>
+  <file alias="resume.png">google_icons/resume.png</file>
 </qresource>
 </RCC>

src/gui/resources/resource.qrc

@@ -50,6 +50,7 @@ GlobalConnectDialog::GlobalConnectDialog(odb::dbBlock* block, QWidget* parent)
       add_(new QPushButton(this)),
       clear_(new QPushButton(this)),
       run_(new QPushButton(this)),
+      run_force_(new QPushButton(this)),
       rules_({}),
       inst_pattern_(new QLineEdit(this)),
       pin_pattern_(new QLineEdit(this)),
@@ -64,6 +65,7 @@ GlobalConnectDialog::GlobalConnectDialog(odb::dbBlock* block, QWidget* parent)
   QHBoxLayout* button_layout = new QHBoxLayout;
   button_layout->addWidget(clear_);
   button_layout->addWidget(run_);
+  button_layout->addWidget(run_force_);
   layout->addLayout(button_layout);
   layout->addWidget(connections_);
 
@@ -75,18 +77,27 @@ GlobalConnectDialog::GlobalConnectDialog(odb::dbBlock* block, QWidget* parent)
   add_->setDefault(false);
   add_->setEnabled(false);
 
-  run_->setIcon(QIcon(":/play.png"));
+  run_->setIcon(QIcon(":/resume.png"));
   run_->setToolTip(tr("Run"));
   run_->setAutoDefault(false);
   run_->setDefault(false);
 
+  run_force_->setIcon(QIcon(":/play.png"));
+  run_force_->setToolTip(tr("Run with forced connections"));
+  run_force_->setAutoDefault(false);
+  run_force_->setDefault(false);
+
   clear_->setIcon(QIcon(":/delete.png"));
   clear_->setToolTip(tr("Clear"));
   clear_->setAutoDefault(false);
   clear_->setDefault(false);
 
   connect(add_, &QPushButton::pressed, this, &GlobalConnectDialog::makeRule);
   connect(run_, &QPushButton::pressed, this, &GlobalConnectDialog::runRules);
+  connect(run_force_,
+          &QPushButton::pressed,
+          this,
+          &GlobalConnectDialog::runRulesWithForce);
   connect(
       clear_, &QPushButton::pressed, this, &GlobalConnectDialog::clearRules);
 
@@ -157,7 +168,12 @@ GlobalConnectDialog::GlobalConnectDialog(odb::dbBlock* block, QWidget* parent)
 
 void GlobalConnectDialog::runRules()
 {
-  runRule(nullptr);
+  runRule(nullptr, false);
+}
+
+void GlobalConnectDialog::runRulesWithForce()
+{
+  runRule(nullptr, true);
 }
 
 void GlobalConnectDialog::clearRules()
@@ -242,7 +258,8 @@ void GlobalConnectDialog::addRule(odb::dbGlobalConnect* gc)
   widgets.run->setToolTip(tr("Run"));
   widgets.run->setAutoDefault(false);
   widgets.run->setDefault(false);
-  connect(widgets.run, &QPushButton::pressed, [this, gc]() { runRule(gc); });
+  connect(
+      widgets.run, &QPushButton::pressed, [this, gc]() { runRule(gc, false); });
   layout_->addWidget(
       widgets.run, row_idx, toValue(GlobalConnectField::kRun), Qt::AlignCenter);
 
@@ -311,15 +328,15 @@ void GlobalConnectDialog::announceConnections(int connections)
       QString::fromStdString(fmt::format("Connected {} pin(s)", connections)));
 }
 
-void GlobalConnectDialog::runRule(odb::dbGlobalConnect* gc)
+void GlobalConnectDialog::runRule(odb::dbGlobalConnect* gc, bool force)
 {
   QApplication::setOverrideCursor(Qt::WaitCursor);
   QApplication::processEvents();
   int connections = 0;
   if (gc == nullptr) {
-    connections = block_->globalConnect();
+    connections = block_->globalConnect(force, true);
   } else {
-    connections = block_->globalConnect(gc);
+    connections = block_->globalConnect(gc, force, true);
   }
   QApplication::restoreOverrideCursor();
   emit connectionsMade(connections);

src/gui/src/globalConnectDialog.cpp

@@ -28,6 +28,7 @@ class GlobalConnectDialog : public QDialog
 
  private slots:
   void runRules();
+  void runRulesWithForce();
   void clearRules();
   void deleteRule(odb::dbGlobalConnect* gconnect);
   void makeRule();
@@ -42,6 +43,7 @@ class GlobalConnectDialog : public QDialog
   QPushButton* add_;
   QPushButton* clear_;
   QPushButton* run_;
+  QPushButton* run_force_;
 
   struct GlobalConnectWidgets
   {
@@ -63,7 +65,7 @@ class GlobalConnectDialog : public QDialog
   QLabel* connections_;
 
   void addRule(odb::dbGlobalConnect* gc);
-  void runRule(odb::dbGlobalConnect* gc);
+  void runRule(odb::dbGlobalConnect* gc, bool force);
 };
 
 }  // namespace gui

src/gui/src/globalConnectDialog.h

@@ -747,8 +747,8 @@ class dbBlock : public dbObject
   /// and helper functions for global connections
   /// on this block.
   ///
-  int globalConnect();
-  int globalConnect(dbGlobalConnect* gc);
+  int globalConnect(bool force, bool verbose);
+  int globalConnect(dbGlobalConnect* gc, bool force, bool verbose);
   int addGlobalConnect(dbRegion* region,
                        const char* instPattern,
                        const char* pinPattern,
@@ -7864,7 +7864,7 @@ class dbGlobalConnect : public dbObject
   // User Code Begin dbGlobalConnect
   std::vector<dbInst*> getInsts() const;
 
-  int connect(dbInst* inst);
+  int connect(dbInst* inst, bool force);
 
   static dbGlobalConnect* create(dbNet* net,
                                  dbRegion* region,

src/odb/include/odb/db.h

@@ -3347,18 +3347,18 @@ void dbBlock::destroyNetWires()
   }
 }
 
-int dbBlock::globalConnect()
+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);
+  return dbblock->globalConnect(connects, force, verbose);
 }
 
-int dbBlock::globalConnect(dbGlobalConnect* gc)
+int dbBlock::globalConnect(dbGlobalConnect* gc, bool force, bool verbose)
 {
   _dbBlock* dbblock = (_dbBlock*) this;
-  return dbblock->globalConnect({gc});
+  return dbblock->globalConnect({gc}, force, verbose);
 }
 
 void dbBlock::clearGlobalConnect()
@@ -3419,12 +3419,14 @@ int dbBlock::addGlobalConnect(dbRegion* region,
       = odb::dbGlobalConnect::create(net, region, instPattern, pinPattern);
 
   if (gc != nullptr && do_connect) {
-    return globalConnect(gc);
+    return globalConnect(gc, false, false);
   }
   return 0;
 }
 
-int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects)
+int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects,
+                            bool force,
+                            bool verbose)
 {
   _dbBlock* dbblock = (_dbBlock*) this;
   utl::Logger* logger = dbblock->getImpl()->getLogger();
@@ -3439,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;
@@ -3472,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);
       }
     }
@@ -3491,12 +3493,25 @@ int _dbBlock::globalConnect(const std::vector<dbGlobalConnect*>& connects)
   }
 
   for (_dbGlobalConnect* connect : non_region_rules) {
-    const auto connections = connect->connect(inst_map[connect->inst_pattern_]);
+    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 = connect->connect(inst_map[connect->inst_pattern_]);
+    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.cpp

@@ -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);
+  int globalConnect(const std::vector<dbGlobalConnect*>& connects,
+                    bool force,
+                    bool verbose);
   _dbTech* getTech();
 
   dbObjectTable* getObjectTable(dbObjectType type);

src/odb/src/db/dbBlock.h

@@ -12,6 +12,8 @@
 #include "dbTable.hpp"
 #include "odb/db.h"
 // User Code Begin Includes
+#include <utility>
+
 #include "dbInst.h"
 #include "dbLib.h"
 #include "dbMTerm.h"
@@ -150,7 +152,7 @@ std::vector<dbInst*> dbGlobalConnect::getInsts() const
   return insts;
 }
 
-int dbGlobalConnect::connect(dbInst* inst)
+int dbGlobalConnect::connect(dbInst* inst, bool force)
 {
   if (inst->isDoNotTouch()) {
     return 0;
@@ -161,7 +163,7 @@ int dbGlobalConnect::connect(dbInst* inst)
     return 0;
   }
 
-  const auto connections = obj->connect({inst});
+  const auto& [connections, skipped] = obj->connect({inst}, force);
   return connections.size();
 }
 
@@ -283,24 +285,28 @@ std::set<dbMTerm*> _dbGlobalConnect::getMTermMapping(
   return mterms;
 }
 
-std::set<dbITerm*> _dbGlobalConnect::connect(const std::vector<dbInst*>& insts)
+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 conenctions",
+        "{} 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_) {
@@ -318,17 +324,25 @@ std::set<dbITerm*> _dbGlobalConnect::connect(const std::vector<dbInst*>& insts)
       auto* iterm = inst->getITerm(mterm);
 
       auto* current_net = iterm->getNet();
+      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);
@@ -338,7 +352,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