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

check slews speedup with multiple corners 

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2024-12-08 14:49:58 -08:00
parent a82361ce3d
commit c312d5b6cd
2 changed files with 173 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

256
search/CheckSlewLimits.cc
View File

@ -87,6 +87,34 @@ CheckSlewLimits::CheckSlewLimits(const StaState *sta) :
{ {
} }
void
CheckSlewLimits::checkSlewLimits(const Pin *pin,
bool violators,
const Corner *corner,
const MinMax *min_max,
PinSeq &slew_pins,
float &min_slack)
{
const Corner *corner1;
const RiseFall *rf;
Slew slew;
float limit, slack;
checkSlew(pin, corner, min_max, true, corner1, rf, slew, limit, slack);
if (!fuzzyInf(slack)) {
if (violators) {
if (slack < 0.0)
slew_pins.push_back(pin);
}
else {
if (slew_pins.empty()
|| slack < min_slack) {
slew_pins.push_back(pin);
min_slack = slack;
}
}
}
}
void void
CheckSlewLimits::checkSlew(const Pin *pin, CheckSlewLimits::checkSlew(const Pin *pin,
const Corner *corner, const Corner *corner,
@ -94,86 +122,121 @@ CheckSlewLimits::checkSlew(const Pin *pin,
bool check_clks, bool check_clks,
// Return values. // Return values.
const Corner *&corner1, const Corner *&corner1,
const RiseFall *&rf, const RiseFall *&rf1,
Slew &slew, Slew &slew1,
float &limit, float &limit1,
float &slack) const float &slack1) const
{ {
corner1 = nullptr; corner1 = nullptr;
rf = nullptr; rf1 = nullptr;
slew = 0.0; slew1 = 0.0;
limit = 0.0; limit1 = 0.0;
slack = MinMax::min()->initValue(); slack1 = MinMax::min()->initValue();
if (corner)
checkSlews1(pin, corner, min_max, check_clks, Vertex *vertex, *bidirect_drvr_vertex;
corner1, rf, slew, limit, slack); sta_->graph()->pinVertices(pin, vertex, bidirect_drvr_vertex);
else { if (vertex)
for (auto corner : *sta_->corners()) { checkSlew1(pin, vertex, corner, min_max, check_clks,
checkSlews1(pin, corner, min_max, check_clks, corner1, rf1, slew1, limit1, slack1);
corner1, rf, slew, limit, slack); if (bidirect_drvr_vertex)
checkSlew1(pin, bidirect_drvr_vertex, corner, min_max, check_clks,
corner1, rf1, slew1, limit1, slack1);
}
void
CheckSlewLimits::checkSlew1(const Pin *pin,
const Vertex *vertex,
const Corner *corner,
const MinMax *min_max,
bool check_clks,
// Return values.
const Corner *&corner1,
const RiseFall *&rf1,
Slew &slew1,
float &limit1,
float &slack1) const
{
if (!vertex->isDisabledConstraint()
&& !vertex->isConstant()
&& !sta_->clkNetwork()->isIdealClock(pin)) {
ClockSet clks;
if (check_clks)
clks = clockDomains(vertex);
if (corner)
checkSlew2(pin, vertex, corner, min_max, clks,
corner1, rf1, slew1, limit1, slack1);
else {
for (auto corner : *sta_->corners()) {
checkSlew2(pin, vertex, corner, min_max, clks,
corner1, rf1, slew1, limit1, slack1);
}
} }
} }
} }
void void
CheckSlewLimits::checkSlews1(const Pin *pin, CheckSlewLimits::checkSlew2(const Pin *pin,
const Corner *corner, const Vertex *vertex,
const MinMax *min_max, const Corner *corner,
bool check_clks, const MinMax *min_max,
// Return values. const ClockSet &clks,
const Corner *&corner1, // Return values.
const RiseFall *&rf1, const Corner *&corner1,
Slew &slew1, const RiseFall *&rf1,
float &limit1, Slew &slew1,
float &slack1) const float &limit1,
float &slack1) const
{ {
Vertex *vertex, *bidirect_drvr_vertex; for (const RiseFall *rf : RiseFall::range()) {
sta_->graph()->pinVertices(pin, vertex, bidirect_drvr_vertex); float limit;
if (vertex) bool exists;
checkSlews1(vertex, corner, min_max, check_clks, findLimit(pin, corner, rf, min_max, clks,
corner1, rf1, slew1, limit1, slack1); limit, exists);
if (bidirect_drvr_vertex) if (exists) {
checkSlews1(bidirect_drvr_vertex, corner, min_max, check_clks, checkSlew3(vertex, corner, rf, min_max, limit,
corner1, rf1, slew1, limit1, slack1); corner1, rf1, slew1, slack1, limit1);
}
}
} }
void void
CheckSlewLimits::checkSlews1(Vertex *vertex, CheckSlewLimits::checkSlew3(const Vertex *vertex,
const Corner *corner, const Corner *corner,
const MinMax *min_max, const RiseFall *rf,
bool check_clks, const MinMax *min_max,
// Return values. float limit,
const Corner *&corner1, // Return values.
const RiseFall *&rf1, const Corner *&corner1,
Slew &slew1, const RiseFall *&rf1,
float &limit1, Slew &slew1,
float &slack1) const float &slack1,
float &limit1) const
{ {
const Pin *pin = vertex->pin(); const DcalcAnalysisPt *dcalc_ap = corner->findDcalcAnalysisPt(min_max);
if (!vertex->isDisabledConstraint() Slew slew = sta_->graph()->slew(vertex, rf, dcalc_ap->index());
&& !vertex->isConstant() float slew2 = delayAsFloat(slew);
&& !sta_->clkNetwork()->isIdealClock(pin)) { float slack = (min_max == MinMax::max())
for (auto rf : RiseFall::range()) { ? limit - slew2 : slew2 - limit;
float limit; if (corner1 == nullptr
bool exists; || (slack < slack1
findLimit(pin, vertex, corner, rf, min_max, check_clks, // Break ties for the sake of regression stability.
limit, exists); || (fuzzyEqual(slack, slack1)
if (exists) { && rf->index() < rf1->index()))) {
checkSlew(vertex, corner, rf, min_max, limit, corner1 = corner;
corner1, rf1, slew1, slack1, limit1); rf1 = rf;
} slew1 = slew;
} slack1 = slack;
limit1 = limit;
} }
} }
// Return the tightest limit. // Return the tightest limit.
void void
CheckSlewLimits::findLimit(const Pin *pin, CheckSlewLimits::findLimit(const Pin *pin,
const Vertex *vertex,
const Corner *corner, const Corner *corner,
const RiseFall *rf, const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
bool check_clks, const ClockSet &clks,
// Return values. // Return values.
float &limit, float &limit,
bool &exists) const bool &exists) const
@ -186,14 +249,10 @@ CheckSlewLimits::findLimit(const Pin *pin,
float limit1; float limit1;
bool exists1; bool exists1;
if (check_clks) { if (!clks.empty()) {
// Look for clock slew limits. // Look for clock slew limits.
bool is_clk = sta_->clkNetwork()->isIdealClock(pin); bool is_clk = sta_->clkNetwork()->isIdealClock(pin);
ClockSet clks; for (Clock *clk : clks) {
clockDomains(vertex, clks);
ClockSet::Iterator clk_iter(clks);
while (clk_iter.hasNext()) {
Clock *clk = clk_iter.next();
PathClkOrData clk_data = is_clk ? PathClkOrData::clk : PathClkOrData::data; PathClkOrData clk_data = is_clk ? PathClkOrData::clk : PathClkOrData::data;
sdc->slewLimit(clk, rf, clk_data, min_max, sdc->slewLimit(clk, rf, clk_data, min_max,
limit1, exists1); limit1, exists1);
@ -284,11 +343,10 @@ CheckSlewLimits::findLimit(const LibertyPort *port,
} }
} }
void ClockSet
CheckSlewLimits::clockDomains(const Vertex *vertex, CheckSlewLimits::clockDomains(const Vertex *vertex) const
// Return value.
ClockSet &clks) const
{ {
ClockSet clks;
VertexPathIterator path_iter(const_cast<Vertex*>(vertex), sta_); VertexPathIterator path_iter(const_cast<Vertex*>(vertex), sta_);
while (path_iter.hasNext()) { while (path_iter.hasNext()) {
Path *path = path_iter.next(); Path *path = path_iter.next();
@ -296,37 +354,7 @@ CheckSlewLimits::clockDomains(const Vertex *vertex,
if (clk) if (clk)
clks.insert(const_cast<Clock*>(clk)); clks.insert(const_cast<Clock*>(clk));
} }
} return clks;
void
CheckSlewLimits::checkSlew(Vertex *vertex,
const Corner *corner,
const RiseFall *rf,
const MinMax *min_max,
float limit,
// Return values.
const Corner *&corner1,
const RiseFall *&rf1,
Slew &slew1,
float &slack1,
float &limit1) const
{
const DcalcAnalysisPt *dcalc_ap = corner->findDcalcAnalysisPt(min_max);
Slew slew = sta_->graph()->slew(vertex, rf, dcalc_ap->index());
float slew2 = delayAsFloat(slew);
float slack = (min_max == MinMax::max())
? limit - slew2 : slew2 - limit;
if (corner1 == nullptr
|| (slack < slack1
// Break ties for the sake of regression stability.
|| (fuzzyEqual(slack, slack1)
&& rf->index() < rf1->index()))) {
corner1 = corner;
rf1 = rf;
slew1 = slew;
slack1 = slack;
limit1 = limit;
}
} }
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
@ -383,32 +411,4 @@ CheckSlewLimits::checkSlewLimits(const Instance *inst,
delete pin_iter; delete pin_iter;
} }
void
CheckSlewLimits::checkSlewLimits(const Pin *pin,
bool violators,
const Corner *corner,
const MinMax *min_max,
PinSeq &slew_pins,
float &min_slack)
{
const Corner *corner1;
const RiseFall *rf;
Slew slew;
float limit, slack;
checkSlew(pin, corner, min_max, true, corner1, rf, slew, limit, slack);
if (!fuzzyInf(slack)) {
if (violators) {
if (slack < 0.0)
slew_pins.push_back(pin);
}
else {
if (slew_pins.empty()
|| slack < min_slack) {
slew_pins.push_back(pin);
min_slack = slack;
}
}
}
}
} // namespace } // namespace

85
search/CheckSlewLimits.hh
View File

@ -33,6 +33,13 @@ class CheckSlewLimits
{ {
public: public:
CheckSlewLimits(const StaState *sta); CheckSlewLimits(const StaState *sta);
// Return pins with the min/max slew limit slack.
// net=null check all nets
// corner=nullptr checks all corners.
PinSeq checkSlewLimits(const Net *net,
bool violators,
const Corner *corner,
const MinMax *min_max);
// corner=nullptr checks all corners. // corner=nullptr checks all corners.
void checkSlew(const Pin *pin, void checkSlew(const Pin *pin,
const Corner *corner, const Corner *corner,
@ -45,13 +52,6 @@ public:
Slew &slew, Slew &slew,
float &limit, float &limit,
float &slack) const; float &slack) const;
// Return pins with the min/max slew limit slack.
// net=null check all nets
// corner=nullptr checks all corners.
PinSeq checkSlewLimits(const Net *net,
bool violators,
const Corner *corner,
const MinMax *min_max);
void findLimit(const LibertyPort *port, void findLimit(const LibertyPort *port,
const Corner *corner, const Corner *corner,
const MinMax *min_max, const MinMax *min_max,
@ -60,43 +60,44 @@ public:
bool &exists) const; bool &exists) const;
protected: protected:
void checkSlews1(const Pin *pin, void checkSlew1(const Pin *pin,
const Corner *corner, const Vertex *vertex,
const MinMax *min_max, const Corner *corner,
bool check_clks, const MinMax *min_max,
// Return values. bool check_clks,
const Corner *&corner1, // Return values.
const RiseFall *&rf1, const Corner *&corner1,
Slew &slew1, const RiseFall *&rf1,
float &limit1, Slew &slew1,
float &slack1) const; float &limit1,
void checkSlews1(Vertex *vertex, float &slack1) const;
const Corner *corner, void checkSlew2(const Pin *pin,
const MinMax *min_max, const Vertex *vertex,
bool check_clks, const Corner *corner,
// Return values. const MinMax *min_max,
const Corner *&corner1, const ClockSet &clks,
const RiseFall *&rf1, // Return values.
Slew &slew1, const Corner *&corner1,
float &limit1, const RiseFall *&rf1,
float &slack1) const; Slew &slew1,
void checkSlew(Vertex *vertex, float &limit1,
const Corner *corner1, float &slack1) const;
const RiseFall *rf1, void checkSlew3(const Vertex *vertex,
const MinMax *min_max, const Corner *corner1,
float limit1, const RiseFall *rf1,
// Return values. const MinMax *min_max,
const Corner *&corner, float limit1,
const RiseFall *&rf, // Return values.
Slew &slew, const Corner *&corner,
float &slack, const RiseFall *&rf,
float &limit) const; Slew &slew,
float &slack,
float &limit) const;
void findLimit(const Pin *pin, void findLimit(const Pin *pin,
const Vertex *vertex,
const Corner *corner, const Corner *corner,
const RiseFall *rf, const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
bool check_clks, const ClockSet &clks,
// Return values. // Return values.
float &limit, float &limit,
bool &limit_exists) const; bool &limit_exists) const;
@ -112,9 +113,7 @@ protected:
const MinMax *min_max, const MinMax *min_max,
PinSeq &slew_pins, PinSeq &slew_pins,
float &min_slack); float &min_slack);
void clockDomains(const Vertex *vertex, ClockSet clockDomains(const Vertex *vertex) const;
// Return value.
ClockSet &clks) const;
const StaState *sta_; const StaState *sta_;
}; };