Delay compare ops round2

dcalc/GraphDelayCalc1.cc

@@ -1246,7 +1246,7 @@ GraphDelayCalc1::findArcDelay(LibertyCell *drvr_cell,
     // Merge slews.
     const Slew &drvr_slew = graph_->slew(drvr_vertex, drvr_rf, ap_index);
     const MinMax *slew_min_max = dcalc_ap->slewMinMax();
-    if (delayGreater(gate_slew, drvr_slew, dcalc_ap->slewMinMax())
+    if (delayGreater(gate_slew, drvr_slew, dcalc_ap->slewMinMax(), this)
 	&& !drvr_vertex->slewAnnotated(drvr_rf, slew_min_max))
       graph_->setSlew(drvr_vertex, drvr_rf, ap_index, gate_slew);
     if (!graph_->arcDelayAnnotated(edge, arc, ap_index)) {
@@ -1446,7 +1446,7 @@ GraphDelayCalc1::annotateLoadDelays(Vertex *drvr_vertex,
 	else {
 	  const Slew &slew = graph_->slew(load_vertex, drvr_rf, ap_index);
 	  if (!merge
-	      || delayGreater(load_slew, slew, slew_min_max))
+	      || delayGreater(load_slew, slew, slew_min_max, this))
 	    graph_->setSlew(load_vertex, drvr_rf, ap_index, load_slew);
 	}
       }
@@ -1459,7 +1459,7 @@ GraphDelayCalc1::annotateLoadDelays(Vertex *drvr_vertex,
 	Delay wire_delay_extra = extra_delay + wire_delay;
 	const MinMax *delay_min_max = dcalc_ap->delayMinMax();
 	if (!merge
-	    || delayGreater(wire_delay_extra, delay, delay_min_max)) {
+	    || delayGreater(wire_delay_extra, delay, delay_min_max, this)) {
 	  graph_->setWireArcDelay(wire_edge, drvr_rf, ap_index,
 				  wire_delay_extra);
 	  if (observer_)

graph/DelayFloat.cc

@@ -94,7 +94,8 @@ delayEqual(const Delay &delay1,
 
 bool
 delayLess(const Delay &delay1,
-	  const Delay &delay2)
+	  const Delay &delay2,
+	  const StaState *)
 {
   return fuzzyLess(delay1, delay2);
 }
@@ -102,7 +103,8 @@ delayLess(const Delay &delay1,
 bool
 delayLess(const Delay &delay1,
 	  const Delay &delay2,
-	  const MinMax *min_max)
+	  const MinMax *min_max,
+	  const StaState *)
 {
   if (min_max == MinMax::max())
     return fuzzyLess(delay1, delay2);
@@ -112,7 +114,8 @@ delayLess(const Delay &delay1,
 
 bool
 delayLessEqual(const Delay &delay1,
-	       const Delay &delay2)
+	       const Delay &delay2,
+	       const StaState *)
 {
   return fuzzyLessEqual(delay1, delay2);
 }
@@ -120,7 +123,8 @@ delayLessEqual(const Delay &delay1,
 bool
 delayLessEqual(const Delay &delay1,
 	       const Delay &delay2,
-	       const MinMax *min_max)
+	       const MinMax *min_max,
+	       const StaState *)
 {
   if (min_max == MinMax::max())
     return fuzzyLessEqual(delay1, delay2);
@@ -130,7 +134,8 @@ delayLessEqual(const Delay &delay1,
 
 bool
 delayGreater(const Delay &delay1,
-	     const Delay &delay2)
+	     const Delay &delay2,
+	     const StaState *)
 {
   return fuzzyGreater(delay1, delay2);
 }
@@ -138,7 +143,8 @@ delayGreater(const Delay &delay1,
 bool
 delayGreater(const Delay &delay1,
 	     const Delay &delay2,
-	     const MinMax *min_max)
+	     const MinMax *min_max,
+	     const StaState *)
 {
   if (min_max == MinMax::max())
     return fuzzyGreater(delay1, delay2);
@@ -148,7 +154,8 @@ delayGreater(const Delay &delay1,
 
 bool
 delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2)
+		  const Delay &delay2,
+		  const StaState *)
 {
   return fuzzyGreaterEqual(delay1, delay2);
 }
@@ -156,7 +163,8 @@ delayGreaterEqual(const Delay &delay1,
 bool
 delayGreaterEqual(const Delay &delay1,
 		  const Delay &delay2,
-		  const MinMax *min_max)
+		  const MinMax *min_max,
+		  const StaState *)
 {
   if (min_max == MinMax::max())
     return fuzzyGreaterEqual(delay1, delay2);

graph/DelayNormal1.cc

@@ -24,8 +24,6 @@
 #include "Fuzzy.hh"
 #include "Units.hh"
 #include "StaState.hh"
-// temporary hack
-#include "Sta.hh"
 
 // SSTA compilation.
 #if (SSTA == 1)
@@ -185,151 +183,6 @@ makeDelay2(float delay,
   return Delay(delay, sigma2);
 }
 
-bool
-delayIsInitValue(const Delay &delay,
-		 const MinMax *min_max)
-{
-  return fuzzyEqual(delay.mean(), min_max->initValue())
-    && delay.sigma2() == 0.0;
-}
-
-bool
-delayZero(const Delay &delay)
-{
-  return fuzzyZero(delay.mean())
-    && fuzzyZero(delay.sigma2());
-}
-
-bool
-delayInf(const Delay &delay)
-{
-  return fuzzyInf(delay.mean());
-}
-
-bool
-delayEqual(const Delay &delay1,
-	   const Delay &delay2)
-{
-  return fuzzyEqual(delay1.mean(), delay2.mean())
-    && fuzzyEqual(delay1.sigma2(), delay2.sigma2());
-}
-
-bool
-delayLess(const Delay &delay1,
-	  const Delay &delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
-		   delayAsFloat(delay2, EarlyLate::early(), sta));
-}
-
-bool
-delayLess(const Delay &delay1,
-	  float delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
-		   delay2);
-}
-
-bool
-delayLess(const Delay &delay1,
-	  const Delay &delay2,
-	  const MinMax *min_max)
-{
-  if (min_max == MinMax::max())
-    return delayLess(delay1, delay2);
-  else
-    return delayGreater(delay1, delay2);
-}
-
-bool
-delayLessEqual(const Delay &delay1,
-	       const Delay &delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
-			delayAsFloat(delay2, EarlyLate::early(), sta));
-}
-
-bool
-delayLessEqual(const Delay &delay1,
-	       float delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
-			delay2);
-}
-
-bool
-delayLessEqual(const Delay &delay1,
-	       const Delay &delay2,
-	       const MinMax *min_max)
-{
-  if (min_max == MinMax::max())
-    return delayLessEqual(delay1, delay2);
-  else
-    return delayGreaterEqual(delay1, delay2);
-}
-
-bool
-delayGreater(const Delay &delay1,
-	     const Delay &delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
-		      delayAsFloat(delay2, EarlyLate::late(), sta));
-}
-
-bool
-delayGreater(const Delay &delay1,
-	     float delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
-		      delay2);
-}
-
-bool
-delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
-			   delayAsFloat(delay2, EarlyLate::late(), sta));
-}
-
-bool
-delayGreaterEqual(const Delay &delay1,
-		  float delay2)
-{
-  Sta *sta = Sta::sta();
-  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
-			   delay2);
-}
-
-bool
-delayGreater(const Delay &delay1,
-	     const Delay &delay2,
-	     const MinMax *min_max)
-{
-  if (min_max == MinMax::max())
-    return delayGreater(delay1, delay2);
-  else
-    return delayLess(delay1, delay2);
-}
-
-bool
-delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2,
-		  const MinMax *min_max)
-{
-  if (min_max == MinMax::max())
-    return delayGreaterEqual(delay1, delay2);
-  else
-    return delayLessEqual(delay1, delay2);
-}
-
 float
 delayAsFloat(const Delay &delay,
 	     const EarlyLate *early_late,
@@ -387,6 +240,156 @@ delayAsString(const Delay &delay,
   return sta->units()->timeUnit()->asString(mean_sigma, digits);
 }
 
+bool
+delayIsInitValue(const Delay &delay,
+		 const MinMax *min_max)
+{
+  return fuzzyEqual(delay.mean(), min_max->initValue())
+    && delay.sigma2() == 0.0;
+}
+
+bool
+delayZero(const Delay &delay)
+{
+  return fuzzyZero(delay.mean())
+    && fuzzyZero(delay.sigma2());
+}
+
+bool
+delayInf(const Delay &delay)
+{
+  return fuzzyInf(delay.mean());
+}
+
+bool
+delayEqual(const Delay &delay1,
+	   const Delay &delay2)
+{
+  return fuzzyEqual(delay1.mean(), delay2.mean())
+    && fuzzyEqual(delay1.sigma2(), delay2.sigma2());
+}
+
+bool
+delayLess(const Delay &delay1,
+	  const Delay &delay2,
+	  const StaState *sta)
+{
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delayAsFloat(delay2, EarlyLate::early(), sta));
+}
+
+bool
+delayLess(const Delay &delay1,
+	  float delay2,
+	  const StaState *sta)
+{
+  return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
+		   delay2);
+}
+
+bool
+delayLess(const Delay &delay1,
+	  const Delay &delay2,
+	  const MinMax *min_max,
+	  const StaState *sta)
+{
+  if (min_max == MinMax::max())
+    return delayLess(delay1, delay2, sta);
+  else
+    return delayGreater(delay1, delay2, sta);
+}
+
+bool
+delayLessEqual(const Delay &delay1,
+	       const Delay &delay2,
+	       const StaState *sta)
+{
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delayAsFloat(delay2, EarlyLate::early(), sta));
+}
+
+bool
+delayLessEqual(const Delay &delay1,
+	       float delay2,
+	       const StaState *sta)
+{
+  return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
+			delay2);
+}
+
+bool
+delayLessEqual(const Delay &delay1,
+	       const Delay &delay2,
+	       const MinMax *min_max,
+	       const StaState *sta)
+{
+  if (min_max == MinMax::max())
+    return delayLessEqual(delay1, delay2, sta);
+  else
+    return delayGreaterEqual(delay1, delay2, sta);
+}
+
+bool
+delayGreater(const Delay &delay1,
+	     const Delay &delay2,
+	     const StaState *sta)
+
+{
+  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
+		      delayAsFloat(delay2, EarlyLate::late(), sta));
+}
+
+bool
+delayGreater(const Delay &delay1,
+	     float delay2,
+	     const StaState *sta)
+{
+  return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
+		      delay2);
+}
+
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const StaState *sta)
+{
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delayAsFloat(delay2, EarlyLate::late(), sta));
+}
+
+bool
+delayGreaterEqual(const Delay &delay1,
+		  float delay2,
+		  const StaState *sta)
+{
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
+			   delay2);
+}
+
+bool
+delayGreater(const Delay &delay1,
+	     const Delay &delay2,
+	     const MinMax *min_max,
+	     const StaState *sta)
+{
+  if (min_max == MinMax::max())
+    return delayGreater(delay1, delay2, sta);
+  else
+    return delayLess(delay1, delay2, sta);
+}
+
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const MinMax *min_max,
+		  const StaState *sta)
+{
+  if (min_max == MinMax::max())
+    return delayGreaterEqual(delay1, delay2, sta);
+  else
+    return delayLessEqual(delay1, delay2, sta);
+}
+
 Delay
 delayRemove(const Delay &delay1,
 	    const Delay &delay2)

