static analysis of communication structures in parallel programs
DESCRIPTION
Static Analysis of Communication Structures in Parallel Programs. So-Yan Ho and Nai-Wei Lin Department of Computer Science and Information Engineering National Chung Cheng University. Motivations. - PowerPoint PPT PresentationTRANSCRIPT
Static Analysis of Static Analysis of Communication Structures in Communication Structures in
Parallel ProgramsParallel Programs
So-Yan Ho and Nai-Wei Lin
Department of Computer Science and Information Engineering
National Chung Cheng University
2
MotivationsMotivations
• Communication structures in message passing programs is the key to understand the behaviors of the programs
• Static analysis of communication structures allows programmers to identify potential communication bugs at compile time
3
Message Passing SchemesMessage Passing Schemes
• Direct-Addressing: CSP, Occam, Ada, MPI
send(task-id, message);message = receive(task-id);
• Indirect-Addressing: Fortran M, CCCsend(channel-id, message);message = receive(channel-id);
4
Channels in CCCChannels in CCC
• Pipes: one-to-one communication
• Spliters: one-to-many communication
• Mergers: many-to-one communication
• Multiplexers: many-to-many communication
5
Merits of Abundant ChannelsMerits of Abundant Channels
• Communication structures are more comprehensive
• The specification of communication structures is easier
• The implementation of communication structures is more efficient
• The static analysis of communication structures is more effective
6
Higher-Order ChannelsHigher-Order Channels
• A channel is first-order if it is used to transfer data
• A channel is higher-order if it is used to transfer channels
• The static analysis of higher-order channels is much more difficult than the static analysis of first-order channels
7
A Simple CCC ProgramA Simple CCC Program
task::main(){ spliter int ch; /* one-to-many channel */ int i;
ch = channel(); par { producer(ch, many); /* one sender */ parfor (i = 0; i < many; i++) consumer(ch); /* many receivers */ }}
8
A Simple CCC ProgramA Simple CCC Program
task::producer(ch, many)spliter int ch;int many;{ int i; for (i = 0; i < num_data; i++) send(ch, i); for (i = 0; i < many; i++) send(ch, end_data); /* signal end of data */}
9
A Simple CCC ProgramA Simple CCC Program
task::consumer(ch)spliter int ch;{ int data; while (1) { data = receive(ch); if (data == end_data) break; process(data); }}
10
Overview of the AnalysisOverview of the Analysis
• For each channel ch, infer the number of senders of ch, ch.s and the number of receivers of ch, ch.r
• Intraprocedural analysis: within a function– infer them once and for all, and use them as the
initial values of the interprocedural analysis
• Interprocedural analysis: among functions– propagate the values among functions until they
reach a fixed point
11
First-Order ChannelsFirst-Order Channels
• Use aliasing induced by parameter passing
• For each channel ch, inferch.s = ch.self.s + ch.others.sch.r = ch.self.r + ch.others.r
where,ch.self.s, ch.self.r: {0, 1}ch.others.s, ch.others.r: {0, 1, 2}
• We call the four tuple {ch.self.s, ch.self.r, ch.others.s, ch.others.r} the mode of ch
12
Intraprocedural AnalysisIntraprocedural Analysis
• For each channel ch,if ch is sent by current function then ch.self.s = 1else ch.self.s = 0if ch is received by current function then ch.self.r = 1else ch.self.r = 0
13
Interprocedural AnalysisInterprocedural Analysis
• Compact control flow trees– call nodes, spawn nodes, block nodes, alternativ
e nodes, repetition nodes– depth-first order (once)
• The call graph and the strongly connected component graph– topological sort order (once)
• Strongly connected components– worklist (iterations)
14
Compact Control Flow TreesCompact Control Flow Treestask::main(){ spliter int ch; int i;
ch = channel(); par { producer(ch, many); parfor (i = 0; i < many; i++) consumer(ch); }}
B
B
S
S
B
R
15
The Call Graph and Strongly The Call Graph and Strongly Connected Component GraphConnected Component Graph
main
producer consumer
process
task :: main() { . . . par { producer(ch,…); parfor ( . . . ) consumer(ch); } . . .}
task :: consumer(ch){ . . . process(data); . . .}
task ::producer(ch, …){ . . .}
16
Call NodesCall Nodes
• Let L be the set of channel parameters aliased with ch at the call node n
• Then chn.self.s = x L x.self.s,
chn.self.r = x L x.self.r,
chn.others.s = x L x.others.s,
chn.others.r = x L x.others.r
17
Spawn NodesSpawn Nodes
• Let L be the set of channel parameters aliased with ch at the spawn node n
• Then chn.self.s = 0,
chn.self.r = 0,
chn.others.s = x L x.self.s + x L x.others.s,
chn.others.r = x L x.self.r + x L x.others.r
18
Block NodesBlock Nodes
• If the block node n is the initial node chn.self.s = value from intraprocedural analysis, chn.self.r = value from intraprocedural analysis, chn.others.s = 0, chn.others.r = 0
• Otherwise chn.self.s = 0, chn.self.r = 0, chn.others.s = 0, chn.others.r = 0
19
Bolck NodesBolck Nodes
• Let L be the sequence of nodes inside the block node n
• Then chn.self.s = chn.self.s || x L chx.self.s,
chn.self.r = chn.self.r || x L chx.self.r,
chn.others.s = chn.others.s + x L chx.others.s,
chn.others.r = chn.other.r + x L chx.others.r
20
Alternative NodesAlternative Nodes
• Let L be the sequence of nodes inside the alternative node n
• Then chn.self.s = maxx L chx.self.s,
chn.self.r = maxx L chx.self.r,
chn.others.s = maxx L chx.others.s,
chn.others.r = maxx L chx.others.r
21
Repetition NodesRepetition Nodes
• Let m be the node inside the repetition node n
• Then chn.self.s = chm.self.s,
chn.self.r = chm.self.r,
chn.others.s = if chm.others.s == 0 then 0 else 2,
chn.others.r = if chm.others.r == 0 then 0 else 2
22
Second-Order ChannelsSecond-Order Channels
• Use aliasing induced by both parameter passing and message passing
• For each second-order channel ch, inferch.sS = the set of channels sent to chch.rS = the set of channels received from
ch
23
Intraprocedural AnalysisIntraprocedural Analysis
• For each second-order channel ch, ch.sS = ch.rS = For each first-order channel x, if x is sent to ch ch.sS = ch.sS ∪ { x } if x is received from ch ch.rS = ch.rS ∪ { x }
24
Parameter Passing AliasingParameter Passing Aliasing
task :: main(){ merger pipe int ch; pipe int m; . . . par { parfor ( . . . ) client(ch, m); server(ch); }}
task :: client(ch, c) { . . . send(ch, c); . . .}
task :: server(ch){ . . . s = receive(ch); . . .}
ch.sS : { c }
ch.sS : { m }ch.sS ::
25
Call and Spawn NodesCall and Spawn Nodes
• Let S be the set of second-order channel parameters aliased with ch at the call node n
• Let F be the set of first-order channel parameters at n, and for each p F, let (p) represent the corresponding channel argument of p at n
• Then chn.sS = x S x.sS{pF ,p/(p)} ,
chn.rS = x S x.rS {pF ,p/(p)}
26
Message Passing AliasingMessage Passing Aliasing
task :: main(){ merger pipe int ch; pipe int m, n; . . . par { parfor ( . . . ) client(ch, m); server(ch, n); }}
task :: client(ch, c) { . . . send(ch, c); . . .}
task :: server(ch, s){ . . . s = receive(ch); . . .}
ch.sS : { c }ch.rS:
ch.sS : { m }ch.rS: { n }
ch.sS :: ch.rS: { s }
27
Call and Spawn NodesCall and Spawn Nodes
• For each x in ch.sS, x is aliased with every y in ch.rS
• Then, for each c in {x} ch.rS c.self.s = d {x} ch.rS d.self.s,
c.self.r = d {x} ch.rS d.self.r,
c.others.s = d {x} ch.rS d.others.s,
c.others.r = d {x} ch.rS d.others.r
28
Block NodesBlock Nodes
• If the block node n is the initial node chn.sS = value from intraprocedural analysis,
chn.rS = value from intraprocedural analysis
• Otherwise chn.sS = ,
chn.rS =
29
Block NodesBlock Nodes
• Let L be the sequence of nodes inside the block node n
• Then chn.sS = chn.sS x L chx.sS,
chn.rS = chn.rS x L chx.rS
30
Alternative NodesAlternative Nodes
• Let L be the sequence of nodes inside the alternative node n
• Then chn.sS = x L chx.sS,
chn.rS = x L chx.rS
31
Repetition NodesRepetition Nodes
• Let m be the node inside the repetition node n
• Then chn.sS = chm.sS,
chn.rS = chm.rS
32
Time ComplexityTime Complexityintraprocedural analysis;for each SCC in SCCG begin while changed begin for each CCFT in the SCC begin for each node in the CCFT begin … endfor endfor endwhileendfor
The time complexity: O(V+E)
33
ConclusionsConclusions
• Design a linear algorithm to infer the number of senders and receivers for each channel
• Handle both first-order and higher-order channels
• Use the information about aliasing induced by both parameter passing and message passing