Merge pull request #10825 from The-OpenROAD-Project-staging/secure-rsz-time-borrow-opt

rsz: Optimize latch time-borrow setup paths

Author: maliberty

src/rsz/src/OptimizerTypes.cc

@@ -3,6 +3,8 @@
 
 #include "OptimizerTypes.hh"
 
+#include <functional>
+#include <set>
 #include <string>
 
 #include "rsz/Resizer.hh"
@@ -195,6 +197,52 @@ const sta::TimingArc* findMatchingTimingArc(const sta::TimingArc* reference,
       reference, candidate, ArcMatchMode::kExact, nullptr);
 }
 
+const sta::Path* latchDataPath(const sta::PathExpanded& expanded)
+{
+  const sta::Path* d_path = nullptr;
+  const sta::Path* q_path = nullptr;
+  sta::Edge* d_q_edge = nullptr;
+  expanded.latchPaths(d_path, q_path, d_q_edge);
+  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>
@@ -27,6 +28,7 @@ class Pin;
 class Pvt;
 class RiseFall;
 class Scene;
+class StaState;
 class TimingArc;
 class TimingArcSet;
 class Vertex;
@@ -132,6 +134,25 @@ struct SelectedArc
 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);
+
+// 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
 // before the next stage consumes it.

src/rsz/src/RepairTargetCollector.cc

@@ -91,7 +91,8 @@ const char* RepairTargetCollector::getEnumString(ViolatorSortType sort_type)
 void RepairTargetCollector::printViolators(int numPrint = 0) const
 {
   if (violating_pins_.empty()) {
-    logger_->info(RSZ, 8, "No violating pins found.");
+    debugPrint(
+        logger_, RSZ, "violator_collector", 1, "No violating pins found.");
     return;
   }
 
@@ -812,9 +813,9 @@ void RepairTargetCollector::collectViolatingEndpoints()
 
   const sta::VertexSet& endpoints = sta_->endpoints();
   for (sta::Vertex* endpoint : endpoints) {
-    const sta::Slack endpoint_slack = sta_->slack(endpoint, max_);
-    if (sta::fuzzyLess(endpoint_slack, slack_margin_)) {
-      violating_endpoints_.emplace_back(endpoint->pin(), endpoint_slack);
+    const sta::Slack slack = sta_->slack(endpoint, max_);
+    if (sta::fuzzyLess(slack, slack_margin_)) {
+      violating_endpoints_.emplace_back(endpoint->pin(), slack);
     }
   }
 
@@ -877,6 +878,47 @@ sta::Path* RepairTargetCollector::findWorstSlackPath(
   return sta_->vertexWorstSlackPath(endpoint, max_);
 }
 
+void RepairTargetCollector::collectExpandedPathDriverTargets(
+    const sta::Path* endpoint_path,
+    const sta::PathExpanded& expanded,
+    const sta::Slack path_slack,
+    std::vector<Target>& targets) const
+{
+  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) {
+    const sta::Path* driver_path = expanded.path(index);
+    sta::Vertex* vertex = driver_path->vertex(sta_);
+    sta::Pin* pin = driver_path->pin(sta_);
+    if (vertex == nullptr || pin == nullptr || !vertex->isDriver(network_)
+        || network_->isTopLevelPort(pin)) {
+      continue;
+    }
+
+    targets.push_back(makePathDriverTarget(
+        endpoint_path, expanded, index, path_slack, *resizer_));
+  }
+}
+
+void RepairTargetCollector::collectExpandedPathDriverPins(
+    const sta::PathExpanded& expanded,
+    set<const sta::Pin*>& pins) const
+{
+  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) {
+    const sta::Path* driver_path = expanded.path(index);
+    sta::Vertex* vertex = driver_path->vertex(sta_);
+    const sta::Pin* pin = driver_path->pin(sta_);
+    if (vertex == nullptr || pin == nullptr || !vertex->isDriver(network_)
+        || network_->isTopLevelPort(pin)
+        || sta_->isClock(pin, sta_->cmdMode())) {
+      continue;
+    }
+    pins.insert(pin);
+  }
+}
+
 std::vector<Target> RepairTargetCollector::collectPathDriverTargets(
     sta::Path* path,
     const sta::Slack path_slack) const
@@ -888,18 +930,19 @@ std::vector<Target> RepairTargetCollector::collectPathDriverTargets(
 
   sta::PathExpanded expanded(path, sta_);
   targets.reserve(expanded.size());
-  for (int index = expanded.startIndex(); index < expanded.size(); ++index) {
-    const sta::Path* driver_path = expanded.path(index);
-    sta::Vertex* vertex = driver_path->vertex(sta_);
-    sta::Pin* pin = driver_path->pin(sta_);
-    if (vertex == nullptr || pin == nullptr || !vertex->isDriver(network_)
-        || network_->isTopLevelPort(pin)) {
-      continue;
-    }
-
-    targets.push_back(
-        makePathDriverTarget(path, expanded, index, path_slack, *resizer_));
-  }
+  collectExpandedPathDriverTargets(path, 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;
 }
@@ -1218,6 +1261,21 @@ set<const sta::Pin*> RepairTargetCollector::collectPinsByPathEndpoint(
         }
       }
     }
