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

TableAxis shared_ptr 

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2022-06-25 16:31:18 -07:00
parent dc9d20f8d5
commit a8a9b27077
13 changed files with 133 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sta/InternalPower.hh
View File

@ -93,11 +93,11 @@ protected:
float &axis_value1, float &axis_value1,
float &axis_value2, float &axis_value2,
float &axis_value3) const; float &axis_value3) const;
float axisValue(TableAxis *axis, float axisValue(TableAxisPtr axis,
float in_slew, float in_slew,
float load_cap) const; float load_cap) const;
bool checkAxes(const TableModel *model); bool checkAxes(const TableModel *model);
bool checkAxis(TableAxis *axis); bool checkAxis(TableAxisPtr axis);
TableModel *model_; TableModel *model_;
}; };

24
include/sta/Liberty.hh
View File

@ -932,24 +932,24 @@ class TableTemplate
public: public:
explicit TableTemplate(const char *name); explicit TableTemplate(const char *name);
TableTemplate(const char *name, TableTemplate(const char *name,
TableAxis *axis1, TableAxisPtr axis1,
TableAxis *axis2, TableAxisPtr axis2,
TableAxis *axis3); TableAxisPtr axis3);
~TableTemplate(); ~TableTemplate();
const char *name() const { return name_; } const char *name() const { return name_; }
void setName(const char *name); void setName(const char *name);
TableAxis *axis1() const { return axis1_; } TableAxisPtr axis1() const { return axis1_; }
void setAxis1(TableAxis *axis); void setAxis1(TableAxisPtr axis);
TableAxis *axis2() const { return axis2_; } TableAxisPtr axis2() const { return axis2_; }
void setAxis2(TableAxis *axis); void setAxis2(TableAxisPtr axis);
TableAxis *axis3() const { return axis3_; } TableAxisPtr axis3() const { return axis3_; }
void setAxis3(TableAxis *axis); void setAxis3(TableAxisPtr axis);
protected: protected:
const char *name_; const char *name_;
TableAxis *axis1_; TableAxisPtr axis1_;
TableAxis *axis2_; TableAxisPtr axis2_;
TableAxis *axis3_; TableAxisPtr axis3_;
}; };
class TestCell class TestCell

1
include/sta/LibertyClass.hh
View File

