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

pocv comparisons use +/- sigma

This commit is contained in:
James Cherry 2020-07-03 10:16:10 -07:00
parent 0a01faa36c
commit 338a82add4
2 changed files with 119 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
graph/DelayNormal1.cc
View File

@ -24,6 +24,8 @@
#include "Fuzzy.hh"
#include "Units.hh"
#include "StaState.hh"
// temporary hack
#include "Sta.hh"
// SSTA compilation.
#if (SSTA == 1)
@ -162,32 +164,31 @@ Delay::operator-=(const Delay &delay)
bool
Delay::operator==(const Delay &delay) const
{
return mean_ == delay.mean_
&& sigma2_ == delay.sigma2_;
return fuzzyEqual(*this, delay);
}
bool
Delay::operator>(const Delay &delay) const
{
return mean_ > delay.mean_;
return fuzzyGreater(*this, delay);
}
bool
Delay::operator>=(const Delay &delay) const
{
return mean_ >= delay.mean_;
return fuzzyGreaterEqual(*this, delay);
}
bool
Delay::operator<(const Delay &delay) const
{
return mean_ < delay.mean_;
return fuzzyLess(*this, delay);
}
bool
Delay::operator<=(const Delay &delay) const
{
return mean_ <= delay.mean_;
return fuzzyLessEqual(*this, delay);
}
////////////////////////////////////////////////////////////////
@ -241,28 +242,36 @@ bool
fuzzyLess(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLess(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
delayAsFloat(delay2, EarlyLate::early(), sta));
}
bool
fuzzyLess(const Delay &delay1,
float delay2)
{
return fuzzyLess(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
delay2);
}
bool
fuzzyLessEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLessEqual(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
delayAsFloat(delay2, EarlyLate::early(), sta));
}
bool
fuzzyLessEqual(const Delay &delay1,
float delay2)
{
return fuzzyLessEqual(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
delay2);
}
bool
@ -271,37 +280,45 @@ fuzzyLessEqual(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLessEqual(delay1.mean(), delay2.mean());
return fuzzyLessEqual(delay1, delay2);
else
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
return fuzzyGreaterEqual(delay1, delay2);
}
bool
fuzzyGreater(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreater(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
delayAsFloat(delay2, EarlyLate::late(), sta));
}
bool
fuzzyGreater(const Delay &delay1,
float delay2)
{
return fuzzyGreater(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
delay2);
}
bool
fuzzyGreaterEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
delayAsFloat(delay2, EarlyLate::late(), sta));
}
bool
fuzzyGreaterEqual(const Delay &delay1,
float delay2)
{
return fuzzyGreaterEqual(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
delay2);
}
bool
@ -310,9 +327,9 @@ fuzzyGreater(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreater(delay1.mean(), delay2.mean());
return fuzzyGreater(delay1, delay2);
else
return fuzzyLess(delay1.mean(), delay2.mean());
return fuzzyLess(delay1, delay2);
}
bool
@ -321,9 +338,9 @@ fuzzyGreaterEqual(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
return fuzzyGreaterEqual(delay1, delay2);
else
return fuzzyLessEqual(delay1.mean(), delay2.mean());
return fuzzyLessEqual(delay1, delay2);
}
bool
@ -332,9 +349,9 @@ fuzzyLess(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLess(delay1.mean(), delay2.mean());
return fuzzyLess(delay1, delay2);
else
return fuzzyGreater(delay1.mean(), delay2.mean());
return fuzzyGreater(delay1, delay2);
}
float

142
graph/DelayNormal2.cc
View File

