TableModel::axis functions return pointer

Signed-off-by: James Cherry <cherry@parallaxsw.com>

include/sta/InternalPower.hh

@@ -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_;
 };

include/sta/TableModel.hh

@@ -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;
+  const TableAxis *axis1() const;
-  TableAxisPtr axis2() const;
+  const TableAxis *axis2() const;
-  TableAxisPtr axis3() 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 const TableAxis *axis1() const { return nullptr; }
-  virtual TableAxisPtr axis2() const { return nullptr; }
+  virtual const TableAxis *axis2() const { return nullptr; }
-  virtual TableAxisPtr axis3() 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_; }
+  const TableAxis *axis1() const override { return axis1_.get(); }
-  TableAxisPtr axis2() const override { return axis2_; }
+  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_; }
+  const TableAxis *axis1() const override { return axis1_.get(); }
-  TableAxisPtr axis2() const override { return axis2_; }
+  const TableAxis *axis2() const override { return axis2_.get(); }
-  TableAxisPtr axis3() const override { return axis3_; }
+  const TableAxis *axis3() const override { return axis3_.get(); }
   float value(size_t axis_index1,
               size_t axis_index2,
               size_t axis_index3) const override;

liberty/InternalPower.cc

@@ -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 TableAxis *axis1 = model->axis1();
-  const TableAxisPtr axis2 = model->axis2();
+  const TableAxis *axis2 = model->axis2();
-  const TableAxisPtr axis3 = model->axis3();
+  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

liberty/Liberty.cc

@@ -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();
+    const TableAxis *axis1 = model->axis1();
-    TableAxisPtr axis2 = model->axis2();
+    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();
+    const TableAxis *axis1 = table->axis1();
-    TableAxisPtr axis2 = table->axis2();
+    const TableAxis *axis2 = table->axis2();
     TableAxisVariable var1 = axis1->variable();
     TableAxisVariable var2 = axis2->variable();
     return (var1 == TableAxisVariable::output_pin_transition

liberty/TableModel.cc

@@ -269,9 +269,9 @@ GateTableModel::maxCapSlew(float in_slew,
 			   float &slew,
 			   float &cap) const
 {
-  TableAxisPtr axis1 = slew_model_->axis1();
+  const TableAxis *axis1 = slew_model_->axis1();
-  TableAxisPtr axis2 = slew_model_->axis2();
+  const TableAxis *axis2 = slew_model_->axis2();
-  TableAxisPtr axis3 = slew_model_->axis3();
+  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();
+  const TableAxis *axis1 = table->axis1();
-  TableAxisPtr axis2 = table->axis2();
+  const TableAxis *axis2 = table->axis2();
-  TableAxisPtr axis3 = table->axis3();
+  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();
+  const TableAxis *axis1 = table->axis1();
-  TableAxisPtr axis2 = table->axis2();
+  const TableAxis *axis2 = table->axis2();
-  TableAxisPtr axis3 = table->axis3();
+  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();
+  const TableAxis *axis1 = table->axis1();
-  TableAxisPtr axis2 = table->axis2();
+  const TableAxis *axis2 = table->axis2();
-  TableAxisPtr axis3 = table->axis3();
+  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()) {

search/MakeTimingModel.cc

@@ -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()

search/MakeTimingModelPvt.hh

@@ -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();

search/WritePathSpice.cc

@@ -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)