A typical verification challenge for the GRID community is\ud
presented. The concrete challenge is to implement a simple recursive algorithm for finding the strongly connected components in a graph. The graph is typically stored in the collective memory of a number of computers, so a distributed algorithm is necessary.\ud
\ud
The implementation should be efficient and scalable, and separate synchronization and implementation details from the purely algorithmic aspects. In the end, a framework is envisaged for distributed algorithms on very large graphs. This would be useful to explore various alternative algorithmic choices

Pol, Jaco van de

English

A typical verification challenge for the GRID community is
presented. The concrete challenge is to implement a simple recursive
algorithm for finding the strongly connected components in a
graph. The graph is typically stored in the collective memory of a
number of computers, so a distributed algorithm is necessary.

The implementation should be efficient and scalable, and separate
synchronization and implementation details from the purely algorithmic
aspects. In the end, a framework is envisaged for distributed
algorithms on very large graphs. This would be useful to explore
various alternative algorithmic choices

van de Pol, Jaco

Dagstuhl Research Online Publication Server

A Typical Verification Challenge for the GRIDJaco van de PolFormal Methods and Tools, Universiteit Twente, The Netherlands1 IntroductionThe task of detecting the strongly connected components of a very large graph isat the heart of many software verification procedures, such as model checking andstate space minimization. In this context, the graphs represent system behaviour,i.e. all states of a system and all state transitions that are reachable from a giveninitial state. This so-called state space can be prohibitively large; often it onlyfits in the collective internal memory of a number of machines. Hence scalabledistributed algorithms that work on partitioned graphs are required.2 The AlgorithmRemember that a strongly connected component (SCC) in a graph is a maximalsubgraph in which all two vertices v, w are connected via a path from v to wand vice versa. Tarjan’s original algorithm [3] for detecting all SCCs is very ef-ficient (linear time) and based on depth first search (DFS). This is unfortunate,because it is actually impossible to efficiently parallelize DFS. Therefore, paral-lel SCC detection algorithms are usually based on breadth first search (BFS),even though the worst case time complexity (total amount of work) increases toquadratic for all known parallel SCC algorithms.Given a graph (with set of vertices V ) and some pivot vertex v ∈ V , onecan compute the set Fwd(v) of all nodes reachable from v by following successoredges, using distributed BFS. Similarly, the set Bwd(v) of all nodes reachablefrom v by following predecessor edges can be computed.The simplest parallel SCC algorithm [2] is based on the following observation:the intersection of Fwd(v) and Bwd(v) coincides with the SCC that contains v.Moreover, all other SCCs lie completely in one of the following sets: B\F , F \B,or V \ (B ∪F ). So these three subgraphs can be processed independently and inparallel. This is illustrated with the figure and pseudocode on the next page.3 The implementation challengeThe challenge is to implement the procedure FB in a distributed and parallelway. The implementation should:1. be efficient and scalable;2. allow experimentation and exploration of alternatives;3. separate implementation details from algorithmic aspects.Dagstuhl Seminar Proceedings 08332 Distributed Verification and Grid Computing  http://drops.dagstuhl.de/opus/volltexte/2008/1629Given: G = (V ,E).procedure FB(V )pick pivot v ∈ V ;F := Fwd(v);B := Bwd(v);report F ∩B;in parallel doFB(F \B);FB(B \ F);FB(V \ (B ∪ F ));end FBB − FvF − BBwdFwdV − (F + B)V − (F + B)Remarks ad 1: The assumption is that the graph doesn’t fit in the memoryof a single workstation. Initially, the graph is given implicitly, by an enumeratorthat provides some initial vertex, and for each vertex a list of its direct successors.A first step could be to generate and store the full state space. Usually, states arepartitioned over the workers by a hash function. Passing around large subgraphs(as suggested by the pseudocode) should probably be avoided.Remarks ad 2: The implementation of FB still allows several strategies, forinstance which pivot vertex is picked, and how the three recursive calls are sched-uled. Note that each instance of FB contains already a distributed reachabilityprocedure. In [1] we showed that handling the three recursive calls sequentiallyis outperformed by handling all recursive calls in parallel. Maybe the optimumis somewhere in between. [1] also introduced a number of improved – but morecomplicated – algorithms, in particular recursive OBF.Remarks ad 3: In order to easily experiment with this and other verificationalgorithms, it would be nice to have a framework for distributed graph algo-rithms, that hides the synchronization and communication details. In this way,it becomes easier to focus on the consequences of purely algorithmic choices.The complicating factor seems to be that the computation is data-driven. Inparticular, the workers share a large data structure that cannot be easily movedaround. As a consequence, the computation is not purely functional.Acknowledgements. The author wishes to thank all participants of the Dagstuhlseminar 08332 for the nice discussion.References1. J. Barnat, J. Chaloupka, and J.C. van de Pol. Improved distributed algorithms forSCC decomposition. In: I. Cerna and B. Haverkort (eds), Proceedings of PDMC’07.ENTCS, 198(1):63–77, 2008.2. W. McLendon III, B. Hendrickson, S.J. Plimpton, and L. Rauchwerger. Findingstrongly connected components in distributed graphs. J. Parallel Distrib. Comput.,65(8):901–910, 2005.3. R. Tarjan. Depth first search and linear graph algorithms. SIAM Journal on com-puting, pages 146–160, 1972.

