From a8a9b27077bc2b068b12121bb8cf581d40293429 Mon Sep 17 00:00:00 2001 From: James Cherry Date: Sat, 25 Jun 2022 16:31:18 -0700 Subject: [PATCH] TableAxis shared_ptr Signed-off-by: James Cherry --- include/sta/InternalPower.hh | 4 +- include/sta/Liberty.hh | 24 ++++++------ include/sta/LibertyClass.hh | 1 + include/sta/TableModel.hh | 62 +++++++++++++----------------- liberty/InternalPower.cc | 10 ++--- liberty/Liberty.cc | 27 ++++++------- liberty/LibertyReader.cc | 43 +++++++++------------ liberty/LibertyReaderPvt.hh | 8 ++-- liberty/LibertyWriter.cc | 10 ++--- liberty/TableModel.cc | 74 +++++++++++++----------------------- search/MakeTimingModel.cc | 14 +++---- search/MakeTimingModel.hh | 2 +- search/WritePathSpice.cc | 32 ++++++++-------- 13 files changed, 133 insertions(+), 178 deletions(-) diff --git a/include/sta/InternalPower.hh b/include/sta/InternalPower.hh index 27a576cc..f1290040 100644 --- a/include/sta/InternalPower.hh +++ b/include/sta/InternalPower.hh @@ -93,11 +93,11 @@ protected: float &axis_value1, float &axis_value2, float &axis_value3) const; - float axisValue(TableAxis *axis, + float axisValue(TableAxisPtr axis, float in_slew, float load_cap) const; bool checkAxes(const TableModel *model); - bool checkAxis(TableAxis *axis); + bool checkAxis(TableAxisPtr axis); TableModel *model_; }; diff --git a/include/sta/Liberty.hh b/include/sta/Liberty.hh index 516f9b58..838922cc 100644 --- a/include/sta/Liberty.hh +++ b/include/sta/Liberty.hh @@ -932,24 +932,24 @@ class TableTemplate public: explicit TableTemplate(const char *name); TableTemplate(const char *name, - TableAxis *axis1, - TableAxis *axis2, - TableAxis *axis3); + TableAxisPtr axis1, + TableAxisPtr axis2, + TableAxisPtr axis3); ~TableTemplate(); const char *name() const { return name_; } void setName(const char *name); - TableAxis *axis1() const { return axis1_; } - void setAxis1(TableAxis *axis); - TableAxis *axis2() const { return axis2_; } - void setAxis2(TableAxis *axis); - TableAxis *axis3() const { return axis3_; } - void setAxis3(TableAxis *axis); + TableAxisPtr axis1() const { return axis1_; } + void setAxis1(TableAxisPtr axis); + TableAxisPtr axis2() const { return axis2_; } + void setAxis2(TableAxisPtr axis); + TableAxisPtr axis3() const { return axis3_; } + void setAxis3(TableAxisPtr axis); protected: const char *name_; - TableAxis *axis1_; - TableAxis *axis2_; - TableAxis *axis3_; + TableAxisPtr axis1_; + TableAxisPtr axis2_; + TableAxisPtr axis3_; }; class TestCell diff --git a/include/sta/LibertyClass.hh b/include/sta/LibertyClass.hh index 6c868592..5ddb8485 100644 --- a/include/sta/LibertyClass.hh +++ b/include/sta/LibertyClass.hh @@ -69,6 +69,7 @@ typedef Set LibertyCellSet; typedef Vector FloatSeq; typedef Vector FloatTable; typedef std::shared_ptr TimingArcAttrsPtr; +typedef std::shared_ptr TableAxisPtr; enum class ScaleFactorType : unsigned { pin_cap, diff --git a/include/sta/TableModel.hh b/include/sta/TableModel.hh index 7a2e1081..49c34e25 100644 --- a/include/sta/TableModel.hh +++ b/include/sta/TableModel.hh @@ -17,6 +17,8 @@ #pragma once #include +#include + #include "MinMax.hh" #include "Vector.hh" #include "Transition.hh" @@ -81,7 +83,7 @@ protected: float &slew, float &cap) const; virtual void setIsScaled(bool is_scaled); - float axisValue(TableAxis *axis, + float axisValue(TableAxisPtr axis, float load_cap, float in_slew, float related_out_cap) const; @@ -110,7 +112,7 @@ protected: float &axis_value1, float &axis_value2, float &axis_value3) const; - static bool checkAxis(TableAxis *axis); + static bool checkAxis(TableAxisPtr axis); TableModel *delay_model_; TableModel *delay_sigma_models_[EarlyLate::index_count]; @@ -163,7 +165,7 @@ protected: float &axis_value1, float &axis_value2, float &axis_value3) const; - float axisValue(TableAxis *axis, + float axisValue(TableAxisPtr axis, float load_cap, float in_slew, float related_out_cap) const; @@ -178,7 +180,7 @@ protected: float related_out_cap, int digits, string *result) const; - static bool checkAxis(TableAxis *axis); + static bool checkAxis(TableAxisPtr axis); TableModel *model_; TableModel *sigma_models_[EarlyLate::index_count]; @@ -196,9 +198,9 @@ public: void setScaleFactorType(ScaleFactorType type); int order() const; TableTemplate *tblTemplate() const { return tbl_template_; } - TableAxis *axis1() const; - TableAxis *axis2() const; - TableAxis *axis3() const; + TableAxisPtr axis1() const; + TableAxisPtr axis2() const; + TableAxisPtr axis3() const; void setIsScaled(bool is_scaled); float value(size_t index1, size_t index2, @@ -253,9 +255,9 @@ public: virtual ~Table() {} void setScaleFactorType(ScaleFactorType type); virtual int order() const = 0; - virtual TableAxis *axis1() const { return nullptr; } - virtual TableAxis *axis2() const { return nullptr; } - virtual TableAxis *axis3() const { return nullptr; } + virtual TableAxisPtr axis1() const { return nullptr; } + virtual TableAxisPtr axis2() const { return nullptr; } + virtual TableAxisPtr axis3() const { return nullptr; } void setIsScaled(bool is_scaled); virtual float value(size_t axis_idx1, size_t axis_idx2, @@ -320,11 +322,10 @@ class Table1 : public Table { public: Table1(FloatSeq *values, - TableAxis *axis1, - bool own_axis1); + TableAxisPtr axis1); virtual ~Table1(); virtual int order() const { return 1; } - virtual TableAxis *axis1() const { return axis1_; } + virtual TableAxisPtr axis1() const { return axis1_; } virtual float value(size_t index1, size_t index2, size_t index3) const; @@ -348,8 +349,7 @@ public: private: FloatSeq *values_; - TableAxis *axis1_; - bool own_axis1_; + TableAxisPtr axis1_; }; // Two dimensional table. @@ -357,14 +357,12 @@ class Table2 : public Table { public: Table2(FloatTable *values, - TableAxis *axis1, - bool own_axis1, - TableAxis *axis2, - bool own_axis2); + TableAxisPtr axis1, + TableAxisPtr axis2); virtual ~Table2(); virtual int order() const { return 2; } - TableAxis *axis1() const { return axis1_; } - TableAxis *axis2() const { return axis2_; } + TableAxisPtr axis1() const { return axis1_; } + TableAxisPtr axis2() const { return axis2_; } virtual float value(size_t index1, size_t index2, size_t index3) const; @@ -390,11 +388,9 @@ public: protected: FloatTable *values_; // Row. - TableAxis *axis1_; - bool own_axis1_; + TableAxisPtr axis1_; // Column. - TableAxis *axis2_; - bool own_axis2_; + TableAxisPtr axis2_; }; // Three dimensional table. @@ -402,15 +398,12 @@ class Table3 : public Table2 { public: Table3(FloatTable *values, - TableAxis *axis1, - bool own_axis1, - TableAxis *axis2, - bool own_axis2, - TableAxis *axis3, - bool own_axis3); - virtual ~Table3(); + TableAxisPtr axis1, + TableAxisPtr axis2, + TableAxisPtr axis3); + virtual ~Table3() {} virtual int order() const { return 3; } - TableAxis *axis3() const { return axis3_; } + TableAxisPtr axis3() const { return axis3_; } virtual float value(size_t index1, size_t index2, size_t index3) const; @@ -432,8 +425,7 @@ public: using Table::findValue; private: - TableAxis *axis3_; - bool own_axis3_; + TableAxisPtr axis3_; }; class TableAxis diff --git a/liberty/InternalPower.cc b/liberty/InternalPower.cc index 61f7abbe..a911c2d3 100644 --- a/liberty/InternalPower.cc +++ b/liberty/InternalPower.cc @@ -194,7 +194,7 @@ InternalPowerModel::findAxisValues(float in_slew, } float -InternalPowerModel::axisValue(TableAxis *axis, +InternalPowerModel::axisValue(TableAxisPtr axis, float in_slew, float load_cap) const { @@ -212,9 +212,9 @@ InternalPowerModel::axisValue(TableAxis *axis, bool InternalPowerModel::checkAxes(const TableModel *model) { - TableAxis *axis1 = model->axis1(); - TableAxis *axis2 = model->axis2(); - TableAxis *axis3 = model->axis3(); + TableAxisPtr axis1 = model->axis1(); + TableAxisPtr axis2 = model->axis2(); + TableAxisPtr axis3 = model->axis3(); bool axis_ok = true; if (axis1) axis_ok &= checkAxis(model->axis1()); @@ -225,7 +225,7 @@ InternalPowerModel::checkAxes(const TableModel *model) } bool -InternalPowerModel::checkAxis(TableAxis *axis) +InternalPowerModel::checkAxis(TableAxisPtr axis) { TableAxisVariable var = axis->variable(); return var == TableAxisVariable::constrained_pin_transition diff --git a/liberty/Liberty.cc b/liberty/Liberty.cc index 4458a653..97981edf 100644 --- a/liberty/Liberty.cc +++ b/liberty/Liberty.cc @@ -337,7 +337,7 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell, case 0: return model->findValue(this, cell, pvt, 0.0, 0.0, 0.0); case 1: { - TableAxis *axis1 = model->axis1(); + TableAxisPtr axis1 = model->axis1(); TableAxisVariable var1 = axis1->variable(); if (var1 == TableAxisVariable::output_pin_transition) return model->findValue(this, cell, pvt, in_slew, 0.0, 0.0); @@ -349,8 +349,8 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell, } } case 2: { - TableAxis *axis1 = model->axis1(); - TableAxis *axis2 = model->axis2(); + TableAxisPtr axis1 = model->axis1(); + TableAxisPtr axis2 = model->axis2(); TableAxisVariable var1 = axis1->variable(); TableAxisVariable var2 = axis2->variable(); if (var1 == TableAxisVariable::output_pin_transition @@ -379,14 +379,14 @@ LibertyLibrary::checkSlewDegradationAxes(Table *table) case 0: return true; case 1: { - TableAxis *axis1 = table->axis1(); + TableAxisPtr axis1 = table->axis1(); TableAxisVariable var1 = axis1->variable(); return var1 == TableAxisVariable::output_pin_transition || var1 == TableAxisVariable::connect_delay; } case 2: { - TableAxis *axis1 = table->axis1(); - TableAxis *axis2 = table->axis2(); + TableAxisPtr axis1 = table->axis1(); + TableAxisPtr axis2 = table->axis2(); TableAxisVariable var1 = axis1->variable(); TableAxisVariable var2 = axis2->variable(); return (var1 == TableAxisVariable::output_pin_transition @@ -2510,9 +2510,9 @@ TableTemplate::TableTemplate(const char *name) : } TableTemplate::TableTemplate(const char *name, - TableAxis *axis1, - TableAxis *axis2, - TableAxis *axis3) : + TableAxisPtr axis1, + TableAxisPtr axis2, + TableAxisPtr axis3) : name_(stringCopy(name)), axis1_(axis1), axis2_(axis2), @@ -2523,9 +2523,6 @@ TableTemplate::TableTemplate(const char *name, TableTemplate::~TableTemplate() { stringDelete(name_); - delete axis1_; - delete axis2_; - delete axis3_; } void @@ -2536,19 +2533,19 @@ TableTemplate::setName(const char *name) } void -TableTemplate::setAxis1(TableAxis *axis) +TableTemplate::setAxis1(TableAxisPtr axis) { axis1_ = axis; } void -TableTemplate::setAxis2(TableAxis *axis) +TableTemplate::setAxis2(TableAxisPtr axis) { axis2_ = axis; } void -TableTemplate::setAxis3(TableAxis *axis) +TableTemplate::setAxis3(TableAxisPtr axis) { axis3_ = axis; } diff --git a/liberty/LibertyReader.cc b/liberty/LibertyReader.cc index 24149ef7..921d2a88 100644 --- a/liberty/LibertyReader.cc +++ b/liberty/LibertyReader.cc @@ -1298,33 +1298,30 @@ void LibertyReader::endTableTemplate(LibertyGroup *group) { if (tbl_template_) { - TableAxis *axis; - makeAxis(0, group, axis); - if (axis) - tbl_template_->setAxis1(axis); - makeAxis(1, group, axis); - if (axis) - tbl_template_->setAxis2(axis); - makeAxis(2, group, axis); - if (axis) - tbl_template_->setAxis3(axis); + TableAxisPtr axis1 = makeAxis(0, group); + if (axis1) + tbl_template_->setAxis1(axis1); + TableAxisPtr axis2 = makeAxis(1, group); + if (axis2) + tbl_template_->setAxis2(axis2); + TableAxisPtr axis3 = makeAxis(2, group); + if (axis3) + tbl_template_->setAxis3(axis3); tbl_template_ = nullptr; } } -void +TableAxisPtr LibertyReader::makeAxis(int index, - LibertyGroup *group, - TableAxis *&axis) + LibertyGroup *group) { - axis = nullptr; TableAxisVariable axis_var = axis_var_[index]; FloatSeq *axis_values = axis_values_[index]; if (axis_var != TableAxisVariable::unknown && axis_values) { const Units *units = library_->units(); float scale = tableVariableUnit(axis_var, units)->scale(); scaleFloats(axis_values, scale); - axis = new TableAxis(axis_var, axis_values); + return std::make_shared(axis_var, axis_values); } else if (axis_var == TableAxisVariable::unknown && axis_values) { libWarn(62, group, "missing variable_%d attribute.", index + 1); @@ -1333,6 +1330,7 @@ LibertyReader::makeAxis(int index, } // No warning for missing index_xx attributes because they are // not required by ic_shell. + return nullptr; } static void @@ -3878,7 +3876,6 @@ LibertyReader::beginTable(LibertyGroup *group, axis_[0] = axis_[1] = axis_[2] = nullptr; } clearAxisValues(); - own_axis_[0] = own_axis_[1] = own_axis_[2] = false; table_ = nullptr; table_model_scale_ = scale; } @@ -3926,25 +3923,20 @@ LibertyReader::makeTable(LibertyAttr *attr, FloatTable *table = makeFloatTable(attr, axis_[0]->size()*axis_[1]->size(), axis_[2]->size(), scale); - table_ = new Table3(table, - axis_[0], own_axis_[0], - axis_[1], own_axis_[1], - axis_[2], own_axis_[2]); + table_ = new Table3(table, axis_[0], axis_[1], axis_[2]); } else if (axis_[0] && axis_[1]) { // Row variable1/axis[0] // Column variable2/axis[1] FloatTable *table = makeFloatTable(attr, axis_[0]->size(), axis_[1]->size(), scale); - table_ = new Table2(table, - axis_[0], own_axis_[0], - axis_[1], own_axis_[1]); + table_ = new Table2(table, axis_[0], axis_[1]); } else if (axis_[0]) { FloatTable *table = makeFloatTable(attr, 1, axis_[0]->size(), scale); FloatSeq *values = (*table)[0]; delete table; - table_ = new Table1(values, axis_[0], own_axis_[0]); + table_ = new Table1(values, axis_[0]); } else { FloatTable *table = makeFloatTable(attr, 1, 1, scale); @@ -4017,8 +4009,7 @@ LibertyReader::makeTableAxis(int index) const Units *units = library_->units(); float scale = tableVariableUnit(var, units)->scale(); scaleFloats(values, scale); - axis_[index] = new TableAxis(var, values); - own_axis_[index] = true; + axis_[index] = std::make_shared(var, values); } } diff --git a/liberty/LibertyReaderPvt.hh b/liberty/LibertyReaderPvt.hh index bec628f0..cd6a99c6 100644 --- a/liberty/LibertyReaderPvt.hh +++ b/liberty/LibertyReaderPvt.hh @@ -481,9 +481,8 @@ protected: LibertyAttr *attr); void visitIndex(int index, LibertyAttr *attr); - void makeAxis(int index, - LibertyGroup *group, - TableAxis *&axis); + TableAxisPtr makeAxis(int index, + LibertyGroup *group); FloatSeq *readFloatSeq(LibertyAttr *attr, float scale); void variableValue(const char *var, @@ -564,8 +563,7 @@ protected: PathType path_type_; LibertyPgPort *pg_port_; ScaleFactorType scale_factor_type_; - TableAxis *axis_[3]; - bool own_axis_[3]; + TableAxisPtr axis_[3]; Table *table_; float table_model_scale_; ModeDef *mode_def_; diff --git a/liberty/LibertyWriter.cc b/liberty/LibertyWriter.cc index b3575af7..ad119030 100644 --- a/liberty/LibertyWriter.cc +++ b/liberty/LibertyWriter.cc @@ -60,7 +60,7 @@ protected: void writeTableModel0(const TableModel *model); void writeTableModel1(const TableModel *model); void writeTableModel2(const TableModel *model); - void writeTableAxis(TableAxis *axis, + void writeTableAxis(TableAxisPtr axis, int index); const char *asString(bool value); @@ -204,9 +204,9 @@ LibertyWriter::writeTableTemplates() void LibertyWriter::writeTableTemplate(TableTemplate *tbl_template) { - TableAxis *axis1 = tbl_template->axis1(); - TableAxis *axis2 = tbl_template->axis2(); - TableAxis *axis3 = tbl_template->axis3(); + TableAxisPtr axis1 = tbl_template->axis1(); + TableAxisPtr axis2 = tbl_template->axis2(); + TableAxisPtr axis3 = tbl_template->axis3(); // skip scalar templates if (axis1) { fprintf(stream_, " lu_table_template(%s) {\n", tbl_template->name()); @@ -229,7 +229,7 @@ LibertyWriter::writeTableTemplate(TableTemplate *tbl_template) } void -LibertyWriter::writeTableAxis(TableAxis *axis, +LibertyWriter::writeTableAxis(TableAxisPtr axis, int index) { fprintf(stream_, " index_%d (\"", index); diff --git a/liberty/TableModel.cc b/liberty/TableModel.cc index e5a6f7ee..03273205 100644 --- a/liberty/TableModel.cc +++ b/liberty/TableModel.cc @@ -268,9 +268,9 @@ GateTableModel::maxCapSlew(const LibertyCell *cell, float &cap) const { const LibertyLibrary *library = cell->libertyLibrary(); - TableAxis *axis1 = slew_model_->axis1(); - TableAxis *axis2 = slew_model_->axis2(); - TableAxis *axis3 = slew_model_->axis3(); + TableAxisPtr axis1 = slew_model_->axis1(); + TableAxisPtr axis2 = slew_model_->axis2(); + TableAxisPtr axis3 = slew_model_->axis3(); if (axis1 && axis1->variable() == TableAxisVariable::total_output_net_capacitance) { cap = axis1->axisValue(axis1->size() - 1); @@ -300,7 +300,7 @@ GateTableModel::maxCapSlew(const LibertyCell *cell, } float -GateTableModel::axisValue(TableAxis *axis, +GateTableModel::axisValue(TableAxisPtr axis, float in_slew, float load_cap, float related_out_cap) const @@ -322,9 +322,9 @@ GateTableModel::axisValue(TableAxis *axis, bool GateTableModel::checkAxes(const Table *table) { - TableAxis *axis1 = table->axis1(); - TableAxis *axis2 = table->axis2(); - TableAxis *axis3 = table->axis3(); + TableAxisPtr axis1 = table->axis1(); + TableAxisPtr axis2 = table->axis2(); + TableAxisPtr axis3 = table->axis3(); bool axis_ok = true; if (axis1) axis_ok &= checkAxis(table->axis1()); @@ -336,7 +336,7 @@ GateTableModel::checkAxes(const Table *table) } bool -GateTableModel::checkAxis(TableAxis *axis) +GateTableModel::checkAxis(TableAxisPtr axis) { TableAxisVariable var = axis->variable(); return var == TableAxisVariable::total_output_net_capacitance @@ -510,7 +510,7 @@ CheckTableModel::findAxisValues(float from_slew, } float -CheckTableModel::axisValue(TableAxis *axis, +CheckTableModel::axisValue(TableAxisPtr axis, float from_slew, float to_slew, float related_out_cap) const @@ -531,9 +531,9 @@ CheckTableModel::axisValue(TableAxis *axis, bool CheckTableModel::checkAxes(const Table *table) { - TableAxis *axis1 = table->axis1(); - TableAxis *axis2 = table->axis2(); - TableAxis *axis3 = table->axis3(); + TableAxisPtr axis1 = table->axis1(); + TableAxisPtr axis2 = table->axis2(); + TableAxisPtr axis3 = table->axis3(); bool axis_ok = true; if (axis1) axis_ok &= checkAxis(table->axis1()); @@ -545,7 +545,7 @@ CheckTableModel::checkAxes(const Table *table) } bool -CheckTableModel::checkAxis(TableAxis *axis) +CheckTableModel::checkAxis(TableAxisPtr axis) { TableAxisVariable var = axis->variable(); return var == TableAxisVariable::constrained_pin_transition @@ -590,19 +590,19 @@ TableModel::setIsScaled(bool is_scaled) is_scaled_ = is_scaled; } -TableAxis * +TableAxisPtr TableModel::axis1() const { return table_->axis1(); } -TableAxis * +TableAxisPtr TableModel::axis2() const { return table_->axis2(); } -TableAxis * +TableAxisPtr TableModel::axis3() const { return table_->axis3(); @@ -762,20 +762,16 @@ Table0::report(const Units *units, //////////////////////////////////////////////////////////////// Table1::Table1(FloatSeq *values, - TableAxis *axis1, - bool own_axis1) : + TableAxisPtr axis1) : Table(), values_(values), - axis1_(axis1), - own_axis1_(own_axis1) + axis1_(axis1) { } Table1::~Table1() { delete values_; - if (own_axis1_) - delete axis1_; } float @@ -887,16 +883,12 @@ Table1::report(const Units *units, //////////////////////////////////////////////////////////////// Table2::Table2(FloatTable *values, - TableAxis *axis1, - bool own_axis1, - TableAxis *axis2, - bool own_axis2) : + TableAxisPtr axis1, + TableAxisPtr axis2) : Table(), values_(values), axis1_(axis1), - own_axis1_(own_axis1), - axis2_(axis2), - own_axis2_(own_axis2) + axis2_(axis2) { } @@ -904,10 +896,6 @@ Table2::~Table2() { values_->deleteContents(); delete values_; - if (own_axis1_) - delete axis1_; - if (own_axis2_) - delete axis2_; } float @@ -1089,24 +1077,14 @@ Table2::report(const Units *units, //////////////////////////////////////////////////////////////// Table3::Table3(FloatTable *values, - TableAxis *axis1, - bool own_axis1, - TableAxis *axis2, - bool own_axis2, - TableAxis *axis3, - bool own_axis3) : - Table2(values, axis1, own_axis1, axis2, own_axis2), - axis3_(axis3), - own_axis3_(own_axis3) + TableAxisPtr axis1, + TableAxisPtr axis2, + TableAxisPtr axis3) : + Table2(values, axis1, axis2), + axis3_(axis3) { } -Table3::~Table3() -{ - if (own_axis3_) - delete axis3_; -} - float Table3::value(size_t index1, size_t index2, diff --git a/search/MakeTimingModel.cc b/search/MakeTimingModel.cc index fab5e44d..8ed5d600 100644 --- a/search/MakeTimingModel.cc +++ b/search/MakeTimingModel.cc @@ -519,7 +519,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin, drvr_self_delay, drvr_self_slew); const TableModel *drvr_table = drvr_gate_model->delayModel(); - const TableAxis *drvr_load_axis = loadCapacitanceAxis(drvr_table); + const TableAxisPtr drvr_load_axis = loadCapacitanceAxis(drvr_table); const FloatSeq *drvr_axis_values = drvr_load_axis->values(); FloatSeq *load_values = new FloatSeq; @@ -538,12 +538,12 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin, } FloatSeq *axis_values = new FloatSeq(*drvr_axis_values); - TableAxis *load_axis = - new TableAxis(TableAxisVariable::total_output_net_capacitance, - axis_values); + TableAxisPtr load_axis = + std::make_shared(TableAxisVariable::total_output_net_capacitance, + axis_values); - Table *delay_table = new Table1(load_values, load_axis, true); - Table *slew_table = new Table1(slew_values, load_axis, true); + Table *delay_table = new Table1(load_values, load_axis); + Table *slew_table = new Table1(slew_values, load_axis); string template_name = "template_"; template_name += std::to_string(tbl_template_index_++); @@ -570,7 +570,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin, return makeGateModelScalar(delay, slew, rf); } -TableAxis * +TableAxisPtr MakeTimingModel::loadCapacitanceAxis(const TableModel *table) { if (table->axis1()->variable() == TableAxisVariable::total_output_net_capacitance) diff --git a/search/MakeTimingModel.hh b/search/MakeTimingModel.hh index 0a3113d8..6d0236f5 100644 --- a/search/MakeTimingModel.hh +++ b/search/MakeTimingModel.hh @@ -75,7 +75,7 @@ private: TimingModel *makeGateModelTable(const Pin *output_pin, Delay delay, RiseFall *rf); - TableAxis *loadCapacitanceAxis(const TableModel *table); + TableAxisPtr loadCapacitanceAxis(const TableModel *table); LibertyPort *modelPort(const Pin *pin); Sta *sta_; diff --git a/search/WritePathSpice.cc b/search/WritePathSpice.cc index 96f8edb3..7b5f0569 100644 --- a/search/WritePathSpice.cc +++ b/search/WritePathSpice.cc @@ -575,25 +575,23 @@ WritePathSpice::slewAxisMinValue(TimingArc *arc) GateTableModel *gate_model = dynamic_cast(arc->model()); if (gate_model) { const TableModel *model = gate_model->delayModel(); - TableAxis *axis; - TableAxisVariable var; - axis = model->axis1(); - var = axis->variable(); - if (var == TableAxisVariable::input_transition_time - || var == TableAxisVariable::input_net_transition) - return axis->axisValue(0); + TableAxisPtr axis1 = model->axis1(); + TableAxisVariable var1 = axis1->variable(); + if (var1 == TableAxisVariable::input_transition_time + || var1 == TableAxisVariable::input_net_transition) + return axis1->axisValue(0); - axis = model->axis2(); - var = axis->variable(); - if (var == TableAxisVariable::input_transition_time - || var == TableAxisVariable::input_net_transition) - return axis->axisValue(0); + TableAxisPtr axis2 = model->axis2(); + TableAxisVariable var2 = axis2->variable(); + if (var2 == TableAxisVariable::input_transition_time + || var2 == TableAxisVariable::input_net_transition) + return axis2->axisValue(0); - axis = model->axis3(); - var = axis->variable(); - if (var == TableAxisVariable::input_transition_time - || var == TableAxisVariable::input_net_transition) - return axis->axisValue(0); + TableAxisPtr axis3 = model->axis3(); + TableAxisVariable var3 = axis3->variable(); + if (var3 == TableAxisVariable::input_transition_time + || var3 == TableAxisVariable::input_net_transition) + return axis3->axisValue(0); } return 0.0; }