sync

parasitics/ConcreteParasitics.cc

@@ -134,6 +134,18 @@ ConcreteParasitic::setPoleResidue(const Pin *,
 {
 }
 
+ParasiticDeviceIterator *
+ConcreteParasitic::deviceIterator()
+{
+  return NULL;
+}
+
+ParasiticNodeIterator *
+ConcreteParasitic::nodeIterator()
+{
+  return NULL;
+}
+
 ////////////////////////////////////////////////////////////////
 
 ConcreteElmore::ConcreteElmore() :
@@ -726,12 +738,37 @@ void
 ConcreteParasiticNetwork::deleteDevices()
 {
   ConcreteParasiticDeviceSet devices1;
-  devices(devices1);
+  devices(&devices1);
   devices1.deleteContents();
 }
 
+ParasiticNodeIterator *
+ConcreteParasiticNetwork::nodeIterator()
+{
+  ConcreteParasiticNodeSeq *nodes = new ConcreteParasiticNodeSeq();
+  ConcreteParasiticPinNodeMap::Iterator node_iter2(pin_nodes_);
+  while (node_iter2.hasNext()) {
+    ConcreteParasiticPinNode *node = node_iter2.next();
+    nodes->push_back(node);
+  }
+  ConcreteParasiticSubNodeMap::Iterator node_iter1(sub_nodes_);
+  while (node_iter1.hasNext()) {
+    ConcreteParasiticSubNode *node = node_iter1.next();
+    nodes->push_back(node);
+  }
+  return new ConcreteParasiticNodeSeqIterator(nodes);
+}
+
+ParasiticDeviceIterator *
+ConcreteParasiticNetwork::deviceIterator()
+{
+  ConcreteParasiticDeviceSet *devices1 = new ConcreteParasiticDeviceSet();
+  devices(devices1);
+  return new ConcreteParasiticDeviceSetIterator(devices1);
+}
+
 void
-ConcreteParasiticNetwork::devices(ConcreteParasiticDeviceSet &devices)
+ConcreteParasiticNetwork::devices(ConcreteParasiticDeviceSet *devices)
 {
   // Collect devices into a set so they are only deleted once
   // because multiple sub-nodes or pin nodes can refer to them.
@@ -741,7 +778,7 @@ ConcreteParasiticNetwork::devices(ConcreteParasiticDeviceSet &devices)
     ConcreteParasiticDeviceSeq::Iterator device_iter(node->devices());
     while (device_iter.hasNext()) {
       ConcreteParasiticDevice *device = device_iter.next();
-      devices.insert(device);
+      devices->insert(device);
     }
   }
 
@@ -751,7 +788,7 @@ ConcreteParasiticNetwork::devices(ConcreteParasiticDeviceSet &devices)
     ConcreteParasiticDeviceSeq::Iterator device_iter(node->devices());
     while (device_iter.hasNext()) {
       ConcreteParasiticDevice *device = device_iter.next();
-      devices.insert(device);
+      devices->insert(device);
     }
   }
 }
@@ -1798,6 +1835,20 @@ ConcreteParasitics::makeResistor(const char *name,
   cnode2->addDevice(resistor);
 }
 
+ParasiticDeviceIterator *
+ConcreteParasitics::deviceIterator(Parasitic *parasitic)
+{
+  ConcreteParasitic *cparasitic = static_cast<ConcreteParasitic*>(parasitic);
+  return cparasitic->deviceIterator();
+}
+
+ParasiticNodeIterator *
+ConcreteParasitics::nodeIterator(Parasitic *parasitic)
+{
+  ConcreteParasitic *cparasitic = static_cast<ConcreteParasitic*>(parasitic);
+  return cparasitic->nodeIterator();
+}
+
 float
 ConcreteParasitics::nodeGndCap(const ParasiticNode *node,
 			       const ParasiticAnalysisPt *) const
@@ -1838,17 +1889,11 @@ ConcreteParasitics::findNode(Parasitic *parasitic,
   return cparasitic->findNode(pin);
 }
 