A Typical Verification Challenge for the GRID

A typical verification challenge for the GRID community is presented. The concrete challenge is to implement a simple recursive algorithm for finding the strongly connected components in a graph. The graph is typically stored in the collective memory of a number of computers, so a distributed algorithm is necessary. The implementation should be efficient and scalable, and separate synchronization and implementation details from the purely algorithmic aspects. In the end, a framework is envisaged for distributed algorithms on very large graphs. This would be useful to explore various alternative algorithmic choices

van de Pol, Jan Cornelis

University of Twente Research Information

A Typical Verification Challenge for the GRIDJaco van de PolFormal Methods and Tools, Universiteit Twente, The Netherlands1 IntroductionThe task of detecting the strongly connected components of a very large graph isat the heart of many software verification procedures, such as model checking andstate space minimization. In this context, the graphs represent system behaviour,i.e. all states of a system and all state transitions that are reachable from a giveninitial state. This so-called state space can be prohibitively large; often it onlyfits in the collective internal memory of a number of machines. Hence scalabledistributed algorithms that work on partitioned graphs are required.2 The AlgorithmRemember that a strongly connected component (SCC) in a graph is a maximalsubgraph in which all two vertices v, w are connected via a path from v to wand vice versa. Tarjan’s original algorithm [3] for detecting all SCCs is very ef-ficient (linear time) and based on depth first search (DFS). This is unfortunate,because it is actually impossible to efficiently parallelize DFS. Therefore, paral-lel SCC detection algorithms are usually based on breadth first search (BFS),even though the worst case time complexity (total amount of work) increases toquadratic for all known parallel SCC algorithms.Given a graph (with set of vertices V ) and some pivot vertex v ∈ V , onecan compute the set Fwd(v) of all nodes reachable from v by following successoredges, using distributed BFS. Similarly, the set Bwd(v) of all nodes reachablefrom v by following predecessor edges can be computed.The simplest parallel SCC algorithm [2] is based on the following observation:the intersection of Fwd(v) and Bwd(v) coincides with the SCC that contains v.Moreover, all other SCCs lie completely in one of the following sets: B\F , F \B,or V \ (B ∪F ). So these three subgraphs can be processed independently and inparallel. This is illustrated with the figure and pseudocode on the next page.3 The implementation challengeThe challenge is to implement the procedure FB in a distributed and parallelway. The implementation should:1. be efficient and scalable;2. allow experimentation and exploration of alternatives;3. separate implementation details from algorithmic aspects.Dagstuhl Seminar Proceedings 08332 Distributed Verification and Grid Computing  http://drops.dagstuhl.de/opus/volltexte/2008/1629Given: G = (V , E).procedure FB(V )pick pivot v ∈ V ;F := Fwd(v);B := Bwd(v);report F ∩B;in parallel doFB(F \B);FB(B \ F);FB(V \ (B ∪ F ));end FBB − FvF − BBwdFwdV − (F + B)V − (F + B)Remarks ad 1: The assumption is that the graph doesn’t fit in the memoryof a single workstation. Initially, the graph is given implicitly, by an enumeratorthat provides some initial vertex, and for each vertex a list of its direct successors.A first step could be to generate and store the full state space. Usually, states arepartitioned over the workers by a hash function. Passing around large subgraphs(as suggested by the pseudocode) should probably be avoided.Remarks ad 2: The implementation of FB still allows several strategies, forinstance which pivot vertex is picked, and how the three recursive calls are sched-uled. Note that each instance of FB contains already a distributed reachabilityprocedure. In [1] we showed that handling the three recursive calls sequentiallyis outperformed by handling all recursive calls in parallel. Maybe the optimumis somewhere in between. [1] also introduced a number of improved – but morecomplicated – algorithms, in particular recursive OBF.Remarks ad 3: In order to easily experiment with this and other verificationalgorithms, it would be nice to have a framework for distributed graph algo-rithms, that hides the synchronization and communication details. In this way,it becomes easier to focus on the consequences of purely algorithmic choices.The complicating factor seems to be that the computation is data-driven. Inparticular, the workers share a large data structure that cannot be easily movedaround. As a consequence, the computation is not purely functional.Acknowledgements. The author wishes to thank all participants of the Dagstuhlseminar 08332 for the nice discussion.References1. J. Barnat, J. Chaloupka, and J.C. van de Pol. Improved distributed algorithms forSCC decomposition. In: I. Cerna and B. Haverkort (eds), Proceedings of PDMC’07.ENTCS, 198(1):63–77, 2008.2. W. McLendon III, B. Hendrickson, S.J. Plimpton, and L. Rauchwerger. Findingstrongly connected components in distributed graphs. J. Parallel Distrib. Comput.,65(8):901–910, 2005.3. R. Tarjan. Depth first search and linear graph algorithms. SIAM Journal on com-puting, pages 146–160, 1972.

Depth ﬁrst search and linear graph algorithms.

Finding strongly connected components in distributed graphs.

Improved distributed algorithms for SCC decomposition. In: I. Cerna and B. Haverkort (eds),

http://drops.dagstuhl.de/opus/volltexte/2008/1629/pdf/08332.vandePolJaco.Paper.1629.pdf

A Typical Verification Challenge for the GRID

Abstract

Similar works

Full text

Available Versions

Dagstuhl Research Online Publication Server

University of Twente Research Information