Merge remote-tracking branch 'parallax/master'

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()),
-  power_(attrs->power())
+  related_pg_port_(related_pg_port),
+  when_(when),
+  power_(power)
 {
-  cell->addLeakagePower(this);
 }
 
 LeakagePower::~LeakagePower()

liberty/LibertyBuilder.cc

@@ -757,11 +757,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

@@ -71,8 +71,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

@@ -2248,7 +2248,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();
@@ -5441,6 +5445,8 @@ LibertyReader::visitRelatedPgPin(LibertyAttr *attr)
 {
   if (internal_power_)
     internal_power_->setRelatedPgPin(getAttrString(attr));
+  else if (leakage_power_)
+    leakage_power_->setRelatedPgPin(getAttrString(attr));
 }
 
 ////////////////////////////////////////////////////////////////
@@ -6103,13 +6109,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

@@ -899,13 +899,21 @@ public:
   virtual ~InternalPowerGroup();
 };
 
-class LeakagePowerGroup : public LeakagePowerAttrs
+class LeakagePowerGroup
 {
 public:
-  explicit LeakagePowerGroup(int line);
-  virtual ~LeakagePowerGroup();
+  LeakagePowerGroup(int line);
+  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

@@ -1296,26 +1296,32 @@ Power::findLeakagePower(const Instance *inst,
   bool found_uncond = false;
   float cond_duty_sum = 0.0;
   for (LeakagePower *leak : *corner_cell->leakagePowers()) {
-    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",
-                 cell->name(),
-                 when->to_string().c_str(),
-                 leak->power(),
-                 cond_duty);
-      cond_leakage += leak->power() * cond_duty;
-      if (leak->power() > 0.0)
-        cond_duty_sum += cond_duty;
-      found_cond = true;
-    }
-    else {
-      debugPrint(debug_, "power", 2, "leakage -- %s %.3e",
-                 cell->name(),
-                 leak->power());
-      uncond_leakage += leak->power();
-      found_uncond = true;
+    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 %s %.3e * %.2f",
+                   cell->name(),
+                   leak->relatedPgPort()->name(),
+                   when->to_string().c_str(),
+                   leak->power(),
+                   cond_duty);
+        cond_leakage += leak->power() * cond_duty;
+        if (leak->power() > 0.0)
+          cond_duty_sum += cond_duty;
+        found_cond = true;
+      }
+      else {
+        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;