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

rm DelayFloatClass

This commit is contained in:
James Cherry 2019-07-19 07:27:32 -07:00
parent 90be94072b
commit ed88ddc292
2 changed files with 0 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

323
graph/DelayFloatClass.cc
View File

@ -1,323 +0,0 @@
// OpenSTA, Static Timing Analyzer
// Copyright (c) 2018, 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 "Machine.hh"
#include "Fuzzy.hh"
#include "Units.hh"
#include "StaState.hh"
#include "Delay.hh"
// Conditional compilation based on delay abstraction from Delay.hh.
#ifdef DELAY_FLOAT_CLASS
namespace sta {
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() :
delay_(0.0)
{
}
Delay::Delay(float delay) :
delay_(delay)
{
}
void
Delay::operator=(const Delay &delay)
{
delay_ = delay.delay_;
}
void
Delay::operator=(float delay)
{
delay_ = delay;
}
void
Delay::operator+=(const Delay &delay)
{
delay_ += delay.delay_;
}
void
Delay::operator+=(float delay)
{
delay_ += delay;
}
Delay
Delay::operator+(const Delay &delay) const
{
return Delay(delay_ + delay.delay_);
}
Delay
Delay::operator+(float delay) const
{
return Delay(delay_ + delay);
}
Delay
Delay::operator-(const Delay &delay) const
{
return Delay(delay_ - delay.delay_);
}
Delay
Delay::operator-(float delay) const
{
return Delay(delay_ - delay);
}
Delay
Delay::operator-() const
{
return Delay(-delay_);
}
void
Delay::operator-=(float delay)
{
delay_ -= delay;
}
bool
Delay::operator==(const Delay &delay) const
{
return delay_ == delay.delay_;
}
bool
Delay::operator>(const Delay &delay) const
{
return delay_ > delay.delay_;
}
bool
Delay::operator>=(const Delay &delay) const
{
return delay_ >= delay.delay_;
}
bool
Delay::operator<(const Delay &delay) const
{
return delay_ < delay.delay_;
}
bool
Delay::operator<=(const Delay &delay) const
{
return delay_ <= delay.delay_;
}
bool
delayIsInitValue(const Delay &delay,
const MinMax *min_max)
{
return fuzzyEqual(delayAsFloat(delay), min_max->initValue());
}
bool
delayFuzzyZero(const Delay &delay)
{
return fuzzyZero(delayAsFloat(delay));
}
bool
delayFuzzyEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyEqual(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyLess(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLess(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyLess(const Delay &delay1,
float delay2)
{
return fuzzyLess(delayAsFloat(delay1), delay2);
}
bool
delayFuzzyLessEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyLessEqual(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyLessEqual(const Delay &delay1,
float delay2)
{
return fuzzyLessEqual(delayAsFloat(delay1), delay2);
}
bool
delayFuzzyLessEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLessEqual(delayAsFloat(delay1), delayAsFloat(delay2));
else
return fuzzyGreaterEqual(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyGreater(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreater(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyGreater(const Delay &delay1,
float delay2)
{
return fuzzyGreater(delayAsFloat(delay1), delay2);
}
bool
delayFuzzyGreaterEqual(const Delay &delay1,
const Delay &delay2)
{
return fuzzyGreaterEqual(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyGreaterEqual(const Delay &delay1,
float delay2)
{
return fuzzyGreaterEqual(delayAsFloat(delay1), delay2);
}
bool
delayFuzzyGreater(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreater(delayAsFloat(delay1), delayAsFloat(delay2));
else
return fuzzyLess(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyGreaterEqual(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyGreaterEqual(delayAsFloat(delay1), delayAsFloat(delay2));
else
return fuzzyLessEqual(delayAsFloat(delay1), delayAsFloat(delay2));
}
bool
delayFuzzyLess(const Delay &delay1,
const Delay &delay2,
const MinMax *min_max)
{
if (min_max == MinMax::max())
return fuzzyLess(delayAsFloat(delay1), delayAsFloat(delay2));
else
return fuzzyGreater(delayAsFloat(delay1), delayAsFloat(delay2));
}
Delay
operator+(float delay1,
const Delay &delay2)
{
return Delay(delay1 + delayAsFloat(delay2));
}
Delay
operator-(float delay1,
const Delay &delay2)
{
return Delay(delay1 - delayAsFloat(delay2));
}
Delay
operator/(float delay1,
const Delay &delay2)
{
return Delay(delay1 / delayAsFloat(delay2));
}
Delay
operator*(const Delay &delay1,
float delay2)
{
return Delay(delayAsFloat(delay1) * delay2);
}
float
delayRatio(const Delay &delay1,
const Delay &delay2)
{
return delayAsFloat(delay1) / delayAsFloat(delay2);
}
const char *
delayAsString(const Delay &delay,
const Units *units,
int digits)
{
return units->timeUnit()->asString(delay.delay(), digits);
}
float
delayMeanSigma(const Delay &delay,
const EarlyLate *)
{
return delay.delay();
}
const char *
delayMeanSigmaString(const Delay &delay,
const EarlyLate *,
const Units *units,
int digits)
{
return units->timeUnit()->asString(delay.delay(), digits);
}
} // namespace
#endif

98
graph/DelayFloatClass.hh
View File

@ -1,98 +0,0 @@
// OpenSTA, Static Timing Analyzer
// Copyright (c) 2018, 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/>.
#ifndef STA_DELAY_FLOAT_CLASS_H
#define STA_DELAY_FLOAT_CLASS_H
#include "MinMax.hh"
namespace sta {
// Delay values defined as class objects that hold a float value.
// This is really a trial balloon for delay values as objects
// instead of simple floats.
class Delay
{
public:
Delay();
Delay(float delay);
float delay() const { return delay_; }
void operator=(const Delay &delay);
void operator=(float delay);
void operator+=(const Delay &delay);
void operator+=(float delay);
Delay operator+(const Delay &delay) const;
Delay operator+(float delay) const;
Delay operator-(const Delay &delay) const;
Delay operator-(float delay) const;
Delay operator-() const;
void operator-=(float delay);
bool operator==(const Delay &delay) const;
bool operator>(const Delay &delay) const;
bool operator>=(const Delay &delay) const;
bool operator<(const Delay &delay) const;
bool operator<=(const Delay &delay) const;
private:
float delay_;
};
const Delay delay_zero(0.0);
inline Delay
makeDelay(float delay,
float,
float)
{
return Delay(delay);
}
inline float
delayAsFloat(const Delay &delay) { return delay.delay(); }
// Most non-operator functions on Delay are not defined as member
// functions so they can be defined on floats, where there is no class
// to define them.
Delay operator+(float delay1,
const Delay &delay2);
Delay operator-(float delay1,
const Delay &delay2);
// Used for parallel gate delay calc.
Delay operator/(float delay1,
const Delay &delay2);
// Used for parallel gate delay calc.
Delay operator*(const Delay &delay2,
float delay1);
Delay operator*(const Delay &delay1,
float delay2);
bool
delayFuzzyLess(const Delay &delay1,
float delay2);
bool
delayFuzzyLessEqual(const Delay &delay1,
float delay2);
bool
delayFuzzyGreater(const Delay &delay1,
float delay2);
bool
delayFuzzyGreaterEqual(const Delay &delay1,
float delay2);
} // namespace
#endif