@ -190,25 +190,25 @@ Delay::operator==(const Delay &delay) const
bool
Delay::operator>(const Delay &delay) const
{
return mean_ > delay.mean_;
return mean_ + sqrt(sigma2_late_) > delay.mean_ + sqrt(delay.sigma2_late_);
}
bool
Delay::operator>=(const Delay &delay) const
{
return mean_ >= delay.mean_;
return mean_ + sqrt(sigma2_late_) >= delay.mean_ + sqrt(delay.sigma2_late_);
}
bool
Delay::operator<(const Delay &delay) const
{
return mean_ < delay.mean_;
return mean_ - sqrt(sigma2_early_) < delay.mean_ - sqrt(delay.sigma2_early_);
}
bool
Delay::operator<=(const Delay &delay) const
{
return mean_ <= delay.mean_;
return mean_ - sqrt(sigma2_early_) <= delay.mean_ - sqrt(delay.sigma2_early_);
}
////////////////////////////////////////////////////////////////
@ -265,28 +265,36 @@ bool
fuzzyLess(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLess(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
delayAsFloat(delay2, EarlyLate::early(), sta));
}
bool
fuzzyLess(const Delay &delay1,
float delay2)
{
return fuzzyLess(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyLess(delayAsFloat(delay1, EarlyLate::early(), sta),
delay2);
}
bool
fuzzyLessEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLessEqual(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
delayAsFloat(delay2, EarlyLate::early(), sta));
}
bool
fuzzyLessEqual(const Delay &delay1,
float delay2)
{
return fuzzyLessEqual(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyLessEqual(delayAsFloat(delay1, EarlyLate::early(), sta),
delay2);
}
bool
@ -295,37 +303,45 @@ fuzzyLessEqual(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLessEqual(delay1.mean(), delay2.mean());
return fuzzyLessEqual(delay1, delay2);
else
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
return fuzzyGreaterEqual(delay1, delay2);
}
bool
fuzzyGreater(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreater(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyGreater(delayAsFloat(delay1, EarlyLate::late(), sta),
delayAsFloat(delay2, EarlyLate::late(), sta));
}
bool
fuzzyGreater(const Delay &delay1,
float delay2)
{
return fuzzyGreater(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
delayAsFloat(delay2, EarlyLate::late(), sta));
}
bool
fuzzyGreaterEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
Sta *sta = Sta::sta();
return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
delay2);
}
bool
fuzzyGreaterEqual(const Delay &delay1,
float delay2)
{
return fuzzyGreaterEqual(delay1.mean(), delay2);
Sta *sta = Sta::sta();
return fuzzyGreaterEqual(delayAsFloat(delay1, EarlyLate::late(), sta),
delay2);
}
bool
@ -334,9 +350,9 @@ fuzzyGreater(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreater(delay1.mean(), delay2.mean());
return fuzzyGreater(delay1, delay2);
else
return fuzzyLess(delay1.mean(), delay2.mean());
return fuzzyLess(delay1, delay2);
}
bool
@ -345,9 +361,9 @@ fuzzyGreaterEqual(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
return fuzzyGreaterEqual(delay1, delay2);
else
return fuzzyLessEqual(delay1.mean(), delay2.mean());
return fuzzyLessEqual(delay1, delay2);
}
bool
@ -356,52 +372,9 @@ fuzzyLess(const Delay &delay1,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLess(delay1.mean(), delay2.mean());
return fuzzyLess(delay1, delay2);
else
return fuzzyGreater(delay1.mean(), delay2.mean());
}
Delay
operator+(float delay1,
const Delay &delay2)
{
return Delay(delay1 + delay2.mean(),
delay2.sigma2Early(),
delay2.sigma2Late());
}
Delay
operator/(float delay1,
const Delay &delay2)
{
return Delay(delay1 / delay2.mean(),
delay2.sigma2Early(),
delay2.sigma2Late());
}
Delay
operator*(const Delay &delay1,
float delay2)
{
return Delay(delay1.mean() * delay2,
delay1.sigma2Early() * delay2 * delay2,
delay1.sigma2Late() * delay2 * delay2);
}
Delay
delayRemove(const Delay &delay1,
const Delay &delay2)
{
return Delay(delay1.mean() - delay2.mean(),
delay1.sigma2Early() - delay2.sigma2Early(),
delay1.sigma2Late() - delay2.sigma2Late());
}
float
delayRatio(const Delay &delay1,
const Delay &delay2)
{
return delay1.mean() / delay2.mean();
return fuzzyGreater(delay1, delay2);
}
float
@ -463,6 +436,49 @@ delayAsString(const Delay &delay,
return sta->units()->timeUnit()->asString(mean_sigma, digits);
}
Delay
delayRemove(const Delay &delay1,
const Delay &delay2)
{
return Delay(delay1.mean() - delay2.mean(),
delay1.sigma2Early() - delay2.sigma2Early(),
delay1.sigma2Late() - delay2.sigma2Late());
}
float
delayRatio(const Delay &delay1,
const Delay &delay2)
{
return delay1.mean() / delay2.mean();
}
Delay
operator+(float delay1,
const Delay &delay2)
{
return Delay(delay1 + delay2.mean(),
delay2.sigma2Early(),
delay2.sigma2Late());
}
Delay
operator/(float delay1,
const Delay &delay2)
{
return Delay(delay1 / delay2.mean(),
delay2.sigma2Early(),
delay2.sigma2Late());
}
Delay
operator*(const Delay &delay1,
float delay2)
{
return Delay(delay1.mean() * delay2,
delay1.sigma2Early() * delay2 * delay2,
delay1.sigma2Late() * delay2 * delay2);
}
} // namespace
#endif // (SSTA == 2)