Merge pull request #7539 from mguthaus/slew_checking

rsz: Add slew violation check to size_down, re-enable size_down.

Author: maliberty

src/rsz/README.md

@@ -5,7 +5,6 @@ the design area is `-max_utilization util` percent of the core area. `util`
 is between 0 and 100.  The `resizer` stops and reports an error if the max
 utilization is exceeded.
 
-
 ## Commands
 
 ```{note}
@@ -79,7 +78,7 @@ The `buffer_ports -inputs` command adds a buffer between the input and its
 loads.  The `buffer_ports -outputs` adds a buffer between the port driver
 and the output port. Inserting buffers on input and output ports makes
 the block input capacitances and output drives independent of the block
-internals. It uses the buffer library cell defined by `-buffer_cell` if it is given. 
+internals. It uses the buffer library cell defined by `-buffer_cell` if it is given.
 
 ```tcl
 buffer_ports 
@@ -479,6 +478,7 @@ cell footprint and leakage are also reported.
 report_buffers
     [-filtered]
 ```
+
 #### Options
 
 | Switch Name | Description |

src/rsz/src/BaseMove.cc

@@ -17,17 +17,19 @@
 #include "rsz/Resizer.hh"
 #include "sta/ArcDelayCalc.hh"
 #include "sta/Delay.hh"
+#include "sta/Fuzzy.hh"
 #include "sta/Graph.hh"
+#include "sta/GraphDelayCalc.hh"
 #include "sta/Liberty.hh"
 #include "sta/MinMax.hh"
 #include "sta/NetworkClass.hh"
+#include "sta/PortDirection.hh"
 #include "sta/TimingArc.hh"
 #include "sta/Transition.hh"
 #include "sta/Vector.hh"
 #include "utl/Logger.h"
 
 namespace rsz {
-
 using std::max;
 using std::string;
 using std::vector;
@@ -403,8 +405,8 @@ Instance* BaseMove::makeBuffer(LibertyCell* cell,
 // Acceptance criteria are as follows:
 // For direct fanout paths (fanout paths of drvr_pin), accept buffer removal
 // if slack improves (may still be violating)
-// For side fanout paths (fanout paths of side_out_pin*), accept buffer removal
-// if slack doesn't become violating (no new violations)
+// For side fanout paths (fanout paths of side_out_pin*), accept buffer
+// removal if slack doesn't become violating (no new violations)
 //
 //               input_net                             output_net
 //  prev_drv_pin ------>  (drvr_input_pin   drvr_pin)  ------>
@@ -699,21 +701,198 @@ bool BaseMove::replaceCell(Instance* inst, const LibertyCell* replacement)
   }
   return false;
 }
+Slack BaseMove::getWorstInputSlack(Instance* inst)
+{
+  Slack worst_slack = INF;
+  auto pin_iter
+      = std::unique_ptr<InstancePinIterator>(network_->pinIterator(inst));
+  while (pin_iter->hasNext()) {
+    const Pin* pin = pin_iter->next();
+    if (network_->direction(pin)->isInput()) {
+      Vertex* vertex = graph_->pinDrvrVertex(pin);
+      if (vertex) {
+        worst_slack
+            = std::min(worst_slack, sta_->vertexSlack(vertex, resizer_->max_));
+      }
+    }
+  }
+  return worst_slack;
+}
+
+Slack BaseMove::getWorstOutputSlack(Instance* inst)
+{
+  Slack worst_slack = INF;
+
+  // Iterate through all pins of the instance to find output pins
+  auto pin_iter
+      = std::unique_ptr<InstancePinIterator>(network_->pinIterator(inst));
+  while (pin_iter->hasNext()) {
+    const Pin* inst_pin = pin_iter->next();
+    if (network_->direction(inst_pin)->isOutput()) {
+      Vertex* vertex = graph_->pinLoadVertex(inst_pin);
+      if (vertex) {
+        worst_slack
+            = std::min(worst_slack, sta_->vertexSlack(vertex, resizer_->max_));
+      }
+    }
+  }
+  return worst_slack;
+}
+
+ArcDelay BaseMove::getWorstIntrinsicDelay(const LibertyPort* input_port)
+{
+  const LibertyCell* cell = input_port->libertyCell();
+  vector<const LibertyPort*> output_ports = getOutputPorts(cell);
+
+  // Just return the worst of all the outputs, if there's more than one
+  ArcDelay worst_intrinsic_delay = -INF;
+  for (const LibertyPort* output_port : output_ports) {
+    if (output_port->direction()->isOutput()) {
+      worst_intrinsic_delay
+          = max(worst_intrinsic_delay, output_port->intrinsicDelay(nullptr));
+    }
+  }
+  return worst_intrinsic_delay;
+}
+
+vector<const LibertyPort*> BaseMove::getOutputPorts(const LibertyCell* cell)
+{
+  vector<const LibertyPort*> fanouts;
+
+  sta::LibertyCellPortIterator port_iter(cell);
+  while (port_iter.hasNext()) {
+    const LibertyPort* port = port_iter.next();
+    if (port->direction()->isOutput()) {
+      fanouts.push_back(port);
+    }
+  }
+
+  return fanouts;
+}
 
-vector<const Pin*> BaseMove::getFanouts(const Instance* inst)
+vector<const Pin*> BaseMove::getOutputPins(const Instance* inst)
 {
-  vector<const Pin*> fanouts;
+  vector<const Pin*> outputs;
 
   auto pin_iter
       = std::unique_ptr<InstancePinIterator>(network_->pinIterator(inst));
   while (pin_iter->hasNext()) {
     const Pin* pin = pin_iter->next();
     if (network_->direction(pin)->isOutput()) {
-      fanouts.push_back(pin);
+      outputs.push_back(pin);
     }
   }
 
-  return fanouts;
+  return outputs;
+}
+
+bool BaseMove::checkMaxCapViolation(const Pin* output_pin,
+                                    LibertyPort* output_port,
+                                    float output_cap)
+{
+  float max_cap;
+  bool cap_limit_exists;
+  // FIXME: Can we update to consider multiple corners?
+  output_port->capacitanceLimit(resizer_->max_, max_cap, cap_limit_exists);
+
+  debugPrint(logger_,
+             RSZ,
+             "opt_moves",
+             3,
+             " fanout pin {} cap {} output_cap {} ",
+             output_port->name(),
+             max_cap,
+             output_cap);
+
+  if (cap_limit_exists && max_cap > 0.0 && output_cap > max_cap) {
+    debugPrint(logger_,
+               RSZ,
+               "opt_moves",
+               2,
+               "  skip based on max cap {} gate={} cap={} max_cap={}",
+               network_->pathName(output_pin),
+               output_port->libertyCell()->name(),
+               output_cap,
+               max_cap);
+    return true;
+  }
+
+  return false;
+}
+
+bool BaseMove::checkMaxSlewViolation(const Pin* output_pin,
+                                     LibertyPort* output_port,
+                                     float output_slew_factor,
+                                     float output_cap,
+                                     const DcalcAnalysisPt* dcalc_ap)
+{
+  float output_res = output_port->driveResistance();
+  float output_slew = output_slew_factor * output_res * output_cap;
+  float max_slew;
+  bool slew_limit_exists;
+
+  sta_->findSlewLimit(output_port,
+                      dcalc_ap->corner(),
+                      resizer_->max_,
+                      max_slew,
+                      slew_limit_exists);
+
+  if (output_slew > max_slew) {
+    debugPrint(logger_,
+               RSZ,
+               "opt_moves",
+               2,
+               "  skip based on max slew {} gate={} slew={} max_slew={}",
+               network_->pathName(output_pin),
+               output_port->libertyCell()->name(),
+               output_slew,
+               max_slew);
+    return true;
+  }
+
+  return false;
+}
+
+float BaseMove::computeElmoreSlewFactor(const Pin* output_pin,
+                                        LibertyPort* output_port,
+                                        float output_load_cap)
+{
+  float elmore_slew_factor = 0.0;
+
+  // Get the vertex for the output pin
+  Vertex* output_vertex = graph_->pinDrvrVertex(output_pin);
+
+  // Get the output slew
+  const Slew output_slew = sta_->vertexSlew(output_vertex, resizer_->max_);
+
+  // Get the output resistance
+  float output_res = output_port->driveResistance();
+
+  // Can have gates without fanout (e.g. QN of flop) which have no load
+  if (output_res > 0.0 && output_load_cap > 0.0) {
+    elmore_slew_factor = output_slew / (output_res * output_load_cap);
+  }
+
+  return elmore_slew_factor;
 }
 
+////////////////////////////////////////////////////////////////
+
+LibertyCellSeq BaseMove::getSwappableCells(LibertyCell* base)
+{
+  LibertyCellSeq buffer_sizes;
+  if (base->isBuffer()) {
+    for (LibertyCell* buffer : resizer_->buffer_fast_sizes_) {
+      buffer_sizes.push_back(buffer);
+    }
+    if (resizer_->buffer_fast_sizes_.count(base) == 0) {
+      return LibertyCellSeq();
+    }
+    return buffer_sizes;
+  }
+  return resizer_->getSwappableCells(base);
+}
+
+////////////////////////////////////////////////////////////////
+// namespace rsz
 }  // namespace rsz

src/rsz/src/BaseMove.hh

@@ -46,6 +46,8 @@ class EstimateParasitics;
 
 namespace rsz {
 
+using std::vector;
+
 using odb::dbMaster;
 
 using odb::dbMaster;
@@ -226,12 +228,29 @@ class BaseMove : public sta::dbStaState
                           const DcalcAnalysisPt* dcalc_ap);
   bool replaceCell(Instance* inst, const LibertyCell* replacement);
 
+  bool checkMaxCapViolation(const Pin* output_pin,
+                            LibertyPort* output_port,
+                            float output_cap);
+  bool checkMaxSlewViolation(const Pin* output_pin,
+                             LibertyPort* output_port,
+                             float output_slew_factor,
+                             float output_cap,
+                             const DcalcAnalysisPt* dcalc_ap);
+  float computeElmoreSlewFactor(const Pin* output_pin,
+                                LibertyPort* output_port,
+                                float output_load_cap);
+  ArcDelay getWorstIntrinsicDelay(const LibertyPort* input_port);
+  Slack getWorstInputSlack(Instance* inst);
+  Slack getWorstOutputSlack(Instance* inst);
+  vector<const LibertyPort*> getOutputPorts(const LibertyCell* cell);
+  vector<const Pin*> getOutputPins(const Instance* inst);
+  LibertyCellSeq getSwappableCells(LibertyCell* base);
+
+  static constexpr int size_down_max_fanout_ = 10;
   static constexpr int rebuffer_max_fanout_ = 20;
   static constexpr int split_load_min_fanout_ = 8;
   static constexpr int buffer_removal_max_fanout_ = 10;
   static constexpr float rebuffer_relaxation_factor_ = 0.03;
-
-  std::vector<const Pin*> getFanouts(const Instance* inst);
 };
 
 }  // namespace rsz

src/rsz/src/CloneMove.cc

@@ -26,12 +26,11 @@
 
 namespace rsz {
 
+using odb::Point;
 using std::pair;
 using std::string;
 using std::vector;
 
-using odb::Point;
-
 using utl::RSZ;
 
 using sta::dbITerm;

src/rsz/src/RepairSetup.cc

@@ -127,10 +127,10 @@ bool RepairSetup::repairSetup(const float setup_slack_margin,
           }
           break;
         case MoveType::SIZE:
+          move_sequence.push_back(resizer_->size_up_move_.get());
           if (!skip_size_down) {
             move_sequence.push_back(resizer_->size_down_move_.get());
           }
-          move_sequence.push_back(resizer_->size_up_move_.get());
           break;
         case MoveType::SIZEUP:
           move_sequence.push_back(resizer_->size_up_move_.get());
@@ -170,9 +170,12 @@ bool RepairSetup::repairSetup(const float setup_slack_margin,
     if (!skip_vt_swap && resizer_->lib_data_->sorted_vt_categories.size() > 1) {
       move_sequence.push_back(resizer_->vt_swap_speed_move_.get());
     }
-    // TODO: Add size_down_move to the sequence if we want to allow
     // Always  have sizing
     move_sequence.push_back(resizer_->size_up_move_.get());
+    // Disabled by default for now
+    if (!skip_size_down) {
+      // move_sequence.push_back(resizer_->size_down_move_.get());
+    }
     if (!skip_pin_swap) {
       move_sequence.push_back(resizer_->swap_pins_move_.get());
     }
@@ -189,6 +192,7 @@ bool RepairSetup::repairSetup(const float setup_slack_margin,
 
   string repair_moves = "Repair move sequence: ";
   for (auto move : move_sequence) {
+    move->init();
     repair_moves += move->name() + string(" ");
   }
   logger_->info(RSZ, 100, repair_moves);
@@ -249,6 +253,7 @@ bool RepairSetup::repairSetup(const float setup_slack_margin,
 
   // Ensure that max cap and max fanout violations don't get worse
   sta_->checkCapacitanceLimitPreamble();
+  sta_->checkSlewLimitPreamble();
   sta_->checkFanoutLimitPreamble();
 
   est::IncrementalParasiticsGuard guard(estimate_parasitics_);