Merge remote-tracking branch 'origin/master' into odb-database-chip

Author: osamahammad21

include/ord/OpenRoad.hh

@@ -101,7 +101,8 @@ class ICeWall;
 
 namespace utl {
 class Logger;
-}
+class CallBackHandler;
+}  // namespace utl
 
 namespace dst {
 class Distributed;
@@ -137,6 +138,7 @@ class OpenRoad
 
   Tcl_Interp* tclInterp() { return tcl_interp_; }
   utl::Logger* getLogger() { return logger_; }
+  utl::CallBackHandler* getCallBackHandler() { return callback_handler_; }
   odb::dbDatabase* getDb() { return db_; }
   sta::dbSta* getSta() { return sta_; }
   sta::dbNetwork* getDbNetwork();
@@ -256,6 +258,7 @@ class OpenRoad
   dst::Distributed* distributer_ = nullptr;
   stt::SteinerTreeBuilder* stt_builder_ = nullptr;
   dft::Dft* dft_ = nullptr;
+  utl::CallBackHandler* callback_handler_ = nullptr;
 
   int threads_ = 1;
 

src/OpenRoad.cc

@@ -54,6 +54,7 @@
 #include "tap/MakeTapcell.h"
 #include "triton_route/MakeTritonRoute.h"
 #include "upf/MakeUpf.h"
+#include "utl/CallBackHandler.h"
 #include "utl/Logger.h"
 #include "utl/MakeLogger.h"
 #include "utl/Progress.h"
@@ -116,6 +117,7 @@ OpenRoad::~OpenRoad()
   dft::deleteDft(dft_);
   delete logger_;
   delete verilog_reader_;
+  delete callback_handler_;
 }
 
 sta::dbNetwork* OpenRoad::getDbNetwork()
