rsz: switch WNS-stagnation gate to initial-baseline comparison

The sliding-window check (window_best - window_oldest over 200 passes)
mis-classified plateaus as futility: any real design whose WNS drops
dramatically early then flat-lines at a topology-bound floor while TNS
keeps improving (aes, clone_flat, repair_fanout*) tripped the gate and
aborted repair_timing too early, leaving worse max_cap/max_slew slack
and different .ok-file output.

Replace with best_wns_ever vs initial_wns_: only fire when WNS has
effectively never moved from its starting value, which is the real
signature of an obviously-futile run.

Also bump rel_tol 0.5% -> 5%. Empirically aes improves WNS by ~50% of
initial, clone_flat by ~95%, repair_fanout by ~90%; the hopeless.v
synthetic only moves WNS by ~2% because buffer insertion chips
something off even a grossly-over-clocked design. 5% sits in the gap.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: Øyvind Harboe <oyvind.harboe@zylin.com>

Author: oharboe

src/rsz/src/RepairSetup.cc

@@ -988,12 +988,11 @@ void RepairSetup::printProgressFooter() const
 
 void RepairSetup::resetStagnationTracking()
 {
-  wns_history_.assign(wns_stagnation_window_passes_, 0.0f);
-  wns_history_head_ = 0;
-  wns_history_count_ = 0;
+  // Initialize best_wns_ to the most-negative finite float so the very first
+  // worstSlack() sample always wins the max().
+  best_wns_ = std::numeric_limits<float>::lowest();
   wns_stagnation_tripped_ = false;
   wns_stagnation_iteration_ = 0;
-  wns_stagnation_last_wns_ = 0;
 }
 
 std::string RepairSetup::wnsStagnationReport(const int iteration) const
@@ -1003,21 +1002,26 @@ std::string RepairSetup::wnsStagnationReport(const int iteration) const
   }
   const int digits = 3;
   return fmt::format(
-      "repair_timing: obviously futile - WNS stuck at {} after {} passes "
-      "(initial {}). This is probably an exploration run, not a timing "
-      "closure run. Aborting with best-effort result.",
-      delayAsString(wns_stagnation_last_wns_, digits, sta_),
+      "repair_timing: obviously futile - WNS only reached {} after {} passes "
+      "(initial {}, improvement {}). This is probably an exploration run, "
+      "not a timing closure run. Aborting with best-effort result.",
+      delayAsString(best_wns_, digits, sta_),
       wns_stagnation_iteration_,
-      delayAsString(initial_wns_, digits, sta_));
+      delayAsString(initial_wns_, digits, sta_),
+      delayAsString(best_wns_ - initial_wns_, digits, sta_));
 }
 
 // Terminate progress if incremental fix rate within an opto interval falls
 // below the threshold.   Bump up the threshold after each large opto
 // interval.
