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

TableModel::axis functions return pointer 

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2023-12-12 15:32:30 -07:00
parent 88c49f1ea7
commit 163d776afa
8 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sta/InternalPower.hh
View File

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

32
include/sta/TableModel.hh
View File

@ -89,7 +89,7 @@ protected:
float &slew,
float &cap) const;
void setIsScaled(bool is_scaled) override;
float axisValue(TableAxisPtr axis,
float axisValue(const TableAxis *axis,
float load_cap,
float in_slew,
float related_out_cap) const;
@ -113,7 +113,7 @@ protected:
float &axis_value1,
float &axis_value2,
float &axis_value3) const;
static bool checkAxis(TableAxisPtr axis);
static bool checkAxis(const TableAxis *axis);
TableModel *delay_model_;
TableModel *delay_sigma_models_[EarlyLate::index_count];
@ -164,7 +164,7 @@ protected:
float &axis_value1,
float &axis_value2,
float &axis_value3) const;
float axisValue(TableAxisPtr axis,
float axisValue(const TableAxis *axis,
float load_cap,
float in_slew,
float related_out_cap) const;
@ -176,7 +176,7 @@ protected:
float to_slew,
float related_out_cap,
int digits) const;
static bool checkAxis(TableAxisPtr axis);
static bool checkAxis(const TableAxis *axis);
TableModel *model_;
TableModel *sigma_models_[EarlyLate::index_count];
@ -193,9 +193,9 @@ public:
void setScaleFactorType(ScaleFactorType type);
int order() const;
TableTemplate *tblTemplate() const { return tbl_template_; }
TableAxisPtr axis1() const;
TableAxisPtr axis2() const;
TableAxisPtr axis3() const;
const TableAxis *axis1() const;
const TableAxis *axis2() const;
const TableAxis *axis3() const;
void setIsScaled(bool is_scaled);
float value(size_t index1,
size_t index2,
@ -245,9 +245,9 @@ public:
virtual ~Table() {}
void setScaleFactorType(ScaleFactorType type);
virtual int order() const = 0;
virtual TableAxisPtr axis1() const { return nullptr; }
virtual TableAxisPtr axis2() const { return nullptr; }
virtual TableAxisPtr axis3() const { return nullptr; }
virtual const TableAxis *axis1() const { return nullptr; }
virtual const TableAxis *axis2() const { return nullptr; }
virtual const TableAxis *axis3() const { return nullptr; }
void setIsScaled(bool is_scaled);
virtual float value(size_t axis_idx1,
size_t axis_idx2,
@ -316,7 +316,7 @@ public:
Table1(Table1 &&table);
Table1 &operator= (Table1 &&table);
int order() const override { return 1; }
TableAxisPtr axis1() const override { return axis1_; }
const TableAxis *axis1() const override { return axis1_.get(); }
float value(size_t axis_index1,
size_t axis_index2,
size_t axis_index3) const override;
@ -361,8 +361,8 @@ public:
TableAxisPtr axis2);
virtual ~Table2();
int order() const override { return 2; }
TableAxisPtr axis1() const override { return axis1_; }
TableAxisPtr axis2() const override { return axis2_; }
const TableAxis *axis1() const override { return axis1_.get(); }
const TableAxis *axis2() const override { return axis2_.get(); }
float value(size_t axis_index1,
size_t axis_index2,
size_t axis_index3) const override;
@ -406,9 +406,9 @@ public:
TableAxisPtr axis3);
virtual ~Table3() {}
int order() const override { return 3; }
TableAxisPtr axis1() const override { return axis1_; }
TableAxisPtr axis2() const override { return axis2_; }
TableAxisPtr axis3() const override { return axis3_; }
const TableAxis *axis1() const override { return axis1_.get(); }
const TableAxis *axis2() const override { return axis2_.get(); }
const TableAxis *axis3() const override { return axis3_.get(); }
float value(size_t axis_index1,
size_t axis_index2,
size_t axis_index3) const override;

10
liberty/InternalPower.cc
View File

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

12
liberty/Liberty.cc
View File

