GraphX: Graph Processing in a Distributed Dataflow Framework

Transcription

1 GraphX: Graph Processing in a Distributed Dataflow Framework Joseph Gonzalez Postdoc, UC-Berkeley MPLab Co-founder, GraphLab Inc. Joint work with Reynold Xin, nkur Dave, Daniel Crankshaw, Michael Franklin, and Ion Stoica OSDI 2014 UC BERKELEY

2 Modern nalytics Link Table Hyperlinks PageRank Top 20 Pages Title Link Title PR Raw Wikipedia < / >! < / >! < / >! XML! Top Communities Com. PR.. Discussion Table Editor Graph Community Detection User Community User Disc. User Com.

3 Tables Link Table Hyperlinks PageRank Top 20 Pages Title Link Title PR Raw Wikipedia < / >! < / >! < / >! XML! Top Communities Com. PR.. Discussion Table Editor Graph Community Detection User Community User Disc. User Com.

4 Graphs Link Table Hyperlinks PageRank Top 20 Pages Title Link Title PR Raw Wikipedia < / >! < / >! < / >! XML! Top Communities Com. PR.. Discussion Table Editor Graph Community Detection User Community User Disc. User Com.

5 Separate Systems Tables Graphs

6 Dataflow Systems Separate Systems Graphs Table Row Row Row Result Row

7 Separate Systems Dataflow Systems Graph Systems Table Row Dependency Graph Row Row Result Row

8 Difficult to Use Users must Learn, Deploy, and Manage multiple systems Leads to brittle and often complex interfaces 8

9 Inefficient Extensive data movement and duplication across the network and file system < / >! < / >! < / >! XML! HDFS HDFS HDFS HDFS Limited reuse internal data-structures across stages 9

10 GraphX Unifies Computation on Tables and Graphs GraphX Table View Spark Dataflow Framework Graph View Enabling a single system to easily and efficiently support the entire pipeline

11 Separate Systems Dataflow Systems Graph Systems Table Row Row Row Row Result? Dependency Graph

12 Separate Systems Dataflow Systems Graph Systems Table Row Dependency Graph Row Row Result Row

13 PageRank on the Live-Journal Graph Hadoop 1340 Spark GraphLab? Runtime (in seconds, PageRank for 10 iterations) Hadoop is 60x slower than GraphLab Spark is 16x slower than GraphLab

14 Key Question How can we naturally express and efficiently execute graph computation in a general purpose dataflow framework? Distill the lessons learned from specialized graph systems

15 Key Question How can we naturally express and efficiently execute graph computation in a general purpose dataflow framework? Representation Optimizations

16 Link Table Hyperlinks PageRank Top 20 Pages Title Link Title PR Raw Wikipedia < / >! < / >! < / >! XML! Top Communities Com. PR.. Discussion Table Editor Graph Community Detection User Community User Disc. User Com.

17 Example Computation: PageRank Express computation locally: R[i] = Rank of Page i Random Reset Prob. X j2inlinks(i) R[j] OutLinks(j) Weighted sum of neighbors ranks Iterate until convergence 17

18 Think like a Vertex. - Malewicz et al., SIGMOD 10 18

19 Graph-Parallel Pattern Gonzalez et al. [OSDI 12] Gather information from neighboring vertices 19

20 Graph-Parallel Pattern Gonzalez et al. [OSDI 12] pply an update the vertex property 20

21 Graph-Parallel Pattern Gonzalez et al. [OSDI 12] Scatter information to neighboring vertices 21

22 Many Graph-Parallel lgorithms Collaborative Filtering» lternating Least Squares» Stochastic Gradient Descent» Tensor Factorization MCHINE Structured Prediction» Loopy Belief Propagation» Max-Product Linear Programs» Gibbs Sampling LERNING Semi-supervised ML» Graph SSL» CoEM Community Detection» Triangle-Counting» K-core Decomposition» K-Truss NETWORK Graph nalytics» PageRank» Personalized PageRank» Shortest Path» Graph Coloring NLYSIS 22

23 Specialized Computational Pattern Specialized Graph Optimizations

24 Graph System Optimizations Specialized Data-Structures Vertex-Cuts Partitioning Remote Caching / Mirroring Message Combiners ctive Set Tracking 24

25 Representation Join Distributed Graphs Horizontally Partitioned Tables Vertex Programs Dataflow Operators Optimizations dvances in Graph Processing Systems Distributed Join Optimization Materialized View Maintenance

26 Property Graph Data Model Property Graph B C D Vertex Property: User Profile Current PageRank Value Edge Property: F E Weights Timestamps

