Palgol: A High-Level DSL for Vertex-Centric Graph Processing with Remote Access

Transcription

1 Palgol: A High-Level DSL for Vertex-Centric Graph Processing with Remote Access Yongzhe Zhang National Institute of Informatics 3rd Spring Festival Workshop March 21, 2017

2 Outline Background of vertex-centric graph processing Example and problems in programming model My research work A novel high-level model for describing vertex-centric graph computation based on remote access Palgol: a concise and efficient domain-specific language for implementing vertex-centric graph algorithm 2

3 The Pregel Model Overview Pregel: a distributed big graph processing framework proposed by Google [SIGMOD 10] Pregel = BSP + vertex-centric approach local computation processors Bulk-Synchronous Parallel (BSP) model data communication barrier synchronization BSP superstep 3 messages v compute() messages Vertex-centric computation

4 Pregel Programming Model Each processor run such code: do foreach active vertex v on the processor (halt, msgs) = v.compute(getmsg(v)) // halt: whether v inactivates itself // msgs: messages sent to other vertices handle(halt, msgs) end exchange data with other processors activate vertices that receive messages until all vertices are inactive The only user-defined function: messages Vertex::compute(Message[])->(Bool, Messages[]) v compute() messages 4

5 Pregel Programming Example (1) A typical Pregel Program (the compute function) fn compute(message[] msgs) { switch (state) { case 1:.. case 2: x = get_data_from_parent(msgs); y = get_data_from_siblings(msgs); z = msgs_to_parent(x, y, this); state = 3; return (false, encode(z)) } case 3:.. case 4:.. } 5 It seems that some messages are emitted in state 1 and state 3 need to handle the messages

6 Pregel Programming Example (2) Vertices send necessary messages in state 1 fn compute(message[] msgs) { switch (state) { case 1: x = msgs_to_children(this); y = msgs_to_siblings(this); h = halt_or_not(..); state = 2; return (h, encode(x, y)); } case 2:.. case 3:.. case 4:.. } 6 case 2: x = get_data_from_parent(msgs); y = get_data_from_siblings(msgs); z = msgs_to_parent(x, y, this); state = 3; return (false, encode(z))

7 Pregel Programming Example (3) State 3 indeed handles the messages sent in state 2 fn compute(message[] msgs) { switch (state) { case 1:.. case 2:.. case 3:.. this.res += get_sum(msgs) b = make_a_decision(this,..) state = (b? 1 : 4); } return (false, []); case 4:.. } 7 case 2: x = get_data_from_parent(msgs); y = get_data_from_siblings(msgs); z = msgs_to_parent(x, y, this); state = 3; return (false, encode(z))

8 Pregel Programming Example (4) Pregel algorithms are usually iterative: fn compute(message[] msgs) { switch (state) { case 1:.. case 2:.. case 3:.. this.res += get_sum(msgs) b = make_a_decision(this,..) state = (b? 1 : 4); return (false, []); } case 4:.. } Implement iteration by state transition (goto state 1) 8

9 Problems in Pregel Programming Too much low-level details and no compile-time check state transition (handle data dependency, iteration) message passing (encoding/decoding) termination control.. Readability hard to understand algorithm Maintainability 9

10 Reason? The gap between high-level algorithm description and Pregel s low-level interfaces do foreach vertex v x = parent s some value y = siblings some value parent.res += f(x, y, v) end until every vertex satisfies.. a simple high-level description 10

11 Reason? The gap between high-level algorithm description and Pregel s low-level interfaces fn compute(message[] msgs) { switch (state) { case 1: x = msgs_to_children(this); y = msgs_to_siblings(this); return (?, encode(x, y)) case 2: x = get_data_from_parent(msgs); y = get_data_from_siblings(msgs);.. case 3:.. case 4:.. } } low-level implementation do foreach vertex v x = parent s some value y = siblings some value parent.res += f(x, y, v) end until every vertex satisfies.. high-level description 11

12 Reason? The gap between high-level algorithm description and Pregel s low-level interfaces fn compute(message[] msgs) { switch (state) { case 1:.. case 2: x = get_data_from_parent(msgs); y = get_data_from_siblings(msgs); z = msgs_to_parent(x, y, this); return (false, encode(z)) case 3: this.res += get_sum(msgs).. case 4:.. } } low-level implementation do foreach vertex v x = parent s some value y = siblings some value parent.res += f(x, y, v) end until every vertex satisfies.. high-level description 12

