rsz: Remove borrowed latch effective slack

Remove the effective slack endpoint model now that setup repair expands latch-through paths to include the latch D fanin.

Use reported STA endpoint slack again for endpoint collection and repair progress checks to avoid creating artificial latch D endpoint violations.

Keep the C++ coverage focused on latch-through target collection and rely on the Tcl regressions for end-to-end borrow reduction.

Test: cmake --build build -j32 --target openroad TestResizer

Test: ctest --test-dir build -R '^TestResizer\.|rsz\.inferred_clock_gator_time_borrow.*\.tcl' --output-on-failure

Test: bazelisk test //src/rsz/test:TestResizer //src/rsz/test:inferred_clock_gator_time_borrow-tcl_test //src/rsz/test:inferred_clock_gator_time_borrow_covered-tcl_test //src/rsz/test:inferred_clock_gator_time_borrow_repair_pin-tcl_test //src/rsz/test:inferred_clock_gator_time_borrow_tns-tcl_test

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

Author: jhkim-pii

src/rsz/src/RepairTargetCollector.cc

@@ -23,7 +23,6 @@
 #include "rsz/Resizer.hh"
 #include "sta/Delay.hh"
 #include "sta/ExceptionPath.hh"
-#include "sta/FuncExpr.hh"
 #include "sta/Fuzzy.hh"
 #include "sta/Graph.hh"
 #include "sta/GraphClass.hh"
@@ -39,12 +38,10 @@
 #include "sta/Sdc.hh"
 #include "sta/Search.hh"
 #include "sta/SearchClass.hh"
-#include "sta/Sequential.hh"
 #include "sta/Sta.hh"
 #include "sta/StringUtil.hh"
 #include "sta/TimingArc.hh"
 #include "sta/Transition.hh"
-#include "sta/VisitPathEnds.hh"
 #include "utl/Logger.h"
 
 namespace rsz {
@@ -815,9 +812,9 @@ void RepairTargetCollector::collectViolatingEndpoints()
 
   const sta::VertexSet& endpoints = sta_->endpoints();
   for (sta::Vertex* endpoint : endpoints) {
-    const sta::Slack effective_slack = getEndpointEffectiveSlack(endpoint);
-    if (sta::fuzzyLess(effective_slack, slack_margin_)) {
-      violating_endpoints_.emplace_back(endpoint->pin(), effective_slack);
+    const sta::Slack slack = sta_->slack(endpoint, max_);
+    if (sta::fuzzyLess(slack, slack_margin_)) {
+      violating_endpoints_.emplace_back(endpoint->pin(), slack);
     }
   }
 
@@ -835,144 +832,6 @@ void RepairTargetCollector::collectViolatingEndpoints()
                  * 100));
 }
 
