Graph traversal and BFS

Transcription

1 Graph traversal and BFS

2 Fundamental building block Graph traversal is part of many important tasks Connected components Tree/Cycle detection Articulation vertex finding Real-world applications Peer-to-peer networks: Discover what s around Broadcasting Web crawlers Notion of proximity GPS navigation systems Garbage collection

3 Bread-first search D F H D F H I I A B A E B A E B C D E I G F H C G C G

4 How do you implement BFS? Input: Graph G (n= V, m= E ) and vertex u Output: Levels of vertices, parents of vertices Level of u is 0, parent of u is -1 Initially k=0 Repeat the following Find all vertices with level k and put them in set N Stop if no vertex found For each vertex v in N Check each neighbor If no level assigned yet, set its level as k+1 and parent as v Increment k

5 How do you implement BFS? Input: Graph G (n= V, m= E ) and vertex u Output: Levels of vertices, parents of vertices Level of u is 0, parent of u is -1 Initially k=0 Repeat the following Find all vertices with level k and put them in set N Stop if no vertex found For each vertex v in N Check each neighbor If no level assigned yet, set its level as k+1 and parent as v Increment k Complexity? - Initialize level, parent arrays: O(n) - Scanning level information: O(n) - r levels: O(rn) - Checking neighbors: O(m) - Total: O(n+rn+m) - Worst case - r is n (chain) - O (m + n 2 )

6 Can we do better? Aim for the most expensive part Scanning level information; O(rn) For real-world networks, what s the expected value of r? We can store the vertices in the next level So, one array for the current level vertices, another for the next Combine them, just make first come-first serve That s called queue So, complexity becomes O(m)

7 Can we do better? Aim for the most expensive part Scanning level information We can store the vertices in the next level So, one array for the current level vertices, another for the next Combine them, just make first come-first serve That s called queue So, complexity becomes O(m)

8 Direction-Optimizing BFS Jason Priest

9 Traditional BFS

10 Small World Phenomenon - Avg degree of 16 - Frontier balloons rapidly - Heavily revisiting edges - Nearly all edge visits fail

11 Small World Phenomenon - After first few steps, nearly all edge visits fail

12 The Improvement - Easy to parallelize by partitioning vertices, no longer requires atomic operations - Requires inverse graph, with large memory overhead, in case of directed graphs

13 Hybrid Approach - Bottom-up is most effective with large frontier - Bottom-up requires checking all vertices to see if they remain unvisited, so a lot of unnecessary work if the graph is multiple components - Best to switch techniques

14 Heuristic Thresholds - switch to Bottom-Up - switch to Top-down m_f = edges adjacent to frontier m_u = edges adjacent to unvisited nodes n_f = vertices in frontier n = total vertices alpha compensates for bottom-up finishing before examining all of m_u Beta compensates for

15 Optimizing Alpha - Chose alpha = 14 - Much larger does not impact which step transition occurs on

16 Optimizing Beta - Chose beta = 24 - Minor variance has little effect because switching back to Top-Down at the very end is inconsequential because majority of work has already been done

17

18 Effect of Degree - Measured in terms of effective number of edges traversed per second - Dense graphs benefit greatly

19 Related Works Efficient Breadth-First Search on the Cell/BE Processor[1] A Scalable Distributed Parallel Breadth-First Search Algorithm on BlueGene/L[2] Designing Multithreaded Algorithms for Breadth-First Search and st-connectivity on the Cray MTA-2[3] Topologically adaptive parallel breadth-first search on multicore processors[4]

20 Depth-first search A D F H D F H B D I I C B A E B A E G E C G C G F H I

21 Notice repetitive pattern Going deep Recursion How to implement? Define function DFS as follows; DFS(G, u, levels, k) Return if levels[u] is assigned Set levels[u] = k For all vertices v which are neighbor to u DFS (G, v, levels, k+1)

22 First in Last Out (FILO) Recursion is stack Any recursion can be performed by a stack Indeed, CPU literally does that! Complexity?

23 BFS vs. DFS Which ones sounds more natural? Which one can be parallelized? Watch for race conditions

24 Sometimes you need multiple BFSs Coarse-level parallelism Each BFS by a processing unit Betweenness centrality Closeness centrality One-to-all shortest paths

25 THE MORE THE MERRIER: EFFICIENT MULTI-SOURCE GRAPH TRAVERSAL Manuel Then*, Moritz Kaufmann*, Fernando Chirigati, Tuan-Anh Hoang-Vu, Kien Pham, Huy T. Vo, Alfons Kemper*, Thomas Neumann* *Technische Universität München, New York University Published at VLDB 2015 Presented by Victor A. Ying February 26, 2018 Slides are from

26 Background Algorithms require many BFSs on one graph E.g., compute centrality metrics across graph Prior work: parallel BFS Barrier synchronization between levels Graph traversals have poor cache behavior Read a single random bit when traversing each edge Small-world phenomenon: graphs have low diameter

27

28

29

30 Multi-Source BFS (MS-BFS) One round: Given frontiers, compute next frontiers By traversing each edge (at most) once in each direction.

31

32

33

34

35

36

37

38 MS-BFS work analysis One round: O(m) work per round O(diameter) rounds needed. O(m diameter) total work for ω traversals. Textbook BFS takes O(m) for one traversal

39 How wide to make the bitvectors? Bitvector width = number of concurrent BFSs (per thread) Maximize SIMD parallelism by matching the width of largest registers? Wider, by using multiple registers?

40 Match the cache line size!

41 MS-BFS maximizes use of each cache miss One round: Each cache line in seen[] accessed once per adjacent edge Many concurrent BFSs amortize cost of cache line movement. Working set size = 3 bits per node per concurrent BFS.

42

43

44

45 Conclusions Making parallel traversals aware of each other improves efficiency. Changing random accesses to predictable array scans improves efficiency. MS-BFS runs multiple BFSs On the same graph Concurrently one core Amortizes cache line movement cost >10x speedup over parallel direction-optimizing BFS

46 Future work Combining parallelism across traversals with parallelism within traversals. Alternative architectures: GPUs? Clusters? Applications beyond closeness centrality. Other graphs. What if few long chains? Other types of traversals. Bellman-Ford? Integrating into a graph analytics framework.

47