Download Parallelization by Refactoring - ParaPhrase Enlarged

Central European Functional Programming School, 2015
Parallelization by Refactoring
Dept. Programming Languages and Compilers
Eötvös Loránd University, Hungary
Judit
Dániel Tamás Melinda István Viktória Zoltán
Kőszegi Horpácsi Kozsik Tóth
Bozó Fördős Horváth
LET'S PARTY!
●
Have fun...
Kozsik, T. et al.: Parallelization by Refactoring
2/100
LET'S PaRTE!
●
Have fun...
Kozsik, T. et al.: Parallelization by Refactoring
3/100
LET'S PaRTE!
●
Have functional programming!
Kozsik, T. et al.: Parallelization by Refactoring
4/100
LET'S PaRTE!
●
Have functional programming!
map-like function
speedup prediction
pattern candidate discovery
task farm
static analysis
refactoring pipeline parallel patterns
algorithmic skeletons
divide and conquer
ParaPhrase Refactoring Tool for Erlang
RefactorErl
Wrangler
Kozsik, T. et al.: Parallelization by Refactoring
5/100
Motivation
●
Highly heterogeneous mega-core computers
●
Performance and energy
●
Think parallel
●
–
High-level programming constructs
–
Deadlocks etc. eliminated by design
–
Communication packaged/abstracted
–
Performance information is part of design
Restructure existing code
Kevin
Hammond
Kozsik, T. et al.: Parallelization by Refactoring
6/100
How shall I parallelize?
●
●
Refactor
–
Use a tool!
–
Guided, semi-automatic transformations
Experiment
–
Measure, validate
●
Repeat
●
Applicable for legacy code as well
Kozsik, T. et al.: Parallelization by Refactoring
7/100
Where shall I parallelize?
●
Independent computations
●
Good potential for speedup
●
–
Complex computation?
–
Low sequential overhead?
Find candidates automatically
–
Use a tool!
–
Static program analysis
Kozsik, T. et al.: Parallelization by Refactoring
8/100
Pattern-based parallelism
High-level approach to parallel programming
●
Rely on a library of algorithmic skeletons
●
Easier to develop code
●
Easier to modify / maintain
●
Better utilization of resources
–
Static resource management
–
Dynamic resource management
Kozsik, T. et al.: Parallelization by Refactoring
9/100
Kozsik, T. et al.: Parallelization by Refactoring
10/100
Pool pattern
Ant Colony Optimization
Kozsik, T. et al.: Parallelization by Refactoring
11/100
picture from Kevin Hammond
Kozsik, T. et al.: Parallelization by Refactoring
12/100
Parallel Patterns for
Adaptive Heterogeneous Multicore Systems
●
●
●
●
Programmability of heterogeneous parallel
architectures
Structured design and implementation of
parallelism
High-level parallel patterns
Dynamic (re)mapping on heterogeneous
hardware
Kozsik, T. et al.: Parallelization by Refactoring
13/100
Kozsik, T. et al.: Parallelization by Refactoring
14/100
●
functional language
●
strict, impure, dynamically typed
●
concurrency, actor model
●
distribution
●
fault tolerance
●
Open Telecom Platform
Kozsik, T. et al.: Parallelization by Refactoring
15/100
Companies using Erlang
Kozsik, T. et al.: Parallelization by Refactoring
16/100
Products using Erlang
Kozsik, T. et al.: Parallelization by Refactoring
17/100
Let's PaRTE!
Assist parallelization of Erlang code with the
ParaPhrase Refactoring Tool for Erlang
Kozsik, T. et al.: Parallelization by Refactoring
18/100
So what is Erlang like?
●
Functional (strict, impure, dynamically typed)
●
Garbage collected
●
Designed for concurrency and distribution
–
Lightweight processes
–
Actor model (message passing)
●
Processing binary data
●
Fault tolerance (failure recovery)
●
Compiles to beam, runs in VM
●
Hot code swap
Kozsik, T. et al.: Parallelization by Refactoring
19/100
Erlang: a functional language
●
Variables bound only once
●
Recursion instead of loops
–
Tail recursive
●
Higher-order functions instead of recursion
●
Lambdas, pattern matching
●
Properties
–
Strict evaluation (call-by-value)
–
Impurity (e.g. communication)
–
No partial applications
Kozsik, T. et al.: Parallelization by Refactoring
20/100
Terms
●
Literals, e.g. 42 or 42.0
●
Atoms, e.g. leaf, blue, ok, error, true
●
Compound data
Funs
fun(X)-> X+1 end
Lists
[0,1,1,2,3,5,8,13,21]
Tuples
●
{may, 10, 2014}
Records
#date{month=june,day=7,year=2015}
Binaries
<<0,1,1,2,3,5,8,13,21>>
Pids, ports, refs
Kozsik, T. et al.: Parallelization by Refactoring
21/100
A complex term
[
{
farm,
[
{
],
12
pipe,
[
{seq, fun scan/1},
{seq, fun parse/1}
]
}
}
]
Kozsik, T. et al.: Parallelization by Refactoring
22/100
Expressions
●
Terms (literals, atoms, compound data)
●
Variables, e.g. X, Long_Variable_Name
●
Function/operator calls, e.g.
●
Data structures, e.g.
●
Control structures
fib(N-1)+fib(N-2)
{june,Day,fib(18)-569}
–
Branching (case and if)
–
Sending and receiving a message
–
Error handling
Kozsik, T. et al.: Parallelization by Refactoring
23/100
Defining a named function
increment(N) -> N+1.
Kozsik, T. et al.: Parallelization by Refactoring
24/100
Pattern matching
fib(N) ->
case N of
0 -> 0;
1 -> 1;
_ -> fib(N-1) + fib(N-2)
end.
Kozsik, T. et al.: Parallelization by Refactoring
25/100
Multiple function clauses
fib(0) -> 0;
fib(1) -> 1;
fib(N) -> fib(N-1) + fib(N-2).
Kozsik, T. et al.: Parallelization by Refactoring
26/100
Guards
fib(N) when N < 2 -> N;
fib(N) -> fib(N-1) + fib(N-2).
Kozsik, T. et al.: Parallelization by Refactoring
27/100
Using an if-expression
fib(N) ->
if
N < 2 -> N;
true
-> fib(N-1) + fib(N-2)
end.
Kozsik, T. et al.: Parallelization by Refactoring
28/100
Recursion
factorial(1) -> 1;
factorial(N) -> N * factorial(N-1).
Kozsik, T. et al.: Parallelization by Refactoring
29/100
Tail recursion
factorial(1) -> 1;
factorial(N) -> N * factorial(N-1).
factorial(N) -> factorial_acc(N,1).
factorial_acc(1,Acc) ->
Acc;
factorial_acc(N,Acc) ->
factorial_acc(N-1, Acc*N).
Kozsik, T. et al.: Parallelization by Refactoring
30/100
Overloading on arity
prime(1) -> false;
prime(N) when N > 1 -> prime(N,2).
% no proper divisors of N
% between M and sqrt(N)
prime(N,M) ->
M*M>N orelse ( N rem M =/= 0 andalso
prime(N,M+1)
).
●
Overloaded functions prime/1 and prime/2
●
prime/2 is helper function
Kozsik, T. et al.: Parallelization by Refactoring
31/100
Lists
[0,1,1,2,3,5,8]
[0 | [1,1,2,3,5,8]]
[0 | [1 | [1 | [2 | [3 | [5 | [8 | []]]]]]]]
[0,1,1,2 | [3 | [5 | [8 | []]]]]
[0,1,1,2 | [3,5,8]]
●
[Head | Tail] notation
●
List comprehension
[N || N <- lists:seq(1,100), prime(N)]
Kozsik, T. et al.: Parallelization by Refactoring
32/100
Scalar-vector multiplication
mul(Scalar,[]) -> [];
mul(Scalar,[Head|Tail]) ->
[ Scalar*Head | mul(Scalar,Tail) ].
Kozsik, T. et al.: Parallelization by Refactoring
33/100
Scalar-vector multiplication
mul(Scalar,[]) -> [];
mul(Scalar,[Head|Tail]) ->
[ Scalar*Head | mul(Scalar,Tail) ].
mul(Scalar,List) ->
[ Scalar*Item || Item <- List ].
Kozsik, T. et al.: Parallelization by Refactoring
34/100
Scalar-vector multiplication
mul(Scalar,[]) -> [];
mul(Scalar,[Head|Tail]) ->
[ Scalar*Head | mul(Scalar,Tail) ].
mul(Scalar,List) ->
[ Scalar*Item || Item <- List ].
mul(Scalar,List) ->
map( fun(Item) -> Scalar*Item end, List ).
Kozsik, T. et al.: Parallelization by Refactoring
35/100
Higher-order functions
map(Fun,[]) -> [];
map(Fun,[Head|Tail]) ->
[ Fun(Head) | map(Fun,Tail) ].
filter(Pred,List) ->
[ Item || Item <- List, Pred(Item) ]
Kozsik, T. et al.: Parallelization by Refactoring
36/100
fun-expressions
map( fun(Item) -> Scalar*Item end, List )
filter( fun prime/1, List )
Kozsik, T. et al.: Parallelization by Refactoring
37/100
Variable binding
●
Formal parameters:
fib(N)-> ...
mul(Scalar,[Head|Tail])-> ...
●
Generator in list comprehension:
[ ... | Item <- List]
●
Pattern matching expression
Syntax: Pattern = Expression
Primes = primes(List)
[ Head | Tail ] = primes(List)
Kozsik, T. et al.: Parallelization by Refactoring
38/100
Sequence of expressions
area( {square, Side} ) ->
Side * Side;
area( {circle, Radius} ) ->
% almost :-)
3.14 * Radius * Radius;
area( {triangle, A, B, C} ) ->
S = (A + B + C)/2,
math:sqrt(S*(S-A)*(S-B)*(S-C)).
●
from http://www.erlang.org/course/course.html
●
Grouping with begin ... end
Kozsik, T. et al.: Parallelization by Refactoring
39/100
Modules
●
Code in .hrl and .erl files
●
Compilation unit: module
●
Modules contain forms
(e.g. function and macro defs)
Kozsik, T. et al.: Parallelization by Refactoring
40/100
Example: mymath.erl
-module(mymath).
-export([fib/1,prime/1,pi/0]).
-define(PI,3.14).
pi() -> ?PI.
fib(N) when N<2 -> N;
fib(N) -> fib(N-1) + fib(N-2).
prime(1) -> false;
prime(N) when N > 1 -> prime(N,2).
prime(N,M) when M*M > N -> true;
prime(N,M) when N rem M == 0 -> false;
prime(N,M) -> prime(N,M+1).
Kozsik, T. et al.: Parallelization by Refactoring
41/100
Calling functions
●
Full name of exported functions:
mymath:prime/1
●
They can be called from other modules:
mymath:prime(1987)
●
●
●
They can be imported and called without
module prefix
Many built-in functions (BIFs) are autoimported
Calling through a variable:
F = fun mymath:prime/1, F(1987)
●
Dynamic call: apply(Module,Function,Args)
Kozsik, T. et al.: Parallelization by Refactoring
42/100
Compiling and running
$ ls mymath.erl
mymath.erl
$ erl
Erlang R16B (erts-5.10.1) [source] [smp:4:4]
[async-threads:10] [hipe] [kernel-poll:false]
Eshell V5.10.1 (abort with ^G)
1> c(mymath).
{ok,mymath}
2> mymath:prime(1987).
true
3> q().
ok
4> $ ls mymath*
mymath.beam mymath.erl
Kozsik, T. et al.: Parallelization by Refactoring
43/100
What else?
●
Concurrency, distributed programming
–
processes, ports, nodes
–
sending and receiving messages
●
Exception handling
●
Standard libraries, OTP
●
Programming patterns (behaviors)
Kozsik, T. et al.: Parallelization by Refactoring
44/100
Coming back to PaRTE...
Assist parallelization of Erlang code with the
ParaPhrase Refactoring Tool for Erlang
●
Discover parallelizable code fragments
●
Predict speedup, make suggestions
●
Perform guided automated refactorings
●
Pattern-based parallelism
Kozsik, T. et al.: Parallelization by Refactoring
45/100
Kozsik, T. et al.: Parallelization by Refactoring
46/100
Parallel skeletons
http://paraphrase-ict.eu/Deliverables/deliverable-2.6
The skel library
●
●
●
Basic algorithmic skeletons
farm, pipe, map, reduce, ord, feedback etc.
High-level patterns: skel hlp
dc, evolutionPool etc.
Heterogeneous skeletons: Lapedo
OpenCL kernels for CPU and GPU
http://paraphrase-ict.eu/Deliverables/d27prototype.tar.gz
Kozsik, T. et al.: Parallelization by Refactoring
47/100
Example: parsing modules
[ parse ( scan ( read ( Module ) ) )
|| Module <- Modules ]
Kozsik, T. et al.: Parallelization by Refactoring
48/100
Example: parsing modules
[ parse ( scan ( read ( Module ) ) )
|| Module <- Modules ]
skel:do([
{ farm, [{ pipe, [ { seq, fun read/1 },
{ seq, fun scan/1 },
{ seq, fun parse/1 }
] }
], 5 }
], Modules )
Kozsik, T. et al.: Parallelization by Refactoring
49/100
Example: radix sort
sort( List ) -> sort(List,0).
sort( List,
List;
_
) when length(List) < 2 ->
sort( List, Level ) ->
lists:append(
[ sort( Bucket, Level+1 )
|| Bucket <- divide( List, Level )
]
).
divide( List, Level ) -> ...
Kozsik, T. et al.: Parallelization by Refactoring
50/100
Divide-and-conquer pattern
{ dc, IsBase, BaseFun, Divide, Combine }
{ dc, IsBase, BaseFun, Divide, Combine,
MaxProcesses }
SEQ_DC =
{ seq_dc, IsBase, BaseFun, Divide, Combine },
PAR_DC =
{ dc, IsSeq, SEQ_DC, Divide, Combine }
Kozsik, T. et al.: Parallelization by Refactoring
51/100
Example: radix sort
sort( List ) -> skel:do( [{ dc,
fun({Lst,Level}) -> length(Lst) < 2 end,
fun({Lst,Level}) -> Lst end,
fun({Lst,Level}) ->
[ {Bucket,Level+1}
|| Bucket <- divide(Lst, Level)
]
end,
fun lists:append/1
}], {List,0}).
Kozsik, T. et al.: Parallelization by Refactoring
52/100
Example: radix sort
sort( List ) -> sk_hlp:dc(
fun({Lst,Level}) -> length(Lst) < 2 end,
fun({Lst,Level}) -> Lst end,
fun({Lst,Level}) ->
[ {Bucket,Level+1}
|| Bucket <- divide(Lst, Level)
]
end,
fun lists:append/1
)
({List,0}).
Kozsik, T. et al.: Parallelization by Refactoring
53/100
ParaPhrase approach
●
Identify (strongly hygienic) components
●
Discover patterns of parallelism
●
Structure the components into a parallel
program
–
Turn the patterns into concrete code
(skeletons)
–
Take performance, energy etc. into account
●
Restructure if necessary
●
Use a refactoring tool
Kozsik, T. et al.: Parallelization by Refactoring
54/100
Effectiveness of the approach
Parallelization
Convolution
Ant Colony
BasicN2
Graphical Lasso
Manual
3 days
1 day
5 days
12 hours
ParaPhrasing
3 hours
1 hour
5 hours
2 hours
Kozsik, T. et al.: Parallelization by Refactoring
55/100
PaRTE
ParaPhrase Refactoring Tool for Erlang
●
Locate parallel pattern candidates
●
Estimate speedup for different configurations
●
Advise programmer
●
Assist with refactoring
●
Enforce preservation of functionality
Kozsik, T. et al.: Parallelization by Refactoring
56/100
Googling the code for patterns
Kozsik, T. et al.: Parallelization by Refactoring
57/100
Googling the code
Kozsik, T. et al.: Parallelization by Refactoring
58/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
59/100
Pattern candidate discovery
●
Collect syntactic & semantic information
–
List comprehensions
–
Library calls (lists:map/2)
–
Recursion structure
–
Side conditions
●
Task farm, pipeline, divide-and-conquer, feedback
●
Heuristics
Kozsik, T. et al.: Parallelization by Refactoring
60/100
Task farm
[ parse(scan(read( Module )))
|| Module <- Modules ]
Work = fun(Module) ->
parse(scan(read(Module))) end,
skel:do([{farm,[{seq,Work}],5}], Modules)
Kozsik, T. et al.: Parallelization by Refactoring
61/100
Pipeline
[ parse(scan(read( Module )))
|| Module <- Modules ]
Stages =
[{seq,read/1},{seq,scan/1},{seq,parse/1}],
skel:do([{pipe,Stages}], Modules)
Kozsik, T. et al.: Parallelization by Refactoring
62/100
Farm of pipes
[ parse(scan(read( Module )))
|| Module <- Modules ]
Stages =
[{seq,read/1},{seq,scan/1},{seq,parse/1}],
Work = {pipe,Stages},
skel:do([{farm,Work,5}], Modules)
Kozsik, T. et al.: Parallelization by Refactoring
63/100
Functional “quicksort”: d&c
qs ( List ) ->
case List of
[]
-> [] ;
[H|T] ->
{List1,List2} = lists:partition(
fun(X) -> X < H end,
T),
qs(List1) ++ [H] ++ qs(List2)
end.
Kozsik, T. et al.: Parallelization by Refactoring
64/100
Karatsuba: d&c
karatsuba( Num1 , Num2 ) ->
...
Z0 = karatsuba( Low1 , Low2 ),
Z1 = karatsuba( add(Low1,High1),
add(Low2,High2) ),
Z2 = karatsuba( High1 , High2 ),
...
Kozsik, T. et al.: Parallelization by Refactoring
65/100
Radix sort: d&c
sort( []
,
_
) -> [] ;
sort( [V] ,
_
) -> [V] ;
sort( List, Level ) ->
Buckets = divide( List, Level ),
SortedLists =
lists:map( fun(B) -> sort(B,Level+1) end,
Buckets ),
lists:append( SortedLists ).
Kozsik, T. et al.: Parallelization by Refactoring
66/100
Minimax: d&c
mm_max( Node, Depth ) ->
case Depth == 0 orelse terminal(Node)
true
-> value ( Node ) ;
false -> lists:max([ mm_min(C, Depth-1)
|| C <- children(Node)
])
end.
mm_min( Node, Depth ) -> ... mm_max ...
Kozsik, T. et al.: Parallelization by Refactoring
67/100
RefactorErl
Static source code analyzer and transformer
http://plc.inf.elte.hu/erlang
Kozsik, T. et al.: Parallelization by Refactoring
68/100
Standard static analyses
●
Data-flow graph
●
Control-flow graph
●
Function call graph
Kozsik, T. et al.: Parallelization by Refactoring
69/100
Pattern-specific analyses
●
Identify components
–
●
Side effects
Identify patterns
–
Data dependency
Kozsik, T. et al.: Parallelization by Refactoring
70/100
Component
Action performed by Worker (farm) or Stage (pipe)
●
●
Side-effect analysis
–
Message passing
–
NIFs and global variables
–
ETS etc.
–
Process dictionary, node names
–
Exceptions
Hygiene rather than purity
Kozsik, T. et al.: Parallelization by Refactoring
71/100
Hygienic component
●
Identify used resources
●
Classify read/alter operations
use(C, R) ∊ { No, Read, Alter }
●
Component set:
components executed in parallel
∀R ∀C1 ≠ C2 ∊ S:
use(C1, R) = Alter → use(C2, R) = No
Kozsik, T. et al.: Parallelization by Refactoring
72/100
Element-wise processing
[ parse(scan(read( Module )))
|| Module <- Modules ]
Kozsik, T. et al.: Parallelization by Refactoring
73/100
Element-wise processing
[ parse(scan(read( Module )))
|| Module <- Modules ]
Work = fun(Module) ->
parse(scan(read(Module))) end,
lists:map(Work,Modules)
psr([]) -> [];
psr([H|T]) -> [parse(scan(read(H)))|psr(T)].
... psr(Modules) ...
Kozsik, T. et al.: Parallelization by Refactoring
74/100
Element-wise processing
f(P1, P2, P3, P4) ->
case P3 of
[] -> [];
a map-like function
[ Head | Tail ] ->
X = ... Head ... ,
[ X | f(P1,P2,Tail,P4) ]
end.
Kozsik, T. et al.: Parallelization by Refactoring
75/100
Element-wise processing
f(P1, P2, P3, P4) ->
case P3 of
[] -> [];
a map-like function
[ Head | Tail ] ->
X = ... Head ... ,
[ X | f(P1,P2,Tail,P4) ]
end.
●
f must be recursive:
the interprocedural CFG must contain an execution path
from the “starting node” of f to a “call-node” of f
∃p ∈ EP(startf) such that callf ∈ p
●
... base case ... single recursive call ... regularities ...
... data dependencies ... compact data flow reaching ...
Kozsik, T. et al.: Parallelization by Refactoring
76/100
Divide-and-conquer
●
●
A function has multiple recursive calls to itself
The arguments of a recursive call do not depend
on the result of another recursive call
Costly!
●
f must be recursive:
the interprocedural CFG must contain an execution path
from the “starting node” of f to a “call-node” of f
∃p ∈ EP(startf ) such that callf ∈ p
●
etc.
Kozsik, T. et al.: Parallelization by Refactoring
77/100
Faster rules
●
●
If h operates on lists, and
–
contains list comprehension with h in head
–
passes h to lists:map/2 or a map-like function
Analyze the function call graph
funcall+
function f
function g
funcall+
funcall+
Kozsik, T. et al.: Parallelization by Refactoring
78/100
●
Ant Colony Optimization
Experiments
Single Machine Total Weighted Tardiness Problem
●
●
Image merging case study
Intensional Computing Engine
Evaluator of the abstract syntax tree of ICE
●
●
Evolutionary Multi-Agent Systems framework
Thorn
Map-reduce framework
●
Mnesia
Distributed database management system
●
RefactorErl core
Static program analysis&transformation framework
Kozsik, T. et al.: Parallelization by Refactoring
79/100
Problem sizes
ELOC
Functions
Files
Ant Colony Optimization
483
56
21
Image merging
779
104
6
ICE evaluator
1094
141
21
Thorn
1313
158
15
EMAS framework
1646
177
25
RefactorErl core
19694
1534
53
Mnesia
22653
1693
31
Kozsik, T. et al.: Parallelization by Refactoring
80/100
Discovery results
farm
Ant Colony Optimization
10
Image merging
34
ICE evaluator
pipe
4
reduce d&c pool
2
7
4
Thorn
17
5
EMAS framework
71
20
16
RefactorErl core
486
49
55
31
Mnesia
135
8
36
57
9
2
Map-like functions: 9
Kozsik, T. et al.: Parallelization by Refactoring
81/100
Some interesting candidates
●
map-like functions
●
divide-and-conquer algorithms
Kozsik, T. et al.: Parallelization by Refactoring
82/100
Map-like function (Mnesia)
reverse([]) -> [];
reverse([ H=#commit{ ram_copies
=
disc_copies
=
disc_only_copies=
snmp
=
| R ]) ->
[ H#commit{
ram_copies
disc_copies
disc_only_copies
snmp
}
| reverse(R) ].
=
=
=
=
Ram,
DC,
DOC,
Snmp }
lists:reverse(Ram),
lists:reverse(DC),
lists:reverse(DOC),
lists:reverse(Snmp)
Kozsik, T. et al.: Parallelization by Refactoring
83/100
Map-like function (EMAS)
count_funstats(_,[]) -> [];
count_funstats(
Agents,
[{Stat, MapFun, ReduceFun, OldAcc} | T]
) ->
NewAcc =
lists:foldl( ReduceFun, OldAcc,
[MapFun(Agent) || Agent <- Agents] ),
[ {Stat, MapFun, ReduceFun, NewAcc}
| count_funstats(Agents,T)
].
Kozsik, T. et al.: Parallelization by Refactoring
84/100
D&C (RefactorErl)
...
listcons_length(N, #expr{}) ->
Ns = ?Dataflow:?reach([N], [back], true),
L1 = [N2 || N2 <- Ns, N2 /= N,
?Graph:class(N2) == expr],
{L2, L3} = lists:partition(
fun is_cons_expr/1, L1 ),
if L2 == [] orelse L3 /= [] ->
incalculable;
true ->
lists:append(lists:map(
fun listcons_length/1, L2))
end;
...
Kozsik, T. et al.: Parallelization by Refactoring
85/100
Another D&C (RefactorErl)
realtoken_neighbour(Node, DirFun, DownFun) ->
case lists:member(?Graph:class(Node),[clause,expr,form,typexp,lex]) of
false -> no;
_
-> case ?Syn:parent(Node) of
[]
-> no;
[{_,Parent}] -> case lists:dropwhile( fun({_T,N}) -> N/=Node end,
DirFun(?Syn:children(Parent))
) of
[{_,Node},{_,NextNode}|_] -> DownFun(NextNode);
_
->
realtoken_neighbour(Parent, DirFun, DownFun)
end;
Parents
-> realtoken_neighbour_( Parents, DownFun(Node),
DirFun, DownFun )
end
end.
% Implementation helper function for realtoken_neighbour/3
realtoken_neighbour_([], _FirstLeaf,_DirFun,_DownFun) -> no;
realtoken_neighbour_([{_,Parent}|Parents], FirstLeaf, DirFun, DownFun) ->
case realtoken_neighbour(Parent, DirFun, DownFun) of
FirstLeaf -> realtoken_neighbour_(Parents, FirstLeaf, DirFun, DownFun);
NextLeaf -> NextLeaf
end.
Kozsik, T. et al.: Parallelization by Refactoring
86/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
87/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
88/100
Benchmarking
●
Split up pattern candidates into components
●
Determine free variables (inputs)
●
Assemble a new module
–
Components turned into functions
–
Instrumented with time measurements
●
Load module
●
Generate random input and profile
●
Make statistics
Kozsik, T. et al.: Parallelization by Refactoring
89/100
Random input?
●
Not always meaningful...
●
... but easy to automate!
●
Find out the type of free variables (TypEr)
●
QuickCheck generates values by type
Kozsik, T. et al.: Parallelization by Refactoring
90/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
91/100
Cost model
●
Approximation
●
E.g. for farm:
●
Needs calibration!
Kozsik, T. et al.: Parallelization by Refactoring
92/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
93/100
Pattern Candidate Browser
●
After ranking pattern candidates
●
Web-based interface
●
–
Information for decision making
–
Not too many details
Services
–
Multiple users
–
Persistent results
–
Export XML, JSON, CSV, Erlang terms
Kozsik, T. et al.: Parallelization by Refactoring
94/100
Pattern
discovery
Cost
model
Complexity
metrics
Candidate
ranking
Calibrate
Costing
Type
inference
Benchmark
User
interface
Data
generation
Refactoring
engine
Kozsik, T. et al.: Parallelization by Refactoring
95/100
Refactoring
●
Program Shaping
●
Introduction of Skeletons
●
Cleanup Transformations
Either directly or after PC discovery
Kozsik, T. et al.: Parallelization by Refactoring
96/100
Program shaping
●
●
Restructures and tunes program to get it into
appropriate shape for skeleton introduction
Removal of:
–
Dependencies
–
Locks
–
Global State
–
Nestings
–
Copying
Kozsik, T. et al.: Parallelization by Refactoring
97/100
Future work: more refactorings
sort( List ) -> sort(List,0).
sort( List,
_
) when length(List) < 2 -> List;
sort( List, Level ) ->
lists:append(
[sort( Bucket, Level+1 ) || Bucket <- divide( List, Level )]
).
sort( List ) -> skel:do( [{ dc,
fun({Lst,Level}) -> length(Lst) < 2 end,
fun({Lst,Level}) -> Lst end,
fun({Lst,Level}) ->
[ {Bucket,Level+1} || Bucket <- divide(Lst, Level) ]
end,
fun lists:append/1
}], {List,0}).
Kozsik, T. et al.: Parallelization by Refactoring
98/100
Resources
ParaPhrase project (FP7 contract no. 288570)
http://paraphrase-ict.eu/
ParaPhrase @ ELTE
http://paraphrase-enlarged.elte.hu/
PaRTE docs & download:
http://pnyf.inf.elte.hu/trac/refactorerl/wiki/parte
CEFP 2015 instructions:
http://pnyf.inf.elte.hu/trac/refactorerl/wiki/parte/cefp
Kozsik, T. et al.: Parallelization by Refactoring
99/100
Conclusions
●
Pattern-based parallelism
●
ParaPhrase Refactoring Tool for Erlang
Pattern discovery and refactoring
Candidates prioritized,
support for decision making
–
Finds many places to introduce parallelism
–
Supports candidate ranking
–
Works effectively with a smart programmer
–
Offers performance gains with small effort
Kozsik, T. et al.: Parallelization by Refactoring
100/100