-namespace {
-
-// Track the worst-slack constrained max path end at a vertex and record its
-// latch time borrow. Non-latch path ends report zero borrow.
-class WorstPathEndBorrowVisitor : public sta::PathEndVisitor
-{
- public:
-  WorstPathEndBorrowVisitor(const sta::MinMax* min_max,
-                            const sta::StaState* sta)
-      : min_max_(min_max), sta_(sta)
-  {
-  }
-  sta::PathEndVisitor* copy() const override
-  {
-    return new WorstPathEndBorrowVisitor(*this);
-  }
-  void visit(sta::PathEnd* path_end) override
-  {
-    if (path_end->isUnconstrained() || path_end->minMax(sta_) != min_max_) {
-      return;
-    }
-    const sta::Slack end_slack = path_end->slack(sta_);
-    if (sta::delayLess(end_slack, worst_slack_, sta_)) {
-      worst_slack_ = end_slack;
-      borrow_ = path_end->borrow(sta_);
-    }
-  }
-  sta::Arrival borrow() const { return borrow_; }
-
- private:
-  const sta::MinMax* min_max_;
-  const sta::StaState* sta_;
-  sta::Slack worst_slack_ = sta::INF;
-  sta::Arrival borrow_ = 0.0;
-};
-
-}  // namespace
-
-sta::Slack RepairTargetCollector::getEndpointEffectiveSlack(
-    sta::Vertex* endpoint) const
-{
-  const sta::Slack reported_slack = sta_->slack(endpoint, max_);
-  if (sta::fuzzyGreater(reported_slack, slack_margin_)) {
-    return reported_slack;
-  }
-
-  // Visit the path ends stored at this endpoint and read the time borrow of
-  // the worst-slack one. This avoids the heavyweight findPathEnds() machinery
-  // (exception filter, path group construction, sorting) per endpoint.
-  sta::VisitPathEnds visit_ends(sta_);
-  WorstPathEndBorrowVisitor borrow_visitor(max_, sta_);
-  visit_ends.visitPathEnds(endpoint, &borrow_visitor);
-
-  const sta::Arrival borrow = borrow_visitor.borrow();
-  if (sta::fuzzyLessEqual(borrow, 0.0f)) {
-    return reported_slack;
-  }
-
-  const std::vector<const sta::Pin*> output_pins = latchOutputPins(endpoint);
-  const sta::Slack output_slack = latchOutputWorstSlack(output_pins);
-  const sta::Slack uncovered_borrow
-      = std::max<float>(borrow - std::max<float>(output_slack, 0.0f), 0.0f);
-  return reported_slack - uncovered_borrow;
-}
-
-std::vector<const sta::Pin*> RepairTargetCollector::latchOutputPins(
-    sta::Vertex* endpoint) const
-{
-  std::vector<const sta::Pin*> output_pins;
-  const std::function<void(
-      sta::Instance*, sta::LibertyCell*, sta::LibertyPort*)>
-      add_output_pin = [this, &output_pins](sta::Instance* inst,
-                                            sta::LibertyCell* cell,
-                                            sta::LibertyPort* state_port) {
-        const sta::Pin* output_pin = network_->findPin(inst, state_port);
-        if (output_pin != nullptr) {
-          output_pins.push_back(output_pin);
-          return;
-        }
-
-        // Some libraries declare latch state as an internal port and expose it
-        // through an output pin function, for example Q = IQ.
-        sta::LibertyCellPortIterator port_iter(cell);
-        while (port_iter.hasNext()) {
-          sta::LibertyPort* port = port_iter.next();
-          sta::FuncExpr* func = port->function();
-          if (!port->direction()->isAnyOutput() || func == nullptr
-              || !func->hasPort(state_port)) {
-            continue;
-          }
-
-          output_pin = network_->findPin(inst, port);
-          if (output_pin != nullptr
-              && std::ranges::find(output_pins, output_pin)
-                     == output_pins.end()) {
-            output_pins.push_back(output_pin);
-          }
-        }
-      };
-
-  const sta::Pin* endpoint_pin = endpoint->pin();
-  sta::LibertyPort* data_port = network_->libertyPort(endpoint_pin);
-  sta::LibertyCell* cell = data_port->libertyCell();
-  sta::Instance* inst = network_->instance(endpoint_pin);
-
-  for (const sta::Sequential& seq : cell->sequentials()) {
-    if (!seq.isLatch() || seq.data() == nullptr
-        || !seq.data()->hasPort(data_port)) {
-      continue;
-    }
-
-    if (seq.output() != nullptr) {
-      add_output_pin(inst, cell, seq.output());
-    }
-    if (seq.outputInv() != nullptr) {
-      add_output_pin(inst, cell, seq.outputInv());
-    }
-  }
-
-  return output_pins;
-}
-
-sta::Slack RepairTargetCollector::latchOutputWorstSlack(
-    const std::vector<const sta::Pin*>& output_pins) const
-{
-  sta::Slack worst_slack = sta::INF;
-
-  for (const sta::Pin* output_pin : output_pins) {
-    sta::Vertex* output_vertex = graph_->pinDrvrVertex(output_pin);
-    const sta::Slack output_slack = sta_->slack(output_vertex, max_);
-    if (sta::delayLess(output_slack, worst_slack, sta_)) {
-      worst_slack = output_slack;
-    }
-  }
-
-  return worst_slack;
-}
-
 void RepairTargetCollector::collectViolatingStartpoints()
 {
   violating_startpoints_.clear();

src/rsz/src/RepairTargetCollector.hh

@@ -173,10 +173,6 @@ class RepairTargetCollector
 
   // Public endpoint collection for TNS Phase
   void collectViolatingEndpoints();
-  // Effective slack includes hidden setup debt from latch time borrowing.
-  // A latch endpoint only pays the part of its borrow that is not covered by
-  // slack on the latch output path.
-  sta::Slack getEndpointEffectiveSlack(sta::Vertex* endpoint) const;
   sta::Slack getPathSlackByIndex(const sta::Pin* endpoint_pin, int path_index);
   const vector<std::pair<const sta::Pin*, sta::Slack>>& getViolatingEndpoints()
       const
@@ -301,9 +297,6 @@ class RepairTargetCollector
                                         std::vector<Target>& targets) const;
   void collectExpandedPathDriverPins(const sta::PathExpanded& expanded,
                                      set<const sta::Pin*>& pins) const;