13 Reason? The gap between high-level algorithm description and Pregel s low-level interfaces fn compute(message[] msgs) { switch (state) { case 1:.. case 2:.. case 3:.. this.res += get_sum(msgs) b = make_a_decision(this,..) state = (b? 1 : 4); return (false, []); case 4:.. } } low-level implementation do foreach vertex v x = parent s some value y = siblings some value parent.res += f(x, y, v) end until every vertex satisfies.. high-level description 13

14 Basic Idea To clearly describe the Pregel algorithm, we need vertex-centric way of algorithm description remote read / write instead of message passing high-level control flow instead of state transition do foreach vertex v x = parent s some value y = siblings some value parent.res += f(x, y, v) end until every vertex satisfies.. 14

15 A Systematic Solution Design a domain-specific language to allow users describe Pregel algorithms concisely: remote access (reading or writing attributes of other vertices through references) high-level control flow (iteration constructor) Compile the DSL to Pregel system analyze the data dependency and produce the state transition machine as well as the message passing scheme 15

16 Challenges Remote reads (using our formalization) are in general complex and hard to efficiently or mechanically translated to message passing all existing DSLs have severe restrictions that make some interesting algorithms hard to be expressed Some Pregel s low-level interfaces are hard to be properly formalized 16

17 Summary of My Research Work Study the translation from common remote access patterns to message passing in Pregel The translation is mechanically The solution is efficient Design and implement a new DSL which is based on remote access It is more expressive than all of existing DSLs It is comparable to manually written code 25% speedup ~ 30% slowdown using popular algorithms (PageRank, etc.) on real-world graphs 17

18 The High-Level Model vertex-centric computation based on remote access input graph output graph algorithmic superstep messages v compute() messages Pregel s message passing model field read v field write step Direct field access from the entire graph iteration sequence & iteration g step 1 g step 2 g sequence 18

19 Algorithmic Superstep a two-phase model that prevents data conflicts input graph field read v step remote read field write compute compute compute intermedi-ate graph computation local write output graph The first phase 19

20 Algorithmic Superstep a two-phase model that prevents data conflicts input graph compute compute compute intermedi-ate graph output graph field read v step remote write (by sending value) receive & reduce final vertex state field write The second phase (optional) 20

21 Example: The Point-Jumping Algorithm Consider the implementation of pointer-jumping Each vertex has a parent pointer Make all vertices point to the root 21

22 Palgol: Pregel Algorithmic Language A Palgol program for pointer-jumping Each vertex has a parent pointer (D field) Make all vertices point to the root field access syntax 1: input[id, D] 2: output[id, D] 3: 4: do chain access 5: for u in V 6: if (D[D[u]]!= D[u]) 7: local D[u] := D[D[u]] 8: end 9: until fix[d] field vertex id D[u] field access D[D[u]] nested field access (or chain access) 22

23 Key Technique Translation of Chain Access How to efficiently translate chain access to Pregel s message passing? e.g. D[D[D[D[u]]]] Convert to logic proposition every u knows D 4 [u] Search for a derivation in our logic system 23

24 Axioms of Our Logic System 1. 8u. u knows u 2. 8u. u knows D[u] 3. (8u. w(u) knowse(u)) ^ (8u. w(u) knowsv(u)) =) 8u. v(u) knowse(u) 24

25 Derivation of every u knows D 4 [u] step1: u knows u u knows D[u] message passing logical inference step2: D[u] knows u D[u] knows D[D[u]] step3: u knows D[D[u]] D[D[u]] knows u D[D[u]] knows D 4 [u] step4: u knows D 4 [u] 25

26 Expressiveness of Palgol Palgol can concisely implement many representative graph algorithms: Single-Source Shortest Path PageRank Randomized Bipartite Matching Strongly Connected Components Triangle Counting Shiloach-Vishkin Algorithm Minimum Spanning Forest Randomized Graph Coloring Approximate Maximum Weight Matching 26

27 Roadmap & Future Plan Distributed Graph Processing Pregel BSP model vertex-centric 8 < : Extend Palgol with more features general remote access graph mutation,.. Pregel algorithms Pregel system Domain-specific languages Compile Palgol to a customized Pregel system to improve the performance 27

28 Thank You Questions & Answers