Merge branch 'master' into rel_3.0

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

include/sta/LeakagePower.hh

@@ -28,34 +28,23 @@
 
 namespace sta {
 
-class LeakagePowerAttrs;
-
-class LeakagePowerAttrs
-{
-public:
-  LeakagePowerAttrs();
-  FuncExpr *when() const { return when_; }
-  void setWhen(FuncExpr *when);
-  float power() { return power_; }
-  void setPower(float power);
-
-protected:
-  FuncExpr *when_;
-  float power_;
-};
-
 class LeakagePower
 {
 public:
+  LeakagePower();
   LeakagePower(LibertyCell *cell,
-               LeakagePowerAttrs *attrs);
+               LibertyPort *related_pg_port,
+               FuncExpr *when,
+               float power);
   ~LeakagePower();
   LibertyCell *libertyCell() const { return cell_; }
+  LibertyPort *relatedPgPort() const { return related_pg_port_; }
   FuncExpr *when() const { return when_; }
-  float power() { return power_; }
+  float power() const { return power_; }
 
 protected:
   LibertyCell *cell_;
+  LibertyPort *related_pg_port_;
   FuncExpr *when_;
   float power_;
 };

liberty/LeakagePower.cc

@@ -30,33 +30,15 @@
 
 namespace sta {
 
-LeakagePowerAttrs::LeakagePowerAttrs() :
-  when_(nullptr),
-  power_(0.0)
-{
-}
-
-void
-LeakagePowerAttrs::setWhen(FuncExpr *when)
-{
-  when_ = when;
-}
-
-void
-LeakagePowerAttrs::setPower(float power)
-{
-  power_ = power;
-}
-
-////////////////////////////////////////////////////////////////
-
 LeakagePower::LeakagePower(LibertyCell *cell,
-                           LeakagePowerAttrs *attrs) :
+                           LibertyPort *related_pg_port,
+                           FuncExpr *when,
+                           float power) :
   cell_(cell),
-  when_(attrs->when()),
+  related_pg_port_(related_pg_port),
-  power_(attrs->power())
+  when_(when),
+  power_(power)
 {
-  cell->addLeakagePower(this);
 }
 
 LeakagePower::~LeakagePower()

liberty/LibertyBuilder.cc

@@ -758,11 +758,4 @@ LibertyBuilder::makeInternalPower(LibertyCell *cell,
   return new InternalPower(cell, port, related_port, attrs);
 }
 
-LeakagePower *
-LibertyBuilder::makeLeakagePower(LibertyCell *cell,
-                                 LeakagePowerAttrs *attrs)
-{
-  return new LeakagePower(cell, attrs);
-}
-
 } // namespace

liberty/LibertyBuilder.hh

@@ -70,8 +70,6 @@ public:
                                    LibertyPort *port,
                                    LibertyPort *related_port,
                                    InternalPowerAttrs *attrs);
-  LeakagePower *makeLeakagePower(LibertyCell *cell,
-                                 LeakagePowerAttrs *attrs);
 
   TimingArcSet *makeFromTransitionArcs(LibertyCell *cell,
                                        LibertyPort *from_port,

liberty/LibertyReader.cc

@@ -2245,7 +2245,11 @@ void
 LibertyReader::makeLeakagePowers()
 {
   for (LeakagePowerGroup *power_group : leakage_powers_) {
-    builder_.makeLeakagePower(cell_, power_group);
+    LibertyPort *related_pg_pin =
+      cell_->findLibertyPort(power_group->relatedPgPin().c_str());
+    LeakagePower *leakage = new LeakagePower(cell_, related_pg_pin, power_group->when(),
+                                             power_group->power());
+    cell_->addLeakagePower(leakage);
     delete power_group;
   }
   leakage_powers_.clear();
@@ -5418,6 +5422,8 @@ LibertyReader::visitRelatedPgPin(LibertyAttr *attr)
 {
   if (internal_power_)
     internal_power_->setRelatedPgPin(getAttrString(attr));
+  else if (leakage_power_)
+    leakage_power_->setRelatedPgPin(getAttrString(attr));
 }
 
 ////////////////////////////////////////////////////////////////
@@ -6080,13 +6086,28 @@ InternalPowerGroup::~InternalPowerGroup()
 ////////////////////////////////////////////////////////////////
 
 LeakagePowerGroup::LeakagePowerGroup(int line) :
-  LeakagePowerAttrs(),
+  when_(nullptr),
+  power_(0.0),
   line_(line)
 {
 }
 
-LeakagePowerGroup::~LeakagePowerGroup()
+void
+LeakagePowerGroup::setRelatedPgPin(std::string pin_name)
 {
+  related_pg_pin_ = std::move(pin_name);
+}
+
+void
+LeakagePowerGroup::setWhen(FuncExpr *when)
+{
+  when_ = when;
+}
+
+void
+LeakagePowerGroup::setPower(float power)
+{
+  power_ = power;
 }
 
 ////////////////////////////////////////////////////////////////

liberty/LibertyReaderPvt.hh

@@ -896,13 +896,21 @@ public:
   virtual ~InternalPowerGroup();
 };
 
-class LeakagePowerGroup : public LeakagePowerAttrs
+class LeakagePowerGroup
 {
 public:
   LeakagePowerGroup(int line);
-  virtual ~LeakagePowerGroup();
+  const std::string &relatedPgPin() const { return related_pg_pin_; }
+  void setRelatedPgPin(std::string pin_name);
+  FuncExpr *when() const { return when_; }
+  void setWhen(FuncExpr *when);
+  float power() const { return power_; }
+  void setPower(float power);
 
 protected:
+  std::string related_pg_pin_;
+  FuncExpr *when_;
+  float power_;
   int line_;
 };
 

power/Power.cc

@@ -1495,12 +1495,16 @@ Power::findLeakagePower(const Instance *inst,
   bool found_uncond = false;
   float cond_duty_sum = 0.0;
   for (LeakagePower *leak : *scene_cell->leakagePowers()) {
+    LibertyPort *pg_port = leak->relatedPgPort();
+    if (pg_port == nullptr
+        || pg_port->pwrGndType() == PwrGndType::primary_power) {
     FuncExpr *when = leak->when();
     if (when) {
       PwrActivity cond_activity = evalActivity(when, inst);
       float cond_duty = cond_activity.duty();
-      debugPrint(debug_, "power", 2, "leakage %s %s %.3e * %.2f",
+        debugPrint(debug_, "power", 2, "leakage %s %s %s %.3e * %.2f",
                  cell->name(),
+                   leak->relatedPgPort()->name(),
                  when->to_string().c_str(),
                  leak->power(),
                  cond_duty);
@@ -1510,13 +1514,15 @@ Power::findLeakagePower(const Instance *inst,
       found_cond = true;
     }
     else {
-      debugPrint(debug_, "power", 2, "leakage -- %s %.3e",
+        debugPrint(debug_, "power", 2, "leakage %s %s -- %.3e",
                  cell->name(),
+                   leak->relatedPgPort()->name(),
                  leak->power());
       uncond_leakage += leak->power();
       found_uncond = true;
     }
   }
+  }
   float leakage = 0.0;
   float cell_leakage;
   bool cell_leakage_exists;