@ -355,7 +355,7 @@ LibertyLibrary::degradeWireSlew(const TableModel *model,
case 0:
return model->findValue(0.0, 0.0, 0.0);
case 1: {
TableAxisPtr axis1 = model->axis1();
const TableAxis *axis1 = model->axis1();
TableAxisVariable var1 = axis1->variable();
if (var1 == TableAxisVariable::output_pin_transition)
return model->findValue(in_slew, 0.0, 0.0);
@ -367,8 +367,8 @@ LibertyLibrary::degradeWireSlew(const TableModel *model,
}
}
case 2: {
TableAxisPtr axis1 = model->axis1();
TableAxisPtr axis2 = model->axis2();
const TableAxis *axis1 = model->axis1();
const TableAxis * axis2 = model->axis2();
TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable();
if (var1 == TableAxisVariable::output_pin_transition
@ -397,14 +397,14 @@ LibertyLibrary::checkSlewDegradationAxes(TablePtr table)
case 0:
return true;
case 1: {
TableAxisPtr axis1 = table->axis1();
const TableAxis *axis1 = table->axis1();
TableAxisVariable var1 = axis1->variable();
return var1 == TableAxisVariable::output_pin_transition
|| var1 == TableAxisVariable::connect_delay;
}
case 2: {
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
const TableAxis *axis1 = table->axis1();
const TableAxis *axis2 = table->axis2();
TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable();
return (var1 == TableAxisVariable::output_pin_transition

42
liberty/TableModel.cc
View File

@ -269,9 +269,9 @@ GateTableModel::maxCapSlew(float in_slew,
float &slew,
float &cap) const
{
TableAxisPtr axis1 = slew_model_->axis1();
TableAxisPtr axis2 = slew_model_->axis2();
TableAxisPtr axis3 = slew_model_->axis3();
const TableAxis *axis1 = slew_model_->axis1();
const TableAxis *axis2 = slew_model_->axis2();
const TableAxis *axis3 = slew_model_->axis3();
if (axis1
&& axis1->variable() == TableAxisVariable::total_output_net_capacitance) {
cap = axis1->axisValue(axis1->size() - 1);
@ -298,7 +298,7 @@ GateTableModel::maxCapSlew(float in_slew,
}
float
GateTableModel::axisValue(TableAxisPtr axis,
GateTableModel::axisValue(const TableAxis *axis,
float in_slew,
float load_cap,
float related_out_cap) const
@ -320,9 +320,9 @@ GateTableModel::axisValue(TableAxisPtr axis,
bool
GateTableModel::checkAxes(const TablePtr table)
{
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisPtr axis3 = table->axis3();
const TableAxis *axis1 = table->axis1();
const TableAxis *axis2 = table->axis2();
const TableAxis *axis3 = table->axis3();
bool axis_ok = true;
if (axis1)
axis_ok &= checkAxis(axis1);
@ -334,7 +334,7 @@ GateTableModel::checkAxes(const TablePtr table)
}
bool
GateTableModel::checkAxis(TableAxisPtr axis)
GateTableModel::checkAxis(const TableAxis *axis)
{
TableAxisVariable var = axis->variable();
return var == TableAxisVariable::total_output_net_capacitance
@ -369,9 +369,9 @@ ReceiverModel::setCapacitanceModel(TableModel *table_model,
bool
ReceiverModel::checkAxes(TablePtr table)
{
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisPtr axis3 = table->axis3();
const TableAxis *axis1 = table->axis1();
const TableAxis *axis2 = table->axis2();
const TableAxis *axis3 = table->axis3();
return (axis1 && axis1->variable() == TableAxisVariable::input_net_transition
&& axis2 == nullptr
&& axis3 == nullptr)
@ -540,7 +540,7 @@ CheckTableModel::findAxisValues(float from_slew,
}
float
CheckTableModel::axisValue(TableAxisPtr axis,
CheckTableModel::axisValue(const TableAxis *axis,
float from_slew,
float to_slew,
float related_out_cap) const
@ -561,9 +561,9 @@ CheckTableModel::axisValue(TableAxisPtr axis,
bool
CheckTableModel::checkAxes(const TablePtr table)
{
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisPtr axis3 = table->axis3();
const TableAxis *axis1 = table->axis1();
const TableAxis *axis2 = table->axis2();
const TableAxis *axis3 = table->axis3();
bool axis_ok = true;
if (axis1)
axis_ok &= checkAxis(axis1);
@ -575,7 +575,7 @@ CheckTableModel::checkAxes(const TablePtr table)
}
bool
CheckTableModel::checkAxis(TableAxisPtr axis)
CheckTableModel::checkAxis(const TableAxis *axis)
{
TableAxisVariable var = axis->variable();
return var == TableAxisVariable::constrained_pin_transition
@ -615,19 +615,19 @@ TableModel::setIsScaled(bool is_scaled)
is_scaled_ = is_scaled;
}
TableAxisPtr
const TableAxis *
TableModel::axis1() const
{
return table_->axis1();
}
TableAxisPtr
const TableAxis *
TableModel::axis2() const
{
return table_->axis2();
}
TableAxisPtr
const TableAxis *
TableModel::axis3() const
{
return table_->axis3();
@ -1778,7 +1778,7 @@ OutputWaveforms::findVoltages(size_t wave_index,
// i = C dv/dt
FloatSeq volts;
Table1 *currents = current_waveforms_[wave_index];
TableAxisPtr time_axis = currents->axis1();
const TableAxis *time_axis = currents->axis1();
float prev_time = time_axis->axisValue(0);
float prev_current = currents->value(0);
float voltage = 0.0;
@ -1901,7 +1901,7 @@ DriverWaveform::~DriverWaveform()
Table1
DriverWaveform::waveform(float slew)
{
TableAxisPtr volt_axis = waveforms_->axis2();
const TableAxis *volt_axis = waveforms_->axis2();
FloatSeq *time_values = new FloatSeq;
FloatSeq *volt_values = new FloatSeq;
for (float volt : *volt_axis->values()) {

4
search/MakeTimingModel.cc
View File

@ -660,7 +660,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
const TableModel *drvr_table = drvr_gate_model->delayModel();
const TableTemplate *drvr_template = drvr_table->tblTemplate();
const TableAxisPtr drvr_load_axis = loadCapacitanceAxis(drvr_table);
const TableAxis *drvr_load_axis = loadCapacitanceAxis(drvr_table);
if (drvr_load_axis) {
const FloatSeq *drvr_axis_values = drvr_load_axis->values();
FloatSeq *load_values = new FloatSeq;
@ -726,7 +726,7 @@ MakeTimingModel::ensureTableTemplate(const TableTemplate *drvr_template,
return model_template;
}
TableAxisPtr
const TableAxis *
MakeTimingModel::loadCapacitanceAxis(const TableModel *table)
{
if (table->axis1()

2
search/MakeTimingModelPvt.hh
View File

@ -82,7 +82,7 @@ private:
const RiseFall *rf);
TableTemplate *ensureTableTemplate(const TableTemplate *drvr_template,
TableAxisPtr load_axis);
TableAxisPtr loadCapacitanceAxis(const TableModel *table);
const TableAxis *loadCapacitanceAxis(const TableModel *table);
LibertyPort *modelPort(const Pin *pin);
void saveSdc();

8
search/WritePathSpice.cc
View File

@ -584,7 +584,7 @@ WritePathSpice::writeWaveformVoltSource(const Pin *pin,
network_->pathName(pin));
streamPrint(spice_stream_, "+%.3e %.3e\n", 0.0, volt0);
Table1 waveform = drvr_waveform->waveform(slew);
TableAxisPtr time_axis = waveform.axis1();
const TableAxis *time_axis = waveform.axis1();
for (size_t time_index = 0; time_index < time_axis->size(); time_index++) {
float time = time_axis->axisValue(time_index);
float wave_volt = waveform.value(time_index);
@ -705,19 +705,19 @@ WritePathSpice::slewAxisMinValue(TimingArc *arc)
GateTableModel *gate_model = dynamic_cast<GateTableModel*>(arc->model());
if (gate_model) {
const TableModel *model = gate_model->delayModel();
TableAxisPtr axis1 = model->axis1();
const TableAxis *axis1 = model->axis1();
TableAxisVariable var1 = axis1->variable();
if (var1 == TableAxisVariable::input_transition_time
|| var1 == TableAxisVariable::input_net_transition)
return axis1->axisValue(0);
TableAxisPtr axis2 = model->axis2();
const TableAxis *axis2 = model->axis2();
TableAxisVariable var2 = axis2->variable();
if (var2 == TableAxisVariable::input_transition_time
|| var2 == TableAxisVariable::input_net_transition)
return axis2->axisValue(0);
TableAxisPtr axis3 = model->axis3();
const TableAxis *axis3 = model->axis3();
TableAxisVariable var3 = axis3->variable();
if (var3 == TableAxisVariable::input_transition_time
|| var3 == TableAxisVariable::input_net_transition)