-ConcreteParasiticDeviceIterator::
-ConcreteParasiticDeviceIterator(ConcreteParasiticNode *node) :
-  iter_(node->devices())
-{
-}
-
 ParasiticDeviceIterator *
 ConcreteParasitics::deviceIterator(ParasiticNode *node) const
 {
   ConcreteParasiticNode *cnode = static_cast<ConcreteParasiticNode*>(node);
-  return new ConcreteParasiticDeviceIterator(cnode);
+  return new ConcreteParasiticDeviceSeqIterator(cnode->devices());
 }
 
 const char *
@@ -2031,4 +2076,34 @@ ConcreteParasitics::estimatePiElmore(const Pin *drvr_pin,
 				       sdc_);
 }
 
+////////////////////////////////////////////////////////////////
+
+ConcreteParasiticDeviceSeqIterator::
+ConcreteParasiticDeviceSeqIterator(ConcreteParasiticDeviceSeq *devices) :
+  iter_(devices)
+{
+}
+
+ConcreteParasiticDeviceSetIterator::
+ConcreteParasiticDeviceSetIterator(ConcreteParasiticDeviceSet *devices) :
+  iter_(devices)
+{
+}
+
+ConcreteParasiticDeviceSetIterator::~ConcreteParasiticDeviceSetIterator()
+{
+  delete iter_.container();
+}
+
+ConcreteParasiticNodeSeqIterator::
+ConcreteParasiticNodeSeqIterator(ConcreteParasiticNodeSeq *nodes) :
+  iter_(nodes)
+{
+}
+
+ConcreteParasiticNodeSeqIterator::~ConcreteParasiticNodeSeqIterator()
+{
+  delete iter_.container();
+}
+
 } // namespace

parasitics/ConcreteParasitics.hh

@@ -162,6 +162,8 @@ public:
   virtual void makeResistor(const char *name, ParasiticNode *node1,
 			    ParasiticNode *node2,
 			    float res, const ParasiticAnalysisPt *ap);
+  virtual ParasiticDeviceIterator *deviceIterator(Parasitic *parasitic);
+  virtual ParasiticNodeIterator *nodeIterator(Parasitic *parasitic);
 
   virtual const char *name(const ParasiticNode *node);
   virtual const Pin *connectionPin(const ParasiticNode *node) const;

parasitics/ConcreteParasiticsPvt.hh

@@ -25,6 +25,7 @@ class ConcretePoleResidue;
 class ConcreteParasiticDevice;
 class ConcreteParasiticPinNode;
 class ConcreteParasiticSubNode;
+class ConcreteParasiticNode;
 
 typedef Map<const Pin*, float> ConcreteElmoreLoadMap;
 typedef ConcreteElmoreLoadMap::Iterator ConcretePiElmoreLoadIterator;
@@ -41,6 +42,7 @@ typedef Map<const Pin*,
 	    ConcreteParasiticPinNode*> ConcreteParasiticPinNodeMap;
 typedef Vector<ConcreteParasiticDevice*> ConcreteParasiticDeviceSeq;
 typedef Set<ConcreteParasiticDevice*> ConcreteParasiticDeviceSet;
+typedef Vector<ConcreteParasiticNode*> ConcreteParasiticNodeSeq;
 
 // Empty base class definitions so casts are not required on returned
 // objects.
@@ -78,6 +80,8 @@ public:
   virtual void setPoleResidue(const Pin *load_pin,
 			      ComplexFloatSeq *poles,
 			      ComplexFloatSeq *residues);
+  virtual ParasiticDeviceIterator *deviceIterator();
+  virtual ParasiticNodeIterator *nodeIterator();
 };
 
 class ConcreteElmore
@@ -268,7 +272,8 @@ protected:
 class ConcreteParasiticSubNode : public ConcreteParasiticNode
 {
 public:
-  ConcreteParasiticSubNode(Net *net, int id);
+  ConcreteParasiticSubNode(Net *net,
+			   int id);
   virtual const char *name(const Network *network) const;
 
 private:
@@ -391,10 +396,22 @@ public:
 private:
 };
 