-// A second, independent "WNS-stagnation" gate also returns true when the
-// best-so-far WNS has failed to improve by a deterministic threshold over
-// the last wns_stagnation_window_passes_ passes. This catches
-// "obviously futile" designs where TNS keeps twitching but WNS is pinned.
+// A second, independent "WNS-stagnation" gate also returns true when, after
+// the warmup, the best-so-far WNS has failed to improve by a deterministic
+// threshold relative to the initial WNS. That detects designs where WNS
+// essentially never moves from its starting value — the real signature of
+// an "obviously futile" run. Plateaus on legitimate designs (WNS drops by
+// orders of magnitude early, then flat-lines while TNS keeps improving) do
+// not trip this gate, because best_wns_ has already moved far from
+// initial_wns_ by the time the plateau starts.
 bool RepairSetup::terminateProgress(const int iteration,
                                     const float initial_tns,
                                     float& prev_tns,
@@ -1028,48 +1032,33 @@ bool RepairSetup::terminateProgress(const int iteration,
                                     const char* phase_name,
                                     const char phase_marker)
 {
-  // WNS-stagnation gate. Sampled every call so the ring buffer advances at
-  // the same rate as the caller's inner loop (deterministic).
-  const sta::Slack wns_now = sta_->worstSlack(max_);
-  if (!wns_history_.empty()) {
-    const size_t window = wns_history_.size();
-    wns_history_[wns_history_head_] = wns_now;
-    wns_history_head_ = (wns_history_head_ + 1) % window;
-    if (wns_history_count_ < window) {
-      wns_history_count_++;
-    } else if (iteration > wns_stagnation_warmup_iterations_) {
-      // Window is full; compare oldest sample (the one we are about to
-      // overwrite on the next call) to the best (largest, i.e. least
-      // negative) slack observed in the window.
-      sta::Slack window_best
-          = *std::max_element(wns_history_.begin(), wns_history_.end());
-      const sta::Slack window_oldest = wns_history_[wns_history_head_];
-      const float threshold
-          = std::max(wns_stagnation_abs_tol_,
-                     wns_stagnation_rel_tol_ * std::fabs(initial_wns_));
-      if (window_best - window_oldest < threshold) {
-        debugPrint(
-            logger_,
-            RSZ,
-            "repair_setup",
-            1,
-            "{}{} Phase: Exiting at iteration {} because WNS best-in-window "
-            "{} only improved {} over last {} passes (threshold {}) "
-            "[endpoint {}/{}]",
-            phase_name,
-            phase_marker,
-            iteration,
-            delayAsString(window_best, 3, sta_),
-            delayAsString(window_best - window_oldest, 3, sta_),
-            window,
-            delayAsString(threshold, 3, sta_),
-            endpt_index,
-            num_endpts);
-        wns_stagnation_tripped_ = true;
-        wns_stagnation_iteration_ = iteration;
-        wns_stagnation_last_wns_ = wns_now;
-        return true;
-      }
+  // WNS-stagnation gate. Sampled every call so the "best so far" tracker
+  // advances at the same rate as the caller's inner loop (deterministic).
+  best_wns_ = std::max(best_wns_, sta_->worstSlack(max_));
+  if (iteration > wns_stagnation_warmup_iterations_) {
+    const float threshold
+        = std::max(wns_stagnation_abs_tol_,
+                   wns_stagnation_rel_tol_ * std::fabs(initial_wns_));
+    if (best_wns_ - initial_wns_ < threshold) {
+      debugPrint(logger_,
+                 RSZ,
+                 "repair_setup",
+                 1,
+                 "{}{} Phase: Exiting at iteration {} because WNS best-so-far "
+                 "{} only improved {} from initial {} (threshold {}) "
+                 "[endpoint {}/{}]",
+                 phase_name,
+                 phase_marker,
+                 iteration,
+                 delayAsString(best_wns_, 3, sta_),
+                 delayAsString(best_wns_ - initial_wns_, 3, sta_),
+                 delayAsString(initial_wns_, 3, sta_),
+                 delayAsString(threshold, 3, sta_),
+                 endpt_index,
+                 num_endpts);
+      wns_stagnation_tripped_ = true;
+      wns_stagnation_iteration_ = iteration;
+      return true;
     }
   }
 

src/rsz/src/RepairSetup.hh

@@ -2,7 +2,6 @@
 // Copyright (c) 2022-2025, The OpenROAD Authors
 
 #pragma once
-#include <cstddef>
 #include <map>
 #include <memory>
 #include <set>
@@ -253,32 +252,34 @@ class RepairSetup : public sta::dbStaState
       = 0.0001;  // default fix rate threshold = 0.01%
   static constexpr int max_last_gasp_passes_ = 10;
 
-  // WNS-stagnation gate. If best-so-far WNS has not improved by at least
-  // max(wns_stagnation_abs_tol_, wns_stagnation_rel_tol_ * |initial_wns|)
-  // over the last wns_stagnation_window_passes_ passes, terminateProgress()
-  // returns true. Combined with the existing two-consecutive-termination rule
-  // this aborts the phase after 2*window passes of no WNS movement.
-  // Deterministic (iteration-count based, no wallclock). Conservative enough
-  // that tape-out flows near closure are dominated by the TNS fix-rate gate
-  // instead.
-  static constexpr int wns_stagnation_window_passes_ = 200;
+  // WNS-stagnation gate. Compares the best-so-far WNS against the WNS
+  // captured at the start of repair_timing (initial_wns_). If after the
+  // warmup the best WNS has improved by less than
+  // max(wns_stagnation_abs_tol_, wns_stagnation_rel_tol_ * |initial_wns_|),
+  // terminateProgress() returns true. "No improvement from initial" is the
+  // real signature of an obviously-futile design; plateaus on legitimate
+  // designs (WNS bottoms out at a topology limit while TNS keeps
+  // improving) are *not* caught, because best_wns_ has already moved far
+  // from initial_wns_. Deterministic (iteration-count based, no wallclock).
   static constexpr float wns_stagnation_abs_tol_ = 1.0e-12f;  // 1 ps
-  static constexpr float wns_stagnation_rel_tol_ = 0.005f;    // 0.5% of |init|
+  // 5% of |initial_wns|. Empirically: aes improves WNS by ~50%, clone_flat
+  // by ~95%, repair_fanout by ~90% of initial; the hopeless.v synthetic only
+  // moves WNS by ~2% because buffer insertion on a grossly-over-clocked
+  // design still chips off a little. 5% sits safely in that gap.
+  static constexpr float wns_stagnation_rel_tol_ = 0.05f;
   // Warmup: skip the gate until this many passes have elapsed, so normal
   // repair progress on ordinary designs is not short-circuited.
   static constexpr int wns_stagnation_warmup_iterations_ = 1000;
 
-  // Per-phase WNS history (ring buffer).
-  std::vector<sta::Slack> wns_history_;
-  size_t wns_history_head_ = 0;
-  size_t wns_history_count_ = 0;
   sta::Slack initial_wns_ = 0;
+  // Best (largest / least-negative) WNS observed since the most recent
+  // resetStagnationTracking(). Reset at the start of each repair phase.
+  sta::Slack best_wns_ = 0;
   // Set by terminateProgress() when the WNS-stagnation gate fires. Consumed
   // by the phase-level abort sites to emit a loud info log. Reset by
   // resetStagnationTracking().
   bool wns_stagnation_tripped_ = false;
   int wns_stagnation_iteration_ = 0;
-  sta::Slack wns_stagnation_last_wns_ = 0;
 };
 
 }  // namespace rsz