441 lines
8.8 KiB
C++
441 lines
8.8 KiB
C++
// OpenSTA, Static Timing Analyzer
|
|
// Copyright (c) 2019, Parallax Software, Inc.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include "config.h"
|
|
#include <cmath> // sqrt
|
|
#include "Machine.hh"
|
|
#include "Error.hh"
|
|
#include "StringUtil.hh"
|
|
#include "Fuzzy.hh"
|
|
#include "Units.hh"
|
|
#include "StaState.hh"
|
|
#include "Delay.hh"
|
|
|
|
// SSTA compilation.
|
|
#if SSTA
|
|
|
|
namespace sta {
|
|
|
|
inline float
|
|
square(float x)
|
|
{
|
|
return x * x;
|
|
}
|
|
|
|
static Delay delay_init_values[MinMax::index_count];
|
|
|
|
void
|
|
initDelayConstants()
|
|
{
|
|
delay_init_values[MinMax::minIndex()] = MinMax::min()->initValue();
|
|
delay_init_values[MinMax::maxIndex()] = MinMax::max()->initValue();
|
|
}
|
|
|
|
const Delay &
|
|
delayInitValue(const MinMax *min_max)
|
|
{
|
|
return delay_init_values[min_max->index()];
|
|
}
|
|
|
|
Delay::Delay() :
|
|
mean_(0.0),
|
|
sigma2_{0.0, 0.0}
|
|
{
|
|
}
|
|
|
|
Delay::Delay(float mean) :
|
|
mean_(mean),
|
|
sigma2_{0.0, 0.0}
|
|
{
|
|
}
|
|
|
|
Delay::Delay(float mean,
|
|
float sigma2_early,
|
|
float sigma2_late) :
|
|
mean_(mean),
|
|
sigma2_{sigma2_early, sigma2_late}
|
|
{
|
|
}
|
|
|
|
float
|
|
Delay::sigma(const EarlyLate *early_late) const
|
|
{
|
|
float sigma = sigma2_[early_late->index()];
|
|
if (sigma < 0.0)
|
|
// Sigma is negative for crpr to offset sigmas in the common
|
|
// clock path.
|
|
return -sqrt(-sigma);
|
|
else
|
|
return sqrt(sigma);
|
|
}
|
|
|
|
float
|
|
Delay::sigma2(const EarlyLate *early_late) const
|
|
{
|
|
return sigma2_[early_late->index()];
|
|
}
|
|
|
|
float
|
|
Delay::sigma2Early() const
|
|
{
|
|
return sigma2_[early_index];
|
|
}
|
|
|
|
float
|
|
Delay::sigma2Late() const
|
|
{
|
|
return sigma2_[late_index];
|
|
}
|
|
|
|
void
|
|
Delay::operator=(const Delay &delay)
|
|
{
|
|
mean_ = delay.mean_;
|
|
sigma2_[early_index] = delay.sigma2_[early_index];
|
|
sigma2_[late_index] = delay.sigma2_[late_index];
|
|
}
|
|
|
|
void
|
|
Delay::operator=(float delay)
|
|
{
|
|
mean_ = delay;
|
|
sigma2_[early_index] = 0.0;
|
|
sigma2_[late_index] = 0.0;
|
|
}
|
|
|
|
void
|
|
Delay::operator+=(const Delay &delay)
|
|
{
|
|
mean_ += delay.mean_;
|
|
sigma2_[early_index] += delay.sigma2_[early_index];
|
|
sigma2_[late_index] += delay.sigma2_[late_index];
|
|
}
|
|
|
|
void
|
|
Delay::operator+=(float delay)
|
|
{
|
|
mean_ += delay;
|
|
}
|
|
|
|
Delay
|
|
Delay::operator+(const Delay &delay) const
|
|
{
|
|
return Delay(mean_ + delay.mean_,
|
|
sigma2_[early_index] + delay.sigma2_[early_index],
|
|
sigma2_[late_index] + delay.sigma2_[late_index]);
|
|
}
|
|
|
|
Delay
|
|
Delay::operator+(float delay) const
|
|
{
|
|
return Delay(mean_ + delay, sigma2_[early_index], sigma2_[late_index]);
|
|
}
|
|
|
|
Delay
|
|
Delay::operator-(const Delay &delay) const
|
|
{
|
|
return Delay(mean_ - delay.mean_,
|
|
sigma2_[early_index] + delay.sigma2_[early_index],
|
|
sigma2_[late_index] + delay.sigma2_[late_index]);
|
|
}
|
|
|
|
Delay
|
|
Delay::operator-(float delay) const
|
|
{
|
|
return Delay(mean_ - delay, sigma2_[early_index], sigma2_[late_index]);
|
|
}
|
|
|
|
Delay
|
|
Delay::operator-() const
|
|
{
|
|
return Delay(-mean_, sigma2_[early_index], sigma2_[late_index]);
|
|
}
|
|
|
|
void
|
|
Delay::operator-=(float delay)
|
|
{
|
|
mean_ -= - delay;
|
|
}
|
|
|
|
bool
|
|
Delay::operator==(const Delay &delay) const
|
|
{
|
|
return mean_ == delay.mean_
|
|
&& sigma2_[early_index] == delay.sigma2_[early_index]
|
|
&& sigma2_[late_index] == delay.sigma2_[late_index];
|
|
}
|
|
|
|
bool
|
|
Delay::operator>(const Delay &delay) const
|
|
{
|
|
return mean_ > delay.mean_;
|
|
}
|
|
|
|
bool
|
|
Delay::operator>=(const Delay &delay) const
|
|
{
|
|
return mean_ >= delay.mean_;
|
|
}
|
|
|
|
bool
|
|
Delay::operator<(const Delay &delay) const
|
|
{
|
|
return mean_ < delay.mean_;
|
|
}
|
|
|
|
bool
|
|
Delay::operator<=(const Delay &delay) const
|
|
{
|
|
return mean_ <= delay.mean_;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
Delay
|
|
makeDelay(float delay,
|
|
float sigma_early,
|
|
float sigma_late)
|
|
{
|
|
return Delay(delay, square(sigma_early), square(sigma_late));
|
|
}
|
|
|
|
Delay
|
|
makeDelay2(float delay,
|
|
float sigma2_early,
|
|
float sigma2_late)
|
|
{
|
|
return Delay(delay, sigma2_early, sigma2_late);
|
|
}
|
|
|
|
bool
|
|
delayIsInitValue(const Delay &delay,
|
|
const MinMax *min_max)
|
|
{
|
|
return fuzzyEqual(delay.mean(), min_max->initValue())
|
|
&& delay.sigma2Early() == 0.0
|
|
&& delay.sigma2Late() == 0.0;
|
|
}
|
|
|
|
bool
|
|
delayFuzzyZero(const Delay &delay)
|
|
{
|
|
return fuzzyZero(delay.mean())
|
|
// && fuzzyZero(delay.sigma2(EarlyLate::early()))
|
|
&& fuzzyZero(delay.sigma2Early())
|
|
&& fuzzyZero(delay.sigma2Late());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyEqual(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return fuzzyEqual(delay1.mean(), delay2.mean())
|
|
&& fuzzyEqual(delay1.sigma2Early(), delay2.sigma2Early())
|
|
&& fuzzyEqual(delay1.sigma2Late(), delay2.sigma2Late());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLess(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return fuzzyLess(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLess(const Delay &delay1,
|
|
float delay2)
|
|
{
|
|
return fuzzyLess(delay1.mean(), delay2);
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLessEqual(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return fuzzyLessEqual(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLessEqual(const Delay &delay1,
|
|
float delay2)
|
|
{
|
|
return fuzzyLessEqual(delay1.mean(), delay2);
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLessEqual(const Delay &delay1,
|
|
const Delay &delay2,
|
|
const MinMax *min_max)
|
|
{
|
|
if (min_max == MinMax::max())
|
|
return fuzzyLessEqual(delay1.mean(), delay2.mean());
|
|
else
|
|
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreater(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return fuzzyGreater(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreater(const Delay &delay1,
|
|
float delay2)
|
|
{
|
|
return fuzzyGreater(delay1.mean(), delay2);
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreaterEqual(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreaterEqual(const Delay &delay1,
|
|
float delay2)
|
|
{
|
|
return fuzzyGreaterEqual(delay1.mean(), delay2);
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreater(const Delay &delay1,
|
|
const Delay &delay2,
|
|
const MinMax *min_max)
|
|
{
|
|
if (min_max == MinMax::max())
|
|
return fuzzyGreater(delay1.mean(), delay2.mean());
|
|
else
|
|
return fuzzyLess(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyGreaterEqual(const Delay &delay1,
|
|
const Delay &delay2,
|
|
const MinMax *min_max)
|
|
{
|
|
if (min_max == MinMax::max())
|
|
return fuzzyGreaterEqual(delay1.mean(), delay2.mean());
|
|
else
|
|
return fuzzyLessEqual(delay1.mean(), delay2.mean());
|
|
}
|
|
|
|
bool
|
|
delayFuzzyLess(const Delay &delay1,
|
|
const Delay &delay2,
|
|
const MinMax *min_max)
|
|
{
|
|
if (min_max == MinMax::max())
|
|
return fuzzyLess(delay1.mean(), delay2.mean());
|
|
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,
|
|
delay1.sigma2Late() * delay2);
|
|
}
|
|
|
|
float
|
|
delayRatio(const Delay &delay1,
|
|
const Delay &delay2)
|
|
{
|
|
return delay1.mean() / delay2.mean();
|
|
}
|
|
|
|
float
|
|
delayAsFloat(const Delay &delay,
|
|
const EarlyLate *early_late)
|
|
{
|
|
if (early_late == EarlyLate::early())
|
|
return delay.mean() - delay.sigma(early_late);
|
|
else if (early_late == EarlyLate::late())
|
|
return delay.mean() + delay.sigma(early_late);
|
|
else
|
|
internalError("unknown early/late value.");
|
|
}
|
|
|
|
float
|
|
delaySigma(const Delay &delay,
|
|
const EarlyLate *early_late)
|
|
{
|
|
return delay.sigma(early_late);
|
|
}
|
|
|
|
float
|
|
delaySigma2(const Delay &delay,
|
|
const EarlyLate *early_late)
|
|
{
|
|
return delay.sigma2(early_late);
|
|
}
|
|
|
|
const char *
|
|
delayAsString(const Delay &delay,
|
|
const Units *units,
|
|
int digits)
|
|
{
|
|
const Unit *unit = units->timeUnit();
|
|
float sigma_early = delay.sigma(EarlyLate::early());
|
|
float sigma_late = delay.sigma(EarlyLate::late());
|
|
if (fuzzyEqual(sigma_early, sigma_late))
|
|
return stringPrintTmp("%s|%s",
|
|
unit->asString(delay.mean(), digits),
|
|
unit->asString(sigma_early, digits));
|
|
else
|
|
return stringPrintTmp("%s|%s:%s",
|
|
unit->asString(delay.mean(), digits),
|
|
unit->asString(sigma_early, digits),
|
|
unit->asString(sigma_late, digits));
|
|
}
|
|
|
|
const char *
|
|
delayAsString(const Delay &delay,
|
|
const EarlyLate *early_late,
|
|
const Units *units,
|
|
int digits)
|
|
{
|
|
float mean_sigma = delayAsFloat(delay, early_late);
|
|
return units->timeUnit()->asString(mean_sigma, digits);
|
|
}
|
|
|
|
} // namespace
|
|
#endif
|