From 514e18c061549b95185cdc22624e5ba660a84e66 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 13 Oct 2003 16:34:26 +0000 Subject: [PATCH] add support for "external" depth first iterators, which store the 'visited' set outside of the iterator itself. llvm-svn: 9090 --- llvm/include/Support/DepthFirstIterator.h | 110 +++++++++++++++++++--- 1 file changed, 99 insertions(+), 11 deletions(-) diff --git a/llvm/include/Support/DepthFirstIterator.h b/llvm/include/Support/DepthFirstIterator.h index 10ef3f378c86..edb8b2d6bd96 100644 --- a/llvm/include/Support/DepthFirstIterator.h +++ b/llvm/include/Support/DepthFirstIterator.h @@ -9,6 +9,18 @@ // idf_begin/idf_end/idf_iterator // * Depth-first iteration on the 'inverse' graph. // +// df_ext_begin/df_ext_end/df_ext_iterator +// * Normal depth-first iteration - visit a node and then all of its children. +// This iterator stores the 'visited' set in an external set, which allows +// it to be more efficient, and allows external clients to use the set for +// other purposes. +// +// idf_ext_begin/idf_ext_end/idf_ext_iterator +// * Depth-first iteration on the 'inverse' graph. +// This iterator stores the 'visited' set in an external set, which allows +// it to be more efficient, and allows external clients to use the set for +// other purposes. +// //===----------------------------------------------------------------------===// #ifndef SUPPORT_DEPTHFIRSTITERATOR_H @@ -19,28 +31,59 @@ #include #include +// df_iterator_storage - A private class which is used to figure out where to +// store the visited set. +template // Non-external set +class df_iterator_storage { +public: + SetType Visited; +}; + +template +class df_iterator_storage { +public: + df_iterator_storage(SetType &VSet) : Visited(VSet) {} + df_iterator_storage(const df_iterator_storage &S) : Visited(S.Visited) {} + SetType &Visited; +}; + + // Generic Depth First Iterator -template > -class df_iterator : public forward_iterator { +template::NodeType*>, + bool ExtStorage = false, class GT = GraphTraits > +class df_iterator : public forward_iterator, + public df_iterator_storage { typedef forward_iterator super; typedef typename GT::NodeType NodeType; typedef typename GT::ChildIteratorType ChildItTy; - std::set Visited; // All of the blocks visited so far... // VisitStack - Used to maintain the ordering. Top = current block // First element is node pointer, second is the 'next child' to visit std::vector > VisitStack; private: inline df_iterator(NodeType *Node) { - Visited.insert(Node); + this->Visited.insert(Node); VisitStack.push_back(std::make_pair(Node, GT::child_begin(Node))); } inline df_iterator() { /* End is when stack is empty */ } + inline df_iterator(NodeType *Node, SetType &S) + : df_iterator_storage(S) { + if (!S.count(Node)) { + this->Visited.insert(Node); + VisitStack.push_back(std::make_pair(Node, GT::child_begin(Node))); + } + } + inline df_iterator(SetType &S) + : df_iterator_storage(S) { + // End is when stack is empty + } + public: typedef typename super::pointer pointer; - typedef df_iterator _Self; + typedef df_iterator _Self; // Provide static begin and end methods as our public "constructors" static inline _Self begin(GraphT G) { @@ -48,6 +91,11 @@ public: } static inline _Self end(GraphT G) { return _Self(); } + // Static begin and end methods as our public ctors for external iterators + static inline _Self begin(GraphT G, SetType &S) { + return _Self(GT::getEntryNode(G), S); + } + static inline _Self end(GraphT G, SetType &S) { return _Self(S); } inline bool operator==(const _Self& x) const { return VisitStack.size() == x.VisitStack.size() && @@ -73,9 +121,9 @@ public: while (It != GT::child_end(Node)) { NodeType *Next = *It++; - if (!Visited.count(Next)) { // Has our next sibling been visited? + if (!this->Visited.count(Next)) { // Has our next sibling been visited? // No, do it now. - Visited.insert(Next); + this->Visited.insert(Next); VisitStack.push_back(std::make_pair(Next, GT::child_begin(Next))); return *this; } @@ -96,7 +144,7 @@ public: // nodes that a depth first iteration did not find: ie unreachable nodes. // inline bool nodeVisited(NodeType *Node) const { - return Visited.count(Node) != 0; + return this->Visited.count(Node) != 0; } }; @@ -113,10 +161,30 @@ df_iterator df_end(T G) { return df_iterator::end(G); } +// Provide global definitions of external depth first iterators... +template +struct df_ext_iterator : public df_iterator { + df_ext_iterator(const df_iterator &V) + : df_iterator(V) {} +}; + +template +df_ext_iterator df_ext_begin(T G, SetTy &S) { + return df_ext_iterator::begin(G, S); +} + +template +df_ext_iterator df_ext_end(T G, SetTy &S) { + return df_ext_iterator::end(G, S); +} + + // Provide global definitions of inverse depth first iterators... -template -struct idf_iterator : public df_iterator > { - idf_iterator(const df_iterator > &V) :df_iterator >(V){} +template ::NodeType*>, + bool External = false> +struct idf_iterator : public df_iterator, SetTy, External> { + idf_iterator(const df_iterator, SetTy, External> &V) + : df_iterator, SetTy, External>(V) {} }; template @@ -129,4 +197,24 @@ idf_iterator idf_end(T G){ return idf_iterator::end(G); } +// Provide global definitions of external inverse depth first iterators... +template ::NodeType*> > +struct idf_ext_iterator : public idf_iterator { + idf_ext_iterator(const idf_iterator &V) + : idf_iterator(V) {} + idf_ext_iterator(const df_iterator, SetTy, true> &V) + : idf_iterator(V) {} +}; + +template +idf_ext_iterator idf_ext_begin(T G, SetTy &S) { + return idf_ext_iterator::begin(G, S); +} + +template +idf_ext_iterator idf_ext_end(T G, SetTy &S) { + return idf_ext_iterator::end(G, S); +} + + #endif