@@ -160,6 +162,7 @@ void OpenRoad::init(Tcl_Interp* tcl_interp,
   // Make components.
   utl::Progress::setBatchMode(batch_mode);
   logger_ = utl::makeLogger(log_filename, metrics_filename);
+  callback_handler_ = new utl::CallBackHandler(logger_);
   db_->setLogger(logger_);
   sta_ = sta::makeDbSta();
   verilog_network_ = makeDbVerilogNetwork();
@@ -219,6 +222,7 @@ void OpenRoad::init(Tcl_Interp* tcl_interp,
                    opendp_,
                    stt_builder_,
                    logger_,
+                   callback_handler_,
                    tcl_interp);
   initTritonCts(tritonCts_,
                 db_,
@@ -240,8 +244,13 @@ void OpenRoad::init(Tcl_Interp* tcl_interp,
   initOpenRCX(extractor_, db_, logger_, getVersion(), tcl_interp);
   initICeWall(icewall_, db_, logger_, tcl_interp);
   initRestructure(restructure_, logger_, sta_, db_, resizer_, tcl_interp);
-  initTritonRoute(
-      detailed_router_, db_, logger_, distributer_, stt_builder_, tcl_interp);
+  initTritonRoute(detailed_router_,
+                  db_,
+                  logger_,
+                  callback_handler_,
+                  distributer_,
+                  stt_builder_,
+                  tcl_interp);
   initPDNSim(pdnsim_, logger_, db_, sta_, resizer_, opendp_, tcl_interp);
   initAntennaChecker(antenna_checker_, db_, logger_, tcl_interp);
   initPartitionMgr(

src/dbSta/include/db_sta/dbNetwork.hh

@@ -67,7 +67,16 @@ class dbNetwork : public ConcreteNetwork
   void clear() override;
   CellPortIterator* portIterator(const Cell* cell) const override;
 
-  void AxiomCheck();
+  // sanity checkers
+  void checkAxioms();
+  void checkSanityModBTerms();
+  void checkSanityModITerms();
+  void checkSanityModuleInsts();
+  void checkSanityModInstTerms();
+  void checkSanityUnusedModules();
+  void checkSanityTermConnectivity();
+  void checkSanityNetConnectivity();
+
   void readLefAfter(dbLib* lib);
   void readDefAfter(dbBlock* block);
   void readDbAfter(dbDatabase* db);

src/dbSta/src/dbNetwork.cc

@@ -4163,12 +4163,16 @@ void dbNetwork::accumulateFlatLoadPinsOnNet(
   visitConnectedPins(net, rp, visited_nets);
 }
 
-void dbNetwork::AxiomCheck()
+// Use this API to check if flat & hier connectivities are ok
+void dbNetwork::checkAxioms()
 {
-  dbSet<dbModNet> mod_nets = block()->getModNets();
-  for (auto mod_net : mod_nets) {
-    findRelatedDbNet(mod_net);
-  }
+  checkSanityModBTerms();
+  checkSanityModITerms();
+  checkSanityModuleInsts();
+  checkSanityModInstTerms();
+  checkSanityUnusedModules();
+  checkSanityTermConnectivity();
+  checkSanityNetConnectivity();
 }
 
 Net* dbNetwork::getFlatNet(Net* net) const
@@ -4186,4 +4190,184 @@ Net* dbNetwork::getFlatNet(Net* net) const
   return dbToSta(db_net);
 }
 
+void dbNetwork::checkSanityModBTerms()
+{
+  if (block_ == nullptr) {
+    return;
+  }
+  for (odb::dbModule* module : block_->getModules()) {
+    std::set<std::string> bterm_names;
+    for (odb::dbModBTerm* bterm : module->getModBTerms()) {
+      const std::string bterm_name = bterm->getName();
+      if (bterm_names.find(bterm_name) != bterm_names.end()) {
+        logger_->error(
+            ORD,
+            2036,
+            "SanityCheck: Duplicate dbModBTerm name '{}' in module '{}'.",
+            bterm_name,
+            module->getName());
+      }
+      bterm_names.insert(bterm_name);
+    }
+  }
+}
+
+void sta::dbNetwork::checkSanityModITerms()
+{
+  if (block_ == nullptr) {
+    return;
+  }
+  for (odb::dbModInst* mod_inst : block_->getModInsts()) {
+    std::set<std::string> iterm_names;
+    for (odb::dbModITerm* iterm : mod_inst->getModITerms()) {
+      const std::string iterm_name = iterm->getName();
+      if (iterm_names.find(iterm_name) != iterm_names.end()) {
+        logger_->error(ORD,
+                       2037,
+                       "SanityCheck: Duplicate dbModITerm name '{}' in module "
+                       "instance '{}'.",
+                       iterm_name,
+                       mod_inst->getName());
+      }
+      iterm_names.insert(iterm_name);
+    }
+  }
+}
+
+void dbNetwork::checkSanityModuleInsts()
+{
+  for (odb::dbModule* module : block_->getModules()) {
+    if (module->getModInsts().empty() && module->getInsts().empty()) {
+      logger_->warn(ORD,
+                    2038,
+                    "SanityCheck: Module '{}' has no instances.",
+                    module->getHierarchicalName());
+    }
+  }
+}
+
+void dbNetwork::checkSanityModInstTerms()
+{
+  for (odb::dbModInst* mod_inst : block_->getModInsts()) {
+    odb::dbModule* master = mod_inst->getMaster();
+    if (master) {
+      if (mod_inst->getModITerms().size() != master->getModBTerms().size()) {
+        logger_->warn(
+            ORD,
+            2042,
+            "SanityCheck: Module instance '{}' has {} ITerms, but its "
+            "master '{}' has {} BTerms.",
+            mod_inst->getHierarchicalName(),
+            mod_inst->getModITerms().size(),
+            master->getHierarchicalName(),
+            master->getModBTerms().size());
+      }
+    }
+  }
+}
+
+void dbNetwork::checkSanityUnusedModules()
+{
+  if (block_ == nullptr) {
+    return;
+  }
+
+  // 1. Collect all modules from the top block and its children.
+  // Unused modules may be placed in child blocks.
+  std::vector<odb::dbModule*> all_modules;
+  for (odb::dbModule* module : block_->getModules()) {
+    all_modules.push_back(module);
+  }
+  for (odb::dbBlock* child_block : block_->getChildren()) {
+    for (odb::dbModule* module : child_block->getModules()) {
+      all_modules.push_back(module);
+    }
+  }
+
+  // 2. Create a set of all instantiated module masters.
+  std::set<odb::dbModule*> instantiated_masters;
+  for (odb::dbModule* module : all_modules) {
+    for (odb::dbModInst* mod_inst : module->getModInsts()) {
+      instantiated_masters.insert(mod_inst->getMaster());
+    }
+  }
+
+  // 3. Iterate through all collected modules to check for usage.
+  odb::dbModule* top_module = block_->getTopModule();
+  for (odb::dbModule* module : all_modules) {
+    // A module is unused if it's not the top module and it's not a master
+    // for any module instance.
+    if (module != top_module
+        && instantiated_masters.find(module) == instantiated_masters.end()) {
+      logger_->warn(
+          ORD,
+          2043,
+          "SanityCheck: Module '{}' is defined but never instantiated.",
+          module->getName());
+    }
+  }
+}
+
+void dbNetwork::checkSanityTermConnectivity()
+{
+  for (odb::dbBTerm* bterm : block_->getBTerms()) {
+    if (bterm->getIoType() != dbIoType::INPUT && bterm->getNet() == nullptr) {
+      logger_->error(
+          ORD,
+          2040,
+          "SanityCheck: non-input BTerm '{}' is not connected to any net.",
+          bterm->getName());
+    }
+  }
+
+  for (odb::dbInst* inst : block_->getInsts()) {
+    for (odb::dbITerm* iterm : inst->getITerms()) {
+      if (iterm->getIoType() != dbIoType::OUTPUT
+          && iterm->getNet() == nullptr) {
+        logger_->error(ORD,
+                       2041,
+                       "SanityCheck: non-output ITerm '{}/{}' is not connected "
+                       "to any net.",
+                       inst->getName(),
+                       iterm->getMTerm()->getName());
+      }
+    }
+  }
+}
+
+void dbNetwork::checkSanityNetConnectivity()
+{
+  // Check for hier net and flat net connectivity
+  dbSet<dbModNet> mod_nets = block()->getModNets();
+  for (auto mod_net : mod_nets) {
+    findRelatedDbNet(mod_net);
+  }
+
+  // Check for incomplete flat net connections
+  for (odb::dbNet* net : block_->getNets()) {
+    const auto iterm_count = net->getITerms().size();
+    const auto bterm_count = net->getBTerms().size();
+    if (iterm_count + bterm_count >= 2) {
+      continue;
+    }
+
+    if (iterm_count == 1) {
+      odb::dbITerm* iterm = *(net->getITerms().begin());
+      if (iterm->getIoType() == odb::dbIoType::OUTPUT) {
+        continue;  // OK: Unconnected output pin
+      }
+    } else if (bterm_count == 1) {  // This is a top level port
+      odb::dbBTerm* bterm = *(net->getBTerms().begin());
+      if (bterm->getIoType() == odb::dbIoType::INPUT) {
+        continue;  // OK: Unconnected input port
+      }
+    }
+
+    logger_->error(ORD,
+                   2039,
+                   "SanityCheck: Net '{}' has less than 2 connections.",
+                   net->getName());
+  }
+}
+
 }  // namespace sta

src/dbSta/src/dbSta.i

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: BSD-3-Clause
 // Copyright (c) 2019-2025, The OpenROAD Authors
 
+// clang-format off
+
 %{
 
 #include "odb/db.h"
@@ -214,4 +216,17 @@ replace_hier_module_cmd(odb::dbModInst* mod_inst, odb::dbModule* module)
   (void) db_network->replaceHierModule(mod_inst, module);
 }
 
+
+namespace sta {
+
+void check_axioms_cmd()
+{
+  ord::OpenRoad* openroad = ord::getOpenRoad();
+  sta::dbSta *sta = openroad->getSta();
+  sta->ensureLinked();
+  sta->getDbNetwork()->checkAxioms();
+}
+
+} // namespace sta
+
 %} // inline

src/dbSta/src/dbSta.tcl

@@ -140,5 +140,11 @@ proc get_hier_module { arg } {
 }
 interp alias {} get_design {} get_hier_module
 
+define_cmd_args "check_axioms" {}
+proc check_axioms { args } {
+  check_argc_eq0 "check_axioms" $args
+  check_axioms_cmd
+}
+
 # namespace
 }

