luke
/
OpenSTA
mirror of https://github.com/The-OpenROAD-Project/OpenSTA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Delay compare ops round2

This commit is contained in:
James Cherry 2020-07-11 17:43:30 -07:00
parent 9468da1ae8
commit 7653096fe6
23 changed files with 379 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dcalc/GraphDelayCalc1.cc
View File

@ -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_)

24
graph/DelayFloat.cc
View File

@ -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);

297
graph/DelayNormal1.cc
View File

@ -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)

64
graph/DelayNormal2.cc
View File

@ -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 delayGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
return fuzzyGreaterEqual(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

35
include/sta/DelayFloat.hh
View File

@ -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);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2);
const MinMax *min_max,
const StaState *sta);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max);
const StaState *sta);
bool
delayGreater(const Delay &delay1,
const Delay &delay2);
delayLessEqual(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);
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
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);

41
include/sta/DelayNormal1.hh
View File

@ -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);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2);
const MinMax *min_max,
const StaState *sta);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max);
const StaState *sta);
bool
delayGreater(const Delay &delay1,
const Delay &delay2);
bool
delayGreaterEqual(const Delay &delay1,
const Delay &delay2);
bool
delayGreaterEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max);
delayLessEqual(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);
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);

89
include/sta/DelayNormal2.hh
View File

@ -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);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2);
const MinMax *min_max,
const StaState *sta);
bool
delayLessEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max);
const StaState *sta);
bool
delayGreater(const Delay &delay1,
const Delay &delay2);
bool
delayGreaterEqual(const Delay &delay1,
const Delay &delay2);
bool
delayGreaterEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max);
delayLessEqual(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);
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);

3
include/sta/Search.hh
View File

@ -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);

2
sdf/SdfReader.cc
View File

@ -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);

4
search/CheckMaxSkews.cc
View File

@ -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_)));

4
search/CheckMinPeriods.cc
View File

@ -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)

4
search/CheckMinPulseWidths.cc
View File

@ -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)

4
search/ClkInfo.cc
View File

@ -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();

3
search/Genclks.cc
View File

@ -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(),

6
search/Latches.cc
View File

@ -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);

8
search/PathEnd.cc
View File

@ -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;

4
search/PathEnum.cc
View File

@ -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);

12
search/PathGroup.cc
View File

@ -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, slack_max_)) {
&& delayLessEqual(slack, threshold_, sta_)
&& delayLessEqual(slack, slack_max_, sta_)) {
// Now check with crpr.
slack = path_end->slack(sta_);
savable = delayLessEqual(slack, threshold_)
&& delayLessEqual(slack, slack_max_)
&& delayGreaterEqual(slack, slack_min_);
savable = delayLessEqual(slack, threshold_, sta_)
&& delayLessEqual(slack, slack_max_, sta_)
&& 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;
}

8
search/Property.cc
View File

@ -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;
}
}

10
search/ReportPath.cc
View File

@ -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,

27
search/Search.cc
View File

@ -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;
}
}

34
search/Sta.cc
View File

@ -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;
}
}

21
search/WorstSlack.cc
View File

@ -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