graph/DelayNormal2.cc

@@ -24,8 +24,6 @@
 #include "Fuzzy.hh"
 #include "Units.hh"
 #include "StaState.hh"
-// temporary hack
-#include "Sta.hh"
 
 // SSTA compilation.
 #if (SSTA == 2)
@@ -241,18 +239,18 @@ delayEqual(const Delay &delay1,
 
 bool
 delayLess(const Delay &delay1,
-	  const Delay &delay2)
+	  const Delay &delay2,
+	  const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
 		   delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 delayLess(const Delay &delay1,
-	  float delay2)
+	  float delay2,
+	  const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
 		   delay2);
 }
@@ -260,28 +258,29 @@ delayLess(const Delay &delay1,
 bool
 delayLess(const Delay &delay1,
 	  const Delay &delay2,
-	  const MinMax *min_max)
+	  const MinMax *min_max,
+	  const StaState *sta)
 {
   if (min_max == MinMax::max())
-    return delayLess(delay1, delay2);
+    return delayLess(delay1, delay2, sta);
   else
-    return delayGreater(delay1, delay2);
+    return delayGreater(delay1, delay2, sta);
 }
 
 bool
 delayLessEqual(const Delay &delay1,
-	       const Delay &delay2)
+	       const Delay &delay2,
+	       const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
 			delayAsFloat(delay2, EarlyLate::early(), sta));
 }
 
 bool
 delayLessEqual(const Delay &delay1,
-	       float delay2)
+	       float delay2,
+	       const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
 			delay2);
 }
