feat(icts): harden lifecycle and optimize runtime hot paths

src/database/data/design/IdbDesign.cpp

@@ -530,6 +530,36 @@ bool IdbDesign::disconnectPinFromNet(IdbPin* pin)
   return true;
 }
 
+std::size_t IdbDesign::disconnectAllPinsFromNet(IdbNet* net)
+{
+  if (net == nullptr) {
+    return 0U;
+  }
+
+  std::size_t disconnected_pin_count = 0U;
+  const auto disconnect_pin_refs = [&](IdbPins* pins) {
+    if (pins == nullptr) {
+      return;
+    }
+    for (auto* pin : pins->get_pin_list()) {
+      if (pin == nullptr || pin->get_net() != net) {
+        continue;
+      }
+      pin->remove_net();
+      refreshPinNetName(pin);
+      ++disconnected_pin_count;
+    }
+    pins->clear_pin_refs();
+  };
+
+  disconnect_pin_refs(net->get_io_pins());
+  disconnect_pin_refs(net->get_instance_pin_list());
+  if (net->get_instance_list() != nullptr) {
+    net->get_instance_list()->reset(false);
+  }
+  return disconnected_pin_count;
+}
+
 bool IdbDesign::connectPinToNet(IdbPin* pin, IdbNet* net)
 {
   if (pin == nullptr || net == nullptr) {
@@ -595,14 +625,7 @@ bool IdbDesign::removeNetSafe(const std::string& net_name)
     return false;
   }
 
-  std::vector<IdbPin*> pin_list;
-  auto& io_pins = net->get_io_pins()->get_pin_list();
-  auto& inst_pins = net->get_instance_pin_list()->get_pin_list();
-  pin_list.insert(pin_list.end(), io_pins.begin(), io_pins.end());
-  pin_list.insert(pin_list.end(), inst_pins.begin(), inst_pins.end());
-  for (auto* pin : pin_list) {
-    disconnectPinFromNet(pin);
-  }
+  disconnectAllPinsFromNet(net);
   net->clear_wire_list();
 
   return _net_list->remove_net_only(net_name);
@@ -634,6 +657,7 @@ bool IdbDesign::mergeNetInto(const std::string& target_net_name, const std::stri
   auto& inst_pins = source_net->get_instance_pin_list()->get_pin_list();
   pin_list.insert(pin_list.end(), io_pins.begin(), io_pins.end());
   pin_list.insert(pin_list.end(), inst_pins.begin(), inst_pins.end());
+  disconnectAllPinsFromNet(source_net);
   for (auto* pin : pin_list) {
     connectPinToNet(pin, target_net);
   }

src/database/data/design/IdbDesign.h

@@ -32,6 +32,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include <cmath>
+#include <cstddef>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -144,6 +145,7 @@ class IdbDesign
   bool connectIoPinToNet(const std::string& io_pin_name, const std::string& net_name);
   bool connectInstancePinToNet(const std::string& inst_name, const std::string& pin_name, const std::string& net_name);
   bool disconnectPinFromNet(IdbPin* pin);
+  std::size_t disconnectAllPinsFromNet(IdbNet* net);
   bool removeNetSafe(const std::string& net_name);
   bool renameNet(IdbNet* net, const std::string& new_name);
   bool mergeNetInto(const std::string& target_net_name, const std::string& source_net_name, bool move_wires = true);

src/database/data/design/db_design/IdbInstance.cpp

@@ -456,6 +456,14 @@ bool IdbInstanceList::contains(IdbInstance* instance)
     return false;
   }
 
+  const auto& name = instance->get_name();
+  if (!name.empty()) {
+    const auto iter = _instance_map.find(name);
+    if (iter != _instance_map.end() && iter->second == instance) {
+      return true;
+    }
+  }
+
   auto iter = std::find(_instance_list.begin(), _instance_list.end(), instance);
   return iter != _instance_list.end();
 }

src/database/data/design/db_design/IdbPins.cpp

@@ -792,6 +792,12 @@ bool IdbPins::erase_pin_ref(IdbPin* pin_remove)
   return true;
 }
 
+void IdbPins::clear_pin_refs()
+{
+  _pin_list.clear();
+  _pin_ref_index.reset();
+}
+
 bool IdbPins::delete_pin(IdbPin* pin_remove)
 {
   if (!erase_pin_ref(pin_remove)) {

src/database/data/design/db_design/IdbPins.h

@@ -163,6 +163,7 @@ class IdbPins
   // Operate
   void remove_pin(IdbPin* pin_remove);
   bool erase_pin_ref(IdbPin* pin_remove);
+  void clear_pin_refs();
   bool delete_pin(IdbPin* pin_remove);
   int32_t getIOPortWidth();
   void checkPins();

src/interface/python/py_icts/py_icts.cpp

@@ -31,6 +31,11 @@ bool CtsReport(const std::string& path)
   return CTS_API_INST.report(path).ok();
 }
 
+bool CtsDestroy()
+{
+  return CTS_API_INST.destroyCTS().ok();
+}
+
 pybind11::dict CtsTimingFeature()
 {
   namespace py = pybind11;

src/interface/python/py_icts/py_icts.h

@@ -22,5 +22,6 @@
 namespace python_interface {
 bool CtsAutoRun(const std::string& cts_config, const std::string& cts_work_dir);
 bool CtsReport(const std::string& path);
+bool CtsDestroy();
 pybind11::dict CtsTimingFeature();
 }  // namespace python_interface

src/interface/python/py_icts/py_register_icts.h

@@ -26,6 +26,7 @@ void register_icts(pybind11::module& m)
 {
   m.def("run_cts", CtsAutoRun, py::arg("cts_config"), py::arg("cts_work_dir"));
   m.def("cts_report", CtsReport, py::arg("path"));
+  m.def("destroy_cts", CtsDestroy);
   m.def("cts_timing_feature", CtsTimingFeature);
 }
 

src/interface/tcl/tcl_icts/tcl_cts.cpp

@@ -98,4 +98,18 @@ unsigned CmdCTSReport::exec()
 
   return 0;
 }
+
+CmdCTSDestroy::CmdCTSDestroy(const char* cmd_name) : TclCmd(cmd_name)
+{
+}
+
+unsigned CmdCTSDestroy::check()
+{
+  return 1U;
+}
+
+unsigned CmdCTSDestroy::exec()
+{
+  return CTS_API_INST.destroyCTS().ok() ? 1U : 0U;
+}
 }  // namespace tcl