src/dbSta/test/CMakeLists.txt

@@ -2,6 +2,7 @@ or_integration_tests(
   "dbSta"
   TESTS
     block_sta1
+    check_axioms
     clock_pin
     constant1
     find_clks1

src/dbSta/test/check_axioms.ok

@@ -0,0 +1,5 @@
+[INFO ODB-0227] LEF file: Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
+[WARNING ORD-2038] SanityCheck: Module 'i_empty' has no instances.
+[WARNING ORD-2038] SanityCheck: Module 'u1' has no instances.
+[WARNING ORD-2038] SanityCheck: Module 'u2' has no instances.
+[ERROR ORD-2039] SanityCheck: Net 'out_unconnected' has less than 2 connections.

src/dbSta/test/check_axioms.tcl

@@ -0,0 +1,22 @@
+# Test for sanity checker APIs (sta::check_axioms)
+source "helpers.tcl"
+
+# Setup
+read_liberty Nangate45/Nangate45_typ.lib
+read_lef Nangate45/Nangate45.lef
+read_verilog check_axioms.v
+link_design top
+
+# Run the checks and capture output.
+# The 'catch' command is used because sta::check_axioms will exit with an
+# error, and we want to continue to check all messages.
+set status [catch { sta::check_axioms } msg]
+
+# check_axioms cannot detect unused_module.
+# - It is because odb does not keep unused modules in its database.
+
+# Check for expected messages.
+#[WARNING ORD-2038] SanityCheck: Module i_empty has no instances.
+#[WARNING ORD-2038] SanityCheck: Module u1 has no instances.
+#[WARNING ORD-2038] SanityCheck: Module u2 has no instances.
+#[ERROR ORD-2039] SanityCheck: Net out_unconnected has less than 2 connections.