-  std::vector<const sta::Pin*> latchOutputPins(sta::Vertex* endpoint) const;
-  sta::Slack latchOutputWorstSlack(
-      const std::vector<const sta::Pin*>& output_pins) const;
 
   // === Cone traversal helpers ==============================================
   // Helper functions for cone-based collection

src/rsz/src/policy/SetupLegacyBase.cc

@@ -109,8 +109,7 @@ bool SetupLegacyBase::repairSetupPin(const sta::Pin* end_pin)
     return false;
   }
 
-  const sta::Slack end_slack
-      = target_collector_->getEndpointEffectiveSlack(end_vertex);
+  const sta::Slack end_slack = sta_->slack(end_vertex, max_);
   sta::Path* end_path = sta_->vertexWorstSlackPath(end_vertex, max_);
   if (end_path == nullptr) {
     return false;
@@ -314,8 +313,7 @@ void SetupLegacyBase::saveImprovedCheckpoint(
 void SetupLegacyBase::refreshEndpointSlacks(
     SetupLegacyBase::EndpointRepairState& endpoint_state)
 {
-  endpoint_state.end_slack
-      = target_collector_->getEndpointEffectiveSlack(endpoint_state.end);
+  endpoint_state.end_slack = sta_->slack(endpoint_state.end, max_);
   sta_->worstSlack(
       max_, endpoint_state.worst_slack, endpoint_state.worst_vertex);
 }

src/rsz/src/policy/SetupTnsPolicy.cc

@@ -190,7 +190,7 @@ void SetupTnsPolicy::repairSetupTns(const float setup_slack_margin,
       estimate_parasitics_->updateParasitics();
       sta_->findRequireds();
 
-      endpoint_slack = target_collector_->getEndpointEffectiveSlack(endpoint);
+      endpoint_slack = sta_->slack(endpoint, max_);
       sta::Slack global_wns = 0.0;
       sta::Vertex* global_wns_vertex = nullptr;
       sta_->worstSlack(max_, global_wns, global_wns_vertex);

src/rsz/test/cpp/TestResizer.cc

@@ -173,30 +173,6 @@ class TestResizer : public tst::IntegratedFixture
     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 = loadVertex("enable_latch/D");
-    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};
-  }
-
   bool hasTargetPin(const std::vector<Target>& targets,
                     const char* pin_name) const
   {
@@ -271,34 +247,6 @@ 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.65) 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.65);
-  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);
-}
-
 TEST_F(TestResizer, LatchThroughPathCollectsLatchDataFaninTargets)
 {
   setupTimeBorrowTiming(0.98);