control edge synchronization edge MGOTO COEND

Size: px

Start display at page:

Download "control edge synchronization edge MGOTO COEND"

Roger Clark
5 years ago
Views:

1 and Optimization of Explicitly Analysis Programs using the Parallel Parallel Program Graph Representation Vivek Sarkar MIT Laboratory for Computer Science 1

2 Motivation Current sequence of steps in compiling explicitly parallel/multithreaded programs: 1. Parallel program is mapped to low-level IL with library calls 2. Sequential compiler translates low-level IL to machine code 3. If machine code runs \correctly" then stop 4. Add volatile declarations to program and/or adjust compiler optimization options 5. Go back to step 1 2

3 Motivation (contd.) Extension of sequential compiler analysis/optimization techniques to parallel programs is necessary for maintaining single-processor performance in parallel programs, adapting program parallelism to target parallel machine, and making compilation of parallel programs less tedious and less error-prone. 3

4 control edges. Edge (a; b; L) 2 E control Edge (a; b; f) 2 E sync Parallel Program Graphs A Parallel Program Graph P P G = (N; E control ; E sync ) is a directed multigraph consisting of: N, a set of nodes (includes CFG nodes and mgoto nodes). An mgoto node is used to create parallel threads of computation. E control N N ftrue; false; uncondg, a set of labeled identies a control edge from node a to node b with label L. E sync N N SynchConds, a set of synchronization edges. denes a synchronization from node a to node b with synchronization condition f. 4

5 S2: X2 := : : : S5: : : : X 4 := : : : S7: X7 := : : : Example of a Parallel Program Graph control edge S1: X1 := : : : synchronization edge post(ev1) cobegin S1 MGOTO post(ev2) S3: wait(ev1) S2 S5 post(ev3) S4: wait(ev8) S3 S6 nn S7 S6: wait(ev2) S8 S8: wait(ev3) S4 post(ev8) COEND coend 5

6 Relating CFGs to PPGs Construction of PPG for a sequential program PPG nodes = CFG nodes PPG control edges = CFG edges PPG synchronization edges = empty set 6

7 Relating PDGs to PPGs Construction of PPG from PDG: PPG nodes = PDG nodes (A region node in a PDG maps to an mgoto node in the PPG) PPG control edges = PDG control dependence edges PPG synchronization edges = PDG data dependence edges Synchronization condition f in PPG synchronization edge mirrors context of PDG data dependence edge 7