@@ -289,70 +288,73 @@ delayLessEqual(const Delay &delay1,
 bool
 delayLessEqual(const Delay &delay1,
 	       const Delay &delay2,
-	       const MinMax *min_max)
+	       const MinMax *min_max,
+	       const StaState *sta)
 {
   if (min_max == MinMax::max())
-    return delayLessEqual(delay1, delay2);
+    return delayLessEqual(delay1, delay2, sta);
   else
-    return delayGreaterEqual(delay1, delay2);
+    return delayGreaterEqual(delay1, delay2, sta);
 }
 
 bool
 delayGreater(const Delay &delay1,
-	     const Delay &delay2)
+	     const Delay &delay2,
+	     const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
 		      delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 delayGreater(const Delay &delay1,
-	     float delay2)
+	     float delay2,
+	     const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
 			   delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2)
+		  const Delay &delay2,
+		  const StaState *sta)
 {
-  Sta *sta = Sta::sta();
   return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
 			   delayAsFloat(delay2, EarlyLate::late(), sta));
 }
 
 bool
 delayGreaterEqual(const Delay &delay1,
-		  float delay2)
+		  float delay2,
+		  const StaState *sta)
 {
-  Sta *sta = Sta::sta();
+  return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
-  return delayGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
 			   delay2);
 }
 
 bool
 delayGreater(const Delay &delay1,
 	     const Delay &delay2,
-	     const MinMax *min_max)
+	     const MinMax *min_max,
+	     const StaState *sta)
 {
   if (min_max == MinMax::max())
-    return delayGreater(delay1, delay2);
+    return delayGreater(delay1, delay2, sta);
   else
-    return delayLess(delay1, delay2);
+    return delayLess(delay1, delay2, sta);
 }
 
 bool
 delayGreaterEqual(const Delay &delay1,
 		  const Delay &delay2,
-		  const MinMax *min_max)
+		  const MinMax *min_max,
+		  const StaState *sta)
 {
   if (min_max == MinMax::max())
-    return delayGreaterEqual(delay1, delay2);
+    return delayGreaterEqual(delay1, delay2, sta);
   else
-    return delayLessEqual(delay1, delay2);
+    return delayLessEqual(delay1, delay2, sta);
 }
 
 float

include/sta/DelayFloat.hh

@@ -96,33 +96,42 @@ delayEqual(const Delay &delay1,
 	   const Delay &delay2);
 bool
 delayLess(const Delay &delay1,
-	  const Delay &delay2);
+	  const Delay &delay2,
+	  const StaState *sta);
 bool
 delayLess(const Delay &delay1,
 	  const Delay &delay2,
-	  const MinMax *min_max);
+	  const MinMax *min_max,
-bool
+	  const StaState *sta);
-delayLessEqual(const Delay &delay1,
-	       const Delay &delay2);
 bool
 delayLessEqual(const Delay &delay1,
 	       const Delay &delay2,
-	       const MinMax *min_max);
+	       const StaState *sta);
 bool
-delayGreater(const Delay &delay1,
+delayLessEqual(const Delay &delay1,
-	     const Delay &delay2);
+	       const Delay &delay2,
+	       const MinMax *min_max,
+	       const StaState *sta);
 bool
 delayGreater(const Delay &delay1,
 	     const Delay &delay2,
-	     const MinMax *min_max);
+	     const StaState *sta);
-bool
-delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2);
 bool
 delayGreaterEqual(const Delay &delay1,
 		  const Delay &delay2,
-		  const MinMax *min_max);
+		  const StaState *sta);
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const MinMax *min_max,
+		  const StaState *sta);
+bool
+delayGreater(const Delay &delay1,
+	     const Delay &delay2,
+	     const MinMax *min_max,
+	     const StaState *sta);
 
+// delay1-delay2 subtracting sigma instead of addiing.
 Delay
 delayRemove(const Delay &delay1,
 	    const Delay &delay2);

include/sta/DelayNormal1.hh

@@ -111,32 +111,41 @@ delayEqual(const Delay &delay1,
 	   const Delay &delay2);
 bool
 delayLess(const Delay &delay1,
-	  const Delay &delay2);
+	  const Delay &delay2,
+	  const StaState *sta);
 bool
 delayLess(const Delay &delay1,
 	  const Delay &delay2,
-	  const MinMax *min_max);
+	  const MinMax *min_max,
-bool
+	  const StaState *sta);
-delayLessEqual(const Delay &delay1,
-	       const Delay &delay2);
 bool
 delayLessEqual(const Delay &delay1,
 	       const Delay &delay2,
-	       const MinMax *min_max);
+	       const StaState *sta);
 bool
-delayGreater(const Delay &delay1,
+delayLessEqual(const Delay &delay1,
-	     const Delay &delay2);
+	       const Delay &delay2,
-bool
+	       const MinMax *min_max,
-delayGreaterEqual(const Delay &delay1,
+	       const StaState *sta);
-		  const Delay &delay2);
-bool
-delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2,
-		  const MinMax *min_max);
 bool
 delayGreater(const Delay &delay1,
 	     const Delay &delay2,
-	     const MinMax *min_max);
+	     const StaState *sta);
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const StaState *sta);
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const MinMax *min_max,
+		  const StaState *sta);
+bool
+delayGreater(const Delay &delay1,
+	     const Delay &delay2,
+	     const MinMax *min_max,
+	     const StaState *sta);
+
 // delay1-delay2 subtracting sigma instead of addiing.
 Delay delayRemove(const Delay &delay1,
 		  const Delay &delay2);

include/sta/DelayNormal2.hh

@@ -66,28 +66,6 @@ const Delay delay_zero(0.0);
 void
 initDelayConstants();
 
-Delay
-makeDelay(float delay,
-	  float sigma_early,
-	  float sigma_late);
-
-Delay
-makeDelay2(float delay,
-	   // sigma^2
-	   float sigma_early,
-	   float sigma_late);
-
-inline float
-delayAsFloat(const Delay &delay) { return delay.mean(); }
-
-// mean late+/early- sigma
-float
-delayAsFloat(const Delay &delay,
-	     const EarlyLate *early_late,
-	     const StaState *sta);
-float
-delaySigma2(const Delay &delay,
-	    const EarlyLate *early_late);
 const char *
 delayAsString(const Delay &delay,
 	      const StaState *sta);
@@ -100,6 +78,32 @@ delayAsString(const Delay &delay,
 	      const EarlyLate *early_late,
 	      const StaState *sta,
 	      int digits);
+
+Delay
+makeDelay(float delay,
+	  float sigma_early,
+	  float sigma_late);
+
+Delay
+makeDelay2(float delay,
+	   // sigma^2
+	   float sigma_early,
+	   float sigma_late);
+
+inline float
+delayAsFloat(const Delay &delay)
+{
+  return delay.mean();
+}
+
+// mean late+/early- sigma
+float
+delayAsFloat(const Delay &delay,
+	     const EarlyLate *early_late,
+	     const StaState *sta);
+float
+delaySigma2(const Delay &delay,
+	    const EarlyLate *early_late);
 const Delay &
 delayInitValue(const MinMax *min_max);
 bool