27 Encoding Property Graphs as Tables Property Graph B C Vertex Cut F E Part. 1 D Part. 2 Vertex Table (RDD) Machine 1 Machine 2 B C D E F Routing Table (RDD) B C D E F Edge Table (RDD) B C E E B C C D E F D F

28 Separate Properties and Structure Reuse structural information across multiple graphs Input Graph Transformed Graph Vertex Table Routing Table Edge Table Vertex Table Routing Table Edge Table Transform Vertex Properties

29 Table Operators Table operators are inherited from Spark: map filter groupby sort union join leftouterjoin rightouterjoin reduce count fold reducebykey groupbykey cogroup cross zip sample take first partitionby mapwith pipe save... 29

30 Graph Operators (Scala) class Graph [ V, E ] { def Graph(vertices: Table[ (Id, V) ], edges: Table[ (Id, Id, E) ]) // Table Views def vertices: Table[ (Id, V) ] def edges: Table[ (Id, Id, E) ] def triplets: Table [ ((Id, V), (Id, V), E) ] // Transformations def reverse: Graph[V, E] def subgraph(pv: (Id, V) => Boolean, pe: Edge[V,E] => Boolean): Graph[V,E] def mapv(m: (Id, V) => T ): Graph[T,E] def mape(m: Edge[V,E] => T ): Graph[V,T] // Joins def joinv(tbl: Table [(Id, T)]): Graph[(V, T), E ] def joine(tbl: Table [(Id, Id, T)]): Graph[V, (E, T)] // Computation def mrtriplets(mapf: (Edge[V,E]) => List[(Id, T)], reducef: (T, T) => T): Graph[T, E] } 30

31 Graph Operators (Scala) class Graph [ V, E ] { def Graph(vertices: Table[ (Id, V) ], edges: Table[ (Id, Id, E) ]) // Table Views def vertices: Table[ (Id, V) ] def edges: Table[ (Id, Id, E) ] def triplets: Table [ ((Id, V), (Id, V), E) ] // Transformations def reverse: Graph[V, E] def subgraph(pv: (Id, V) => Boolean, pe: Edge[V,E] => Boolean): Graph[V,E] def mapv(m: (Id, V) => T ): Graph[T,E] def mape(m: Edge[V,E] => T ): Graph[V,T] // Joins def joinv(tbl: Table [(Id, T)]): Graph[(V, T), E ] def joine(tbl: Table [(Id, Id, T)]): Graph[V, (E, T)] // Computation def mrtriplets(mapf: (Edge[V,E]) => List[(Id, T)], reducef: (T, T) => T): Graph[T, E] } capture the Gather-Scatter pattern from specialized graph-processing systems 31

32 Triplets Join Vertices and Edges The triplets operator joins vertices and edges: Vertices Triplets Edges B B C C D B C C D B C B C C D

33 Map-Reduce Triplets Map-Reduce triplets collects information about the neighborhood of each vertex: Src. or Dst. MapFunction( ) à (B, ) MapFunction( ) à (C, ) MapFunction( ) à (C, ) B MapFunction( C D ) à (D, ) B C C Reduce (B, ) (C, + ) (D, ) Message Combiners

34 Using these basic GraphX operators we implemented Pregel and GraphLab in under 50 lines of code! 34

35 The GraphX Stack (Lines of Code) PageRank (20) Connected Comp. (20) Pregel PI (34) K-core (60) Triangle Count (50) LD (220) SVD++ (110) GraphX (2,500) Spark (30,000) Some algorithms are more naturally expressed using the GraphX primitive operators

36 Representation Join Distributed Graphs Horizontally Partitioned Tables Vertex Programs Dataflow Operators Optimizations dvances in Graph Processing Systems Distributed Join Optimization Materialized View Maintenance

37 Join Site Selection using Routing Tables Routing Table (RDD) 1 2 Vertex Table (RDD) Never Shuffle Edges! Edge Table (RDD) B C B 1 B B C C 1 C C D D 1 2 D E E 2 E E F D F 2 F E F

38 Caching for Iterative mrtriplets Vertex Table (RDD) B C D E F Reusable Hash Index Reusable Hash Index Mirror Cache B C D Mirror Cache D E F Edge Table (RDD) Scan Scan B C E E B C C D E F D F

39 Incremental Updates for Triplets View Change Vertex Table (RDD) B Mirror Cache B C Edge Table (RDD) B B C C C D C D Change D E Mirror Cache D E Scan E E F D F F E F

40 Vertex Table (RDD) Edge Table (RDD) B C C D B C E F E F E D Mirror Cache B C D Mirror Cache D E F ggregation for Iterative mrtriplets B C D E F Change Change Scan Change Change Change Change Local ggregate Local ggregate B C D F

41 Reduction in Communication Due to Cached Updates Network Comm. (MB) Connected Components on Twitter Graph Most vertices are within 8 hops of all vertices in their comp Iteration

42 Benefit of Indexing ctive Vertices Runtime (Seconds) Connected Components on Twitter Graph Without ctive Tracking ctive Vertex Tracking Iteration

43 Join Elimination Identify and bypass joins for unused triplet fields» Java bytecode inspection PageRank on Twitter Communication (MB) Without Join Elimination Join Elimination Factor of 2 reduction in communication Iteration Better 43

44 dditional Optimizations Indexing and Bitmaps:» To accelerate joins across graphs» To efficiently construct sub-graphs Lineage based fault-tolerance» Exploits Spark lineage to recover in parallel» Eliminates need for costly check-points Substantial Index and Data Reuse:» Reuse routing tables across graphs and sub-graphs» Reuse edge adjacency information and indices 44

45 System Comparison Goal: Demonstrate that GraphX achieves performance parity with specialized graph-processing systems. Setup: 16 node EC2 Cluster (m2.4xlarge) + 1GigE Compare against GraphLab/PowerGraph (C++), Giraph (Java), & Spark (Java/Scala)

46 PageRank Benchmark EC2 Cluster of 16 x m2.4xlarge (8 cores) + 1GigE Runtime (Seconds) Twitter Graph (42M Vertices,1.5B Edges) x UK-Graph (106M Vertices, 3.7B Edges) 18x GraphX performs comparably to state-of-the-art graph processing systems.

47 Connected Comp. Benchmark EC2 Cluster of 16 x m2.4xlarge (8 cores) + 1GigE Runtime (Seconds) Twitter Graph (42M Vertices,1.5B Edges) x UK-Graph (106M Vertices, 3.7B Edges) 10x Out-of-Memory GraphX performs comparably to state-of-the-art graph processing systems.

48 Graphs are just one stage. What about a pipeline?

49 Small Pipeline in GraphX Raw Wikipedia Hyperlinks PageRank Top 20 Pages < / >! < / >! < / >! XML! HDFS HDFS Spark Giraph + Spark GraphLab + Spark GraphX Spark Preprocess Compute Spark Post Total Runtime (in Seconds) Timed end-to-end GraphX is the fastest

50 doption and Impact GraphX is now part of pache Spark Part of Cloudera Hadoop Distribution In production at libaba Taobao Order of magnitude gains over Spark Inspired GraphLab Inc. SFrame technology Unifies Tables & Graphs on Disk

51 GraphX à Unified Tables and Graphs New PI Blurs the distinction between Tables and Graphs New System Unifies Data-Parallel Graph-Parallel Systems Enabling users to easily and efficiently express the entire analytics pipeline

52 What did we Learn? Specialized Systems Graph Systems Integrated Frameworks GraphX

53 Future Work Specialized Systems Graph Systems Integrated Frameworks GraphX Parameter Server?

54 Future Work Specialized Systems Graph Systems Integrated Frameworks GraphX Parameter Server synchrony Non-deterministic Shared-State

55 Thank You Reynold Xin nkur Dave Daniel Crankshaw Michael Franklin Ion Stoica

56 Related Work Specialized Graph-Processing Systems: GraphLab [UI 10], Pregel [SIGMOD 10], Signal-Collect [ISWC 10], Combinatorial BLS [IJHPC 11], GraphChi [OSDI 12], PowerGraph [OSDI 12], Ligra [PPoPP 13], X-Stream [SOSP 13] lternative to Dataflow framework: Naiad [SOSP 13]: GraphLINQ Hyracks: Pregelix [VLDB 15] Distributed Join Optimization: Multicast Join [frati et al., EDBT 10] Semi-Join in MapReduce [Blanas et al., SIGMOD 10]

57 Edge Files Have Locality 1200 UK-Graph (106M Vertices, 3.7B Edges) GraphLab rebalances the edge-files on-load. GraphX preserves the ondisk layout through Spark. à Better Vertex-Cut Runtime (Seconds) 0 GraphLab GraphX + Shuffle GraphX

58 Scalability Twitter Graph (42M Vertices,1.5B Edges) Scales slightly better than PowerGraph/GraphLab 350 Runtime Linear Scaling EC2-Nodes

59 pache Spark Dataflow Platform Resilient Distributed Datasets (RDD): Zaharia et al., NSDI 12 RDD RDD RDD HDFS Load Map Reduce HDFS Load Map

60 pache Spark Dataflow Platform Resilient Distributed Datasets (RDD): RDD RDD Zaharia et al., NSDI 12 Persist in Memory RDD HDFS Load Map Reduce HDFS Load Map Optimized for iterative access to data..cache()

61 PageRank Benchmark EC2 Cluster of 16 x m2.4xlarge Nodes + 1GigE Runtime (Seconds) Twitter Graph (42M Vertices,1.5B Edges)? UK-Graph (106M Vertices, 3.7B Edges)? GraphX performs comparably to state-of-the-art graph processing systems.

62 Shared Memory dvantage Spark Shared Nothing Model Core Core Core Core Shuffle Files GraphLab Shared Memory Shared De-serialized In-Memory Graph Core Core Core Core

63 Shared Memory dvantage Spark Shared Nothing Model Core Core Core Core Shuffle Files GraphLab No SHM. TCP/IP Core Core Core Core Twitter Graph (42M Vertices,1.5B Edges) GraphLab GraphLab NoSHM GraphX Runtime (Seconds)

64 PageRank Benchmark Twitter Graph (42M Vertices,1.5B Edges) UK-Graph (106M Vertices, 3.7B Edges) GraphX performs comparably to state-of-the-art graph processing systems.

65 Connected Comp. Benchmark EC2 Cluster of 16 x m2.4xlarge Nodes + 1GigE Runtime (Seconds) Twitter Graph (42M Vertices,1.5B Edges) x UK-Graph (106M Vertices, 3.7B Edges) 10x Out-of-Memory Out-of-Memory GraphX performs comparably to state-of-the-art graph processing systems.

66 Fault-Tolerance Leverage Spark Fault-Tolerance Mechanism Runtime (Seconds) No Failure Lineage Restart

67 Graph-Processing Systems oogle Ligra GraphChi CombBLS GPS X-Stream Kineograph Representation Expose specialized PI to simplify graph programming. 67

68 Vertex-Program bstraction Pregel_PageRank(i, messages) : // Receive all the messages total = 0 foreach( msg in messages) : total = total + msg i // Update the rank of this vertex R[i] = total // Send new messages to neighbors foreach(j in out_neighbors[i]) : Send msg(r[i]) to vertex j 68

69 The Vertex-Program bstraction GraphLab_PageRank(i) // Compute sum over neighbors total = 0 foreach( j in neighbors(i)): total += R[j] * w ji // Update the PageRank R[i] = total R[4] * w Low, Gonzalez, et al. [UI 10] 69

70 Example: Oldest Follower Calculate the number of older followers for each user? val olderfollowerge = graph.mrtriplets( e => // Map if(e.src.age > e.dst.age) { (e.srcid, 1) else { Empty }, (a,b) => a + b // Reduce ).vertices B D 30 F C E

71 Enhanced Pregel in GraphX pregelpr(i, messagelist messagesum ):! // Receive all the messages! total = 0! messagesum foreach( msg in messagelist) :! total = total + msg! // Update the rank of this vertex! R[i] = total! combinemsg(a, b):! // // Compute Send new sum messages of two to messages! sendmsg(ià j, R[i], R[j], E[i,j]):! neighbors! return // foreach(j a + Compute in b! single out_neighbors[i]) message! :!! return Send msg(r[i]/e[i,j])! to vertex!! Require Message Combiners Remove Message Computation from the Vertex Program 71

72 ! PageRank in GraphX // Load and initialize the graph! val graph = GraphBuilder.text( hdfs://web.txt )! val prgraph = graph.joinvertices(graph.outdegrees)! // Implement and Run PageRank! val pagerank =! prgraph.pregel(initialmessage = 0.0, iter = 10)(! (oldv, msgsum) => * msgsum,! triplet => triplet.src.pr / triplet.src.deg,! (msg, msgb) => msg + msgb)! 72

73 Example nalytics Pipeline // Load raw data tables! val articles = sc.textfile( hdfs://wiki.xml ).map(xmlparser)! val links = articles.flatmap(article => article.outlinks)! // Build the graph from tables! val graph = new Graph(articles, links)! // Run PageRank lgorithm! val pr = graph.pagerank(tol = 1.0e-5)! // Extract and print the top 20 articles! val toprticles = articles.join(pr).top(20).collect! for ((article, pagerank) <- toprticles) {! println(article.title + \t + pagerank)! }!

74 pache Spark Dataflow Platform Resilient Distributed Datasets (RDD): RDD RDD Zaharia et al., NSDI 12 Persist in Memory RDD HDFS Load Map Reduce HDFS Load Map Lineage:.cache() Load Map Reduce HDFS RDD RDD RDD