src/interface/tcl/tcl_icts/tcl_cts.h

@@ -35,7 +35,8 @@ using ecc::TclStringOption;
 
 namespace tcl {
 
-class CmdCTSAutoRun : public TclCmd {
+class CmdCTSAutoRun : public TclCmd
+{
  public:
   explicit CmdCTSAutoRun(const char* cmd_name);
   ~CmdCTSAutoRun() override = default;
@@ -48,7 +49,8 @@ class CmdCTSAutoRun : public TclCmd {
   // private data
 };
 
-class CmdCTSReport : public TclCmd {
+class CmdCTSReport : public TclCmd
+{
  public:
   explicit CmdCTSReport(const char* cmd_name);
   ~CmdCTSReport() override = default;
@@ -60,4 +62,14 @@ class CmdCTSReport : public TclCmd {
   // private function
   // private data
 };
+
+class CmdCTSDestroy : public TclCmd
+{
+ public:
+  explicit CmdCTSDestroy(const char* cmd_name);
+  ~CmdCTSDestroy() override = default;
+
+  unsigned check() override;
+  unsigned exec() override;
+};
 }  // namespace tcl

src/interface/tcl/tcl_icts/tcl_register_cts.h

@@ -31,10 +31,12 @@
 using namespace ecc;
 namespace tcl {
 
-int registerCmdCTS() {
+int registerCmdCTS()
+{
   registerTclCmd(CmdCTSAutoRun, "run_cts");
   registerTclCmd(CmdCTSReport, "cts_report");
   registerTclCmd(CmdCTSConfig, "cts_config");
+  registerTclCmd(CmdCTSDestroy, "destroy_cts");
 
   return EXIT_SUCCESS;
 }

src/operation/iCTS/interface/CTSAPI.cc

@@ -29,6 +29,7 @@
 #include "LogTable.hh"
 #include "Logger.hh"
 #include "Monitor.hh"
+#include "Utility.hh"
 #include "data_manager/DataManager.hh"
 #include "evaluation/Evaluation.hh"
 #include "evaluation/qor/QOREvaluation.hh"
@@ -71,11 +72,7 @@ auto buildInputStatus(const DataManagerStatus& input_status) -> CTSStatus
 
 CTSAPI::CTSAPI() = default;
 
-CTSAPI::~CTSAPI()
-{
-  DataManager::destroyInst();
-  Logger::destroyInst();
-}
+CTSAPI::~CTSAPI() = default;
 
 auto CTSAPI::setLastStatus(CTSStatus status) -> CTSStatus
 {
@@ -152,18 +149,28 @@ auto CTSAPI::report(const std::string& save_dir) -> CTSStatus
                                           : CTSStatus{.code = CTSStatusCode::kReportError, .message = "CTS report generation failed.", .diagnostics = {}});
 }
 
-auto CTSAPI::resetAPI() -> void
+auto CTSAPI::destroyCTS() -> CTSStatus
 {
   auto& api = getInst();
+  Logger::initInst();
+  CTSLOG.info(Loc::current(), "Starting CTS destruction...");
   DataManager::destroyInst();
-  Logger::destroyInst();
   api._initialized = false;
-  api.setLastStatus(buildOkStatus("CTS API reset."));
+  const auto memory_stats = Utility::releaseMemory();
+  const auto status = api.setLastStatus(buildOkStatus("CTS destruction completed."));
+  if (memory_stats.supported) {
+    CTSLOG.info(Loc::current(), "Completed CTS destruction; allocator release supported, RSS before=", Utility::formatFixed(memory_stats.rss_before_mb, 2),
+                " MiB, RSS after=", Utility::formatFixed(memory_stats.rss_after_mb, 2), " MiB.");
+  } else {
+    CTSLOG.info(Loc::current(), "Completed CTS destruction; allocator release unsupported.");
+  }
+  Logger::destroyInst();
+  return status;
 }
 
 auto CTSAPI::init(const std::string& config_file, const std::string& work_dir) -> CTSStatus
 {
-  resetAPI();
+  (void) destroyCTS();
   auto& api = getInst();
   Logger::initInst();
   Monitor monitor;
@@ -176,8 +183,7 @@ auto CTSAPI::init(const std::string& config_file, const std::string& work_dir) -
   auto status = buildInputStatus(input_status);
   if (!input_status.ok()) {
     CTSLOG.warn(Loc::current(), "CTS initialization failed: ", input_status.message, monitor.getStatsInfo());
-    DataManager::destroyInst();
-    Logger::destroyInst();
+    (void) destroyCTS();
     return api.setLastStatus(std::move(status));
   }
   api._initialized = true;

src/operation/iCTS/interface/CTSAPI.hh

@@ -63,7 +63,7 @@ class CTSAPI
   static auto report(const std::string& save_dir) -> CTSStatus;
 
   // Lifecycle API
-  static auto resetAPI() -> void;
+  static auto destroyCTS() -> CTSStatus;
   static auto init(const std::string& config_file, const std::string& work_dir = "") -> CTSStatus;
   static auto lastStatus() -> CTSStatus;