max_slew/fanout/capacitance_check_slack

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

include/sta/Sta.hh

@@ -626,6 +626,7 @@ public:
 		 Slew &slew,
 		 float &limit,
 		 float &slack);
+  float maxSlewCheckSlack();
 
   void checkFanoutLimitPreamble();
   // Return pins with the min/max fanout limit slack.
@@ -646,6 +647,7 @@ public:
 		   float &fanout,
 		   float &limit,
 		   float &slack);
+  float maxFanoutCheckSlack();
 
   void checkCapacitanceLimitPreamble();
   // Return pins with the min/max slew limit slack.
@@ -672,6 +674,7 @@ public:
 			float &capacitance,
 			float &limit,
 			float &slack);
+  float maxCapacitanceCheckSlack();
 
   // Min pulse width check with the least slack.
   // corner=nullptr checks all corners.

search/CheckFanoutLimits.hh

@@ -41,9 +41,6 @@ public:
   PinSeq *checkFanoutLimits(Net *net,
                             bool violators,
                             const MinMax *min_max);
-
-
-protected:
   void checkFanout(const Pin *pin,
 		   const MinMax *min_max,
 		   float limit1,
@@ -51,6 +48,8 @@ protected:
 		   float &fanout,
 		   float &slack,
 		   float &limit) const;
+
+protected:
   void findLimit(const Pin *pin,
 		 const MinMax *min_max,
 		 // Return values.

search/Sta.cc

@@ -5187,6 +5187,26 @@ Sta::checkSlew(const Pin *pin,
 				corner1, rf, slew, limit, slack);
 }
 
+float
+Sta::maxSlewCheckSlack()
+{
+  checkSlewLimitPreamble();
+  PinSeq *pins = check_slew_limits_->checkSlewLimits(nullptr, false, nullptr,
+                                                     MinMax::max());
+  float slack = INF;
+  if (!pins->empty()) {
+    Pin *pin = (*pins)[0];
+    const Corner *corner;
+    const RiseFall *rf;
+    Slew slew;
+    float limit;
+    check_slew_limits_->checkSlew(pin, nullptr, MinMax::max(), true,
+                                  corner, rf, slew, limit, slack);
+  }
+  delete pins;
+  return slack;
+}
+
 ////////////////////////////////////////////////////////////////'
 
 void
@@ -5247,6 +5267,23 @@ Sta::checkFanout(const Pin *pin,
 				    fanout, limit, slack);
 }
 
+float
+Sta::maxFanoutCheckSlack()
+{
+  checkFanoutLimitPreamble();
+  PinSeq *pins = check_fanout_limits_->checkFanoutLimits(nullptr, false, MinMax::max());
+  float slack = INF;
+  if (!pins->empty()) {
+    Pin *pin = (*pins)[0];
+    float fanout;
+    float limit;
+    check_fanout_limits_->checkFanout(pin, MinMax::max(), true,
+                                      fanout, limit, slack);
+  }
+  delete pins;
+  return slack;
+}
+
 ////////////////////////////////////////////////////////////////'
 
 void
@@ -5321,6 +5358,27 @@ Sta::checkCapacitance(const Pin *pin,
 					      limit, slack);
 }
 
+float
+Sta::maxCapacitanceCheckSlack()
+{
+  checkCapacitanceLimitPreamble();
+  PinSeq *pins = check_capacitance_limits_->checkCapacitanceLimits(nullptr, false,
+                                                                   nullptr,
+                                                                   MinMax::max());
+  float slack = INF;
+  if (!pins->empty()) {
+    Pin *pin = (*pins)[0];
+    const Corner *corner;
+    const RiseFall *rf;
+    float capacitance;
+    float limit;
+    check_capacitance_limits_->checkCapacitance(pin, nullptr, MinMax::max(),
+                                                corner, rf, capacitance, limit, slack);
+  }
+  delete pins;
+  return slack;
+}
+
 ////////////////////////////////////////////////////////////////
 
 void

tcl/StaTcl.i

@@ -4755,6 +4755,13 @@ max_slew_violation_count()
   return Sta::sta()->checkSlewLimits(nullptr, true, nullptr, MinMax::max())->size();
 }
 
+float
+max_slew_check_slack()
+{
+  cmdLinkedNetwork();
+  return Sta::sta()->maxSlewCheckSlack();
+}
+
 void
 report_slew_limit_short_header()
 {
@@ -4795,6 +4802,13 @@ max_fanout_violation_count()
   return Sta::sta()->checkFanoutLimits(nullptr, true, MinMax::max())->size();
 }
 
+float
+max_fanout_check_slack()
+{
+  cmdLinkedNetwork();
+  return Sta::sta()->maxFanoutCheckSlack();
+}
+
 void
 report_fanout_limit_short_header()
 {
@@ -4834,6 +4848,13 @@ max_capacitance_violation_count()
   return Sta::sta()->checkCapacitanceLimits(nullptr, true,nullptr,MinMax::max())->size();
 }
 
+float
+max_capacitance_check_slack()
+{
+  cmdLinkedNetwork();
+  return Sta::sta()->maxCapacitanceCheckSlack();
+}
+
 void
 report_capacitance_limit_short_header()
 {