test: Add time-borrow effective slack coverage

Move the RSZ time-borrow regression checks into log-comparison tests so the golden .ok files validate the expected output directly.

Add C++ coverage to TestResizer for covered and uncovered latch borrow cases, and wire the shared DEF fixture through both CMake and Bazel.

Drop the pass/fail sentinel output from the Tcl tests because the golden log comparison already provides the pass condition.

Signed-off-by: Jaehyun Kim <jhkim@precisioninno.com>

Author: jhkim-pii

src/rsz/test/BUILD

@@ -250,15 +250,15 @@ TESTS = [
     "global_sizing",
     "global_sizing_threads",
     "global_sizing_presize",
+    "inferred_clock_gator_time_borrow",
+    "inferred_clock_gator_time_borrow_covered",
 ]
 
 # From CMakeLists.txt or_integration_tests(PASSFAIL_TESTS
 PASSFAIL_TESTS = [
     # NOTE: cpp_tests excluded - it's a CMake-specific wrapper script that expects
     # build directory structure not compatible with Bazel
     # "cpp_tests",
-    "inferred_clock_gator_time_borrow",
-    "inferred_clock_gator_time_borrow_covered",
     "repair_setup_legacy_mt",
     "repair_setup_mt1",
 ]
@@ -478,13 +478,25 @@ cc_test(
     name = "TestResizer",
     srcs = ["cpp/TestResizer.cc"],
     copts = ["-Isrc/rsz/src"],
-    data = glob(["cpp/TestResizer*.v"]),
+    data = glob(["cpp/TestResizer*.v"]) + [
+        "inferred_clock_gator_time_borrow.def",
+    ],
     features = ["-layering_check"],  # TODO: includes private headers
     deps = [
+        "//src/ant",
+        "//src/dbSta",
+        "//src/dbSta:dbNetwork",
+        "//src/dpl",
+        "//src/est",
+        "//src/grt",
         "//src/odb/src/db",
+        "//src/odb/src/defin",
         "//src/rsz",  # build_cleaner keep provides the private headers
         "//src/sta:opensta_lib",
+        "//src/stt",
+        "//src/tst",
         "//src/tst:integrated_fixture",
+        "//src/utl",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

src/rsz/test/CMakeLists.txt

@@ -238,9 +238,9 @@ or_integration_tests(
     global_sizing
     global_sizing_threads
     global_sizing_presize
-  PASSFAIL_TESTS
     inferred_clock_gator_time_borrow
     inferred_clock_gator_time_borrow_covered
+  PASSFAIL_TESTS
     repair_setup_legacy_mt
     repair_setup_mt1
     cpp_tests

src/rsz/test/cpp/CMakeLists.txt

@@ -100,6 +100,7 @@ target_link_libraries(TestResizer
         dpl_lib
         stt_lib
         odb
+        defin
         tst
         ${TCL_LIBRARY}
 )

src/rsz/test/cpp/TestResizer.cc

@@ -3,11 +3,22 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
+#include "RepairTargetCollector.hh"
 #include "gtest/gtest.h"
 #include "odb/db.h"
+#include "odb/defin.h"
+#include "sta/Clock.hh"
+#include "sta/Graph.hh"
 #include "sta/Liberty.hh"
+#include "sta/MinMax.hh"
+#include "sta/Mode.hh"
 #include "sta/NetworkClass.hh"
+#include "sta/Sdc.hh"
+#include "sta/Sta.hh"
+#include "sta/Transition.hh"
+#include "sta/Units.hh"
 #include "tst/IntegratedFixture.h"
 
 namespace rsz {
@@ -35,6 +46,157 @@ class TestResizer : public tst::IntegratedFixture
     return modnet ? modnet->getName() : "None";
   }
 
+  float staTime(const float value) const
+  {
+    return sta_->units()->timeUnit()->userToSta(value);
+  }
+
+  void readDefForTiming(const char* def_file)
+  {
+    odb::dbChip* chip = db_->getChip();
+    if (chip == nullptr) {
+      chip = odb::dbChip::create(db_.get(), db_->getTech());
+    }
+
+    std::vector<odb::dbLib*> search_libs;
+    for (odb::dbLib* db_lib : db_->getLibs()) {
+      search_libs.push_back(db_lib);
+    }
+
+    const std::string def_path = getFilePath(test_root_path_ + def_file);
+    odb::defin def_reader(db_.get(), &logger_);
+    def_reader.readChip(search_libs, def_path.c_str(), chip);
+
+    sta_->postReadDb(db_.get());
+    block_ = chip->getBlock();
+    sta_->postReadDef(block_);
+  }
+
+  sta::Pin* findTopPin(const char* port_name) const
+  {
+    sta::Instance* top_inst = db_network_->topInstance();
+    sta::Cell* top_cell = db_network_->cell(top_inst);
+    if (top_cell == nullptr) {
+      ADD_FAILURE() << "missing top cell";
+      return nullptr;
+    }
+
+    sta::Port* port = db_network_->findPort(top_cell, port_name);
+    if (port == nullptr) {
+      ADD_FAILURE() << "missing top port " << port_name;
+      return nullptr;
+    }
+
+    sta::Pin* pin = db_network_->findPin(top_inst, port);
+    if (pin == nullptr) {
+      ADD_FAILURE() << "missing top pin " << port_name;
+      return nullptr;
+    }
+    return pin;
+  }
+
+  void makeClock(const char* clock_name, sta::Pin* pin) const
+  {
+    sta::PinSet pins(db_network_);
+    if (pin != nullptr) {
+      pins.insert(pin);
+    }
+
+    const float period = staTime(1.0);
+    sta::FloatSeq waveform;
+    waveform.push_back(0.0);
+    waveform.push_back(period / 2.0);
+
+    sta_->makeClock(
+        clock_name, pins, false, period, waveform, "", sta_->cmdMode());
+  }
+
+  void setInputDelay(const char* port_name,
+                     const char* clock_name,
+                     const float delay) const
+  {
+    sta::Sdc* sdc = sta_->cmdMode()->sdc();
+    sta::Clock* clock = sdc->findClock(clock_name);
+    ASSERT_NE(clock, nullptr);
+
+    sta::Pin* pin = findTopPin(port_name);
+    ASSERT_NE(pin, nullptr);
+
+    sta_->setInputDelay(pin,
+                        sta::RiseFallBoth::riseFall(),
+                        clock,
+                        sta::RiseFall::rise(),
+                        nullptr,
+                        false,
+                        false,
+                        sta::MinMaxAll::all(),
+                        true,
+                        staTime(delay),
+                        sdc);
+  }
+
+  void setupTimeBorrowTiming(const float input_delay)
+  {
+    readDefForTiming("inferred_clock_gator_time_borrow.def");
+
+    sta::Pin* clk_pin = findTopPin("clk");
+    ASSERT_NE(clk_pin, nullptr);
+
+    makeClock("clk", clk_pin);
+    makeClock("vclk", nullptr);
+
+    sta::Clock* clk = sta_->cmdMode()->sdc()->findClock("clk");
+    ASSERT_NE(clk, nullptr);
+    sta_->setPropagatedClock(clk, sta_->cmdMode());
+    setInputDelay("en_in", "vclk", input_delay);
+
+    sta_->ensureGraph();
+    sta_->ensureLevelized();
+    resizer_.initBlock();
+    ep_.estimateWireParasitics();
+    sta_->updateTiming(true);
+  }
+
+  sta::Vertex* latchDataEndpoint() const
+  {
+    sta::Pin* latch_d = db_network_->findPin("enable_latch/D");
+    if (latch_d == nullptr) {
+      ADD_FAILURE() << "missing latch D pin";
+      return nullptr;
+    }
+
+    sta::Vertex* endpoint = sta_->graph()->pinLoadVertex(latch_d);
+    if (endpoint == nullptr) {
+      ADD_FAILURE() << "missing latch D load vertex";
+      return nullptr;
+    }
+    return endpoint;
+  }
+
+  struct SlackPair
+  {
+    sta::Slack reported_slack;
+    sta::Slack effective_slack;
+  };
+
+  SlackPair latchDataSlack(const float input_delay)
+  {
+    setupTimeBorrowTiming(input_delay);
+
+    RepairTargetCollector collector(&resizer_);
+    collector.init(0.0f);
+
+    sta::Vertex* endpoint = latchDataEndpoint();
+    if (endpoint == nullptr) {
+      return {0.0f, 0.0f};
+    }
+
+    const sta::Slack reported_slack = sta_->slack(endpoint, sta::MinMax::max());
+    const sta::Slack effective_slack
+        = collector.getEndpointEffectiveSlack(endpoint);
+    return {reported_slack, effective_slack};
+  }
+
   sta::LibertyPort* findLibertyPort(sta::Instance* inst, const char* port_name)
   {
     std::unique_ptr<sta::InstancePinIterator> pin_iter{
@@ -96,4 +258,32 @@ TEST_F(TestResizer, SwapPinsFeedthroughModNet)
   writeAndCompareVerilogOutputFile(test_name, test_name + "_post.v");
 }
 
+// A large virtual-clock input delay (0.98) forces the enable latch to borrow
+// more time than the downstream logic can absorb (uncovered borrow). In that
+// case getEndpointEffectiveSlack() must subtract the uncovered borrow, yielding
+// an effective slack strictly worse than the reported slack so that
+// repair_timing targets the latch D endpoint.
+TEST_F(TestResizer, UncoveredBorrowReducesEffectiveSlack)
+{
+  const SlackPair slack = latchDataSlack(0.98);
+  const float one_ps = staTime(0.001);
+
+  EXPECT_LE(slack.reported_slack, 0.0);
+  EXPECT_LT(slack.effective_slack, slack.reported_slack - one_ps);
+}
+
+// A smaller virtual-clock input delay (0.80) leaves enough downstream setup
+// margin to fully cover the latch borrow (covered borrow).
+// getEndpointEffectiveSlack() must then leave the reported slack unchanged, so
+// that repair_timing does not spuriously optimize the already-covered latch D
+// endpoint.
+TEST_F(TestResizer, CoveredBorrowKeepsReportedSlack)
+{
+  const SlackPair slack = latchDataSlack(0.80);
+  const float one_ps = staTime(0.001);
+
+  EXPECT_NEAR(slack.reported_slack, 0.0, one_ps);
+  EXPECT_NEAR(slack.effective_slack, slack.reported_slack, one_ps);
+}
+
 }  // namespace rsz