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

range iterators

This commit is contained in:
James Cherry 2019-07-18 06:19:00 -07:00
parent 73fb94a2dd
commit 9d93130ff2
36 changed files with 409 additions and 849 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dcalc/GraphDelayCalc.cc
View File

@ -148,9 +148,7 @@ GraphDelayCalc::minPeriod(const Pin *pin,
{
exists = false;
const MinMax *min_max = MinMax::max();
DcalcAnalysisPtIterator dcalc_ap_iter(this);
while (dcalc_ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = dcalc_ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
// Sdf annotation.
float min_period1 = 0.0;
bool exists1 = false;

68
dcalc/GraphDelayCalc1.cc
View File

@ -140,14 +140,10 @@ MultiDrvrNet::findDelaysSlews(ArcDelayCalc *arc_delay_calc,
int count = TransRiseFall::index_count * corners->dcalcAnalysisPtCount();
parallel_delays_ = new ArcDelay[count];
parallel_slews_ = new Slew[count];
DcalcAnalysisPtIterator ap_iter(dcalc);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index();
const Pvt *pvt = dcalc_ap->operatingConditions();
TransRiseFallIterator drvr_tr_iter;
while (drvr_tr_iter.hasNext()) {
TransRiseFall *drvr_tr = drvr_tr_iter.next();
for (auto drvr_tr : TransRiseFall::range()) {
int drvr_tr_index = drvr_tr->index();
int index = ap_index*TransRiseFall::index_count+drvr_tr_index;
dcalc->findMultiDrvrGateDelay(this, drvr_tr, pvt, dcalc_ap,
@ -184,16 +180,12 @@ MultiDrvrNet::findCaps(const GraphDelayCalc1 *dcalc,
int count = TransRiseFall::index_count * corners->dcalcAnalysisPtCount();
net_caps_ = new NetCaps[count];
const Pin *drvr_pin = dcalc_drvr_->pin();
DcalcAnalysisPtIterator ap_iter(dcalc);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index();
const Corner *corner = dcalc_ap->corner();
const OperatingConditions *op_cond = dcalc_ap->operatingConditions();
const MinMax *min_max = dcalc_ap->constraintMinMax();
TransRiseFallIterator drvr_tr_iter;
while (drvr_tr_iter.hasNext()) {
TransRiseFall *drvr_tr = drvr_tr_iter.next();
for (auto drvr_tr : TransRiseFall::range()) {
int drvr_tr_index = drvr_tr->index();
int index = ap_index * TransRiseFall::index_count + drvr_tr_index;
NetCaps &net_caps = net_caps_[index];
@ -593,12 +585,8 @@ GraphDelayCalc1::seedDrvrSlew(Vertex *drvr_vertex,
Port *port = network_->port(drvr_pin);
drive = sdc_->findInputDrive(port);
}
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto tr : TransRiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
if (drive) {
const MinMax *cnst_min_max = dcalc_ap->constraintMinMax();
LibertyCell *drvr_cell;
@ -697,12 +685,8 @@ GraphDelayCalc1::seedLoadSlew(Vertex *vertex)
vertex->name(sdc_network_));
ClockSet *clks = sdc_->findVertexPinClocks(pin);
initSlew(vertex);
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
const TransRiseFall *tr = tr_iter.next();
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto tr : TransRiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax();
if (!vertex->slewAnnotated(tr, slew_min_max)) {
float slew = 0.0;
@ -956,14 +940,10 @@ GraphDelayCalc1::findDriverDelays1(Vertex *drvr_vertex,
void
GraphDelayCalc1::initRootSlews(Vertex *vertex)
{
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax();
DcalcAPIndex ap_index = dcalc_ap->index();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
if (!vertex->slewAnnotated(tr, slew_min_max))
graph_->setSlew(vertex, tr, ap_index, default_slew);
}
@ -986,9 +966,7 @@ GraphDelayCalc1::findDriverEdgeDelays(LibertyCell *drvr_cell,
bool delay_changed = false;
if (related_out_port)
related_out_pin = network_->findPin(drvr_inst, related_out_port);
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
const Pvt *pvt = sdc_->pvt(drvr_inst, dcalc_ap->constraintMinMax());
if (pvt == nullptr)
pvt = dcalc_ap->operatingConditions();
@ -1027,9 +1005,7 @@ GraphDelayCalc1::loadCap(const Pin *drvr_pin,
{
const MinMax *min_max = dcalc_ap->constraintMinMax();
float load_cap = 0.0;
TransRiseFallIterator drvr_tr_iter;
while (drvr_tr_iter.hasNext()) {
TransRiseFall *drvr_tr = drvr_tr_iter.next();
for (auto drvr_tr : TransRiseFall::range()) {
Parasitic *drvr_parasitic = arc_delay_calc_->findParasitic(drvr_pin, drvr_tr,
dcalc_ap);
float cap = loadCap(drvr_pin, nullptr, drvr_parasitic, drvr_tr, dcalc_ap);
@ -1151,12 +1127,8 @@ GraphDelayCalc1::netCaps(const Pin *drvr_pin,
void
GraphDelayCalc1::initSlew(Vertex *vertex)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto tr : TransRiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax();
if (!vertex->slewAnnotated(tr, slew_min_max)) {
DcalcAPIndex ap_index = dcalc_ap->index();
@ -1176,17 +1148,13 @@ GraphDelayCalc1::initWireDelays(Vertex *drvr_vertex,
Edge *wire_edge = edge_iter.next();
if (wire_edge->isWire()) {
Vertex *load_vertex = wire_edge->to(graph_);
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *delay_min_max = dcalc_ap->delayMinMax();
const MinMax *slew_min_max = dcalc_ap->slewMinMax();
Delay delay_init_value(delay_min_max->initValue());
Slew slew_init_value(slew_min_max->initValue());
DcalcAPIndex ap_index = dcalc_ap->index();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
if (!graph_->wireDelayAnnotated(wire_edge, tr, ap_index))
graph_->setWireArcDelay(wire_edge, tr, ap_index, delay_init_value);
// Init load vertex slew.
@ -1541,9 +1509,7 @@ GraphDelayCalc1::findCheckEdgeDelays(Edge *edge,
const Pin *related_out_pin = 0;
if (related_out_port)
related_out_pin = network_->findPin(inst, related_out_port);
DcalcAnalysisPtIterator ap_iter(this);
while (ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index();
if (!graph_->arcDelayAnnotated(edge, arc, ap_index)) {
const Pvt *pvt = sdc_->pvt(inst,dcalc_ap->constraintMinMax());

9
liberty/InternalPower.cc
View File

@ -36,10 +36,7 @@ InternalPowerAttrs::~InternalPowerAttrs()
void
InternalPowerAttrs::deleteContents()
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
InternalPowerModel *model = models_[tr_index];
if (model)
delete model;
@ -80,9 +77,7 @@ InternalPower::InternalPower(LibertyCell *cell,
when_(attrs->when()),
related_pg_pin_(attrs->relatedPgPin())
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
int tr_index = tr->index();
models_[tr_index] = attrs->model(tr);
}

36
liberty/Liberty.cc
View File

@ -94,10 +94,7 @@ LibertyLibrary::LibertyLibrary(const char *name,
addTableTemplate(scalar_template, type);
}
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
wire_slew_degradation_tbls_[tr_index] = nullptr;
input_threshold_[tr_index] = input_threshold_default_;
output_threshold_[tr_index] = output_threshold_default_;
@ -114,10 +111,7 @@ LibertyLibrary::~LibertyLibrary()
scale_factors_map_.deleteContents();
delete scale_factors_;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
TableModel *model = wire_slew_degradation_tbls_[tr_index];
delete model;
}
@ -2569,10 +2563,7 @@ ScaleFactors::ScaleFactors(const char *name) :
{
for (int type = 0; type < scale_factor_type_count; type++) {
for (int pvt = 0; pvt < int(ScaleFactorPvt::count); pvt++) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
scales_[type][pvt][tr_index] = 0.0;
}
}
@ -2637,7 +2628,6 @@ ScaleFactors::print()
ScaleFactorType type = (ScaleFactorType) type_index;
printf("%10s ", scaleFactorTypeName(type));
for (int pvt_index = 0; pvt_index < int(ScaleFactorPvt::count); pvt_index++) {
TransRiseFallIterator tr_iter;
if (scaleFactorTypeRiseFallSuffix(type)
|| scaleFactorTypeRiseFallPrefix(type)
|| scaleFactorTypeLowHighSuffix(type)) {
@ -2711,14 +2701,8 @@ TestCell::setScanOutInv(LibertyPort *port)
OcvDerate::OcvDerate(const char *name) :
name_(name)
{
EarlyLateIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
int el_index = early_late->index();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto el_index : EarlyLate::rangeIndex()) {
for (auto tr_index : TransRiseFall::rangeIndex()) {
derate_[tr_index][el_index][int(PathType::clk)] = nullptr;
derate_[tr_index][el_index][int(PathType::data)] = nullptr;
}
@ -2731,14 +2715,8 @@ OcvDerate::~OcvDerate()
// Derating table models can be shared in multiple places in derate_;
// Collect them in a set to avoid duplicate deletes.
Set<Table*> models;
EarlyLateIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
int el_index = early_late->index();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto el_index : EarlyLate::rangeIndex()) {
for (auto tr_index : TransRiseFall::rangeIndex()) {
Table *derate;
derate = derate_[tr_index][el_index][int(PathType::clk)];
if (derate)

58
liberty/LibertyReader.cc
View File

@ -129,9 +129,7 @@ LibertyReader::readLibertyFile(const char *filename,
pg_port_ = nullptr;
have_resistance_unit_ = false;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
int tr_index = tr_iter.next()->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
have_input_threshold_[tr_index] = false;
have_output_threshold_[tr_index] = false;
have_slew_lower_threshold_[tr_index] = false;
@ -459,9 +457,7 @@ LibertyReader::defineScalingFactorVisitors()
ScaleFactorPvt pvt = static_cast<ScaleFactorPvt>(pvt_index);
const char *pvt_name = scaleFactorPvtName(pvt);
if (scaleFactorTypeRiseFallSuffix(type)) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
const char *tr_name = (tr == TransRiseFall::rise()) ? "rise":"fall";
const char *attr_name = stringPrintTmp("k_%s_%s_%s",
pvt_name,
@ -471,9 +467,7 @@ LibertyReader::defineScalingFactorVisitors()
}
}
else if (scaleFactorTypeRiseFallPrefix(type)) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
const char *tr_name = (tr == TransRiseFall::rise()) ? "rise":"fall";
const char *attr_name = stringPrintTmp("k_%s_%s_%s",
pvt_name,
@ -483,9 +477,7 @@ LibertyReader::defineScalingFactorVisitors()
}
}
else if (scaleFactorTypeLowHighSuffix(type)) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
const char *tr_name = (tr == TransRiseFall::rise()) ? "high":"low";
const char *attr_name = stringPrintTmp("k_%s_%s_%s",
pvt_name,
@ -617,9 +609,7 @@ LibertyReader::endLibraryAttrs(LibertyGroup *group)
}
bool missing_threshold = false;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
int tr_index = tr->index();
if (!have_input_threshold_[tr_index]) {
libWarn(group, "input_threshold_pct_%s not found.\n", tr->name());
@ -2185,9 +2175,7 @@ TimingGroup::makeTimingModels(LibertyLibrary *library,
void
TimingGroup::makeLinearModels(LibertyLibrary *library)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
int tr_index = tr->index();
float intr = intrinsic_[tr_index];
bool intr_exists = intrinsic_exists_[tr_index];
@ -2216,9 +2204,7 @@ TimingGroup::makeLinearModels(LibertyLibrary *library)
void
TimingGroup::makeTableModels(LibertyReader *visitor)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
int tr_index = tr->index();
TableModel *cell = cell_[tr_index];
TableModel *constraint = constraint_[tr_index];
@ -2644,12 +2630,8 @@ LibertyReader::endPorts()
void
LibertyReader::setPortCapDefault(LibertyPort *port)
{
MinMaxIterator min_max_iter;
while (min_max_iter.hasNext()) {
MinMax *min_max = min_max_iter.next();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto min_max : MinMax::range()) {
for (auto tr : TransRiseFall::range()) {
float cap;
bool exists;
port->capacitance(tr, min_max, cap, exists);
@ -3462,9 +3444,7 @@ LibertyReader::endTiming(LibertyGroup *)
{
if (timing_) {
// Set scale factor type in constraint tables.
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
TableModel *model = timing_->constraint(tr);
if (model) {
ScaleFactorType type=timingTypeScaleFactorType(timing_->timingType());
@ -4623,12 +4603,8 @@ void
LibertyReader::endOcvDerateFactors(LibertyGroup *)
{
if (ocv_derate_) {
EarlyLateIterator el_iter(derate_type_);
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
TransRiseFallIterator tr_iter(rf_type_);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto early_late : derate_type_->range()) {
for (auto tr : rf_type_->range()) {
if (path_type_ == PathType::clk_and_data) {
ocv_derate_->setDerateTable(tr, early_late, PathType::clk, table_);
ocv_derate_->setDerateTable(tr, early_late, PathType::data, table_);
@ -5011,10 +4987,7 @@ TimingGroup::TimingGroup(int line) :
RelatedPortGroup(line),
related_output_port_name_(nullptr)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
cell_[tr_index] = nullptr;
constraint_[tr_index] = nullptr;
transition_[tr_index] = nullptr;
@ -5023,10 +4996,7 @@ TimingGroup::TimingGroup(int line) :
resistance_[tr_index] = 0.0F;
resistance_exists_[tr_index] = false;
MinMaxIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
int el_index = early_late->index();
for (auto el_index : EarlyLate::rangeIndex()) {
delay_sigma_[tr_index][el_index] = nullptr;
slew_sigma_[tr_index][el_index] = nullptr;
constraint_sigma_[tr_index][el_index] = nullptr;

11
liberty/TableModel.cc
View File

@ -42,10 +42,7 @@ GateTableModel::GateTableModel(TableModel *delay_model,
delay_model_(delay_model),
slew_model_(slew_model)
{
MinMaxIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
int el_index = early_late->index();
for (auto el_index : EarlyLate::rangeIndex()) {
slew_sigma_models_[el_index] = slew_sigma_models[el_index];
delay_sigma_models_[el_index] = delay_sigma_models[el_index];
}
@ -348,13 +345,9 @@ CheckTableModel::CheckTableModel(TableModel *model,
TableModel *sigma_models[EarlyLate::index_count]) :
model_(model)
{
MinMaxIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *early_late = el_iter.next();
int el_index = early_late->index();
for (auto el_index : EarlyLate::rangeIndex())
sigma_models_[el_index] = sigma_models[el_index];
}
}
CheckTableModel::~CheckTableModel()
{

5
liberty/TimingArc.cc
View File

@ -188,10 +188,7 @@ TimingArcSet::init(LibertyCell *cell)
if (cell)
index_ = cell->addTimingArcSet(this);
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
from_arc1_[tr_index] = nullptr;
from_arc2_[tr_index] = nullptr;
}

188
liberty/Transition.cc
View File

@ -21,24 +21,10 @@ namespace sta {
using std::max;
TransRiseFall *TransRiseFall::rise_;
TransRiseFall *TransRiseFall::fall_;
void
TransRiseFall::init()
{
rise_ = new TransRiseFall("rise", "^", 0);
fall_ = new TransRiseFall("fall", "v", 1);;
}
void
TransRiseFall::destroy()
{
delete rise_;
rise_ = nullptr;
delete fall_;
fall_ = nullptr;
}
TransRiseFall TransRiseFall::rise_("rise", "^", 0);
TransRiseFall TransRiseFall::fall_("fall", "v", 1);
const std::array<TransRiseFall*, 2> TransRiseFall::range_{&rise_, &fall_};
const std::array<int, 2> TransRiseFall::range_index_{rise_.index(), fall_.index()};
TransRiseFall::TransRiseFall(const char *name,
const char *short_name,
@ -64,19 +50,19 @@ TransRiseFall::setShortName(const char *short_name)
TransRiseFall *
TransRiseFall::opposite() const
{
if (this == rise_)
return fall_;
if (this == &rise_)
return &fall_;
else
return rise_;
return &rise_;
}
TransRiseFall *
TransRiseFall::find(const char *tr_str)
{
if (stringEq(tr_str, rise_->name()))
return rise_;
else if (stringEq(tr_str, fall_->name()))
return fall_;
if (stringEq(tr_str, rise_.name()))
return &rise_;
else if (stringEq(tr_str, fall_.name()))
return &fall_;
else
return nullptr;
}
@ -84,16 +70,16 @@ TransRiseFall::find(const char *tr_str)
TransRiseFall *
TransRiseFall::find(int index)
{
if (index == rise_->index())
return rise_;
if (index == rise_.index())
return &rise_;
else
return fall_;
return &fall_;
}
TransRiseFallBoth *
TransRiseFall::asRiseFallBoth()
{
if (this == rise_)
if (this == &rise_)
return TransRiseFallBoth::rise();
else
return TransRiseFallBoth::fall();
@ -102,7 +88,7 @@ TransRiseFall::asRiseFallBoth()
const TransRiseFallBoth *
TransRiseFall::asRiseFallBoth() const
{
if (this == rise_)
if (this == &rise_)
return TransRiseFallBoth::rise();
else
return TransRiseFallBoth::fall();
@ -111,7 +97,7 @@ TransRiseFall::asRiseFallBoth() const
Transition *
TransRiseFall::asTransition() const
{
if (this == rise_)
if (this == &rise_)
return Transition::rise();
else
return Transition::fall();
@ -119,37 +105,33 @@ TransRiseFall::asTransition() const
////////////////////////////////////////////////////////////////
TransRiseFallBoth *TransRiseFallBoth::rise_;
TransRiseFallBoth *TransRiseFallBoth::fall_;
TransRiseFallBoth *TransRiseFallBoth::rise_fall_;
void
TransRiseFallBoth::init()
{
rise_ = new TransRiseFallBoth("rise", "^", 0, TransRiseFall::rise());
fall_ = new TransRiseFallBoth("fall", "v", 1, TransRiseFall::fall());
rise_fall_ = new TransRiseFallBoth("rise_fall", "rf", 2, nullptr);
}
void
TransRiseFallBoth::destroy()
{
delete rise_;
rise_ = nullptr;
delete fall_;
fall_ = nullptr;
delete rise_fall_;
rise_fall_ = nullptr;
}
TransRiseFallBoth TransRiseFallBoth::rise_("rise", "^", 0,
TransRiseFall::rise(),
{TransRiseFall::rise()},
{TransRiseFall::riseIndex()});
TransRiseFallBoth TransRiseFallBoth::fall_("fall", "v", 1,
TransRiseFall::fall(),
{TransRiseFall::fall()},
{TransRiseFall::fallIndex()});
TransRiseFallBoth TransRiseFallBoth::rise_fall_("rise_fall", "rf", 2,
nullptr,
{TransRiseFall::rise(),
TransRiseFall::fall()},
{TransRiseFall::riseIndex(),
TransRiseFall::fallIndex()});
TransRiseFallBoth::TransRiseFallBoth(const char *name,
const char *short_name,
int sdf_triple_index,
TransRiseFall *as_rise_fall) :
TransRiseFall *as_rise_fall,
std::vector<TransRiseFall*> range,
std::vector<int> range_index) :
name_(name),
short_name_(stringCopy(short_name)),
sdf_triple_index_(sdf_triple_index),
as_rise_fall_(as_rise_fall)
as_rise_fall_(as_rise_fall),
range_(range),
range_index_(range_index)
{
}
@ -161,12 +143,12 @@ TransRiseFallBoth::~TransRiseFallBoth()
TransRiseFallBoth *
TransRiseFallBoth::find(const char *tr_str)
{
if (stringEq(tr_str, rise_->name()))
return rise_;
else if (stringEq(tr_str, fall_->name()))
return fall_;
else if (stringEq(tr_str, rise_fall_->name()))
return rise_fall_;
if (stringEq(tr_str, rise_.name()))
return &rise_;
else if (stringEq(tr_str, fall_.name()))
return &fall_;
else if (stringEq(tr_str, rise_fall_.name()))
return &rise_fall_;
else
return nullptr;
}
@ -174,17 +156,17 @@ TransRiseFallBoth::find(const char *tr_str)
bool
TransRiseFallBoth::matches(const TransRiseFall *tr) const
{
return this == rise_fall_
return this == &rise_fall_
|| as_rise_fall_ == tr;
}
bool
TransRiseFallBoth::matches(const Transition *tr) const
{
return this == rise_fall_
|| (this == rise_
return this == &rise_fall_
|| (this == &rise_
&& tr == Transition::rise())
|| (this == fall_
|| (this == &fall_
&& tr == Transition::fall());
}
@ -197,42 +179,23 @@ TransRiseFallBoth::setShortName(const char *short_name)
////////////////////////////////////////////////////////////////
TransitionMap *Transition::transition_map_;
TransitionMap Transition::transition_map_;
int Transition::max_index_ = 0;
Transition *Transition::rise_;
Transition *Transition::fall_;
Transition *Transition::tr_0Z_;
Transition *Transition::tr_Z1_;
Transition *Transition::tr_1Z_;
Transition *Transition::tr_Z0_;
Transition *Transition::tr_0X_;
Transition *Transition::tr_X1_;
Transition *Transition::tr_1X_;
Transition *Transition::tr_X0_;
Transition *Transition::tr_XZ_;
Transition *Transition::tr_ZX_;
Transition *Transition::rise_fall_;
void
Transition::init()
{
transition_map_ = new TransitionMap;
// Sdf triple order defined on Sdf 3.0 spec, pg 3-17.
rise_ = new Transition( "^", "01", TransRiseFall::rise(), 0);
fall_ = new Transition( "v", "10", TransRiseFall::fall(), 1);
tr_0Z_ = new Transition("0Z", "0Z", TransRiseFall::rise(), 2);
tr_Z1_ = new Transition("Z1", "Z1", TransRiseFall::rise(), 3);
tr_1Z_ = new Transition("1Z", "1Z", TransRiseFall::fall(), 4);
tr_Z0_ = new Transition("Z0", "Z0", TransRiseFall::fall(), 5);
tr_0X_ = new Transition("0X", "0X", TransRiseFall::rise(), 6);
tr_X1_ = new Transition("X1", "X1", TransRiseFall::rise(), 7);
tr_1X_ = new Transition("1X", "1X", TransRiseFall::fall(), 8);
tr_X0_ = new Transition("X0", "X0", TransRiseFall::fall(), 9);
tr_XZ_ = new Transition("XZ", "XZ", nullptr, 10);
tr_ZX_ = new Transition("ZX", "ZX", nullptr, 11);
rise_fall_ = new Transition("*", "**", nullptr, -1);
}
Transition Transition::rise_{ "^", "01", TransRiseFall::rise(), 0};
Transition Transition::fall_ { "v", "10", TransRiseFall::fall(), 1};
Transition Transition::tr_0Z_{"0Z", "0Z", TransRiseFall::rise(), 2};
Transition Transition::tr_Z1_{"Z1", "Z1", TransRiseFall::rise(), 3};
Transition Transition::tr_1Z_{"1Z", "1Z", TransRiseFall::fall(), 4};
Transition Transition::tr_Z0_{"Z0", "Z0", TransRiseFall::fall(), 5};
Transition Transition::tr_0X_{"0X", "0X", TransRiseFall::rise(), 6};
Transition Transition::tr_X1_{"X1", "X1", TransRiseFall::rise(), 7};
Transition Transition::tr_1X_{"1X", "1X", TransRiseFall::fall(), 8};
Transition Transition::tr_X0_{"X0", "X0", TransRiseFall::fall(), 9};
Transition Transition::tr_XZ_{"XZ", "XZ", nullptr, 10};
Transition Transition::tr_ZX_{"ZX", "ZX", nullptr, 11};
Transition Transition::rise_fall_{"*", "**", nullptr, -1};
Transition::Transition(const char *name,
const char *init_final,
@ -243,8 +206,8 @@ Transition::Transition(const char *name,
as_rise_fall_(as_rise_fall),
sdf_triple_index_(sdf_triple_index)
{
(*transition_map_)[name_] = this;
(*transition_map_)[init_final_] = this;
transition_map_[name_] = this;
transition_map_[init_final_] = this;
max_index_ = max(sdf_triple_index, max_index_);
}
@ -253,28 +216,6 @@ Transition::~Transition()
stringDelete(name_);
}
void
Transition::destroy()
{
if (transition_map_) {
delete rise_;
delete fall_;
delete tr_0Z_;
delete tr_Z1_;
delete tr_1Z_;
delete tr_Z0_;
delete tr_0X_;
delete tr_X1_;
delete tr_1X_;
delete tr_X0_;
delete tr_XZ_;
delete tr_ZX_;
delete rise_fall_;
delete transition_map_;
transition_map_ = nullptr;
}
}
bool
Transition::matches(const Transition *tr) const
{
@ -284,7 +225,7 @@ Transition::matches(const Transition *tr) const
Transition *
Transition::find(const char *tr_str)
{
return transition_map_->findKey(tr_str);
return transition_map_.findKey(tr_str);
}
const TransRiseFallBoth *
@ -334,4 +275,3 @@ TransRiseFallIterator::next()
}
} // namespace

109
liberty/Transition.hh
View File

@ -17,6 +17,8 @@
#ifndef STA_TRANSITION_H
#define STA_TRANSITION_H
#include <array>
#include <vector>
#include "DisallowCopyAssign.hh"
#include "Iterator.hh"
#include "Map.hh"
@ -34,13 +36,11 @@ typedef Map<const char*, Transition*, CharPtrLess> TransitionMap;
class TransRiseFall
{
public:
static void init();
static void destroy();
// Singleton accessors.
static TransRiseFall *rise() { return rise_; }
static TransRiseFall *fall() { return fall_; }
static int riseIndex() { return rise_->sdf_triple_index_; }
static int fallIndex() { return fall_->sdf_triple_index_; }
static TransRiseFall *rise() { return &rise_; }
static TransRiseFall *fall() { return &fall_; }
static int riseIndex() { return rise_.sdf_triple_index_; }
static int fallIndex() { return fall_.sdf_triple_index_; }
const char *asString() const { return short_name_; }
const char *name() const { return name_; }
const char *shortName() const { return short_name_; }
@ -55,6 +55,11 @@ public:
static TransRiseFall *find(int index);
TransRiseFall *opposite() const;
// for range support.
// for (auto tr : TransRiseFall::range()) {}
static const std::array<TransRiseFall*, 2> &range() { return range_; }
// for (auto tr_index : TransRiseFall::rangeIndex()) {}
static const std::array<int, 2> &rangeIndex() { return range_index_; }
static const int index_count = 2;
static const int index_max = (index_count - 1);
static const int index_bit_count = 1;
@ -69,8 +74,10 @@ protected:
const char *short_name_;
const int sdf_triple_index_;
static TransRiseFall *rise_;
static TransRiseFall *fall_;
static TransRiseFall rise_;
static TransRiseFall fall_;
static const std::array<TransRiseFall*, 2> range_;
static const std::array<int, 2> range_index_;
private:
DISALLOW_COPY_AND_ASSIGN(TransRiseFall);
@ -80,12 +87,10 @@ private:
class TransRiseFallBoth
{
public:
static void init();
static void destroy();
// Singleton accessors.
static TransRiseFallBoth *rise() { return rise_; }
static TransRiseFallBoth *fall() { return fall_; }
static TransRiseFallBoth *riseFall() { return rise_fall_; }
static TransRiseFallBoth *rise() { return &rise_; }
static TransRiseFallBoth *fall() { return &fall_; }
static TransRiseFallBoth *riseFall() { return &rise_fall_; }
const char *asString() const { return short_name_; }
const char *name() const { return name_; }
const char *shortName() const { return short_name_; }
@ -96,6 +101,10 @@ public:
TransRiseFall *asRiseFall() const { return as_rise_fall_; }
// Find transition corresponding to string.
static TransRiseFallBoth *find(const char *tr_str);
// for (auto tr : min_max->range()) {}
const std::vector<TransRiseFall*> &range() const { return range_; }
// for (auto tr_index : min_max->rangeIndex()) {}
const std::vector<int> &rangeIndex() const { return range_index_; }
static const int index_count = 3;
static const int index_max = (index_count - 1);
@ -105,17 +114,21 @@ protected:
TransRiseFallBoth(const char *name,
const char *short_name,
int sdf_triple_index,
TransRiseFall *as_rise_fall);
TransRiseFall *as_rise_fall,
std::vector<TransRiseFall*> range,
std::vector<int> range_index);
~TransRiseFallBoth();
const char *name_;
const char *short_name_;
const int sdf_triple_index_;
TransRiseFall *as_rise_fall_;
const std::vector<TransRiseFall*> range_;
const std::vector<int> range_index_;
static TransRiseFallBoth *rise_;
static TransRiseFallBoth *fall_;
static TransRiseFallBoth *rise_fall_;
static TransRiseFallBoth rise_;
static TransRiseFallBoth fall_;
static TransRiseFallBoth rise_fall_;
private:
DISALLOW_COPY_AND_ASSIGN(TransRiseFallBoth);
@ -125,24 +138,22 @@ private:
class Transition
{
public:
static void init();
static void destroy();
// Singleton accessors.
static Transition *rise() { return rise_; }
static Transition *fall() { return fall_; }
static Transition *tr0Z() { return tr_0Z_; }
static Transition *trZ1() { return tr_Z1_; }
static Transition *tr1Z() { return tr_1Z_; }
static Transition *trZ0() { return tr_Z0_; }
static Transition *tr0X() { return tr_0X_; }
static Transition *trX1() { return tr_X1_; }
static Transition *tr1X() { return tr_1X_; }
static Transition *trX0() { return tr_X0_; }
static Transition *trXZ() { return tr_XZ_; }
static Transition *trZX() { return tr_ZX_; }
static Transition *rise() { return &rise_; }
static Transition *fall() { return &fall_; }
static Transition *tr0Z() { return &tr_0Z_; }
static Transition *trZ1() { return &tr_Z1_; }
static Transition *tr1Z() { return &tr_1Z_; }
static Transition *trZ0() { return &tr_Z0_; }
static Transition *tr0X() { return &tr_0X_; }
static Transition *trX1() { return &tr_X1_; }
static Transition *tr1X() { return &tr_1X_; }
static Transition *trX0() { return &tr_X0_; }
static Transition *trXZ() { return &tr_XZ_; }
static Transition *trZX() { return &tr_ZX_; }
void setName(const char *name);
// Matches rise and fall.
static Transition *riseFall() { return rise_fall_; }
static Transition *riseFall() { return &rise_fall_; }
const char *asString() const { return name_; }
// As initial/final value pair.
const char *asInitFinalString() const { return init_final_; }
@ -160,10 +171,6 @@ private:
const char *init_final,
TransRiseFall *as_rise_fall,
int sdf_triple_index);
~Transition();
const char *name_;
@ -171,30 +178,32 @@ private:
TransRiseFall *as_rise_fall_;
const int sdf_triple_index_;
static Transition *rise_;
static Transition *fall_;
static Transition *tr_0Z_;
static Transition *tr_Z1_;
static Transition *tr_1Z_;
static Transition *tr_Z0_;
static Transition *tr_0X_;
static Transition *tr_X1_;
static Transition *tr_1X_;
static Transition *tr_X0_;
static Transition *tr_XZ_;
static Transition *tr_ZX_;
static Transition *rise_fall_;
static Transition rise_;
static Transition fall_;
static Transition tr_0Z_;
static Transition tr_Z1_;
static Transition tr_1Z_;
static Transition tr_Z0_;
static Transition tr_0X_;
static Transition tr_X1_;
static Transition tr_1X_;
static Transition tr_X0_;
static Transition tr_XZ_;
static Transition tr_ZX_;
static Transition rise_fall_;
static const int index_count = 13;
static const int index_max = (index_count - 1);
static const int index_bit_count = 4;
static TransitionMap *transition_map_;
static TransitionMap transition_map_;
static int max_index_;
private:
DISALLOW_COPY_AND_ASSIGN(Transition);
};
// Obsolete. Use range iteration instead.
// for (auto tr : TransRiseFall::range()) {}
class TransRiseFallIterator : public Iterator<TransRiseFall*>
{
public:

4
parasitics/ConcreteParasitics.cc
View File

@ -912,9 +912,7 @@ ConcreteParasitics::deleteParasitics(const Pin *drvr_pin,
{
ConcreteParasitic **parasitics = drvr_parasitic_map_[drvr_pin];
if (parasitics) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
int ap_tr_index = parasiticAnalysisPtIndex(ap, tr);
delete parasitics[ap_tr_index];
parasitics[ap_tr_index] = nullptr;

16
sdc/Clock.cc
View File

@ -124,9 +124,7 @@ void
Clock::makeClkEdges()
{
clk_edges_ = new ClockEdge*[TransRiseFall::index_count];
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
clk_edges_[tr->index()] = new ClockEdge(this, tr);
}
}
@ -667,26 +665,18 @@ InterClockUncertainty::setUncertainty(const TransRiseFallBoth *src_tr,
const SetupHoldAll *setup_hold,
float uncertainty)
{
TransRiseFallIterator src_tr_iter(src_tr);
while (src_tr_iter.hasNext()) {
TransRiseFall *src_tr = src_tr_iter.next();
int src_tr_index = src_tr->index();
for (auto src_tr_index : src_tr->rangeIndex())
uncertainties_[src_tr_index].setValue(tgt_tr, setup_hold, uncertainty);
}
}
void
InterClockUncertainty::removeUncertainty(const TransRiseFallBoth *src_tr,
const TransRiseFallBoth *tgt_tr,
const SetupHoldAll *setup_hold)
{
TransRiseFallIterator src_tr_iter(src_tr);
while (src_tr_iter.hasNext()) {
TransRiseFall *src_tr = src_tr_iter.next();
int src_tr_index = src_tr->index();
for (auto src_tr_index : src_tr->rangeIndex())
uncertainties_[src_tr_index].removeValue(tgt_tr, setup_hold);
}
}
const RiseFallMinMax *
InterClockUncertainty::uncertainties(TransRiseFall *src_tr) const

32
sdc/ClockInsertion.cc
View File

@ -19,7 +19,8 @@
namespace sta {
ClockInsertion::ClockInsertion(const Clock *clk, const Pin *pin) :
ClockInsertion::ClockInsertion(const Clock *clk,
const Pin *pin) :
clk_(clk),
pin_(pin)
{
@ -28,17 +29,16 @@ ClockInsertion::ClockInsertion(const Clock *clk, const Pin *pin) :
void
ClockInsertion::setDelay(const TransRiseFallBoth *tr,
const MinMaxAll *min_max,
const EarlyLateAll *early_late, float delay)
const EarlyLateAll *early_late,
float delay)
{
EarlyLateIterator el_iter(early_late);
while (el_iter.hasNext()) {
EarlyLate *el = el_iter.next();
delays_[el->index()].setValue(tr, min_max, delay);
}
for (auto el_index : early_late->rangeIndex())
delays_[el_index].setValue(tr, min_max, delay);
}
float
ClockInsertion::delay(const TransRiseFall *tr, const MinMax *min_max,
ClockInsertion::delay(const TransRiseFall *tr,
const MinMax *min_max,
const EarlyLate *early_late)
{
float insertion;
@ -51,10 +51,12 @@ ClockInsertion::delay(const TransRiseFall *tr, const MinMax *min_max,
}
void
ClockInsertion::delay(const TransRiseFall *tr, const MinMax *min_max,
ClockInsertion::delay(const TransRiseFall *tr,
const MinMax *min_max,
const EarlyLate *early_late,
// Return values.
float &insertion, bool &exists)
float &insertion,
bool &exists)
{
delays_[early_late->index()].value(tr, min_max, insertion, exists);
@ -65,7 +67,8 @@ ClockInsertion::delay(const TransRiseFall *tr, const MinMax *min_max,
void
ClockInsertion::setDelay(const TransRiseFall *tr,
const MinMax *min_max,
const EarlyLate *early_late, float delay)
const EarlyLate *early_late,
float delay)
{
delays_[early_late->index()].setValue(tr, min_max, delay);
}
@ -73,11 +76,8 @@ ClockInsertion::setDelay(const TransRiseFall *tr,
void
ClockInsertion::setDelays(RiseFallMinMax *delays)
{
EarlyLateIterator el_iter;
while (el_iter.hasNext()) {
EarlyLate *el = el_iter.next();
delays_[el->index()].setValues(delays);
}
for (auto el_index : EarlyLate::rangeIndex())
delays_[el_index].setValues(delays);
}
RiseFallMinMax *

19
sdc/DataCheck.cc
View File

@ -47,35 +47,24 @@ DataCheck::setMargin(const TransRiseFallBoth *from_tr,
const SetupHoldAll *setup_hold,
float margin)
{
TransRiseFallIterator from_tr_iter(from_tr);
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr1 = from_tr_iter.next();
int from_tr_index = from_tr1->index();
for (auto from_tr_index : from_tr->rangeIndex())
margins_[from_tr_index].setValue(to_tr, setup_hold, margin);
}
}
void
DataCheck::removeMargin(const TransRiseFallBoth *from_tr,
const TransRiseFallBoth *to_tr,
const SetupHoldAll *setup_hold)
{
TransRiseFallIterator from_tr_iter(from_tr);
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr1 = from_tr_iter.next();
int from_tr_index = from_tr1->index();
for (auto from_tr_index : from_tr->rangeIndex())
margins_[from_tr_index].removeValue(to_tr, setup_hold);
}
}
bool
DataCheck::empty() const
{
TransRiseFallIterator from_tr_iter;
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr1 = from_tr_iter.next();
int from_tr_index = from_tr1->index();
if (!margins_[from_tr_index].empty())
for (auto tr_index : TransRiseFall::rangeIndex()) {
if (!margins_[tr_index].empty())
return false;
}
return true;

5
sdc/DeratingFactors.cc
View File

@ -36,12 +36,9 @@ DeratingFactors::setFactor(PathClkOrData clk_data,
const EarlyLate *early_late,
float factor)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
for (auto tr1 : tr->range())
factors_[int(clk_data)].setValue(tr1, early_late, factor);
}
}
void
DeratingFactors::factor(PathClkOrData clk_data,

39
sdc/InputDrive.cc
View File

@ -21,26 +21,17 @@ namespace sta {
InputDrive::InputDrive()
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
drive_cells_[tr->index()][mm->index()] = nullptr;
}
for (auto tr_index : TransRiseFall::rangeIndex()) {
for (auto mm_index : MinMax::rangeIndex())
drive_cells_[tr_index][mm_index] = nullptr;
}
}
InputDrive::~InputDrive()
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
InputDriveCell *drive_cell = drive_cells_[tr->index()][mm->index()];
for (auto tr_index : TransRiseFall::rangeIndex()) {
for (auto mm_index : MinMax::rangeIndex()) {
InputDriveCell *drive_cell = drive_cells_[tr_index][mm_index];
delete drive_cell;
}
}
@ -96,14 +87,8 @@ InputDrive::setDriveCell(LibertyLibrary *library,
const TransRiseFallBoth *tr,
const MinMaxAll *min_max)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto tr_index : tr->rangeIndex()) {
for (auto mm_index : min_max->rangeIndex()) {
InputDriveCell *drive = drive_cells_[tr_index][mm_index];
if (drive) {
drive->setLibrary(library);
@ -221,12 +206,8 @@ InputDriveCell::setToPort(LibertyPort *to_port)
void
InputDriveCell::setFromSlews(float *from_slews)
{
TransRiseFallIterator from_tr_iter;
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr = from_tr_iter.next();
int from_index = from_tr->index();
from_slews_[from_index] = from_slews[from_index];
}
for (auto tr_index : TransRiseFall::rangeIndex())
from_slews_[tr_index] = from_slews[tr_index];
}
bool

16
sdc/MinMaxValues.hh
View File

@ -67,10 +67,7 @@ public:
void
setValue(TYPE value)
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto mm_index : MinMax::rangeIndex()) {
values_[mm_index] = value;
exists_[mm_index] = true;
}
@ -80,10 +77,7 @@ public:
setValue(const MinMaxAll *min_max,
TYPE value)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto mm_index : min_max->rangeIndex()) {
values_[mm_index] = value;
exists_[mm_index] = true;
}
@ -142,13 +136,9 @@ public:
void
removeValue(const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto mm_index : min_max->rangeIndex())
exists_[mm_index] = false;
}
}
static bool equal(MinMaxValues *values1,
MinMaxValues *values2)

41
sdc/RiseFallMinMax.cc
View File

@ -65,14 +65,8 @@ RiseFallMinMax::setValue(const TransRiseFallBoth *tr,
const MinMaxAll *min_max,
float value)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto tr_index : tr->rangeIndex()) {
for (auto mm_index : min_max->rangeIndex()) {
values_[tr_index][mm_index] = value;
exists_[tr_index][mm_index] = true;
}
@ -84,37 +78,25 @@ RiseFallMinMax::removeValue(const TransRiseFallBoth *tr,
const MinMax *min_max)
{
int mm_index = min_max->index();
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : tr->rangeIndex())
exists_[tr_index][mm_index] = false;
}
}
void
RiseFallMinMax::removeValue(const TransRiseFallBoth *tr,
const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range())
removeValue(tr, mm);
}
}
void
RiseFallMinMax::mergeValue(const TransRiseFallBoth *tr,
const MinMaxAll *min_max,
float value)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
int tr_index = tr1->index();
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto tr_index : tr->rangeIndex()) {
for (auto mm : min_max->range()) {
int mm_index = mm->index();
if (!exists_[tr_index][mm_index]
|| mm->compare(value, values_[tr_index][mm_index])) {
@ -131,10 +113,7 @@ RiseFallMinMax::setValue(const TransRiseFallBoth *tr,
float value)
{
int mm_index = min_max->index();
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : tr->rangeIndex()) {
values_[tr_index][mm_index] = value;
exists_[tr_index][mm_index] = true;
}
@ -206,11 +185,9 @@ RiseFallMinMax::hasValue(const TransRiseFall *tr, const MinMax *min_max) const
void
RiseFallMinMax::mergeWith(RiseFallMinMax *rfmm)
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *min_max = mm_iter.next();
for (auto min_max : MinMax::range()) {
int mm_index = min_max->index();
for (int tr_index=0;tr_index<TransRiseFall::index_count;tr_index++) {
for (auto tr_index : TransRiseFall::rangeIndex()) {
bool exists1 = exists_[tr_index][mm_index];
bool exists2 = rfmm->exists_[tr_index][mm_index];
if (exists1 && exists2) {

27
sdc/RiseFallValues.cc
View File

@ -27,20 +27,13 @@ RiseFallValues::RiseFallValues()
void
RiseFallValues::clear()
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex())
exists_[tr_index] = false;
}
}
RiseFallValues::RiseFallValues(float init_value)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
values_[tr_index] = init_value;
exists_[tr_index] = true;
}
@ -53,19 +46,18 @@ RiseFallValues::setValue(float value)
}
void
RiseFallValues::setValue(const TransRiseFallBoth *tr, float value)
RiseFallValues::setValue(const TransRiseFallBoth *tr,
float value)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : tr->rangeIndex()) {
values_[tr_index] = value;
exists_[tr_index] = true;
}
}
void
RiseFallValues::setValue(const TransRiseFall *tr, float value)
RiseFallValues::setValue(const TransRiseFall *tr,
float value)
{
int tr_index = tr->index();
values_[tr_index] = value;
@ -75,10 +67,7 @@ RiseFallValues::setValue(const TransRiseFall *tr, float value)
void
RiseFallValues::setValues(RiseFallValues *values)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
int tr_index = tr->index();
for (auto tr_index : TransRiseFall::rangeIndex()) {
values_[tr_index] = values->values_[tr_index];
exists_[tr_index] = values->exists_[tr_index];
}

65
sdc/Sdc.cc
View File

@ -328,10 +328,8 @@ Sdc::deleteInstancePvts()
// Multiple instances can share a pvt, so put them in a set
// so they are only deleted once.
PvtSet pvts;
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
InstancePvtMap *pvt_map = instance_pvt_maps_[mm->index()];
for (auto mm_index : MinMax::rangeIndex()) {
InstancePvtMap *pvt_map = instance_pvt_maps_[mm_index];
InstancePvtMap::Iterator pvt_iter(pvt_map);
while (pvt_iter.hasNext()) {
Pvt *pvt = pvt_iter.next();
@ -416,11 +414,8 @@ Sdc::removeLibertyAnnotations()
void
Sdc::initInstancePvtMaps()
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
instance_pvt_maps_[mm->index()] = nullptr;
}
for (auto mm_index : MinMax::rangeIndex())
instance_pvt_maps_[mm_index] = nullptr;
}
////////////////////////////////////////////////////////////////
@ -516,13 +511,9 @@ void
Sdc::setOperatingConditions(OperatingConditions *op_cond,
const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
int mm_index = mm->index();
for (auto mm_index : min_max->rangeIndex())
operating_conditions_[mm_index] = op_cond;
}
}
void
Sdc::setOperatingConditions(OperatingConditions *op_cond,
@ -555,9 +546,7 @@ Sdc::setPvt(Instance *inst, const
MinMaxAll *min_max,
Pvt *pvt)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
int mm_index = mm_iter.next()->index();
for (auto mm_index : min_max->rangeIndex()) {
InstancePvtMap *pvt_map = instance_pvt_maps_[mm_index];
if (pvt_map == nullptr) {
pvt_map = new InstancePvtMap;
@ -2691,11 +2680,8 @@ void
Sdc::setMinPulseWidth(const TransRiseFallBoth *tr,
float min_width)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
min_pulse_width_.setValue(tr, min_width);
}
for (auto tr1 : tr->range())
min_pulse_width_.setValue(tr1, min_width);
}
void
@ -2708,11 +2694,8 @@ Sdc::setMinPulseWidth(const Pin *pin,
widths = new RiseFallValues;
pin_min_pulse_width_map_[pin] = widths;
}
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
widths->setValue(tr, min_width);
}
for (auto tr1 : tr->range())
widths->setValue(tr1, min_width);
}
void
@ -2725,11 +2708,8 @@ Sdc::setMinPulseWidth(const Instance *inst,
widths = new RiseFallValues;
inst_min_pulse_width_map_[inst] = widths;
}
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
widths->setValue(tr, min_width);
}
for (auto tr1 : tr->range())
widths->setValue(tr1, min_width);
}
void
@ -2742,11 +2722,8 @@ Sdc::setMinPulseWidth(const Clock *clk,
widths = new RiseFallValues;
clk_min_pulse_width_map_[clk] = widths;
}
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
widths->setValue(tr, min_width);
}
for (auto tr1 : tr->range())
widths->setValue(tr1, min_width);
}
void
@ -5905,11 +5882,8 @@ void
Sdc::setWireload(Wireload *wireload,
const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
wireload_[mm->index()] = wireload;
}
for (auto mm_index : min_max->rangeIndex())
wireload_[mm_index] = wireload;
}
void
@ -5946,11 +5920,8 @@ void
Sdc::setWireloadSelection(WireloadSelection *selection,
const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
wireload_selection_[mm->index()] = selection;
}
for (auto mm_index : min_max->rangeIndex())
wireload_selection_[mm_index] = selection;
}
////////////////////////////////////////////////////////////////

54
sdc/WriteSdc.cc
View File

@ -687,15 +687,9 @@ writeInterClockUncertainty(InterClockUncertainty *uncertainty) const
fprintf(stream_, "\n");
}
else {
TransRiseFallIterator src_tr_iter;
while (src_tr_iter.hasNext()) {
const TransRiseFall *src_tr = src_tr_iter.next();
TransRiseFallIterator tgt_tr_iter;
while (tgt_tr_iter.hasNext()) {
const TransRiseFall *tgt_tr = tgt_tr_iter.next();
MinMaxIterator sh_iter;
while (sh_iter.hasNext()) {
const SetupHold *setup_hold = sh_iter.next();
for (auto src_tr : TransRiseFall::range()) {
for (auto tgt_tr : TransRiseFall::range()) {
for (auto setup_hold : SetupHold::range()) {
float value;
bool exists;
sdc_->clockUncertainty(src_clk, src_tr, tgt_clk, tgt_tr,
@ -1500,9 +1494,7 @@ WriteSdc::writeDataChecks() const
void
WriteSdc::writeDataCheck(DataCheck *check) const
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
SetupHold *setup_hold = mm_iter.next();
for (auto setup_hold : SetupHold::range()) {
float margin;
bool one_value;
check->marginIsOneValue(setup_hold, margin, one_value);
@ -1510,12 +1502,8 @@ WriteSdc::writeDataCheck(DataCheck *check) const
writeDataCheck(check, TransRiseFallBoth::riseFall(),
TransRiseFallBoth::riseFall(), setup_hold, margin);
else {
TransRiseFallIterator from_tr_iter;
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr = from_tr_iter.next();
TransRiseFallIterator to_tr_iter;
while (to_tr_iter.hasNext()) {
TransRiseFall *to_tr = to_tr_iter.next();
for (auto from_tr : TransRiseFall::range()) {
for (auto to_tr : TransRiseFall::range()) {
float margin;
bool margin_exists;
check->margin(from_tr, to_tr, setup_hold, margin, margin_exists);
@ -1627,9 +1615,7 @@ WriteSdc::writeDriveResistances() const
Port *port = port_iter->next();
InputDrive *drive = sdc_->findInputDrive(port);
if (drive) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
const TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
if (drive->driveResistanceMinMaxEqual(tr)) {
float res;
bool exists;
@ -1642,16 +1628,14 @@ WriteSdc::writeDriveResistances() const
fprintf(stream_, "\n");
}
else {
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
const MinMax *mm = mm_iter.next();
for (auto min_max : MinMax::range()) {
float res;
bool exists;
drive->driveResistance(tr, mm, res, exists);
drive->driveResistance(tr, min_max, res, exists);
if (exists) {
fprintf(stream_, "set_drive %s %s ",
transRiseFallFlag(tr),
minMaxFlag(mm));
minMaxFlag(min_max));
writeResistance(res);
fprintf(stream_, " ");
writeGetPort(port);
@ -1929,9 +1913,7 @@ WriteSdc::writeDeratings() const
DeratingFactorsNet *factors;
net_iter.next(net, factors);
WriteGetNet write_net(net, this);
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
const MinMax *early_late = mm_iter.next();
for (auto early_late : EarlyLate::range()) {
writeDerating(factors, TimingDerateType::net_delay, early_late,
&write_net);
}
@ -1959,10 +1941,7 @@ WriteSdc::writeDeratings() const
void
WriteSdc::writeDerating(DeratingFactorsGlobal *factors) const
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
const MinMax *early_late = mm_iter.next();
for (auto early_late : EarlyLate::range()) {
bool delay_is_one_value, check_is_one_value, net_is_one_value;
float delay_value, check_value, net_value;
factors->factors(TimingDerateType::cell_delay)->isOneValue(early_late,
@ -2001,9 +1980,7 @@ void
WriteSdc::writeDerating(DeratingFactorsCell *factors,
WriteSdcObject *write_obj) const
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
const MinMax *early_late = mm_iter.next();
for (auto early_late : EarlyLate::range()) {
DeratingFactors *delay_factors=factors->factors(TimingDerateType::cell_delay);
writeDerating(delay_factors, TimingDerateType::cell_delay, early_late, write_obj);
DeratingFactors *check_factors=factors->factors(TimingDerateType::cell_check);
@ -2057,10 +2034,7 @@ WriteSdc::writeDerating(DeratingFactors *factors,
}
}
else {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
MinMaxIterator mm_iter;
for (auto tr : TransRiseFall::range()) {
float factor;
bool exists;
factors->factor(clk_data, tr, early_late, factor, exists);

8
sdf/ReportAnnotation.cc
View File

@ -403,9 +403,7 @@ ReportAnnotated::findWidthPeriodCount(Pin *pin)
int width_index = TimingRole::width()->index();
if (report_role_[width_index]) {
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *hi_low = tr_iter.next();
for (auto hi_low : TransRiseFall::range()) {
port->minPulseWidth(hi_low, value, exists);
if (exists) {
edge_count_[width_index]++;
@ -559,9 +557,7 @@ ReportAnnotated::reportWidthPeriodArcs(Pin *pin,
if (report_role_[width_index]
&& (max_lines_ == 0 || i < max_lines_)) {
bool report = false;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *hi_low = tr_iter.next();
for (auto hi_low : TransRiseFall::range()) {
port->minPulseWidth(hi_low, value, exists);
if (exists) {
edge_count_[width_index]++;

4
sdf/SdfWriter.cc
View File

@ -503,9 +503,7 @@ SdfWriter::writeTimingChecks(const Instance *inst,
writeCheck(edge, sdf_check);
}
}
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *hi_low = tr_iter.next();
for (auto hi_low : TransRiseFall::range()) {
float min_width, max_width;
bool exists;
graph_delay_calc_->minPulseWidth(pin, hi_low, arc_delay_min_index_,

10
search/CheckSlewLimits.cc
View File

@ -116,10 +116,8 @@ CheckSlewLimits::checkSlews(const Pin *pin,
checkSlews1(pin, corner, min_max,
corner1, tr, slew, limit, slack);
else {
CornerIterator corner_iter(sta_);
while (corner_iter.hasNext()) {
const Corner *corner2 = corner_iter.next();
checkSlews1(pin, corner2, min_max,
for (auto corner : *sta_->corners()) {
checkSlews1(pin, corner, min_max,
corner1, tr, slew, limit, slack);
}
}
@ -156,9 +154,7 @@ CheckSlewLimits::checkSlews1(Vertex *vertex,
float &limit,
float &slack) const
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
for (auto tr1 : TransRiseFall::range()) {
float limit1;
bool limit1_exists;
findLimit(vertex->pin(), vertex, tr1, min_max, limit1, limit1_exists);

29
search/Corner.cc
View File

@ -124,14 +124,12 @@ Corners::makeParasiticAnalysisPtsMinMax()
parasitics_->deleteParasitics();
parasitic_analysis_pts_.deleteContentsClear();
parasitic_analysis_pts_.resize(MinMax::index_count);
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *min_max = mm_iter.next();
int index = min_max->index();
for (auto min_max : MinMax::range()) {
int mm_index = min_max->index();
ParasiticAnalysisPt *ap = new ParasiticAnalysisPt(min_max->asString(),
index,
mm_index,
min_max);
parasitic_analysis_pts_[index] = ap;
parasitic_analysis_pts_[mm_index] = ap;
}
updateCornerParasiticAnalysisPts();
}
@ -461,25 +459,6 @@ CornerIterator::next()
////////////////////////////////////////////////////////////////
ParasiticAnalysisPtIterator::ParasiticAnalysisPtIterator(const StaState *sta) :
ap_iter_(sta->corners()->parasiticAnalysisPts())
{
}
bool
ParasiticAnalysisPtIterator::hasNext()
{
return ap_iter_.hasNext();
}
ParasiticAnalysisPt *
ParasiticAnalysisPtIterator::next()
{
return ap_iter_.next();
}
////////////////////////////////////////////////////////////////
DcalcAnalysisPtIterator::DcalcAnalysisPtIterator(const StaState *sta) :
ap_iter_(sta->corners()->dcalcAnalysisPts())
{

28
search/Corner.hh
View File

@ -68,6 +68,11 @@ public:
PathAnalysisPt *findPathAnalysisPt(PathAPIndex path_index) const;
PathAnalysisPtSeq &pathAnalysisPts();
const PathAnalysisPtSeq &pathAnalysisPts() const;
CornerSeq &corners() { return corners_; }
// Iterators for range iteration.
// for (auto corner : *sta->corners()) {}
CornerSeq::iterator begin() { return corners_.begin(); }
CornerSeq::iterator end() { return corners_.end(); }
protected:
void makeAnalysisPts();
@ -81,7 +86,6 @@ protected:
bool swap_clk_min_max,
DcalcAnalysisPt *dcalc_ap_min,
DcalcAnalysisPt *dcalc_ap_max);
CornerSeq &corners() { return corners_; }
private:
CornerMap corner_map_;
@ -90,7 +94,6 @@ private:
DcalcAnalysisPtSeq dcalc_analysis_pts_;
PathAnalysisPtSeq path_analysis_pts_;
friend class CornerIterator;
DISALLOW_COPY_AND_ASSIGN(Corners);
};
@ -130,6 +133,8 @@ private:
DISALLOW_COPY_AND_ASSIGN(Corner);
};
// Obsolete. Use range iterator.
// for (auto corner : *sta->corners()) {}
class CornerIterator : public Iterator<Corner*>
{
public:
@ -145,21 +150,8 @@ private:
DISALLOW_COPY_AND_ASSIGN(CornerIterator);
};
class ParasiticAnalysisPtIterator : public Iterator<ParasiticAnalysisPt*>
{
public:
explicit ParasiticAnalysisPtIterator(const StaState *sta);
virtual ~ParasiticAnalysisPtIterator() {}
virtual bool hasNext();
virtual ParasiticAnalysisPt *next();
protected:
ParasiticAnalysisPtSeq::ConstIterator ap_iter_;
private:
DISALLOW_COPY_AND_ASSIGN(ParasiticAnalysisPtIterator);
};
// Obsolete. Use range iterator.
// for (auto dcalc_ap : sta->corners()->dcalcAnalysisPts()) {}
class DcalcAnalysisPtIterator : public Iterator<DcalcAnalysisPt*>
{
public:
@ -175,6 +167,8 @@ private:
DISALLOW_COPY_AND_ASSIGN(DcalcAnalysisPtIterator);
};
// Obsolete. Use range iterator.
// for (auto path_ap : sta->corners()->pathAnalysisPts()) {}
class PathAnalysisPtIterator : public Iterator<PathAnalysisPt*>
{
public:

16
search/Genclks.cc
View File

@ -727,14 +727,10 @@ Genclks::seedSrcPins(Clock *gclk,
TagGroupBldr tag_bldr(true, this);
tag_bldr.init(vertex);
copyGenClkSrcPaths(vertex, &tag_bldr);
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *min_max = path_ap->pathMinMax();
const EarlyLate *early_late = min_max;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
Tag *tag = makeTag(gclk, master_clk, master_pin, tr, src_filter,
path_ap);
Arrival insert = search_->clockInsertion(master_clk, master_pin, tr,
@ -1147,12 +1143,8 @@ Genclks::seedPllPin(const Clock *gclk,
TagGroupBldr tag_bldr(true, this);
tag_bldr.init(vertex);
copyGenClkSrcPaths(vertex, &tag_bldr);
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
for (auto tr : TransRiseFall::range()) {
Tag *tag = makeTag(gclk, gclk, pll_out_pin, tr, pll_filter, path_ap);
tag_bldr.setArrival(tag, 0.0, nullptr);
}

17
search/PathGroup.cc
View File

@ -325,10 +325,7 @@ PathGroups::makeGroups(int group_count,
PathGroups::~PathGroups()
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *min_max = mm_iter.next();
int mm_index = min_max->index();
for (auto mm_index : MinMax::rangeIndex()) {
named_map_[mm_index].deleteContents();
clk_map_[mm_index].deleteContents();
delete path_delay_[mm_index];
@ -425,9 +422,7 @@ PathGroups::groupPathTo(const PathEnd *path_end) const
void
PathGroups::pushGroupPathEnds(PathEndSeq *path_ends)
{
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
MinMax *min_max = mm_iter.next();
for (auto min_max : MinMax::range()) {
int mm_index = min_max->index();
GroupPathIterator group_path_iter(sdc_);
while (group_path_iter.hasNext()) {
@ -465,9 +460,7 @@ PathGroups::pushUnconstrainedPathEnds(PathEndSeq *path_ends,
const MinMaxAll *min_max)
{
Set<PathGroup *> groups;
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *path_min_max = path_ap->pathMinMax();
if (min_max->matches(path_min_max)) {
int mm_index = path_min_max->index();
@ -744,9 +737,7 @@ PathGroups::makeGroupPathEnds(ExceptionTo *to,
MakePathEndsAll make_path_ends(endpoint_count, this);
makeGroupPathEnds(to, corner, min_max, &make_path_ends);
MinMaxIterator mm_iter;
while (mm_iter.hasNext()) {
const MinMax *path_min_max = mm_iter.next();
for (auto path_min_max : MinMax::range()) {
int mm_index = path_min_max->index();
GroupPathIterator group_path_iter(sdc_);
while (group_path_iter.hasNext()) {

4
search/Power.cc
View File

@ -590,9 +590,7 @@ Power::findInternalPower(const Pin *to_pin,
else
duty = 0.5;
float port_energy = 0.0;
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *to_tr = tr_iter.next();
for (auto to_tr : TransRiseFall::range()) {
// Should use unateness to find from_tr.
TransRiseFall *from_tr = to_tr;
float slew = delayAsFloat(graph_->slew(from_vertex,

4
search/Property.cc
View File

@ -863,9 +863,7 @@ edgeDelayProperty(Edge *edge,
TimingArc *arc = arc_iter.next();
TransRiseFall *to_tr = arc->toTrans()->asRiseFall();
if (to_tr == tr) {
CornerIterator corner_iter(sta);
while (corner_iter.hasNext()) {
Corner *corner = corner_iter.next();
for (auto corner : *sta->corners()) {
DcalcAnalysisPt *dcalc_ap = corner->findDcalcAnalysisPt(min_max);
ArcDelay arc_delay = sta->arcDelay(edge, arc, dcalc_ap);
if (!delay_exists

32
search/Search.cc
View File

@ -1483,13 +1483,9 @@ Search::seedClkArrivals(const Pin *pin,
for (auto clk : *sdc_->findVertexPinClocks(pin)) {
debugPrint2(debug_, "search", 2, "arrival seed clk %s pin %s\n",
clk->name(), network_->pathName(pin));
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *min_max = path_ap->pathMinMax();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
ClockEdge *clk_edge = clk->edge(tr);
const EarlyLate *early_late = min_max;
if (clk->isGenerated()
@ -1606,13 +1602,9 @@ Search::makeUnclkedPaths(Vertex *vertex,
{
bool search_from = false;
const Pin *pin = vertex->pin();
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *min_max = path_ap->pathMinMax();
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
Tag *tag = fromUnclkedInputTag(pin, tr, min_max, path_ap,
is_segment_start);
if (tag) {
@ -1781,9 +1773,7 @@ Search::seedInputDelayArrival(const Pin *pin,
clk_edge = sdc_->defaultArrivalClockEdge();
if (ref_pin) {
Vertex *ref_vertex = graph_->pinLoadVertex(ref_pin);
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *min_max = path_ap->pathMinMax();
TransRiseFall *ref_tr = input_delay->refTransition();
const Clock *clk = input_delay->clock();
@ -1804,9 +1794,7 @@ Search::seedInputDelayArrival(const Pin *pin,
}
}
else {
PathAnalysisPtIterator path_ap_iter(this);
while (path_ap_iter.hasNext()) {
PathAnalysisPt *path_ap = path_ap_iter.next();
for (auto path_ap : corners_->pathAnalysisPts()) {
const MinMax *min_max = path_ap->pathMinMax();
float clk_arrival, clk_insertion, clk_latency;
inputDelayClkArrival(input_delay, clk_edge, min_max, path_ap,
@ -1859,9 +1847,7 @@ Search::seedInputDelayArrival(const Pin *pin,
PathAnalysisPt *path_ap,
TagGroupBldr *tag_bldr)
{
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
for (auto tr : TransRiseFall::range()) {
if (input_delay) {
float delay;
bool exists;
@ -3671,9 +3657,7 @@ Search::totalNegativeSlack(const MinMax *min_max)
{
tnsPreamble();
Slack tns = 0.0;
CornerIterator corner_iter(this);
while (corner_iter.hasNext()) {
Corner *corner = corner_iter.next();
for (auto corner : *corners_) {
PathAPIndex path_ap_index = corner->findPathAnalysisPt(min_max)->index();
Slack tns1 = tns_[path_ap_index];
if (tns1 < tns)

68
search/Sta.cc
View File

@ -224,11 +224,6 @@ void
initSta()
{
initElapsedTime();
MinMax::init();
MinMaxAll::init();
TransRiseFall::init();
TransRiseFallBoth::init();
Transition::init();
TimingRole::init();
PortDirection::init();
initTmpStrings();
@ -251,11 +246,6 @@ deleteAllMemory()
}
deleteDelayCalcs();
deleteTmpStrings();
MinMax::destroy();
MinMaxAll::destroy();
TransRiseFall::destroy();
TransRiseFallBoth::destroy();
Transition::destroy();
TimingRole::destroy();
PortDirection::destroy();
deleteLiberty();
@ -3060,9 +3050,7 @@ Sta::vertexSlew(Vertex *vertex,
{
findDelays(vertex);
Slew mm_slew = min_max->initValue();
DcalcAnalysisPtIterator dcalc_ap_iter(this);
while (dcalc_ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = dcalc_ap_iter.next();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) {
Slew slew = graph_->slew(vertex, tr, dcalc_ap->index());
if (fuzzyGreater(slew, mm_slew, min_max))
mm_slew = slew;
@ -3214,9 +3202,7 @@ Sta::setArcDelay(Edge *edge,
const MinMaxAll *min_max,
ArcDelay delay)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range()) {
const DcalcAnalysisPt *dcalc_ap = corner->findDcalcAnalysisPt(mm);
DcalcAPIndex ap_index = dcalc_ap->index();
graph_->setArcDelay(edge, arc, ap_index, delay);
@ -3238,14 +3224,10 @@ Sta::setAnnotatedSlew(Vertex *vertex,
const TransRiseFallBoth *tr,
float slew)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range()) {
const DcalcAnalysisPt *dcalc_ap = corner->findDcalcAnalysisPt(mm);
DcalcAPIndex ap_index = dcalc_ap->index();
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
for (auto tr1 : tr->range()) {
graph_->setSlew(vertex, tr1, ap_index, slew);
// Don't let delay calculation clobber the value.
vertex->setSlewAnnotated(true, tr1, ap_index);
@ -3307,12 +3289,8 @@ Sta::setPortExtPinCap(Port *port,
const MinMaxAll *min_max,
float cap)
{
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto tr1 : tr->range()) {
for (auto mm : min_max->range()) {
sdc_->setPortExtPinCap(port, tr1, mm, cap);
}
}
@ -3345,12 +3323,8 @@ Sta::setPortExtWireCap(Port *port,
float cap)
{
Corner *corner = cmd_corner_;
TransRiseFallIterator tr_iter(tr);
while (tr_iter.hasNext()) {
TransRiseFall *tr1 = tr_iter.next();
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto tr1 : tr->range()) {
for (auto mm : min_max->range()) {
sdc_->setPortExtWireCap(port, subtract_pin_cap, tr1, corner, mm, cap);
}
}
@ -3376,11 +3350,8 @@ Sta::setPortExtFanout(Port *port,
int fanout,
const MinMaxAll *min_max)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range())
sdc_->setPortExtFanout(port, mm, fanout);
}
delaysInvalidFromFanin(port);
}
@ -3391,11 +3362,8 @@ Sta::setNetWireCap(Net *net,
const MinMaxAll *min_max,
float cap)
{
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range())
sdc_->setNetWireCap(net, subtract_pin_cap, corner, mm, cap);
}
delaysInvalidFromFanin(net);
}
@ -3540,9 +3508,7 @@ Sta::makePiElmore(Pin *drvr_pin,
float c1)
{
Corner *corner = cmd_corner_;
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range()) {
ParasiticAnalysisPt *ap = corner->findParasiticAnalysisPt(mm);
parasitics_->makePiElmore(drvr_pin, tr, ap, c2, rpi, c1);
}
@ -3576,9 +3542,7 @@ Sta::setElmore(Pin *drvr_pin,
float elmore)
{
Corner *corner = cmd_corner_;
MinMaxIterator mm_iter(min_max);
while (mm_iter.hasNext()) {
MinMax *mm = mm_iter.next();
for (auto mm : min_max->range()) {
const ParasiticAnalysisPt *ap = corner->findParasiticAnalysisPt(mm);
Parasitic *pi_elmore = parasitics_->findPiElmore(drvr_pin, tr, ap);
if (pi_elmore)
@ -4724,12 +4688,8 @@ InstanceMaxSlewGreater::instMaxSlew(const Instance *inst) const
Pin *pin = pin_iter->next();
if (network->isDriver(pin)) {
Vertex *vertex = graph->pinDrvrVertex(pin);
TransRiseFallIterator tr_iter;
while (tr_iter.hasNext()) {
TransRiseFall *tr = tr_iter.next();
DcalcAnalysisPtIterator dcalc_ap_iter(sta_);
while (dcalc_ap_iter.hasNext()) {
DcalcAnalysisPt *dcalc_ap = dcalc_ap_iter.next();
for (auto tr : TransRiseFall::range()) {
for (auto dcalc_ap : sta_->corners()->dcalcAnalysisPts()) {
Slew slew = graph->slew(vertex, tr, dcalc_ap->index());
if (slew > max_slew)
max_slew = slew;

4
search/VisitPathEnds.cc
View File

@ -505,9 +505,7 @@ VisitPathEnds::visitDataCheckEnd(const Pin *pin,
DataCheck *check = check_iter.next();
const Pin *from_pin = check->from();
Vertex *from_vertex = graph_->pinLoadVertex(from_pin);
TransRiseFallIterator from_tr_iter;
while (from_tr_iter.hasNext()) {
TransRiseFall *from_tr = from_tr_iter.next();
for (auto from_tr : TransRiseFall::range()) {
float margin;
bool margin_exists;
check->margin(from_tr, end_tr, min_max, margin, margin_exists);

4
search/WorstSlack.cc
View File

@ -42,9 +42,7 @@ WorstSlacks::worstSlack(const MinMax *min_max,
{
worst_slack = MinMax::min()->initValue();
worst_vertex = nullptr;
CornerIterator corner_iter(sta_);
while (corner_iter.hasNext()) {
Corner *corner = corner_iter.next();
for (auto corner : *sta_->corners()) {
PathAPIndex path_ap_index = corner->findPathAnalysisPt(min_max)->index();
Slack worst_slack1;
Vertex *worst_vertex1;

28
tcl/StaTcl.i
View File

@ -5718,9 +5718,7 @@ arrivals_clk(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
floats->push_back(delayAsFloat(sta->vertexArrival(self, tr, clk_edge,
path_ap)));
}
@ -5738,9 +5736,7 @@ arrivals_clk_delays(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
arrivals->push_back(delayAsString(sta->vertexArrival(self, tr, clk_edge,
path_ap),
sta, digits));
@ -5758,9 +5754,7 @@ requireds_clk(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
floats->push_back(delayAsFloat(sta->vertexRequired(self, tr, clk_edge,
path_ap)));
}
@ -5778,9 +5772,7 @@ requireds_clk_delays(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
requireds->push_back(delayAsString(sta->vertexRequired(self, tr, clk_edge,
path_ap),
sta, digits));
@ -5793,9 +5785,7 @@ slacks(TransRiseFall *tr)
{
Sta *sta = Sta::sta();
TmpFloatSeq *floats = new FloatSeq;
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
floats->push_back(delayAsFloat(sta->vertexSlack(self, tr, path_ap)));
}
return floats;
@ -5812,9 +5802,7 @@ slacks_clk(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
floats->push_back(delayAsFloat(sta->vertexSlack(self, tr, clk_edge,
path_ap)));
}
@ -5832,9 +5820,7 @@ slacks_clk_delays(const TransRiseFall *tr,
const ClockEdge *clk_edge = nullptr;
if (clk)
clk_edge = clk->edge(clk_tr);
PathAnalysisPtIterator ap_iter(sta);
while (ap_iter.hasNext()) {
PathAnalysisPt *path_ap = ap_iter.next();
for (auto path_ap : sta->corners()->pathAnalysisPts()) {
slacks->push_back(delayAsString(sta->vertexSlack(self, tr, clk_edge,
path_ap),
sta, digits));

88
util/MinMax.cc
View File

@ -39,24 +39,10 @@ compareMax(float value1,
////////////////////////////////////////////////////////////////
MinMax *MinMax::min_;
MinMax *MinMax::max_;
void
MinMax::init()
{
min_ = new MinMax("min", 0, INF, compareMin);
max_ = new MinMax("max", 1, -INF, compareMax);
}
void
MinMax::destroy()
{
delete min_;
min_ = nullptr;
delete max_;
max_ = nullptr;
}
MinMax MinMax::min_("min", 0, INF, compareMin);
MinMax MinMax::max_("max", 1, -INF, compareMax);
const std::array<MinMax*, 2> MinMax::range_{&min_, &max_};
const std::array<int, 2> MinMax::range_index_{min_.index(), max_.index()};
MinMax::MinMax(const char *name,
int index,
@ -72,7 +58,7 @@ MinMax::MinMax(const char *name,
MinMaxAll *
MinMax::asMinMaxAll() const
{
if (this == min_)
if (this == &min_)
return MinMaxAll::min();
else
return MinMaxAll::max();
@ -81,10 +67,10 @@ MinMax::asMinMaxAll() const
MinMax *
MinMax::opposite() const
{
if (this == max_)
return min_;
if (this == &max_)
return &min_;
else
return max_;
return &max_;
}
MinMax *
@ -92,10 +78,10 @@ MinMax::find(const char *min_max)
{
if (stringEq(min_max, "min")
|| stringEq(min_max, "early"))
return min();
return &min_;
else if (stringEq(min_max, "max")
|| stringEq(min_max, "late"))
return max();
return &max_;
else
return nullptr;
}
@ -103,10 +89,10 @@ MinMax::find(const char *min_max)
MinMax *
MinMax::find(int index)
{
if (index == min_->index())
return min();
else if (index == max_->index())
return max();
if (index == min_.index())
return &min_;
else if (index == max_.index())
return &max_;
else
return nullptr;
}
@ -120,40 +106,26 @@ MinMax::compare(float value1,
////////////////////////////////////////////////////////////////
MinMaxAll *MinMaxAll::min_;
MinMaxAll *MinMaxAll::max_;
MinMaxAll *MinMaxAll::all_;
void
MinMaxAll::init()
{
min_ = new MinMaxAll("min", 0);
max_ = new MinMaxAll("max", 1);
all_ = new MinMaxAll("all", 2);
}
void
MinMaxAll::destroy()
{
delete min_;
min_ = nullptr;
delete max_;
max_ = nullptr;
delete all_;
all_ = nullptr;
}
MinMaxAll MinMaxAll::min_("min", 0, {MinMax::min()}, {MinMax::min()->index()});
MinMaxAll MinMaxAll::max_("max", 1, {MinMax::max()}, {MinMax::max()->index()});
MinMaxAll MinMaxAll::all_("all", 2, {MinMax::min(), MinMax::max()},
{MinMax::min()->index(), MinMax::max()->index()});
MinMaxAll::MinMaxAll(const char *name,
int index) :
int index,
std::vector<MinMax*> range,
std::vector<int> range_index) :
name_(name),
index_(index)
index_(index),
range_(range),
range_index_(range_index)
{
}
MinMax *
MinMaxAll::asMinMax() const
{
if (this == min_)
if (this == &min_)
return MinMax::min();
else
return MinMax::max();
@ -162,13 +134,13 @@ MinMaxAll::asMinMax() const
bool
MinMaxAll::matches(const MinMax *min_max) const
{
return this == all_ || asMinMax() == min_max;
return this == &all_ || asMinMax() == min_max;
}
bool
MinMaxAll::matches(const MinMaxAll *min_max) const
{
return this == all_ || this == min_max;
return this == &all_ || this == min_max;
}
MinMaxAll *
@ -176,14 +148,14 @@ MinMaxAll::find(const char *min_max)
{
if (stringEq(min_max, "min")
|| stringEq(min_max, "early"))
return min();
return &min_;
else if (stringEq(min_max, "max")
|| stringEq(min_max, "late"))
return max();
return &max_;
else if (stringEq(min_max, "all")
|| stringEq(min_max, "min_max")
|| stringEq(min_max, "minmax"))
return all_;
return &all_;
else
return nullptr;
}

104
util/MinMax.hh
View File

@ -17,6 +17,8 @@
#ifndef STA_MIN_MAX_H
#define STA_MIN_MAX_H
#include <array>
#include <vector>
#include "DisallowCopyAssign.hh"
#include "Iterator.hh"
@ -24,12 +26,10 @@ namespace sta {
class MinMax;
class MinMaxAll;
class MinMaxIterator;
// Use typedefs to make early/late functional equivalents to min/max.
typedef MinMax EarlyLate;
typedef MinMaxAll EarlyLateAll;
typedef MinMaxIterator EarlyLateIterator;
// Large value used for min/max initial values.
extern const float INF;
@ -40,14 +40,14 @@ public:
static void init();
static void destroy();
// Singleton accessors.
static MinMax *min() { return min_; }
static MinMax *max() { return max_; }
static EarlyLate *early() { return min_; }
static EarlyLate *late() { return max_; }
static int minIndex() { return min_->index_; }
static int earlyIndex() { return min_->index_; }
static int maxIndex() { return max_->index_; }
static int lateIndex() { return max_->index_; }
static MinMax *min() { return &min_; }
static MinMax *max() { return &max_; }
static EarlyLate *early() { return &min_; }
static EarlyLate *late() { return &max_; }
static int minIndex() { return min_.index_; }
static int earlyIndex() { return min_.index_; }
static int maxIndex() { return max_.index_; }
static int lateIndex() { return max_.index_; }
const char *asString() const { return name_; }
int index() const { return index_; }
float initValue() const { return init_value_; }
@ -56,6 +56,11 @@ public:
float value2) const;
MinMaxAll *asMinMaxAll() const;
MinMax *opposite() const;
// for range support.
// for (auto min_max : MinMax::range()) {}
static const std::array<MinMax*, 2> &range() { return range_; }
// for (auto mm_index : MinMax::rangeIndex()) {}
static const std::array<int, 2> &rangeIndex() { return range_index_; }
static MinMax *find(const char *min_max);
// Find transition from index.
static MinMax *find(int index);
@ -77,10 +82,53 @@ private:
bool (*compare_)(float value1,
float value2);
static MinMax *min_;
static MinMax *max_;
static MinMax min_;
static MinMax max_;
static const std::array<MinMax*, 2> range_;
static const std::array<int, 2> range_index_;
};
// Min/Max/All, where "All" means use both min and max.
class MinMaxAll
{
public:
// Singleton accessors.
static MinMaxAll *min() { return &min_; }
static MinMaxAll *early() { return &min_; }
static MinMaxAll *max() { return &max_; }
static MinMaxAll *late() { return &max_; }
static MinMaxAll *all() { return &all_; }
const char *asString() const { return name_; }
int index() const { return index_; }
MinMax *asMinMax() const;
bool matches(const MinMax *min_max) const;
bool matches(const MinMaxAll *min_max) const;
static MinMaxAll *find(const char *min_max);
// for (auto min_max : min_max->range()) {}
const std::vector<MinMax*> &range() const { return range_; }
// for (auto mm_index : min_max->rangeIndex()) {}
const std::vector<int> &rangeIndex() const { return range_index_; }
private:
DISALLOW_COPY_AND_ASSIGN(MinMaxAll);
MinMaxAll(const char *name,
int index,
std::vector<MinMax*> range,
std::vector<int> range_index);
const char *name_;
int index_;
const std::vector<MinMax*> range_;
const std::vector<int> range_index_;
static MinMaxAll min_;
static MinMaxAll max_;
static MinMaxAll all_;
};
////////////////////////////////////////////////////////////////
// Obsolete. Use range iteration.
class MinMaxIterator : public Iterator<MinMax*>
{
public:
@ -97,37 +145,7 @@ private:
int index_max_;
};
// Min/Max/All, where "All" means use both min and max.
class MinMaxAll
{
public:
static void init();
static void destroy();
// Singleton accessors.
static MinMaxAll *min() { return min_; }
static MinMaxAll *early() { return min_; }
static MinMaxAll *max() { return max_; }
static MinMaxAll *late() { return max_; }
static MinMaxAll *all() { return all_; }
const char *asString() const { return name_; }
int index() const { return index_; }
MinMax *asMinMax() const;
bool matches(const MinMax *min_max) const;
bool matches(const MinMaxAll *min_max) const;
static MinMaxAll *find(const char *min_max);
private:
DISALLOW_COPY_AND_ASSIGN(MinMaxAll);
MinMaxAll(const char *name,
int index);
const char *name_;
int index_;
static MinMaxAll *min_;
static MinMaxAll *max_;
static MinMaxAll *all_;
};
typedef MinMaxIterator EarlyLateIterator;
} // namespace
#endif