rsz: Refine latch borrow effective slack

Compute latch endpoint effective slack from uncovered time borrow instead of subtracting the full borrowed amount. This prevents repair_timing from over-optimizing latch D input paths when the latch output path has enough positive slack to absorb the borrow.

Find latch output pins through both direct sequential output pins and output functions that reference internal latch state ports. Add a covered-borrow regression to ensure repair_timing leaves fully covered latch borrow unchanged.

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

Author: jhkim-pii

src/rsz/src/RepairTargetCollector.cc

@@ -23,6 +23,7 @@
 #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"
@@ -38,10 +39,12 @@
 #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 {
@@ -832,6 +835,44 @@ 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
 {
@@ -840,45 +881,121 @@ sta::Slack RepairTargetCollector::getEndpointEffectiveSlack(
     return reported_slack;
   }
 
-  sta::PinSet* to_pins = new sta::PinSet(network_);
-  to_pins->insert(endpoint->pin());
-  sta::ExceptionTo* to = sdc_->makeExceptionTo(to_pins,
-                                               nullptr,
-                                               nullptr,
-                                               sta::RiseFallBoth::riseFall(),
-                                               sta::RiseFallBoth::riseFall());
+  // 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);
 
-  sta::StringSeq group_names;
-  sta::PathEndSeq path_ends
-      = search_->findPathEnds(nullptr,                // from
-                              nullptr,                // thrus
-                              to,                     // to
-                              false,                  // unconstrained
-                              sta_->scenes(),         // scene
-                              sta::MinMaxAll::max(),  // min_max
-                              1,                      // group_path_count
-                              1,                      // endpoint_path_count
-                              false,                  // unique_pins
-                              false,                  // unique_edges
-                              -sta::INF,              // slack_min
-                              sta::INF,               // slack_max
-                              true,                   // sort_by_slack
-                              group_names,            // group_names
-                              true,
-                              false,
-                              true,
-                              true,
-                              true,
-                              true);  // checks
-
-  if (path_ends.empty()) {
+  const sta::Arrival borrow = borrow_visitor.borrow();
+  if (sta::fuzzyLessEqual(borrow, 0.0f)) {
     return reported_slack;
   }
 
-  // Treat consumed latch transparency as hidden setup debt for repair_timing.
-  // Only positive borrow adds debt; flop endpoints report zero borrow.
-  const sta::Arrival borrow = path_ends[0]->borrow(search_);
-  return reported_slack - std::max<float>(borrow, 0.0f);
+  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::find(output_pins.begin(), output_pins.end(), 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::PinSet* from_pins = new sta::PinSet(network_);
+    from_pins->insert(output_pin);
+    sta::ExceptionFrom* from = sdc_->makeExceptionFrom(
+        from_pins, nullptr, nullptr, sta::RiseFallBoth::riseFall());
+
+    sta::StringSeq group_names;
+    sta::PathEndSeq path_ends = search_->findPathEnds(from,
+                                                      nullptr,
+                                                      nullptr,
+                                                      false,
+                                                      sta_->scenes(),
+                                                      sta::MinMaxAll::max(),
+                                                      1,
+                                                      1,
+                                                      false,
+                                                      false,
+                                                      -sta::INF,
+                                                      sta::INF,
+                                                      true,
+                                                      group_names,
+                                                      true,
+                                                      false,
+                                                      true,
+                                                      true,
+                                                      true,
+                                                      true);
+
+    for (sta::PathEnd* path_end : path_ends) {
+      worst_slack = std::min(worst_slack, path_end->slack(search_));
+    }
+  }
+
+  return worst_slack;
 }
 
 void RepairTargetCollector::collectViolatingStartpoints()

src/rsz/src/RepairTargetCollector.hh

@@ -170,8 +170,8 @@ class RepairTargetCollector
   // Public endpoint collection for TNS Phase
   void collectViolatingEndpoints();
   // Effective slack includes hidden setup debt from latch time borrowing.
-  // A latch endpoint with reported slack of zero but positive borrow is treated
-  // as a setup violation by subtracting the borrow from the reported slack.
+  // 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()
@@ -290,6 +290,9 @@ class RepairTargetCollector
   void sortByHeuristic(float load_delay_threshold = 0.0);
   std::map<const sta::Pin*, sta::Delay> getLocalTns() const;
   sta::Delay getLocalPinTns(const sta::Pin* pin) 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/test/BUILD

@@ -258,6 +258,7 @@ PASSFAIL_TESTS = [
     # 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",
 ]

src/rsz/test/CMakeLists.txt

@@ -240,6 +240,7 @@ or_integration_tests(
     global_sizing_presize
   PASSFAIL_TESTS
     inferred_clock_gator_time_borrow
+    inferred_clock_gator_time_borrow_covered
     repair_setup_legacy_mt
     repair_setup_mt1
     cpp_tests

src/rsz/test/inferred_clock_gator_time_borrow_covered.tcl

@@ -0,0 +1,64 @@
+source "helpers.tcl"
+
+set test_name inferred_clock_gator_time_borrow_covered
+
+source Nangate45/Nangate45.vars
+read_liberty Nangate45/Nangate45_typ.lib
+read_lef Nangate45/Nangate45.lef
+read_def inferred_clock_gator_time_borrow.def
+
+create_clock -name clk -period 1.0 clk
+create_clock -name vclk -period 1.0
+set_input_delay -clock vclk 0.90 [get_ports en_in]
+
+source Nangate45/Nangate45.rc
+source $layer_rc_file
+set_wire_rc -signal -layer $wire_rc_layer
+set_wire_rc -clock -layer $wire_rc_layer_clk
+
+clock_tree_synthesis -root_buf CLKBUF_X3 \
+  -buf_list CLKBUF_X3 \
+  -wire_unit 20 \
+  -sink_clustering_enable \
+  -distance_between_buffers 80 \
+  -num_static_layers 1 \
+  -repair_clock_nets
+
+set_propagated_clock [all_clocks]
+estimate_parasitics -placement
+
+proc extract_borrow { report_text } {
+  if { ![regexp {actual time borrow[ ]+([0-9.]+)} $report_text -> borrow] } {
+    utl::error RSZ 1009 "Missing actual time borrow in report_checks output."
+  }
+  return $borrow
+}
+
+proc borrow_report { test_name label } {
+  set report_file [make_result_file "${test_name}_${label}.rpt"]
+  report_checks -path_delay max -to enable_latch/D \
+    -group_path_count 1 -format full_clock_expanded -digits 4 > $report_file
+  set stream [open $report_file r]
+  set report_text [read $stream]
+  close $stream
+  return $report_text
+}
+
+set before_report [borrow_report $test_name "before"]
+set before_borrow [extract_borrow $before_report]
+puts [format "BEFORE_BORROW %.4f" $before_borrow]
+
+repair_timing -setup -skip_last_gasp -skip_pin_swap -skip_gate_cloning \
+  -max_passes 20
+
+set after_report [borrow_report $test_name "after"]
+set after_borrow [extract_borrow $after_report]
+puts [format "AFTER_BORROW %.4f" $after_borrow]
+
+if { abs($after_borrow - $before_borrow) > 0.001 } {
+  utl::error RSZ 1010 [format \
+    "repair_timing changed covered latch borrow: before %.4f after %.4f" \
+    $before_borrow $after_borrow]
+}
+
+puts "pass inferred_clock_gator_time_borrow_covered"