+
+    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",
+                 4,
+                 "Added {} latch D fanin pins from latch-through path",
+                 viol_pins.size() - old_size);
+    }
     debugPrint(logger_, RSZ, "violator_collector", 5, "\n");
   }
 
@@ -2206,7 +2264,6 @@ void RepairTargetCollector::setToEndpoint(int index)
   current_endpoint_index_ = index;
   const auto& end_slack_pair = violating_endpoints_[current_endpoint_index_];
   current_endpoint_ = graph_->pinLoadVertex(end_slack_pair.first);
-  current_end_original_slack_ = end_slack_pair.second;
 }
 
 void RepairTargetCollector::setToStartpoint(int index)
@@ -2215,7 +2272,6 @@ void RepairTargetCollector::setToStartpoint(int index)
   const auto& start_slack_pair
       = violating_startpoints_[current_startpoint_index_];
   current_startpoint_ = graph_->pinLoadVertex(start_slack_pair.first);
-  // Note: For startpoints, we don't use current_end_original_slack_
 }
 
 void RepairTargetCollector::advanceToNextEndpoint()

src/rsz/src/RepairTargetCollector.hh

@@ -23,6 +23,10 @@
 #include "sta/Sta.hh"
 #include "utl/Logger.h"
 
+namespace sta {
+class PathExpanded;
+}
+
 namespace rsz {
 
 using std::pair;
@@ -94,10 +98,6 @@ class RepairTargetCollector
   void setToEndpoint(int index);
   sta::Vertex* getCurrentEndpoint() const { return current_endpoint_; }
   sta::Slack getCurrentEndpointSlack() const;
-  sta::Slack getCurrentEndpointOriginalSlack() const
-  {
-    return current_end_original_slack_;
-  }
   int getCurrentEndpointIndex() const { return current_endpoint_index_; }
   int getMaxEndpointCount() const { return violating_endpoints_.size(); }
   int getCurrentPass() const;
@@ -286,6 +286,12 @@ 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;
+  void collectExpandedPathDriverTargets(const sta::Path* endpoint_path,
+                                        const sta::PathExpanded& expanded,
+                                        sta::Slack path_slack,
+                                        std::vector<Target>& targets) const;
+  void collectExpandedPathDriverPins(const sta::PathExpanded& expanded,
+                                     set<const sta::Pin*>& pins) const;
 
   // === Cone traversal helpers ==============================================
   // Helper functions for cone-based collection
@@ -333,7 +339,6 @@ class RepairTargetCollector
   // Current endpoint iteration state
   bool iteration_began_;
   sta::Vertex* current_endpoint_;
-  sta::Slack current_end_original_slack_;
   int current_endpoint_index_;
 
   // === Startpoint iteration state ==========================================

src/rsz/src/policy/SetupLegacyBase.cc

@@ -88,6 +88,7 @@ bool SetupLegacyBase::repairSetupPin(const sta::Pin* end_pin)
   }
 
   initializeSetupServices();
+  target_collector_->init(config_.setup_slack_margin);
   setup_context_.max_repairs_per_pass = 1;
 
   sta::Vertex* end_vertex = graph_->pinLoadVertex(end_pin);
@@ -451,8 +452,29 @@ 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_);
-  for (int index = expanded.startIndex(); index < expanded.size(); index++) {
+  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
+{
+  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++) {
     const sta::Path* driver_path = expanded.path(index);
     sta::Vertex* path_vertex = driver_path->vertex(sta_);
     const sta::Pin* path_pin = driver_path->pin(sta_);
@@ -726,35 +748,57 @@ 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 auto 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());
+             ranked_targets.size());
+
+  std::ranges::stable_sort(ranked_targets,
+                           [](const std::pair<Target, sta::Delay>& lhs,
+                              const std::pair<Target, sta::Delay>& rhs) {
+                             return lhs.second > rhs.second;
+                           });
 
-  // Construct target vector
   std::vector<Target> targets;
-  targets.reserve(load_delays.size());
-  for (const auto& [drvr_index, ignored] : load_delays) {
-    static_cast<void>(ignored);
-    Target target;
-    makePathDriverTarget(path, expanded, drvr_index, path_slack, target);
-    targets.push_back(std::move(target));
+  targets.reserve(ranked_targets.size());
+  for (std::pair<Target, sta::Delay>& ranked_target : ranked_targets) {
+    targets.push_back(std::move(ranked_target.first));
   }
 
   // Prewarm for legacy MT policy