rsz: Walk chained latch fanin paths

Extend latch-through path handling from a single latch D-side segment to a chained fanin walk. This lets setup repair collect and rank drivers through cascaded transparent latches instead of stopping after the first latch data path.

Add a shared latch fanin visitor, update repair target collection and legacy setup repair to use it, and cover the behavior with a two-latch DEF plus C++ and Tcl regressions.

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

Author: jhkim-pii

src/rsz/src/OptimizerTypes.cc

@@ -3,6 +3,8 @@
 
 #include "OptimizerTypes.hh"
 
+#include <functional>
+#include <set>
 #include <string>
 
 #include "rsz/Resizer.hh"
@@ -195,8 +197,7 @@ const sta::TimingArc* findMatchingTimingArc(const sta::TimingArc* reference,
       reference, candidate, ArcMatchMode::kExact, nullptr);
 }
 
-const sta::Path* latchDataPath(const sta::PathExpanded& expanded,
-                               const sta::StaState*)
+const sta::Path* latchDataPath(const sta::PathExpanded& expanded)
 {
   const sta::Path* d_path = nullptr;
   const sta::Path* q_path = nullptr;
@@ -205,6 +206,43 @@ const sta::Path* latchDataPath(const sta::PathExpanded& expanded,
   return d_path;
 }
 
+bool visitLatchFaninSegments(
+    const sta::PathExpanded& expanded,
+    const sta::StaState* sta,
+    const std::function<bool(const sta::Path*, sta::PathExpanded&)>& visitor)
+{
+  // Guard against accidental latch loops while following D-side fanin chains.
+  std::set<const sta::Pin*> visited_latch_d;
+  const sta::Path* d_path = latchDataPath(expanded);
+  while (d_path != nullptr) {
+    const sta::Pin* d_pin = d_path->pin(sta);
+    if (visited_latch_d.contains(d_pin)) {
+      break;
+    }
+    visited_latch_d.insert(d_pin);
+
+    sta::PathExpanded d_expanded(d_path, sta);
+    if (visitor(d_path, d_expanded)) {
+      return true;
+    }
+    d_path = latchDataPath(d_expanded);
+  }
+  return false;
+}
+
+bool visitPathSegments(
+    const sta::Path* path,
+    sta::PathExpanded& expanded,
+    const sta::StaState* sta,
+    const std::function<bool(const sta::Path*, sta::PathExpanded&)>& visitor)
+{
+  if (visitor(path, expanded)) {
+    return true;
+  }
+
+  return visitLatchFaninSegments(expanded, sta, visitor);
+}
+
 bool Target::canBePathDriver() const
 {
   return (views & kPathDriverView) != 0 && driver_pin != nullptr

src/rsz/src/OptimizerTypes.hh

@@ -6,6 +6,7 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <stdexcept>
@@ -134,8 +135,23 @@ const sta::TimingArc* findMatchingTimingArc(const sta::TimingArc* reference,
                                             const sta::TimingArcSet* candidate);
 
 // Return the latch D-side path attached to an expanded latch-through path.
-const sta::Path* latchDataPath(const sta::PathExpanded& expanded,
-                               const sta::StaState* sta);
+const sta::Path* latchDataPath(const sta::PathExpanded& expanded);
+
+// Walk the chained latch D-side fanin segments of an expanded path.  Each
+// visitor PathExpanded reference is valid only during that visitor call.
+// A visitor returns true to stop walking and false to continue.
+bool visitLatchFaninSegments(
+    const sta::PathExpanded& expanded,
+    const sta::StaState* sta,
+    const std::function<bool(const sta::Path*, sta::PathExpanded&)>& visitor);
+
+// Visit the main expanded path and every chained latch D-side fanin segment.
+// A visitor returns true to stop walking and false to continue.
+bool visitPathSegments(
+    const sta::Path* path,
+    sta::PathExpanded& expanded,
+    const sta::StaState* sta,
+    const std::function<bool(const sta::Path*, sta::PathExpanded&)>& visitor);
 
 // One timing arc that can contribute to the driver's output slew merge for the
 // selected output transition.  STA merges output slew across all such arcs

src/rsz/src/RepairTargetCollector.cc

@@ -932,14 +932,17 @@ std::vector<Target> RepairTargetCollector::collectPathDriverTargets(
   targets.reserve(expanded.size());
   collectExpandedPathDriverTargets(path, expanded, path_slack, targets);
 
-  // A latch-through path starts at latch Q in OpenSTA, with the latch D path
-  // stored as side context.  Expand that D path separately so repair_timing can
-  // optimize the logic that consumed the borrowed time.
-  const sta::Path* d_path = latchDataPath(expanded, sta_);
-  if (d_path != nullptr) {
-    sta::PathExpanded d_expanded(d_path, sta_);
-    collectExpandedPathDriverTargets(d_path, d_expanded, path_slack, targets);
-  }
+  // A latch-through path starts at latch Q in OpenSTA, with each latch D path
+  // stored as side context.  Expand those D paths separately so repair_timing
+  // can optimize the logic that consumed the borrowed time.
+  visitLatchFaninSegments(
+      expanded,
+      sta_,
+      [&](const sta::Path* d_path, sta::PathExpanded& d_expanded) {
+        collectExpandedPathDriverTargets(
+            d_path, d_expanded, path_slack, targets);
+        return false;
+      });
 
   return targets;
 }
@@ -1259,11 +1262,13 @@ set<const sta::Pin*> RepairTargetCollector::collectPinsByPathEndpoint(
       }
     }
 
-    const sta::Path* d_path = latchDataPath(expanded, sta_);
-    if (d_path != nullptr) {
-      sta::PathExpanded d_expanded(d_path, sta_);
-      const size_t old_size = viol_pins.size();
-      collectExpandedPathDriverPins(d_expanded, viol_pins);
+    const size_t old_size = viol_pins.size();
+    visitLatchFaninSegments(
+        expanded, sta_, [&](const sta::Path*, sta::PathExpanded& d_expanded) {
+          collectExpandedPathDriverPins(d_expanded, viol_pins);
+          return false;
+        });
+    if (viol_pins.size() > old_size) {
       debugPrint(logger_,
                  RSZ,
                  "violator_collector",

src/rsz/src/policy/SetupLegacyBase.cc

@@ -452,32 +452,26 @@ bool SetupLegacyBase::makePinTargetOnPath(const sta::Pin* pin,
     return false;
   }
 
+  // Search the main path first, then the latch D fanin path of a
+  // latch-through path.
   sta::PathExpanded expanded(path, sta_);
-  if (makePinTargetInExpandedPath(pin, path, expanded, focus_slack, target)) {
-    return true;
-  }
-
-  const sta::Path* d_path = latchDataPath(expanded, sta_);
-  if (d_path == nullptr) {
-    return false;
-  }
-
-  sta::PathExpanded d_expanded(d_path, sta_);
-  return makePinTargetInExpandedPath(
-      pin, d_path, d_expanded, focus_slack, target);
+  return visitPathSegments(
+      path,
+      expanded,
+      sta_,
+      [&](const sta::Path* seg_path, sta::PathExpanded& seg_expanded) {
+        return makePinTargetInExpandedPath(
+            pin, vertex, seg_path, seg_expanded, focus_slack, target);
+      });
 }
 
 bool SetupLegacyBase::makePinTargetInExpandedPath(const sta::Pin* pin,
+                                                  sta::Vertex* vertex,
                                                   const sta::Path* path,
                                                   sta::PathExpanded& expanded,
                                                   const sta::Slack focus_slack,
                                                   Target& target) const
 {
-  sta::Vertex* vertex = graph_->pinDrvrVertex(pin);
-  if (vertex == nullptr) {
-    return false;
-  }
-
   const int start_index = static_cast<int>(expanded.startIndex());
   const int path_count = static_cast<int>(expanded.size());
   for (int index = start_index; index < path_count; index++) {
@@ -754,51 +748,46 @@ bool SetupLegacyBase::repairPath(sta::Path* path,
     return false;
   }
 
-  const sta::Scene* corner = path->scene(sta_);
   if (path->minMax(sta_) != resizer_.max_) {
     logger_->error(utl::RSZ,
                    kMsgRepairSetupExpectedMaxPath,
                    "repairSetup expects max delay path");
     return false;
   }
 
-  const std::vector<std::pair<int, sta::Delay>> load_delays
-      = rankPathDrivers(expanded, corner, corner->libertyIndex(resizer_.max_));
   const int repairs_per_pass = repairBudget(path_slack, force_single_repair);
 
+  // Rank drivers on the main path and, for latch-through paths, on the latch
+  // D fanin path, then merge both segments into a single ranking.
+  std::vector<std::pair<Target, sta::Delay>> ranked_targets;
+  visitPathSegments(
+      path,
+      expanded,
+      sta_,
+      [&](const sta::Path* seg_path, sta::PathExpanded& seg_expanded) {
+        const sta::Scene* seg_corner = seg_path->scene(sta_);
+        const std::vector<std::pair<int, sta::Delay>> load_delays
+            = rankPathDrivers(seg_expanded,
+                              seg_corner,
+                              seg_corner->libertyIndex(resizer_.max_));
+        ranked_targets.reserve(ranked_targets.size() + load_delays.size());
+        for (const std::pair<int, sta::Delay>& load_delay : load_delays) {
+          Target target;
+          makePathDriverTarget(
+              seg_path, seg_expanded, load_delay.first, path_slack, target);
+          ranked_targets.emplace_back(std::move(target), load_delay.second);
+        }
+        return false;
+      });
+
   debugPrint(logger_,
              RSZ,
              "repair_setup",
              3,
-             "Path slack: {}, repairs: {}, load_delays: {}",
+             "Path slack: {}, repairs: {}, ranked_targets: {}",
              delayAsString(path_slack, 3, sta_),
              repairs_per_pass,
-             load_delays.size());
-
-  // Construct target vector
-  std::vector<std::pair<Target, sta::Delay>> ranked_targets;
-  ranked_targets.reserve(load_delays.size());
-  for (const std::pair<int, sta::Delay>& load_delay : load_delays) {
-    Target target;
-    makePathDriverTarget(path, expanded, load_delay.first, path_slack, target);
-    ranked_targets.emplace_back(std::move(target), load_delay.second);
-  }
-
-  const sta::Path* d_path = latchDataPath(expanded, sta_);
-  if (d_path != nullptr) {
-    sta::PathExpanded d_expanded(d_path, sta_);
-    const sta::Scene* d_corner = d_path->scene(sta_);
-    const std::vector<std::pair<int, sta::Delay>> d_load_delays
-        = rankPathDrivers(
-            d_expanded, d_corner, d_corner->libertyIndex(resizer_.max_));
-    ranked_targets.reserve(ranked_targets.size() + d_load_delays.size());
-    for (const std::pair<int, sta::Delay>& load_delay : d_load_delays) {
-      Target target;
-      makePathDriverTarget(
-          d_path, d_expanded, load_delay.first, path_slack, target);
-      ranked_targets.emplace_back(std::move(target), load_delay.second);
-    }
-  }
+             ranked_targets.size());
 
   std::ranges::stable_sort(ranked_targets,
                            [](const std::pair<Target, sta::Delay>& lhs,

src/rsz/src/policy/SetupLegacyBase.hh

@@ -141,6 +141,7 @@ class SetupLegacyBase : public OptimizationPolicy
                            sta::Slack focus_slack,
                            Target& target) const;
   bool makePinTargetInExpandedPath(const sta::Pin* pin,
+                                   sta::Vertex* vertex,
                                    const sta::Path* path,
                                    sta::PathExpanded& expanded,
                                    sta::Slack focus_slack,

src/rsz/test/BUILD

@@ -254,6 +254,7 @@ TESTS = [
     "inferred_clock_gator_time_borrow_covered",
     "inferred_clock_gator_time_borrow_repair_pin",
     "inferred_clock_gator_time_borrow_tns",
+    "latch_borrow_chain",
 ]
 
 # From CMakeLists.txt or_integration_tests(PASSFAIL_TESTS
@@ -482,6 +483,7 @@ cc_test(
     copts = ["-Isrc/rsz/src"],
     data = glob(["cpp/TestResizer*.v"]) + [
         "inferred_clock_gator_time_borrow.def",
+        "latch_borrow_chain.def",
     ],
     features = ["-layering_check"],  # TODO: includes private headers
     deps = [

src/rsz/test/CMakeLists.txt

@@ -242,6 +242,7 @@ or_integration_tests(
     inferred_clock_gator_time_borrow_covered
     inferred_clock_gator_time_borrow_repair_pin
     inferred_clock_gator_time_borrow_tns
+    latch_borrow_chain
   PASSFAIL_TESTS
     repair_setup_legacy_mt
     repair_setup_mt1

src/rsz/test/cpp/TestResizer.cc

@@ -135,9 +135,9 @@ class TestResizer : public tst::IntegratedFixture
                         sdc);
   }
 
-  void setupTimeBorrowTiming(const float input_delay)
+  void setupTimeBorrowTiming(const char* def_file, const float input_delay)
   {
-    readDefForTiming("inferred_clock_gator_time_borrow.def");
+    readDefForTiming(def_file);
 
     sta::Pin* clk_pin = findTopPin("clk");
     ASSERT_NE(clk_pin, nullptr);
@@ -249,7 +249,7 @@ TEST_F(TestResizer, SwapPinsFeedthroughModNet)
 
 TEST_F(TestResizer, LatchThroughPathCollectsLatchDataFaninTargets)
 {
-  setupTimeBorrowTiming(0.98);
+  setupTimeBorrowTiming("inferred_clock_gator_time_borrow.def", 0.98);
 
   RepairTargetCollector collector(&resizer_);
   collector.init(0.0f);
@@ -267,4 +267,24 @@ TEST_F(TestResizer, LatchThroughPathCollectsLatchDataFaninTargets)
   EXPECT_TRUE(hasTargetPin(targets, "enable_buf1/Z"));
 }
 
+TEST_F(TestResizer, ChainedLatchFaninTargets)
+{
+  setupTimeBorrowTiming("latch_borrow_chain.def", 0.84);
+
+  RepairTargetCollector collector(&resizer_);
+  collector.init(0.0f);
+
+  sta::Vertex* endpoint = loadVertex("gated_ff0/D");
+  ASSERT_NE(endpoint, nullptr);
+
+  sta::Path* path = sta_->vertexWorstSlackPath(endpoint, sta::MinMax::max());
+  ASSERT_NE(path, nullptr);
+
+  const std::vector<Target> targets
+      = collector.collectPathDriverTargets(path, path->slack(sta_.get()));
+
+  EXPECT_TRUE(hasTargetPin(targets, "mid_buf0/Z"));
+  EXPECT_TRUE(hasTargetPin(targets, "deep_buf0/Z"));
+}
+
 }  // namespace rsz