@@ -114,32 +118,41 @@ delayEqual(const Delay &delay1,
 	   const Delay &delay2);
 bool
 delayLess(const Delay &delay1,
-	  const Delay &delay2);
+	  const Delay &delay2,
+	  const StaState *sta);
 bool
 delayLess(const Delay &delay1,
 	  const Delay &delay2,
-	  const MinMax *min_max);
+	  const MinMax *min_max,
-bool
+	  const StaState *sta);
-delayLessEqual(const Delay &delay1,
-	       const Delay &delay2);
 bool
 delayLessEqual(const Delay &delay1,
 	       const Delay &delay2,
-	       const MinMax *min_max);
+	       const StaState *sta);
 bool
-delayGreater(const Delay &delay1,
+delayLessEqual(const Delay &delay1,
-	     const Delay &delay2);
+	       const Delay &delay2,
-bool
+	       const MinMax *min_max,
-delayGreaterEqual(const Delay &delay1,
+	       const StaState *sta);
-		  const Delay &delay2);
-bool
-delayGreaterEqual(const Delay &delay1,
-		  const Delay &delay2,
-		  const MinMax *min_max);
 bool
 delayGreater(const Delay &delay1,
 	     const Delay &delay2,
-	     const MinMax *min_max);
+	     const StaState *sta);
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const StaState *sta);
+bool
+delayGreaterEqual(const Delay &delay1,
+		  const Delay &delay2,
+		  const MinMax *min_max,
+		  const StaState *sta);
+bool
+delayGreater(const Delay &delay1,
+	     const Delay &delay2,
+	     const MinMax *min_max,
+	     const StaState *sta);
+
 // delay1-delay2 subtracting sigma instead of addiing.
 Delay delayRemove(const Delay &delay1,
 		  const Delay &delay2);

include/sta/Search.hh

@@ -752,7 +752,8 @@ public:
 		     const StaState *sta);
   void requiredSet(int arrival_index,
 		   Required required,
-		   const MinMax *min_max);
+		   const MinMax *min_max,
+		   const StaState *sta);
   // Return true if the requireds changed.
   bool requiredsSave(Vertex *vertex,
 		     const StaState *sta);

sdf/SdfReader.cc

