rm SlowDrvrIterator

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

include/sta/Network.hh

@@ -238,6 +238,7 @@ public:
   // the other primitives.
   LeafInstanceIterator *leafInstanceIterator() const;
   LeafInstanceIterator *leafInstanceIterator(const Instance *hier_inst) const;
+  InstanceSeq leafInstances();
   // Iterate over the children of an instance.
   virtual InstanceChildIterator *
   childIterator(const Instance *instance) const = 0;

include/sta/Sta.hh

@@ -1106,9 +1106,8 @@ public:
   // with normal constant propagate for timing.
   void clearLogicConstants();
 
-  // Iterator for instances sorted by max driver pin slew.
-  // Caller owns iterator and iterator->container().
-  SlowDrvrIterator *slowDrvrIterator();
+  // Instances sorted by max driver pin slew.
+  InstanceSeq slowDrivers(int count);
 
   // Make parasitic analysis points.
   // per_corner per_min_max     ap_count

network/Network.cc

@@ -1189,6 +1189,19 @@ Network::leafPinCount()
   return count;
 }
 
+InstanceSeq
+Network::leafInstances()
+{
+  InstanceSeq insts;
+  LeafInstanceIterator *iter = leafInstanceIterator();
+  while (iter->hasNext()) {
+    const Instance *inst = iter->next();
+    insts.push_back(inst);
+  }
+  delete iter;
+  return insts;
+}
+
 void
 Network::setPathDivider(char divider)
 {

search/Sta.cc

@@ -5152,67 +5152,37 @@ Sta::crossesHierarchy(Edge *edge) const
 
 ////////////////////////////////////////////////////////////////
 
-class InstanceMaxSlewGreater
+static Slew
+instMaxSlew(const Instance *inst,
+            Sta *sta)
 {
-public:
-  explicit InstanceMaxSlewGreater(const StaState *sta);
-  bool operator()(const Instance *inst1,
-		  const Instance *inst2) const;
-
-protected:
-  Slew instMaxSlew(const Instance *inst) const;
-  const StaState *sta_;
-};
-
-InstanceMaxSlewGreater::InstanceMaxSlewGreater(const StaState *sta) :
-  sta_(sta)
-{
-}
-
-bool
-InstanceMaxSlewGreater::operator()(const Instance *inst1,
-				   const Instance *inst2) const
-{
-  return delayGreater(instMaxSlew(inst1), instMaxSlew(inst2), sta_);
-}
-
-Slew
-InstanceMaxSlewGreater::instMaxSlew(const Instance *inst) const
-{
-  Network *network = sta_->network();
-  Graph *graph = sta_->graph();
+  Network *network = sta->network();
+  Graph *graph = sta->graph();
   Slew max_slew = 0.0;
   InstancePinIterator *pin_iter = network->pinIterator(inst);
   while (pin_iter->hasNext()) {
     Pin *pin = pin_iter->next();
     if (network->isDriver(pin)) {
       Vertex *vertex = graph->pinDrvrVertex(pin);
-      for (RiseFall *rf : RiseFall::range()) {
-	for (DcalcAnalysisPt *dcalc_ap : sta_->corners()->dcalcAnalysisPts()) {
-	  Slew slew = graph->slew(vertex, rf, dcalc_ap->index());
-	  if (delayGreater(slew, max_slew, sta_))
-	    max_slew = slew;
-	}
-      }
+      max_slew = max(max_slew, sta->vertexSlew(vertex, MinMax::max()));
     }
   }
   delete pin_iter;
   return max_slew;
 }
 
-SlowDrvrIterator *
-Sta::slowDrvrIterator()
+InstanceSeq
+Sta::slowDrivers(int count)
 {
-  InstanceSeq *insts = new InstanceSeq;
-  LeafInstanceIterator *leaf_iter = network_->leafInstanceIterator();
-  while (leaf_iter->hasNext()) {
-    Instance *leaf = leaf_iter->next();
-    insts->push_back(leaf);
-  }
-  delete leaf_iter;
-
-  sort(insts, InstanceMaxSlewGreater(this));
-  return new SlowDrvrIterator(insts);
+  InstanceSeq insts = network_->leafInstances();
+  sort(insts, [=] (const Instance *inst1,
+                   const Instance *inst2) {
+    return delayGreater(instMaxSlew(inst1, this),
+                        instMaxSlew(inst2, this),
+                        this);
+  });
+  insts.resize(count);
+  return insts;
 }
 
 ////////////////////////////////////////////////////////////////

tcl/StaTcl.i

@@ -441,13 +441,6 @@ private:
   ~VertexPathIterator();
 };
 
-class SlowDrvrIterator
-{
-private:
-  SlowDrvrIterator();
-  ~SlowDrvrIterator();
-};
-
 class ExceptionFrom
 {
 private:
@@ -990,14 +983,7 @@ find_instance(char *path_name)
 InstanceSeq
 network_leaf_instances()
 {
-  InstanceSeq insts;
-  LeafInstanceIterator *iter = cmdLinkedNetwork()->leafInstanceIterator();
-  while (iter->hasNext()) {
-    const Instance *inst = iter->next();
-    insts.push_back(inst);
-  }
-  delete iter;
-  return insts;
+  return cmdLinkedNetwork()->leafInstances();
 }
 
 InstanceSeq
@@ -3618,10 +3604,10 @@ pin_logic_value(const Pin *pin)
   return logicValueString(value);
 }
 
-SlowDrvrIterator *
-slow_driver_iterator()
+InstanceSeq
+slow_drivers(int count)
 {
-  return Sta::sta()->slowDrvrIterator();
+  return Sta::sta()->slowDrivers(count);
 }
 
 bool
@@ -5021,18 +5007,6 @@ next()
 void finish() { delete self; }
 }
 
-%extend SlowDrvrIterator {
-bool has_next() { return self->hasNext(); }
-const Instance *next() { return self->next(); }
-void
-finish()
-{
-  delete self->container();
-  delete self;
-}
-
-}
-
 %extend Corner {
 const char *name() { return self->name(); }
 }