8 REACH in (n) = set of denitions d s.t. there is a path from d to n Reaching Denitions Analysis on CFGs and d is not killed along that path. REACH out (n) = (REACH in (n) Kill(n)) [ Gen(n) REACH in (n) = [ REACH out (p) pred(n) 2 p 8

9 3. there is no CFG path from d to n Computing Redenition (REDEF) sets for CFGs REDEF in (n) = set of denitions d s.t. d is redened (killed) on paths from d to n (and there is at least one path from d to n) ALL out (n) = (REDEF in (n) Gen(n)) [ REDEF (Kill(n) \ REACH in (n)) \ p 2 pred(n) REDEF in (n) = REDEF out (p) Three mutually exclusive cases for denition d and basic block n: 1. d 2 REACH in (n) 2. d 2 REDEF in (n) 9

10 1 (p) CA out REACH REDEF out (n) = (REDEF in (n) Gen(n)) [ Reaching Denitions Analysis on PPGs REACH out (n) = (REACH in (n) Kill(n)) [ Gen(n) 0 B@ [ REACH in (n) = REDEF in (n) p 2 pred(n) (Kill(n) \ REACH in (n)) [ [ REDEF in (n) = REDEF out (p) p 2 sync pred(n) \ REDEF out (p) p 2 control pred(n) 10

11 n REDEF in (n) REACH in (n) REDEF out (n) REACH out (n) Node ; ; ; fx 1 g S1 ; fx 1 g ; fx 1 g cobegin ; fx 1 g fx 1 g fx 2 g S2 fx 1 g fx 2 g fx 1 g fx 2 g S3 ; fx 1 g ; fx 1 g S5 fx 1 g fx 2 g fx 1 g fx 2 g S6 fx 1 g fx 2 g fx 1 ; X 2 g fx 7 g S7 fx 1 g fx 2 g fx 1 ; X 2 g fx 7 g S8 fx 1 ; X 2 g fx 7 g fx 1 ; X 2 ; X 7 g fx 4 g S4 coend fx 1 ; X 2 ; X 7 g fx 4 g fx 1 ; X 2 ; X 7 g fx 4 g Reaching Denitions Analysis on Example PPG 11

12 Related Work [Midki et al 89], [Chow, Harrison 92], : : : Analysis of explicit (nondeterministic) parallel programs with scalar and array variables, a sequentially consistent memory model, and structured parallelism (no explicit synchronization) [Pingali et al 90] Presented a constant propagation algorithm for Dependence Flow Graphs (dataow graphs with an imperative store) [Srinivasan 94], [Ferrante et al 96] Analysis of explicit deterministic parallel programs with scalar and array variables and copy-in/copy-out semantics 12

13 Conclusions In this talk, we motivated using the Parallel Program Graph (PPG) representation in analysis and optimization of parallel programs, and presented a solution for reaching denitions analysis on PPGs that is more precise than in past work. 13

14 Future Work Extend other traditional analysis and optimization algorithms for use on PPGs Use PPGs as intermediate representation in common compilation and execution environment for dierent parallel programming languages Extend PPG execution model to support mutual exclusion and nondeterminism 14

15 An execution instance I a When an execution instance I a branch label as L, it creates a new execution instances I b Parallel Control Flow in a PPG Three cases: 1. An mgoto node a with k 0 outgoing control edges, (a; b 1 ; uncond), : : :, (a; b k ; uncond), all with label uncond: of node a creates new execution instances I b1 ; : : : ; I b k of nodes b 1; : : : ; b k and then terminates itself. 2. A non-mgoto node a with one outgoing control edge (a; b; L) for branch label L: of node a evaluates node a's of node b and then terminates itself. 15

16 When an execution instance I a 3. A non-mgoto node a with no outgoing control edges for branch label L: of node a evaluates node a's branch label as L, it terminates itself.

17 H(I a ) = execution history of instance I a caused execution instance I a of PPG node a Execution Histories = sequence of (node,label) branch conditions that to be created Execution histories are dened recursively: 1. H(I start ) = <> (empty sequence) 2. If execution instance I a creates execution instance I b due to control edge (a; b; L), then H(I b ) = concat(h(i a ); < a; L >) 16

18 Consider synchronization edge (a; b; f) 2 E sync f(h(i a ); H(I b )) = true means that execution instance I a complete execution before execution instance I b Synchronization Conditions Synchronization condition f is a boolean function on execution histories Given execution instances I a and I b of nodes a and b, must can be started 17

19 Write-write hazard if I a Weak (Deterministic) Memory Consistency Model All memory accesses are assumed to be non-atomic Read-write hazard if I a reads location l in i and there is a parallel write of a dierent value, then the result is an error writes value v into location l and there is a parallel write of a dierent value, then the resulting value in location l is undened Separation of data communication and synchronization: { Data communication specied by read/write operations { Sequencing specied by synchronization and control edges 18

20 Control-Independent Synchronizations in a PPG A synchronization edge (x; y; f) is control-independent if a necessary condition for f(h(i a ); H(I b )) =true is that nodeprex(h(i x ); a) = nodeprex(h(i y ); a) for all nodes a that are control ancestors of both x and y. 19

21 Consider an execution instance I x Control-Independent Synchronizations in a PPG (contd.) of PPG node x with execution history H(I x ) =< u 1 ; L 1 ; : : : ; u i ; : : : ; u j ; : : : ; u k ; L k >, u k = x. We dene nodeprex(h(i x ); a) as follows: If a 6= x, nodeprex(h(i x ); a) =< u 1 ; L 1 ; : : : ; u i ; L i >; u i = a, u j 6= a, i < j k. If a = x, then nodeprex(h(i x ); a) = H(I x ) =< u 1 ; L 1 ; : : : ; u i ; : : : ; u j ; : : : ; u k ; L k >. A node a is a control ancestor of node x if there exists an acyclic path of control edges from START to x such that a is on that path. 20

Analysis and Optimization of Explicitly Parallel Programs using the Parallel Program Graph Representation Vivek Sarkar Laboratory for Computer Science

Analysis and Optimization of Explicitly Parallel Programs using the Parallel Program Graph Representation Vivek Sarkar Laboratory for Computer Science Massachusetts Institute of Technology 545 Technology