@ -69,6 +69,7 @@ typedef Set<LibertyCell*> LibertyCellSet;
typedef Vector<float> FloatSeq; typedef Vector<float> FloatSeq;
typedef Vector<FloatSeq*> FloatTable; typedef Vector<FloatSeq*> FloatTable;
typedef std::shared_ptr<TimingArcAttrs> TimingArcAttrsPtr; typedef std::shared_ptr<TimingArcAttrs> TimingArcAttrsPtr;
typedef std::shared_ptr<TableAxis> TableAxisPtr;
enum class ScaleFactorType : unsigned { enum class ScaleFactorType : unsigned {
pin_cap, pin_cap,

62
include/sta/TableModel.hh
View File

@ -17,6 +17,8 @@
#pragma once #pragma once
#include <string> #include <string>
#include <memory>
#include "MinMax.hh" #include "MinMax.hh"
#include "Vector.hh" #include "Vector.hh"
#include "Transition.hh" #include "Transition.hh"
@ -81,7 +83,7 @@ protected:
float &slew, float &slew,
float &cap) const; float &cap) const;
virtual void setIsScaled(bool is_scaled); virtual void setIsScaled(bool is_scaled);
float axisValue(TableAxis *axis, float axisValue(TableAxisPtr axis,
float load_cap, float load_cap,
float in_slew, float in_slew,
float related_out_cap) const; float related_out_cap) const;
@ -110,7 +112,7 @@ protected:
float &axis_value1, float &axis_value1,
float &axis_value2, float &axis_value2,
float &axis_value3) const; float &axis_value3) const;
static bool checkAxis(TableAxis *axis); static bool checkAxis(TableAxisPtr axis);
TableModel *delay_model_; TableModel *delay_model_;
TableModel *delay_sigma_models_[EarlyLate::index_count]; TableModel *delay_sigma_models_[EarlyLate::index_count];
@ -163,7 +165,7 @@ protected:
float &axis_value1, float &axis_value1,
float &axis_value2, float &axis_value2,
float &axis_value3) const; float &axis_value3) const;
float axisValue(TableAxis *axis, float axisValue(TableAxisPtr axis,
float load_cap, float load_cap,
float in_slew, float in_slew,
float related_out_cap) const; float related_out_cap) const;
@ -178,7 +180,7 @@ protected:
float related_out_cap, float related_out_cap,
int digits, int digits,
string *result) const; string *result) const;
static bool checkAxis(TableAxis *axis); static bool checkAxis(TableAxisPtr axis);
TableModel *model_; TableModel *model_;
TableModel *sigma_models_[EarlyLate::index_count]; TableModel *sigma_models_[EarlyLate::index_count];
@ -196,9 +198,9 @@ public:
void setScaleFactorType(ScaleFactorType type); void setScaleFactorType(ScaleFactorType type);
int order() const; int order() const;
TableTemplate *tblTemplate() const { return tbl_template_; } TableTemplate *tblTemplate() const { return tbl_template_; }
TableAxis *axis1() const; TableAxisPtr axis1() const;
TableAxis *axis2() const; TableAxisPtr axis2() const;
TableAxis *axis3() const; TableAxisPtr axis3() const;
void setIsScaled(bool is_scaled); void setIsScaled(bool is_scaled);
float value(size_t index1, float value(size_t index1,
size_t index2, size_t index2,
@ -253,9 +255,9 @@ public:
virtual ~Table() {} virtual ~Table() {}
void setScaleFactorType(ScaleFactorType type); void setScaleFactorType(ScaleFactorType type);
virtual int order() const = 0; virtual int order() const = 0;
virtual TableAxis *axis1() const { return nullptr; } virtual TableAxisPtr axis1() const { return nullptr; }
virtual TableAxis *axis2() const { return nullptr; } virtual TableAxisPtr axis2() const { return nullptr; }
virtual TableAxis *axis3() const { return nullptr; } virtual TableAxisPtr axis3() const { return nullptr; }
void setIsScaled(bool is_scaled); void setIsScaled(bool is_scaled);
virtual float value(size_t axis_idx1, virtual float value(size_t axis_idx1,
size_t axis_idx2, size_t axis_idx2,
@ -320,11 +322,10 @@ class Table1 : public Table
{ {
public: public:
Table1(FloatSeq *values, Table1(FloatSeq *values,
TableAxis *axis1, TableAxisPtr axis1);
bool own_axis1);
virtual ~Table1(); virtual ~Table1();
virtual int order() const { return 1; } virtual int order() const { return 1; }
virtual TableAxis *axis1() const { return axis1_; } virtual TableAxisPtr axis1() const { return axis1_; }
virtual float value(size_t index1, virtual float value(size_t index1,
size_t index2, size_t index2,
size_t index3) const; size_t index3) const;
@ -348,8 +349,7 @@ public:
private: private:
FloatSeq *values_; FloatSeq *values_;
TableAxis *axis1_; TableAxisPtr axis1_;
bool own_axis1_;
}; };
// Two dimensional table. // Two dimensional table.
@ -357,14 +357,12 @@ class Table2 : public Table
{ {
public: public:
Table2(FloatTable *values, Table2(FloatTable *values,
TableAxis *axis1, TableAxisPtr axis1,
bool own_axis1, TableAxisPtr axis2);
TableAxis *axis2,
bool own_axis2);
virtual ~Table2(); virtual ~Table2();
virtual int order() const { return 2; } virtual int order() const { return 2; }
TableAxis *axis1() const { return axis1_; } TableAxisPtr axis1() const { return axis1_; }
TableAxis *axis2() const { return axis2_; } TableAxisPtr axis2() const { return axis2_; }
virtual float value(size_t index1, virtual float value(size_t index1,
size_t index2, size_t index2,
size_t index3) const; size_t index3) const;
@ -390,11 +388,9 @@ public:
protected: protected:
FloatTable *values_; FloatTable *values_;
// Row. // Row.
TableAxis *axis1_; TableAxisPtr axis1_;
bool own_axis1_;
// Column. // Column.
TableAxis *axis2_; TableAxisPtr axis2_;
bool own_axis2_;
}; };
// Three dimensional table. // Three dimensional table.
@ -402,15 +398,12 @@ class Table3 : public Table2
{ {
public: public:
Table3(FloatTable *values, Table3(FloatTable *values,
TableAxis *axis1, TableAxisPtr axis1,
bool own_axis1, TableAxisPtr axis2,
TableAxis *axis2, TableAxisPtr axis3);
bool own_axis2, virtual ~Table3() {}
TableAxis *axis3,
bool own_axis3);
virtual ~Table3();
virtual int order() const { return 3; } virtual int order() const { return 3; }
TableAxis *axis3() const { return axis3_; } TableAxisPtr axis3() const { return axis3_; }
virtual float value(size_t index1, virtual float value(size_t index1,
size_t index2, size_t index2,
size_t index3) const; size_t index3) const;
@ -432,8 +425,7 @@ public:
using Table::findValue; using Table::findValue;
private: private:
TableAxis *axis3_; TableAxisPtr axis3_;
bool own_axis3_;
}; };
class TableAxis class TableAxis

10
liberty/InternalPower.cc
View File

@ -194,7 +194,7 @@ InternalPowerModel::findAxisValues(float in_slew,
} }
float float
InternalPowerModel::axisValue(TableAxis *axis, InternalPowerModel::axisValue(TableAxisPtr axis,
float in_slew, float in_slew,
float load_cap) const float load_cap) const
{ {
@ -212,9 +212,9 @@ InternalPowerModel::axisValue(TableAxis *axis,
bool bool
InternalPowerModel::checkAxes(const TableModel *model) InternalPowerModel::checkAxes(const TableModel *model)
{ {
TableAxis *axis1 = model->axis1(); TableAxisPtr axis1 = model->axis1();
TableAxis *axis2 = model->axis2(); TableAxisPtr axis2 = model->axis2();
TableAxis *axis3 = model->axis3(); TableAxisPtr axis3 = model->axis3();
bool axis_ok = true; bool axis_ok = true;
if (axis1) if (axis1)
axis_ok &= checkAxis(model->axis1()); axis_ok &= checkAxis(model->axis1());
@ -225,7 +225,7 @@ InternalPowerModel::checkAxes(const TableModel *model)
} }
bool bool
InternalPowerModel::checkAxis(TableAxis *axis) InternalPowerModel::checkAxis(TableAxisPtr axis)
{ {
TableAxisVariable var = axis->variable(); TableAxisVariable var = axis->variable();
return var == TableAxisVariable::constrained_pin_transition return var == TableAxisVariable::constrained_pin_transition

27
liberty/Liberty.cc
View File

@ -337,7 +337,7 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell,
case 0: case 0:
return model->findValue(this, cell, pvt, 0.0, 0.0, 0.0); return model->findValue(this, cell, pvt, 0.0, 0.0, 0.0);
case 1: { case 1: {
TableAxis *axis1 = model->axis1(); TableAxisPtr axis1 = model->axis1();
TableAxisVariable var1 = axis1->variable(); TableAxisVariable var1 = axis1->variable();
if (var1 == TableAxisVariable::output_pin_transition) if (var1 == TableAxisVariable::output_pin_transition)
return model->findValue(this, cell, pvt, in_slew, 0.0, 0.0); return model->findValue(this, cell, pvt, in_slew, 0.0, 0.0);
@ -349,8 +349,8 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell,
} }
} }
case 2: { case 2: {
TableAxis *axis1 = model->axis1(); TableAxisPtr axis1 = model->axis1();
TableAxis *axis2 = model->axis2(); TableAxisPtr axis2 = model->axis2();
TableAxisVariable var1 = axis1->variable(); TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable(); TableAxisVariable var2 = axis2->variable();
if (var1 == TableAxisVariable::output_pin_transition if (var1 == TableAxisVariable::output_pin_transition
@ -379,14 +379,14 @@ LibertyLibrary::checkSlewDegradationAxes(Table *table)
case 0: case 0:
return true; return true;
case 1: { case 1: {
TableAxis *axis1 = table->axis1(); TableAxisPtr axis1 = table->axis1();
TableAxisVariable var1 = axis1->variable(); TableAxisVariable var1 = axis1->variable();
return var1 == TableAxisVariable::output_pin_transition return var1 == TableAxisVariable::output_pin_transition
|| var1 == TableAxisVariable::connect_delay; || var1 == TableAxisVariable::connect_delay;
} }
case 2: { case 2: {
TableAxis *axis1 = table->axis1(); TableAxisPtr axis1 = table->axis1();
TableAxis *axis2 = table->axis2(); TableAxisPtr axis2 = table->axis2();
TableAxisVariable var1 = axis1->variable(); TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable(); TableAxisVariable var2 = axis2->variable();
return (var1 == TableAxisVariable::output_pin_transition return (var1 == TableAxisVariable::output_pin_transition
@ -2510,9 +2510,9 @@ TableTemplate::TableTemplate(const char *name) :
} }
TableTemplate::TableTemplate(const char *name, TableTemplate::TableTemplate(const char *name,
TableAxis *axis1, TableAxisPtr axis1,
TableAxis *axis2, TableAxisPtr axis2,
TableAxis *axis3) : TableAxisPtr axis3) :
name_(stringCopy(name)), name_(stringCopy(name)),
axis1_(axis1), axis1_(axis1),
axis2_(axis2), axis2_(axis2),
@ -2523,9 +2523,6 @@ TableTemplate::TableTemplate(const char *name,
TableTemplate::~TableTemplate() TableTemplate::~TableTemplate()
{ {
stringDelete(name_); stringDelete(name_);
delete axis1_;
delete axis2_;
delete axis3_;
} }
void void
@ -2536,19 +2533,19 @@ TableTemplate::setName(const char *name)
} }
void void
TableTemplate::setAxis1(TableAxis *axis) TableTemplate::setAxis1(TableAxisPtr axis)
{ {
axis1_ = axis; axis1_ = axis;
} }
void void
TableTemplate::setAxis2(TableAxis *axis) TableTemplate::setAxis2(TableAxisPtr axis)
{ {
axis2_ = axis; axis2_ = axis;
} }
void void
TableTemplate::setAxis3(TableAxis *axis) TableTemplate::setAxis3(TableAxisPtr axis)
{ {
axis3_ = axis; axis3_ = axis;
} }

43
liberty/LibertyReader.cc
View File

@ -1298,33 +1298,30 @@ void
LibertyReader::endTableTemplate(LibertyGroup *group) LibertyReader::endTableTemplate(LibertyGroup *group)
{ {
if (tbl_template_) { if (tbl_template_) {
TableAxis *axis; TableAxisPtr axis1 = makeAxis(0, group);
makeAxis(0, group, axis); if (axis1)
if (axis) tbl_template_->setAxis1(axis1);
tbl_template_->setAxis1(axis); TableAxisPtr axis2 = makeAxis(1, group);
makeAxis(1, group, axis); if (axis2)
if (axis) tbl_template_->setAxis2(axis2);
tbl_template_->setAxis2(axis); TableAxisPtr axis3 = makeAxis(2, group);
makeAxis(2, group, axis); if (axis3)
if (axis) tbl_template_->setAxis3(axis3);
tbl_template_->setAxis3(axis);
tbl_template_ = nullptr; tbl_template_ = nullptr;
} }
} }
void TableAxisPtr
LibertyReader::makeAxis(int index, LibertyReader::makeAxis(int index,
LibertyGroup *group, LibertyGroup *group)
TableAxis *&axis)
{ {
axis = nullptr;
TableAxisVariable axis_var = axis_var_[index]; TableAxisVariable axis_var = axis_var_[index];
FloatSeq *axis_values = axis_values_[index]; FloatSeq *axis_values = axis_values_[index];
if (axis_var != TableAxisVariable::unknown && axis_values) { if (axis_var != TableAxisVariable::unknown && axis_values) {
const Units *units = library_->units(); const Units *units = library_->units();
float scale = tableVariableUnit(axis_var, units)->scale(); float scale = tableVariableUnit(axis_var, units)->scale();
scaleFloats(axis_values, scale); scaleFloats(axis_values, scale);
axis = new TableAxis(axis_var, axis_values); return std::make_shared<TableAxis>(axis_var, axis_values);
} }
else if (axis_var == TableAxisVariable::unknown && axis_values) { else if (axis_var == TableAxisVariable::unknown && axis_values) {
libWarn(62, group, "missing variable_%d attribute.", index + 1); 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 // No warning for missing index_xx attributes because they are
// not required by ic_shell. // not required by ic_shell.
return nullptr;
} }
static void static void
@ -3878,7 +3876,6 @@ LibertyReader::beginTable(LibertyGroup *group,
axis_[0] = axis_[1] = axis_[2] = nullptr; axis_[0] = axis_[1] = axis_[2] = nullptr;
} }
clearAxisValues(); clearAxisValues();
own_axis_[0] = own_axis_[1] = own_axis_[2] = false;
table_ = nullptr; table_ = nullptr;
table_model_scale_ = scale; table_model_scale_ = scale;
} }
@ -3926,25 +3923,20 @@ LibertyReader::makeTable(LibertyAttr *attr,
FloatTable *table = makeFloatTable(attr, FloatTable *table = makeFloatTable(attr,
axis_[0]->size()*axis_[1]->size(), axis_[0]->size()*axis_[1]->size(),
axis_[2]->size(), scale); axis_[2]->size(), scale);
table_ = new Table3(table, table_ = new Table3(table, axis_[0], axis_[1], axis_[2]);
axis_[0], own_axis_[0],
axis_[1], own_axis_[1],
axis_[2], own_axis_[2]);
} }
else if (axis_[0] && axis_[1]) { else if (axis_[0] && axis_[1]) {
// Row variable1/axis[0] // Row variable1/axis[0]
// Column variable2/axis[1] // Column variable2/axis[1]
FloatTable *table = makeFloatTable(attr, axis_[0]->size(), FloatTable *table = makeFloatTable(attr, axis_[0]->size(),
axis_[1]->size(), scale); axis_[1]->size(), scale);
table_ = new Table2(table, table_ = new Table2(table, axis_[0], axis_[1]);
axis_[0], own_axis_[0],
axis_[1], own_axis_[1]);
} }
else if (axis_[0]) { else if (axis_[0]) {
FloatTable *table = makeFloatTable(attr, 1, axis_[0]->size(), scale); FloatTable *table = makeFloatTable(attr, 1, axis_[0]->size(), scale);
FloatSeq *values = (*table)[0]; FloatSeq *values = (*table)[0];
delete table; delete table;
table_ = new Table1(values, axis_[0], own_axis_[0]); table_ = new Table1(values, axis_[0]);
} }
else { else {
FloatTable *table = makeFloatTable(attr, 1, 1, scale); FloatTable *table = makeFloatTable(attr, 1, 1, scale);
@ -4017,8 +4009,7 @@ LibertyReader::makeTableAxis(int index)
const Units *units = library_->units(); const Units *units = library_->units();
float scale = tableVariableUnit(var, units)->scale(); float scale = tableVariableUnit(var, units)->scale();
scaleFloats(values, scale); scaleFloats(values, scale);
axis_[index] = new TableAxis(var, values); axis_[index] = std::make_shared<TableAxis>(var, values);
own_axis_[index] = true;
} }
} }

8
liberty/LibertyReaderPvt.hh
View File

@ -481,9 +481,8 @@ protected:
LibertyAttr *attr); LibertyAttr *attr);
void visitIndex(int index, void visitIndex(int index,
LibertyAttr *attr); LibertyAttr *attr);
void makeAxis(int index, TableAxisPtr makeAxis(int index,
LibertyGroup *group, LibertyGroup *group);
TableAxis *&axis);
FloatSeq *readFloatSeq(LibertyAttr *attr, FloatSeq *readFloatSeq(LibertyAttr *attr,
float scale); float scale);
void variableValue(const char *var, void variableValue(const char *var,
@ -564,8 +563,7 @@ protected:
PathType path_type_; PathType path_type_;
LibertyPgPort *pg_port_; LibertyPgPort *pg_port_;
ScaleFactorType scale_factor_type_; ScaleFactorType scale_factor_type_;
TableAxis *axis_[3]; TableAxisPtr axis_[3];
bool own_axis_[3];
Table *table_; Table *table_;
float table_model_scale_; float table_model_scale_;
ModeDef *mode_def_; ModeDef *mode_def_;

10
liberty/LibertyWriter.cc
View File

@ -60,7 +60,7 @@ protected:
void writeTableModel0(const TableModel *model); void writeTableModel0(const TableModel *model);
void writeTableModel1(const TableModel *model); void writeTableModel1(const TableModel *model);
void writeTableModel2(const TableModel *model); void writeTableModel2(const TableModel *model);
void writeTableAxis(TableAxis *axis, void writeTableAxis(TableAxisPtr axis,
int index); int index);
const char *asString(bool value); const char *asString(bool value);
@ -204,9 +204,9 @@ LibertyWriter::writeTableTemplates()
void void
LibertyWriter::writeTableTemplate(TableTemplate *tbl_template) LibertyWriter::writeTableTemplate(TableTemplate *tbl_template)
{ {
TableAxis *axis1 = tbl_template->axis1(); TableAxisPtr axis1 = tbl_template->axis1();
TableAxis *axis2 = tbl_template->axis2(); TableAxisPtr axis2 = tbl_template->axis2();
TableAxis *axis3 = tbl_template->axis3(); TableAxisPtr axis3 = tbl_template->axis3();
// skip scalar templates // skip scalar templates
if (axis1) { if (axis1) {
fprintf(stream_, " lu_table_template(%s) {\n", tbl_template->name()); fprintf(stream_, " lu_table_template(%s) {\n", tbl_template->name());
@ -229,7 +229,7 @@ LibertyWriter::writeTableTemplate(TableTemplate *tbl_template)
} }
void void
LibertyWriter::writeTableAxis(TableAxis *axis, LibertyWriter::writeTableAxis(TableAxisPtr axis,
int index) int index)
{ {
fprintf(stream_, " index_%d (\"", index); fprintf(stream_, " index_%d (\"", index);

74
liberty/TableModel.cc
View File

@ -268,9 +268,9 @@ GateTableModel::maxCapSlew(const LibertyCell *cell,
float &cap) const float &cap) const
{ {
const LibertyLibrary *library = cell->libertyLibrary(); const LibertyLibrary *library = cell->libertyLibrary();
TableAxis *axis1 = slew_model_->axis1(); TableAxisPtr axis1 = slew_model_->axis1();
TableAxis *axis2 = slew_model_->axis2(); TableAxisPtr axis2 = slew_model_->axis2();
TableAxis *axis3 = slew_model_->axis3(); TableAxisPtr axis3 = slew_model_->axis3();
if (axis1 if (axis1
&& axis1->variable() == TableAxisVariable::total_output_net_capacitance) { && axis1->variable() == TableAxisVariable::total_output_net_capacitance) {
cap = axis1->axisValue(axis1->size() - 1); cap = axis1->axisValue(axis1->size() - 1);
@ -300,7 +300,7 @@ GateTableModel::maxCapSlew(const LibertyCell *cell,
} }
float float
GateTableModel::axisValue(TableAxis *axis, GateTableModel::axisValue(TableAxisPtr axis,
float in_slew, float in_slew,
float load_cap, float load_cap,
float related_out_cap) const float related_out_cap) const
@ -322,9 +322,9 @@ GateTableModel::axisValue(TableAxis *axis,
bool bool
GateTableModel::checkAxes(const Table *table) GateTableModel::checkAxes(const Table *table)
{ {
TableAxis *axis1 = table->axis1(); TableAxisPtr axis1 = table->axis1();
TableAxis *axis2 = table->axis2(); TableAxisPtr axis2 = table->axis2();
TableAxis *axis3 = table->axis3(); TableAxisPtr axis3 = table->axis3();
bool axis_ok = true; bool axis_ok = true;
if (axis1) if (axis1)
axis_ok &= checkAxis(table->axis1()); axis_ok &= checkAxis(table->axis1());
@ -336,7 +336,7 @@ GateTableModel::checkAxes(const Table *table)
} }
bool bool
GateTableModel::checkAxis(TableAxis *axis) GateTableModel::checkAxis(TableAxisPtr axis)
{ {
TableAxisVariable var = axis->variable(); TableAxisVariable var = axis->variable();
return var == TableAxisVariable::total_output_net_capacitance return var == TableAxisVariable::total_output_net_capacitance
@ -510,7 +510,7 @@ CheckTableModel::findAxisValues(float from_slew,
} }
float float
CheckTableModel::axisValue(TableAxis *axis, CheckTableModel::axisValue(TableAxisPtr axis,
float from_slew, float from_slew,
float to_slew, float to_slew,
float related_out_cap) const float related_out_cap) const
@ -531,9 +531,9 @@ CheckTableModel::axisValue(TableAxis *axis,
bool bool
CheckTableModel::checkAxes(const Table *table) CheckTableModel::checkAxes(const Table *table)
{ {
TableAxis *axis1 = table->axis1(); TableAxisPtr axis1 = table->axis1();
TableAxis *axis2 = table->axis2(); TableAxisPtr axis2 = table->axis2();
TableAxis *axis3 = table->axis3(); TableAxisPtr axis3 = table->axis3();
bool axis_ok = true; bool axis_ok = true;
if (axis1) if (axis1)
axis_ok &= checkAxis(table->axis1()); axis_ok &= checkAxis(table->axis1());
@ -545,7 +545,7 @@ CheckTableModel::checkAxes(const Table *table)
} }
bool bool
CheckTableModel::checkAxis(TableAxis *axis) CheckTableModel::checkAxis(TableAxisPtr axis)
{ {
TableAxisVariable var = axis->variable(); TableAxisVariable var = axis->variable();
return var == TableAxisVariable::constrained_pin_transition return var == TableAxisVariable::constrained_pin_transition
@ -590,19 +590,19 @@ TableModel::setIsScaled(bool is_scaled)
is_scaled_ = is_scaled; is_scaled_ = is_scaled;
} }
TableAxis * TableAxisPtr
TableModel::axis1() const TableModel::axis1() const
{ {
return table_->axis1(); return table_->axis1();
} }
TableAxis * TableAxisPtr
TableModel::axis2() const TableModel::axis2() const
{ {
return table_->axis2(); return table_->axis2();
} }
TableAxis * TableAxisPtr
TableModel::axis3() const TableModel::axis3() const
{ {
return table_->axis3(); return table_->axis3();
@ -762,20 +762,16 @@ Table0::report(const Units *units,
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
Table1::Table1(FloatSeq *values, Table1::Table1(FloatSeq *values,
TableAxis *axis1, TableAxisPtr axis1) :
bool own_axis1) :
Table(), Table(),
values_(values), values_(values),
axis1_(axis1), axis1_(axis1)
own_axis1_(own_axis1)
{ {
} }
Table1::~Table1() Table1::~Table1()
{ {
delete values_; delete values_;
if (own_axis1_)
delete axis1_;
} }
float float
@ -887,16 +883,12 @@ Table1::report(const Units *units,
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
Table2::Table2(FloatTable *values, Table2::Table2(FloatTable *values,
TableAxis *axis1, TableAxisPtr axis1,
bool own_axis1, TableAxisPtr axis2) :
TableAxis *axis2,
bool own_axis2) :
Table(), Table(),
values_(values), values_(values),
axis1_(axis1), axis1_(axis1),
own_axis1_(own_axis1), axis2_(axis2)
axis2_(axis2),
own_axis2_(own_axis2)
{ {
} }
@ -904,10 +896,6 @@ Table2::~Table2()
{ {
values_->deleteContents(); values_->deleteContents();
delete values_; delete values_;
if (own_axis1_)
delete axis1_;
if (own_axis2_)
delete axis2_;
} }
float float
@ -1089,24 +1077,14 @@ Table2::report(const Units *units,
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
Table3::Table3(FloatTable *values, Table3::Table3(FloatTable *values,
TableAxis *axis1, TableAxisPtr axis1,
bool own_axis1, TableAxisPtr axis2,
TableAxis *axis2, TableAxisPtr axis3) :
bool own_axis2, Table2(values, axis1, axis2),
TableAxis *axis3, axis3_(axis3)
bool own_axis3) :
Table2(values, axis1, own_axis1, axis2, own_axis2),
axis3_(axis3),
own_axis3_(own_axis3)
{ {
} }
Table3::~Table3()
{
if (own_axis3_)
delete axis3_;
}
float float
Table3::value(size_t index1, Table3::value(size_t index1,
size_t index2, size_t index2,

14
search/MakeTimingModel.cc
View File

@ -519,7 +519,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
drvr_self_delay, drvr_self_slew); drvr_self_delay, drvr_self_slew);
const TableModel *drvr_table = drvr_gate_model->delayModel(); 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(); const FloatSeq *drvr_axis_values = drvr_load_axis->values();
FloatSeq *load_values = new FloatSeq; FloatSeq *load_values = new FloatSeq;
@ -538,12 +538,12 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
} }
FloatSeq *axis_values = new FloatSeq(*drvr_axis_values); FloatSeq *axis_values = new FloatSeq(*drvr_axis_values);
TableAxis *load_axis = TableAxisPtr load_axis =
new TableAxis(TableAxisVariable::total_output_net_capacitance, std::make_shared<TableAxis>(TableAxisVariable::total_output_net_capacitance,
axis_values); axis_values);
Table *delay_table = new Table1(load_values, load_axis, true); Table *delay_table = new Table1(load_values, load_axis);
Table *slew_table = new Table1(slew_values, load_axis, true); Table *slew_table = new Table1(slew_values, load_axis);
string template_name = "template_"; string template_name = "template_";
template_name += std::to_string(tbl_template_index_++); template_name += std::to_string(tbl_template_index_++);
@ -570,7 +570,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
return makeGateModelScalar(delay, slew, rf); return makeGateModelScalar(delay, slew, rf);
} }
TableAxis * TableAxisPtr
MakeTimingModel::loadCapacitanceAxis(const TableModel *table) MakeTimingModel::loadCapacitanceAxis(const TableModel *table)
{ {
if (table->axis1()->variable() == TableAxisVariable::total_output_net_capacitance) if (table->axis1()->variable() == TableAxisVariable::total_output_net_capacitance)

2
search/MakeTimingModel.hh
View File

@ -75,7 +75,7 @@ private:
TimingModel *makeGateModelTable(const Pin *output_pin, TimingModel *makeGateModelTable(const Pin *output_pin,
Delay delay, Delay delay,
RiseFall *rf); RiseFall *rf);
TableAxis *loadCapacitanceAxis(const TableModel *table); TableAxisPtr loadCapacitanceAxis(const TableModel *table);
LibertyPort *modelPort(const Pin *pin); LibertyPort *modelPort(const Pin *pin);
Sta *sta_; Sta *sta_;

32
search/WritePathSpice.cc
View File

@ -575,25 +575,23 @@ WritePathSpice::slewAxisMinValue(TimingArc *arc)
GateTableModel *gate_model = dynamic_cast<GateTableModel*>(arc->model()); GateTableModel *gate_model = dynamic_cast<GateTableModel*>(arc->model());
if (gate_model) { if (gate_model) {
const TableModel *model = gate_model->delayModel(); const TableModel *model = gate_model->delayModel();
TableAxis *axis; TableAxisPtr axis1 = model->axis1();
TableAxisVariable var; TableAxisVariable var1 = axis1->variable();
axis = model->axis1(); if (var1 == TableAxisVariable::input_transition_time
var = axis->variable(); || var1 == TableAxisVariable::input_net_transition)
if (var == TableAxisVariable::input_transition_time return axis1->axisValue(0);
|| var == TableAxisVariable::input_net_transition)
return axis->axisValue(0);
axis = model->axis2(); TableAxisPtr axis2 = model->axis2();
var = axis->variable(); TableAxisVariable var2 = axis2->variable();
if (var == TableAxisVariable::input_transition_time if (var2 == TableAxisVariable::input_transition_time
|| var == TableAxisVariable::input_net_transition) || var2 == TableAxisVariable::input_net_transition)
return axis->axisValue(0); return axis2->axisValue(0);
axis = model->axis3(); TableAxisPtr axis3 = model->axis3();
var = axis->variable(); TableAxisVariable var3 = axis3->variable();
if (var == TableAxisVariable::input_transition_time if (var3 == TableAxisVariable::input_transition_time
|| var == TableAxisVariable::input_net_transition) || var3 == TableAxisVariable::input_net_transition)
return axis->axisValue(0); return axis3->axisValue(0);
} }
return 0.0; return 0.0;
} }