@@ -809,7 +809,7 @@ SdfReader::setEdgeArcDelaysCondUse(Edge *edge,
       delay = graph_->arcDelay(edge, arc, arc_delay_index) + *value;
     else if (graph_->arcDelayAnnotated(edge, arc, arc_delay_index)) {
       ArcDelay prev_value = graph_->arcDelay(edge, arc, arc_delay_index);
-      if (delayGreater(prev_value, delay, min_max))
+      if (delayGreater(prev_value, delay, min_max, this))
 	delay = prev_value;
     }
     graph_->setArcDelay(edge, arc, arc_delay_index, delay);

search/CheckMaxSkews.cc

@@ -107,7 +107,7 @@ void
 MaxSkewViolatorsVisititor::visit(MaxSkewCheck &check,
 				 const StaState *sta)
 {
-  if (delayLess(check.slack(sta), 0.0))
+  if (delayLess(check.slack(sta), 0.0, sta))
     checks_.push_back(new MaxSkewCheck(check));
 }
 
@@ -280,7 +280,7 @@ MaxSkewSlackLess::operator()(const MaxSkewCheck *check1,
 {
   Slack slack1 = check1->slack(sta_);
   Slack slack2 = check2->slack(sta_);
-  return delayLess(slack1, slack2)
+  return delayLess(slack1, slack2, sta_)
     || (delayEqual(slack1, slack2)
 	// Break ties based on constrained pin names.
 	&& sta_->network()->pinLess(check1->clkPin(sta_),check2->clkPin(sta_)));

search/CheckMinPeriods.cc

@@ -79,7 +79,7 @@ void
 MinPeriodViolatorsVisitor::visit(MinPeriodCheck &check,
 				 StaState *sta)
 {
-  if (delayLess(check.slack(sta), 0.0))
+  if (delayLess(check.slack(sta), 0.0, sta))
     checks_.push_back(check.copy());
 }
 
@@ -231,7 +231,7 @@ MinPeriodSlackLess::operator()(const MinPeriodCheck *check1,
   Slack slack2 = check2->slack(sta_);
   const Pin *pin1 = check1->pin();
   const Pin *pin2 = check2->pin();
-  return delayLess(slack1, slack2)
+  return delayLess(slack1, slack2, sta_)
     // Break ties based on pin and clock names.
     || (delayEqual(slack1, slack2)
 	&& (sta_->network()->pinLess(pin1, pin2)

search/CheckMinPulseWidths.cc

@@ -167,7 +167,7 @@ void
 MinPulseWidthViolatorsVisitor::visit(MinPulseWidthCheck &check,
 				     const StaState *sta)
 {
-  if (delayLess(check.slack(sta), 0.0)
+  if (delayLess(check.slack(sta), 0.0, sta)
       && (corner_ == nullptr
 	  || check.corner(sta) == corner_)) {
     MinPulseWidthCheck *copy = new MinPulseWidthCheck(check.openPath());
@@ -499,7 +499,7 @@ MinPulseWidthSlackLess::operator()(const MinPulseWidthCheck *check1,
   Slack slack2 = check2->slack(sta_);
   const Pin *pin1 = check1->pin(sta_);
   const Pin *pin2 = check2->pin(sta_);
-  return delayLess(slack1, slack2)
+  return delayLess(slack1, slack2, sta_)
     || (delayEqual(slack1, slack2)
 	// Break ties for the sake of regression stability.
 	&& (sta_->network()->pinLess(pin1, pin2)

search/ClkInfo.cc

@@ -294,9 +294,9 @@ clkInfoCmp(const ClkInfo *clk_info1,
 
   const Arrival &insert1 = clk_info1->insertion();
   const Arrival &insert2 = clk_info2->insertion();
-  if (delayLess(insert1, insert2))
+  if (delayLess(insert1, insert2, sta))
     return -1;
-  if (delayGreater(insert1, insert2))
+  if (delayGreater(insert1, insert2, sta))
     return 1;
 
   float latency1 = clk_info1->latency();

search/Genclks.cc

@@ -970,7 +970,8 @@ Genclks::recordSrcPaths(Clock *gclk)
 	    && (src_path.isNull()
 		|| delayGreater(path->arrival(this),
 				src_path.arrival(this),
-				early_late))) {
+				early_late,
+				this))) {
 	  debugPrint4(debug_, "genclk", 2, "  %s insertion %s %s %s\n",
 		      network_->pathName(gclk_pin),
 		      early_late->asString(),

search/Latches.cc

@@ -98,7 +98,7 @@ Latches::latchRequired(const Path *data_path,
 		network_->pathName(data_path->pin(this)),
 		delayAsString(data_arrival, this),
 		delayAsString(enable_arrival, this));
-    if (delayLessEqual(data_arrival, enable_arrival)) {
+    if (delayLessEqual(data_arrival, enable_arrival, this)) {
       // Data arrives before latch opens.
       required = enable_arrival;
       borrow = 0.0;
@@ -108,7 +108,7 @@ Latches::latchRequired(const Path *data_path,
     else {
       // Data arrives while latch is transparent.
       borrow = data_arrival - enable_arrival;
-      if (delayLessEqual(borrow, max_borrow))
+      if (delayLessEqual(borrow, max_borrow, this))
 	required = data_arrival;
       else {
 	borrow = max_borrow;
@@ -332,7 +332,7 @@ Latches::latchOutArrival(Path *data_path,
 	   latchRequired(data_path, enable_path, &disable_path, path_ap,
 			 required, borrow, adjusted_data_arrival,
 			 time_given_to_startpoint);
-	   if (delayGreater(borrow, 0.0)) {
+	   if (delayGreater(borrow, 0.0, this)) {
 	     // Latch is transparent when data arrives.
 	     arc_delay = search_->deratedDelay(data_vertex, d_q_arc, d_q_edge,
 					       false, path_ap);

search/PathEnd.cc

@@ -1244,7 +1244,7 @@ PathEndLatchCheck::targetClkWidth(const StaState *sta) const
   if (enable_clk_info->isPulseClk())
     return disable_arrival - enable_arrival;
   else {
-    if (delayGreater(enable_arrival, disable_arrival)) {
+    if (delayGreater(enable_arrival, disable_arrival, sta)) {
       float period = enable_clk_info->clock()->period();
       disable_arrival += period;
     }
@@ -1999,14 +1999,14 @@ PathEnd::cmpSlack(const PathEnd *path_end1,
     // based on borrow time.
     if (delayEqual(borrow1, borrow2))
       return 0;
-    else if (delayGreater(borrow1, borrow2))
+    else if (delayGreater(borrow1, borrow2, sta))
       return -1;
     else
       return 1;
   }
   else if (delayEqual(slack1, slack2))
     return 0;
-  else if (delayLess(slack1, slack2))
+  else if (delayLess(slack1, slack2, sta))
     return -1;
   else
     return 1;
@@ -2022,7 +2022,7 @@ PathEnd::cmpArrival(const PathEnd *path_end1,
   const MinMax *min_max = path_end1->minMax(sta);
   if (delayEqual(arrival1, arrival2))
     return 0;
-  else if (delayLess(arrival1, arrival2, min_max))
+  else if (delayLess(arrival1, arrival2, min_max, sta))
     return -1;
   else
     return 1;

search/PathEnum.cc

@@ -348,7 +348,7 @@ PathEnumFaninVisitor::visitFromToPath(const Pin *,
       // Make the diverted path end to check slack with from_path crpr.
       makeDivertedPathEnd(from_path, arc, div_end, after_div_copy);
       // Only enumerate paths with greater slack.
-      if (delayGreaterEqual(div_end->slack(sta_), path_end_slack_)) {
+      if (delayGreaterEqual(div_end->slack(sta_), path_end_slack_, sta_)) {
 	reportDiversion(arc, from_path);
 	path_enum_->makeDiversion(div_end, after_div_copy);
       }
@@ -356,7 +356,7 @@ PathEnumFaninVisitor::visitFromToPath(const Pin *,
 	delete div_end;
     }
     // Only enumerate slower/faster paths.
-    else if (delayLessEqual(to_arrival, before_div_arrival_, min_max)) {
+    else if (delayLessEqual(to_arrival, before_div_arrival_, min_max, sta_)) {
       PathEnd *div_end;
       PathEnumed *after_div_copy;
       makeDivertedPathEnd(from_path, arc, div_end, after_div_copy);

search/PathGroup.cc

@@ -101,19 +101,19 @@ PathGroup::savable(PathEnd *path_end)
     // without crpr first because it is expensive to find.
     Slack slack = path_end->slackNoCrpr(sta_);
     if (!delayIsInitValue(slack, min_max_)
- 	&& delayLessEqual(slack, threshold_)
+ 	&& delayLessEqual(slack, threshold_, sta_)
- 	&& delayLessEqual(slack, slack_max_)) {
+ 	&& delayLessEqual(slack, slack_max_, sta_)) {
       // Now check with crpr.
       slack = path_end->slack(sta_);
-      savable = delayLessEqual(slack, threshold_)
+      savable = delayLessEqual(slack, threshold_, sta_)
- 	&& delayLessEqual(slack, slack_max_)
+ 	&& delayLessEqual(slack, slack_max_, sta_)
- 	&& delayGreaterEqual(slack, slack_min_);
+ 	&& delayGreaterEqual(slack, slack_min_, sta_);
     }
   }
   else {
     const Arrival &arrival = path_end->dataArrivalTime(sta_);
     savable = !delayIsInitValue(arrival, min_max_)
-      && delayGreaterEqual(arrival, threshold_, min_max_);
+      && delayGreaterEqual(arrival, threshold_, min_max_, sta_);
   }
   return savable;
 }

search/Property.cc

@@ -801,12 +801,12 @@ pinSlewProperty(const Pin *pin,
   Slew slew = min_max->initValue();
   if (vertex) {
     Slew vertex_slew = sta->vertexSlew(vertex, rf, min_max);
-    if (delayGreater(vertex_slew, slew, min_max))
+    if (delayGreater(vertex_slew, slew, min_max, sta))
       slew = vertex_slew;
   }
   if (bidirect_drvr_vertex) {
     Slew vertex_slew = sta->vertexSlew(bidirect_drvr_vertex, rf, min_max);
-    if (delayGreater(vertex_slew, slew, min_max))
+    if (delayGreater(vertex_slew, slew, min_max, sta))
       slew = vertex_slew;
   }
   return PropertyValue(delayPropertyValue(slew, sta));
@@ -879,9 +879,9 @@ edgeDelayProperty(Edge *edge,
 	ArcDelay arc_delay = sta->arcDelay(edge, arc, dcalc_ap);
 	if (!delay_exists
 	    || ((min_max == MinMax::max()
-		 && delayGreater(arc_delay, delay))
+		 && delayGreater(arc_delay, delay, sta))
 		|| (min_max == MinMax::min()
-		    && delayLess(arc_delay, delay))))
+		    && delayLess(arc_delay, delay, sta))))
 	  delay = arc_delay;
       }
     }

search/ReportPath.cc

@@ -578,7 +578,7 @@ ReportPath::reportFull(const PathEndLatchCheck *end,
   else
     reportTgtClk(end, result);
 
-  if (delayGreaterEqual(borrow, 0.0))
+  if (delayGreaterEqual(borrow, 0.0, this))
     reportLine("time borrowed from endpoint", borrow, req_time,
 	       early_late, result);
   else
@@ -659,7 +659,7 @@ ReportPath::reportBorrowing(const PathEndLatchCheck *end,
       reportLineTotalMinus("CRPR difference", crpr_diff, early_late, result);
     reportLineTotal("max time borrow", max_borrow, early_late, result);
   }
-  if (delayGreater(borrow, delay_zero)
+  if (delayGreater(borrow, delay_zero, this)
       && (!fuzzyZero(open_uncertainty)
 	  || !delayZero(open_crpr))) {
     reportDashLineTotal(result);
@@ -2050,7 +2050,7 @@ ReportPath::reportSrcClkAndPath(const Path *path,
       else if (clk_used_as_data) {
 	reportClkLine(clk, clk_name.c_str(), clk_end_rf, clk_time,
 		      early_late, result);
- 	if (delayGreater(clk_insertion, 0.0))
+ 	if (delayGreater(clk_insertion, 0.0, this))
 	  reportClkSrcLatency(clk_insertion, clk_time, early_late, result);
 	if (reportClkPath())
 	  reportPath1(path, expanded, true, time_offset, result);
@@ -2067,7 +2067,7 @@ ReportPath::reportSrcClkAndPath(const Path *path,
       }
       else {
 	if (is_path_delay) {
-	  if (delayGreater(clk_delay, 0.0))
+	  if (delayGreater(clk_delay, 0.0, this))
 	    reportLine(clkNetworkDelayIdealProp(is_prop), clk_delay,
 		       clk_end_time, early_late, result);
 	}
@@ -2613,7 +2613,7 @@ ReportPath::reportPath1(const Path *path,
       }
       Arrival time = latch_enable_time + latch_time_given;
       Arrival incr = latch_time_given;
-      if (delayGreaterEqual(incr, 0.0))
+      if (delayGreaterEqual(incr, 0.0, this))
 	reportLine("time given to startpoint", incr, time, early_late, result);
       else
 	reportLine("time borrowed from startpoint", incr, time,

search/Search.cc

@@ -1238,7 +1238,7 @@ ArrivalVisitor::visitFromToPath(const Pin *,
   Tag *tag_match;
   tag_bldr_->tagMatchArrival(to_tag, tag_match, arrival, arrival_index);
   if (tag_match == nullptr
-      || delayGreater(to_arrival, arrival, min_max)) {
+      || delayGreater(to_arrival, arrival, min_max, sta_)) {
     debugPrint5(debug, "search", 3, "   %s + %s = %s %s %s\n",
 		delayAsString(from_path->arrival(sta_), sta_),
 		delayAsString(arc_delay, sta_),
@@ -1258,7 +1258,7 @@ ArrivalVisitor::visitFromToPath(const Pin *,
       tag_bldr_no_crpr_->tagMatchArrival(to_tag, tag_match,
 					 arrival, arrival_index);
       if (tag_match == nullptr
-	  || delayGreater(to_arrival, arrival, min_max)) {
+	  || delayGreater(to_arrival, arrival, min_max, sta_)) {
 	tag_bldr_no_crpr_->setMatchArrival(to_tag, tag_match,
 					   to_arrival, arrival_index,
 					   &prev_path);
@@ -1300,7 +1300,7 @@ ArrivalVisitor::pruneCrprArrivals()
 		    delayAsString(max_crpr, sta_),
 		    delayAsString(max_arrival_max_crpr, sta_));
 	Arrival arrival = tag_bldr_->arrival(arrival_index);
-	if (delayGreater(max_arrival_max_crpr, arrival, min_max)) {
+	if (delayGreater(max_arrival_max_crpr, arrival, min_max, sta_)) {
 	  debugPrint1(debug, "search", 3, "  pruned %s\n",
 		      tag->asString(sta_));
 	  tag_bldr_->deleteArrival(tag);
@@ -3254,7 +3254,7 @@ FindEndRequiredVisitor::visit(PathEnd *path_end)
     bool arrival_exists;
     path.arrivalIndex(arrival_index, arrival_exists);
     Required required = path_end->requiredTime(sta_);
-    required_cmp_->requiredSet(arrival_index, required, req_min);
+    required_cmp_->requiredSet(arrival_index, required, req_min, sta_);
   }
 }
 
@@ -3319,9 +3319,10 @@ RequiredCmp::requiredsInit(Vertex *vertex,
 void
 RequiredCmp::requiredSet(int arrival_index,
 			 Required required,
-			 const MinMax *min_max)
+			 const MinMax *min_max,
+			 const StaState *sta)
 {
-  if (delayGreater(required, requireds_[arrival_index], min_max)) {
+  if (delayGreater(required, requireds_[arrival_index], min_max, sta)) {
     requireds_[arrival_index] = required;
     have_requireds_ = true;
   }
@@ -3463,7 +3464,7 @@ RequiredVisitor::visitFromToPath(const Pin *,
 		  delayAsString(from_required, sta_),
 		  min_max == MinMax::max() ? "<" : ">",
 		  delayAsString(required_cmp_->required(arrival_index), sta_));
-      required_cmp_->requiredSet(arrival_index, from_required, req_min);
+      required_cmp_->requiredSet(arrival_index, from_required, req_min, sta_);
     }
     else {
       if (sta_->search()->crprApproxMissingRequireds()) {
@@ -3487,7 +3488,7 @@ RequiredVisitor::visitFromToPath(const Pin *,
 			min_max == MinMax::max() ? "<" : ">",
 			delayAsString(required_cmp_->required(arrival_index),
 				      sta_));
-	    required_cmp_->requiredSet(arrival_index, from_required, req_min);
+	    required_cmp_->requiredSet(arrival_index, from_required, req_min, sta_);
 	    break;
 	  }
 	}
@@ -3640,7 +3641,7 @@ Search::totalNegativeSlack(const MinMax *min_max)
   for (Corner *corner : *corners_) {
     PathAPIndex path_ap_index = corner->findPathAnalysisPt(min_max)->index();
     Slack tns1 = tns_[path_ap_index];
-    if (delayLess(tns1, tns))
+    if (delayLess(tns1, tns, this))
       tns = tns1;
   }
   return tns;
@@ -3735,7 +3736,7 @@ Search::tnsIncr(Vertex *vertex,
 		Slack slack,
 		PathAPIndex path_ap_index)
 {
-  if (delayLess(slack, 0.0)) {
+  if (delayLess(slack, 0.0, this)) {
     debugPrint2(debug_, "tns", 3, "tns+ %s %s\n",
 		delayAsString(slack, this),
 		vertex->name(sdc_network_));
@@ -3754,7 +3755,7 @@ Search::tnsDecr(Vertex *vertex,
   bool found;
   tns_slacks_[path_ap_index].findKey(vertex, slack, found);
   if (found
-      && delayLess(slack, 0.0)) {
+      && delayLess(slack, 0.0, this)) {
     debugPrint2(debug_, "tns", 3, "tns- %s %s\n",
 		delayAsString(slack, this),
 		vertex->name(sdc_network_));
@@ -3880,7 +3881,7 @@ FindEndSlackVisitor::visit(PathEnd *path_end)
     PathRef &path = path_end->pathRef();
     PathAPIndex path_ap_index = path.pathAnalysisPtIndex(sta_);
     Slack slack = path_end->slack(sta_);
-    if (delayLess(slack, slacks_[path_ap_index]))
+    if (delayLess(slack, slacks_[path_ap_index], sta_))
       slacks_[path_ap_index] = slack;
   }
 }
@@ -3907,7 +3908,7 @@ Search::wnsSlacks(Vertex *vertex,
       PathAPIndex path_ap_index = path->pathAnalysisPtIndex(this);
       const Slack path_slack = path->slack(this);
       if (!path->tag(this)->isFilter()
-	  && delayLess(path_slack, slacks[path_ap_index]))
+	  && delayLess(path_slack, slacks[path_ap_index], this))
 	slacks[path_ap_index] = path_slack;
     }
   }

search/Sta.cc

@@ -2669,7 +2669,7 @@ Sta::vertexWorstArrivalPath(Vertex *vertex,
     PathVertex *path = path_iter.next();
     Arrival arrival = path->arrival(this);
     if (!path->tag(this)->isGenClkSrcPath()
-	&& delayGreater(arrival, worst_arrival, min_max)) {
+	&& delayGreater(arrival, worst_arrival, min_max, this)) {
       worst_arrival = arrival;
       worst_path.init(path);
     }
@@ -2689,7 +2689,7 @@ Sta::vertexWorstArrivalPath(Vertex *vertex,
     Arrival arrival = path->arrival(this);
     if (path->minMax(this) == min_max
 	&& !path->tag(this)->isGenClkSrcPath()
-	&& delayGreater(arrival, worst_arrival, min_max)) {
+	&& delayGreater(arrival, worst_arrival, min_max, this)) {
       worst_arrival = arrival;
       worst_path.init(path);
     }
@@ -2709,7 +2709,7 @@ Sta::vertexWorstSlackPath(Vertex *vertex,
     PathVertex *path = path_iter.next();
     Slack slack = path->slack(this);
     if (!path->tag(this)->isGenClkSrcPath()
-	&& delayLess(slack, min_slack)) {
+	&& delayLess(slack, min_slack, this)) {
       min_slack = slack;
       worst_path.init(path);
     }
@@ -2730,7 +2730,7 @@ Sta::vertexWorstSlackPath(Vertex *vertex,
     if (path->minMax(this) == min_max
 	&& !path->tag(this)->isGenClkSrcPath()) {
       Slack slack = path->slack(this);
-      if (delayLess(slack, min_slack)) {
+      if (delayLess(slack, min_slack, this)) {
 	min_slack = slack;
 	worst_path.init(path);
       }
@@ -2764,7 +2764,7 @@ Sta::vertexArrival(Vertex *vertex,
     if ((clk_edge == clk_edge_wildcard
 	 || clk_info->clkEdge() == clk_edge)
 	&& !clk_info->isGenClkSrcPath()
-	&& delayGreater(path->arrival(this), arrival, min_max))
+	&& delayGreater(path->arrival(this), arrival, min_max, this))
       arrival = path_arrival;
   }
   return arrival;
@@ -2782,7 +2782,7 @@ Sta::vertexRequired(Vertex *vertex,
     const Path *path = path_iter.next();
     if (path->minMax(this) == min_max) {
       const Required path_required = path->required(this);
-      if (delayGreater(path_required, required, req_min_max))
+      if (delayGreater(path_required, required, req_min_max, this))
 	required = path_required;
     }
   }
@@ -2812,7 +2812,7 @@ Sta::vertexRequired(Vertex *vertex,
     const Required path_required = path->required(this);
     if ((clk_edge == clk_edge_wildcard
 	 || path->clkEdge(search_) == clk_edge)
-	&& delayGreater(path_required, required, min_max))
+	&& delayGreater(path_required, required, min_max, this))
       required = path_required;
   }
   return required;
@@ -2830,7 +2830,7 @@ Sta::netSlack(const Net *net,
     if (network_->isLoad(pin)) {
       Vertex *vertex = graph_->pinLoadVertex(pin);
       Slack pin_slack = vertexSlack(vertex, min_max);
-      if (delayLess(pin_slack, slack))
+      if (delayLess(pin_slack, slack, this))
 	slack = pin_slack;
     }
   }
@@ -2849,7 +2849,7 @@ Sta::pinSlack(const Pin *pin,
     slack = vertexSlack(vertex, min_max);
   if (bidirect_drvr_vertex) {
     Slack slack1 = vertexSlack(bidirect_drvr_vertex, min_max);
-    if (delayLess(slack1, slack))
+    if (delayLess(slack1, slack, this))
       slack = slack1;
   }
   return slack;
@@ -2868,7 +2868,7 @@ Sta::pinSlack(const Pin *pin,
     slack = vertexSlack(vertex, rf, min_max);
   if (bidirect_drvr_vertex) {
     Slack slack1 = vertexSlack(bidirect_drvr_vertex, rf, min_max);
-    if (delayLess(slack1, slack))
+    if (delayLess(slack1, slack, this))
       slack = slack1;
   }
   return slack;
@@ -2886,7 +2886,7 @@ Sta::vertexSlack(Vertex *vertex,
     Path *path = path_iter.next();
     if (path->minMax(this) == min_max) {
       Slack path_slack = path->slack(this);
-      if (delayLess(path_slack, slack))
+      if (delayLess(path_slack, slack, this))
 	slack = path_slack;
     }
   }
@@ -2904,7 +2904,7 @@ Sta::vertexSlack(Vertex *vertex,
   while (path_iter.hasNext()) {
     Path *path = path_iter.next();
     Slack path_slack = path->slack(this);
-    if (delayLess(path_slack, slack))
+    if (delayLess(path_slack, slack, this))
       slack = path_slack;
   }
   return slack;
@@ -2943,7 +2943,7 @@ Sta::vertexSlack1(Vertex *vertex,
     Slack path_slack = path->slack(this);
     if ((clk_edge == clk_edge_wildcard
 	 || path->clkEdge(search_) == clk_edge)
-	&& delayLess(path_slack, slack))
+	&& delayLess(path_slack, slack, this))
       slack = path_slack;
   }
   return slack;
@@ -2965,7 +2965,7 @@ Sta::vertexSlacks(Vertex *vertex,
     Slack path_slack = path->slack(this);
     int rf_index = path->rfIndex(this);
     int mm_index = path->minMax(this)->index();
-    if (delayLess(path_slack, slacks[rf_index][mm_index]))
+    if (delayLess(path_slack, slacks[rf_index][mm_index], this))
       slacks[rf_index][mm_index] = path_slack;
   }
 }
@@ -3160,7 +3160,7 @@ Sta::vertexSlew(Vertex *vertex,
   Slew mm_slew = min_max->initValue();
   for (DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
     Slew slew = graph_->slew(vertex, rf, dcalc_ap->index());
-    if (delayGreater(slew, mm_slew, min_max))
+    if (delayGreater(slew, mm_slew, min_max, this))
       mm_slew = slew;
   }
   return mm_slew;
@@ -4782,7 +4782,7 @@ bool
 InstanceMaxSlewGreater::operator()(const Instance *inst1,
 				   const Instance *inst2) const
 {
-  return delayGreater(instMaxSlew(inst1), instMaxSlew(inst2));
+  return delayGreater(instMaxSlew(inst1), instMaxSlew(inst2), sta_);
 }
 
 Slew
@@ -4799,7 +4799,7 @@ InstanceMaxSlewGreater::instMaxSlew(const Instance *inst) const
       for (RiseFall *rf : RiseFall::range()) {
 	for (DcalcAnalysisPt *dcalc_ap : sta_->corners()->dcalcAnalysisPts()) {
 	  Slew slew = graph->slew(vertex, rf, dcalc_ap->index());
-	  if (delayGreater(slew, max_slew))
+	  if (delayGreater(slew, max_slew, sta_))
 	    max_slew = slew;
 	}
       }

search/WorstSlack.cc

@@ -48,7 +48,7 @@ WorstSlacks::worstSlack(const MinMax *min_max,
     Vertex *worst_vertex1;
     worst_slacks_[path_ap_index].worstSlack(path_ap_index, sta_,
 					    worst_slack1, worst_vertex1);
-    if (delayLess(worst_slack1, worst_slack)) {
+    if (delayLess(worst_slack1, worst_slack, sta_)) {
       worst_slack = worst_slack1;
       worst_vertex = worst_vertex1;
     }
@@ -160,9 +160,9 @@ WorstSlack::initQueue(PathAPIndex path_ap_index,
     Vertex *vertex = end_iter.next();
     Slack slack = search->wnsSlack(vertex, path_ap_index);
     if (!delayEqual(slack, slack_init_)) {
-      if (delayLess(slack, worst_slack_))
+      if (delayLess(slack, worst_slack_, sta))
 	setWorstSlack(vertex, slack, sta);
-      if (delayLessEqual(slack, slack_threshold_))
+      if (delayLessEqual(slack, slack_threshold_, sta))
 	queue_.insert(vertex);
       int queue_size = queue_.size();
       if (queue_size >= max_queue_size_)
@@ -206,7 +206,7 @@ WorstSlack::sortQueue(PathAPIndex path_ap_index,
     while (queue_iter2.hasNext()) {
       Vertex *vertex = queue_iter2.next();
       Slack slack = search->wnsSlack(vertex, path_ap_index);
-      if (delayGreater(slack, slack_threshold_))
+      if (delayGreater(slack, slack_threshold_, sta))
 	break;
       queue_.insert(vertex);
     }
@@ -231,7 +231,7 @@ WorstSlack::findWorstInQueue(PathAPIndex path_ap_index,
   while (queue_iter.hasNext()) {
     Vertex *vertex = queue_iter.next();
     Slack slack = search->wnsSlack(vertex, path_ap_index);
-    if (delayLess(slack, worst_slack_))
+    if (delayLess(slack, worst_slack_, sta))
       setWorstSlack(vertex, slack, sta);
   }
 }
@@ -249,7 +249,7 @@ WorstSlack::checkQueue(PathAPIndex path_ap_index,
   while (end_iter.hasNext()) {
     Vertex *end = end_iter.next();
     if (delayLessEqual(search->wnsSlack(end, path_ap_index),
-			    slack_threshold_))
+		       slack_threshold_, sta))
       ends.push_back(end);
   }
   WnsSlackLess slack_less(path_ap_index, sta);
@@ -262,7 +262,7 @@ WorstSlack::checkQueue(PathAPIndex path_ap_index,
     end_set.insert(end);
     if (!queue_.hasKey(end)
 	&& delayLessEqual(search->wnsSlack(end, path_ap_index),
-			       slack_threshold_))
+			  slack_threshold_, sta))
       report->print("WorstSlack queue missing %s %s < %s\n",
 		    end->name(network),
 		    delayAsString(search->wnsSlack(end, path_ap_index), sta),
@@ -294,14 +294,14 @@ WorstSlack::updateWorstSlack(Vertex *vertex,
   // threads.
   UniqueLock lock(lock_);
   if (worst_vertex_
-      && delayLess(slack, worst_slack_))
+      && delayLess(slack, worst_slack_, sta))
     setWorstSlack(vertex, slack, sta);
   else if (vertex == worst_vertex_)
     // Mark worst slack as unknown (updated by findWorstSlack().
     worst_vertex_ = nullptr;
 
   if (!delayEqual(slack, slack_init_)
-      && delayLessEqual(slack, slack_threshold_)) {
+      && delayLessEqual(slack, slack_threshold_, sta)) {
     debugPrint2(debug, "wns", 3, "insert %s %s\n",
 		vertex->name(network),
 		delayAsString(slack, sta));
@@ -342,7 +342,8 @@ WnsSlackLess::operator()(Vertex *vertex1,
 			 Vertex *vertex2)
 {
   return delayLess(search_->wnsSlack(vertex1, path_ap_index_),
-		   search_->wnsSlack(vertex2, path_ap_index_));
+		   search_->wnsSlack(vertex2, path_ap_index_),
+		   search_);
 }
 
 } // namespace