-class ConcreteParasiticDeviceIterator : public ParasiticDeviceIterator
+class ConcreteParasiticDeviceSetIterator : public ParasiticDeviceIterator
 {
 public:
-  ConcreteParasiticDeviceIterator(ConcreteParasiticNode *node);
+  ConcreteParasiticDeviceSetIterator(ConcreteParasiticDeviceSet *devices);
+  virtual ~ConcreteParasiticDeviceSetIterator();
+  bool hasNext() { return iter_.hasNext(); }
+  ParasiticDevice *next() { return iter_.next(); }
+
+private:
+  ConcreteParasiticDeviceSet::ConstIterator iter_;
+};
+
+class ConcreteParasiticDeviceSeqIterator : public ParasiticDeviceIterator
+{
+public:
+  ConcreteParasiticDeviceSeqIterator(ConcreteParasiticDeviceSeq *devices);
   bool hasNext() { return iter_.hasNext(); }
   ParasiticDevice *next() { return iter_.next(); }
 
@@ -402,6 +419,18 @@ private:
   ConcreteParasiticDeviceSeq::ConstIterator iter_;
 };
 
+class ConcreteParasiticNodeSeqIterator : public ParasiticNodeIterator
+{
+public:
+  ConcreteParasiticNodeSeqIterator(ConcreteParasiticNodeSeq *devices);
+  virtual ~ConcreteParasiticNodeSeqIterator();
+  bool hasNext() { return iter_.hasNext(); }
+  ParasiticNode *next() { return iter_.next(); }
+
+private:
+  ConcreteParasiticNodeSeq::ConstIterator iter_;
+};
+
 class ConcreteParasiticNetwork : public ParasiticNetwork,
 				 public ConcreteParasitic
 {
@@ -418,7 +447,10 @@ public:
   ConcreteParasiticPinNodeMap *pinNodes() { return &pin_nodes_; }
   ConcreteParasiticSubNodeMap *subNodes() { return &sub_nodes_; }
   void disconnectPin(const Pin *pin, Net *net);
-  void devices(ConcreteParasiticDeviceSet &devices);
+  virtual ParasiticDeviceIterator *deviceIterator();
+  virtual ParasiticNodeIterator *nodeIterator();
+  virtual void devices(// Return value.
+		       ConcreteParasiticDeviceSet *devices);
 
 private:
   void deleteNodes();

parasitics/NullParasitics.hh

@@ -126,6 +126,8 @@ public:
   makeParasiticNetwork(Net *net,
 		       bool pin_cap_included,
 		       const ParasiticAnalysisPt *ap);
+  virtual ParasiticDeviceIterator *deviceIterator(Parasitic *) { return NULL; }
+  virtual ParasiticNodeIterator *nodeIterator(Parasitic *) { return NULL; }
   virtual bool includesPinCaps(Parasitic *parasitic) const;
   virtual void deleteParasiticNetwork(const Net *net,
 				      const ParasiticAnalysisPt *ap);

parasitics/Parasitics.hh

@@ -33,6 +33,7 @@ class Corner;
 typedef std::complex<float> ComplexFloat;
 typedef Vector<ComplexFloat> ComplexFloatSeq;
 typedef Iterator<ParasiticDevice*> ParasiticDeviceIterator;
+typedef Iterator<ParasiticNode*> ParasiticNodeIterator;
 
 // Parasitics API.
 // All parasitic parameters can have multiple values, each corresponding
@@ -171,7 +172,7 @@ public:
 			   ComplexFloat &residue) const=0;
 
   ////////////////////////////////////////////////////////////////
-  // Parasitic Network (detailed parasitics, or DSPF).
+  // Parasitic Network (detailed parasitics).
   // This api assumes that parasitic networks are not rise/fall
   // dependent because they do not include pin capacitances.
   virtual bool isParasiticNetwork(Parasitic *parasitic) const = 0;
@@ -184,6 +185,8 @@ public:
   virtual Parasitic *makeParasiticNetwork(Net *net,
 					  bool pin_cap_included,
 					  const ParasiticAnalysisPt *ap) = 0;
+  virtual ParasiticDeviceIterator *deviceIterator(Parasitic *parasitic) = 0;
+  virtual ParasiticNodeIterator *nodeIterator(Parasitic *parasitic) = 0;
   // Delete parasitic network if it exists.
   virtual void deleteParasiticNetwork(const Net *net,
 				      const ParasiticAnalysisPt *ap) = 0;