This thesis has introduced two novel approaches to automatic pattern discovery for pure functional languages. Our program slicingapproach is, in principle, able to analyse a wider range of pure explicitly recursive functions than current approaches. Similarly, ouranti-unificationapproach is able to discover a wider range of patterns, including custom patterns provided by the programmer, in pure explicitly recursive functions than current approaches. The discovery of more pattern instances, and a wider variety of patterns, facilitates the introduction of parallelism by exposing more opportunities for parallelism and by further automating the process. Consequently, it is now possible to automatically parallelise more functional programs with a wider range of parallel structures. This allows programmers to take advantage of now-ubiquitous parallel hardware in a simple and safe way, and improve the performance of their programs with minimal effort.
Appendix
A
Proof for Soundness of Slicing
Algorithm
Lemma A.1. For all programs, p, and their respective program environments, Gp; for all fixpoint expressions, e, in p where,
e=fix(l(f,x1, . . . ,xn) !e0)
and for all variables x, such that x=xµ whereµ2[1,n], we can derive the slice
of e with criterion x,Se|x, by
Gp,f,x,µ`e:Se|x
using the inference rules in Figure 4.4. Similarly, for all subexpressions, h,d, of e, (i.e.8h,h⌧e and 8d,d⌧e) we obtain the slice of h, Sh|x, by
Gp,f,x,µ`h:Sh|x and the slice ofd by
Gp,f,x,µ`d:Sd|x Given bothSh|x andSd|x, when d⌧h, it follows that
8y,y2Sd|x implies that y2Sh|x
Case 1. h=y, given thaty/⇤px.
Sincey/⇤px, the inference rulevar1 applies and so,Sy|x={y}.
Sinceyis a variable, from the definition of subexpression (Definition 4.2.2) we know thatd=h=y.
Consequently,Sd|x=Sy|x.
It follows trivially that y is in the slice of both d and h since d=h=y
and Sd|x=Sh|x=Sy|x.
Case 2. h=constz zs, given that h⌘x; i.e. thatz/px,zs/px, andz6=zs.
Sinceh⌘x, the inference rulelst2 applies and so,Sh|x={x,z,zs}. From the definition of subexpression (Definition 4.2.2), there are three subcases.
Case 2.1. When d=h.
This case is analogous to Case 1. Case 2.2. When d=z.
Since d=z, and since we know that z/⇤pxby Definition 4.2.3, the infer-
ence rulevar1 applies and so,Sz|x={z}.
It follows trivially that both z2Sz|x and z2Sd|x.
Case 2.3. When d=zs.
This case is analogous to Case 2.2. Case 3. h=conste1e2, given thath6⌘x.
Sinceh6⌘x, the inference rulelst3applies and so,Sh|x=S1[S2. From the definition of subexpression (Definition 4.2.2), there are three subcases.
Case 3.1. When d=h.
Case 3.2. Whend=e1.
The induction hypothesis (IH) isy2Se1|x.
Given Gp,f,x,µ`e1:Se1|x, Gp,f,x,µ`e2:Se2|x, and IH, it follows trivially fromSh|x=S1[S2that y2Sh|x.
Case 3.3. Whend=e2.
The case is analogous to Case 3.2.
Case 4. h=caseysof nilt !e1, constz zs!e2.
This case is analogous to Case 3. Case 5. h= f(e1, . . . ,en).
The inference rulerec-appapplies and so,Sh|x=S
j2[1,n]Sj.
From the definition of subexpression (Definition 4.2.2), there are nsub- cases; i.e.d=ej. Sincerec-appdefines a special case foreµ, these subcases
can be divided into two groups: where j6=µ and j=µ.
Case 5.1. Wherej6=µ.
This case is similar to Case 3.2. The induction hypothesis is y2Sej|x.
Given the slice for eachej,Sej|x=Sj, according torec-app; sinceSh|x= S
j2[1,n]Sj; and from the induction hypothesis we know that Sµ=∆; it
follows trivially that y2Sh|x.
Case 5.2. Wherej=µ.
Therec-appinference rule defines four special cases for ej, consequently there are four subcases.
Case 5.2.1. Whereeµ/⇤px.
From therec-appinference rule, Sµ=∆.
It follows trivially that sinceSd|x=S
µ=∆, y2∆implies that y2Sh|x.
Case 5.2.2. Whereeµ⌘x.
Case 5.2.3. Where eµ=constekel, given thatel⌘x and that there are no
subexpressions, e0
k, of ek that are either reachable from x or a recursive
call (i.e. ¬(9e0
k,e0k⌧ek^(e0k/⇤px_e0k=f(e0k1, . . . ,e0kn)))).
This case is analogous to Case 5.2.1.
Case 5.2.4. Otherwise, where ¬(eµ/⇤px)^(eµ6⌘x)^¬(eµ=constekel^ el⌘x^¬(9ek0,e0k⌧ek^(ek0 /⇤px_e0k= f(e0k1, . . . ,e0kn))).
This case is similar to Case 3.2.
The induction hypothesis is y2Sµ. Given the slice for eµ, Seµ|x, from rec-appwe know that Sd|x=S
µ={x}[Seµ|x.
Since we know that Sh|x=S
j2[1,n]Sj; and from the induction hypothesis
we know thaty2Sµ; it follows trivially thaty2Sh|x.
Case 6. h=e0(e1, . . . ,en), where e06= f. This case is similar to Case 3.
Sincee06= f, the inference ruleappapplies and so, Sh|x=Snj=0Sej|x. From the definition of subexpression (Definition 4.2.2), there are n+2
subcases; i.e. d=h and 8j2[0,n],d=ej. As before, we group the latter n+1 subcases into a single subcase.
Case 6.1. Whered=h.
This case is analogous to Case 1. Case 6.2. Where8j2[0,n],d=ej.
This case is similar to Case 5.1. The induction hypothesis is y2Sej|x.
It follows trivially that since Sh|x=Sn
j=0Sej|x, and given the induction
Case 7. h=l(a1, . . . ,an) ! e1.
From thefuninference rule we know thatSh|x=Se1|x.
From the definition of subexpression (Definition 4.2.2), there are two subcases.
Case 7.1. Whend=h.
This case is analogous to Case 1. Case 7.2. Whend=e1.
The induction hypothesis is y2Se1|x.
Given the slice of e1, Se1|x, given the induction hypothesis, and since we
know that Sh|x=Se1|x, it follows trivially that Sh|x=Sd|x=Se1|x.
Consequently,y2Sh|x.
Case 8. h=fixe1.
This case is analogous to Case 7.
Corollary A.1. It immediately follows from Lemma A.1 that 8y,y2 Sh|x implies that y2Se|x.
Lemma A.2. For all programs, p, and their respective program environments, Gp; for all fixpoint expressions, e, in p where,
e=fix(l(f,x1, . . . ,xn) ! d)
Definition 4.3.2 produces the variable usage escaped e, e#= (e\
#x). For clarity, we will use#to denote the subexpression corresponding to the same subexpression in e#. For example, in
e#=fix(l(f,x1, . . . ,x
n) ! d#)
d# is corresponds to d in e.
For all subexpressions,h, to e and all subexpressions,d, to e# (i.e.8h,h⌧e and
8d,d⌧e#), given that h and d are corresponding subexpressions in e and e# respectively (i.e.d=h#), and given the slices ofh andd,
Gp,f,x,µ`h:Sh|x (A.1) Gp,f,x,µ`d:Sd|x (A.2) it follows that
Sh|x=Sd|x Proof Sketch. The proof is by case analysis on h.
Recall that the definition of variable usage escapement (Definition 4.3.2) substitutes occurrences of x and expressions that are syntactically equi- valent tox inefor the variable #, representing an empty expression and
considered to be syntactically equivalent to x (i.e.#⌘x). Definition 4.3.2 targets such substitutable expressions only in recursive calls, specifically the µth argument,eµ. Consequently, there are four cases.
Case 1. h= f(e1, . . . ,en)andeµ=x, given that8j2([1,µ)[(µ,n]),Sej|x=
Se#j|x.
Since h is a recursive call, therec-appinference rule applies and so we
know that, Seµ|x=S
From the definition of variable usage escapement (Definition 4.3.2), we know that e#
µ=#.
Since d is a recursive call and e#µ=#, therec-app inference rule applies
and so we know that,Se#µ|x=Sµ=∆.
Since both h and d are recursive calls, it follows from therec-app rule
that Sh|x=S
j2[1,n]Sj and Sd|x =Sj2[1,n]Sj where Sj=Se #
j|x and where Sµ=∆.
Since 8j2([1,µ)[(µ,n]),Sej|x=Se#j|x holds, and that ∆=∆, it follows
trivially that Sh|x=Sd|x.
Case 2. h=f(e1, . . . ,en)andeµ⌘x, given that8j2([1,µ)[(µ,n]),Sej|x=
Se#j|x.
This case is analogous to Case 1.
Case 3. h=f(e1, . . . ,en)andeµ=constekel, given thatel⌘x^¬(9e0k,e0k⌧ ek^(e0k/⇤px_e0k= f(e0k1, . . . ,ekn0 )))and 8j2([1,µ)[(µ,n]),Sej|x=Se#j|x.
This case is analogous to Case 1. Case 4. Otherwise.
From Definition 4.3.2 we know thath=d, and the result follows trivially.
Corollary A.2. It immediately follows from Lemma A.2 thatSe|x=Se#|x
Theorem A.1(Soundness of Slicing Algorithm). For all programs, p, and their respective program environments, Gp; for all fixpoint expressions, e, in p where,
e=fix(l(f,x1, . . . ,xn) !e0)
and for all variables x, such that x=xµ whereµ2[1,n], we can derive the slice
of e with criterion x,Se|x, by
Gp,f,x,µ`e:Se|x It follows that
8y,y2Se|x implies that y⇠xe
where y ⇠x e denotes that y is either used or updated in e according to Definitions 4.3.3 and 4.3.1, respectively.
Proof Sketch. The proof is by case analysis on y.
We must show that ify⇠xe, i.e. if yis either usedorupdated ine, then y
is in the slice of e,Se|x. From Definitions 4.3.1 and 4.3.3, there are three
possible cases. We must also show that ify is neitherusednorupdated in
ethen yis not in Se|x.
Case 1. y/+p x; i.e. (y/p⇤x)^(y6=x).
From the definition of usage, in order for y⇠xxto hold, we must show
that both y/⇤px and y⌧(e\#x) hold.
Sincey/+p e, it follows trivially that y/⇤px.
Let e#= (e\
#x), we must show thaty2Se|x implies thaty⌧e#.
Wheny is an expression, we know that the slice,Gp,f,x,µ`y:Sy|x, pro-
duced by the var1 inference rule isSy|x={y}. Consequently,y2Sy|x. If y2Sy|x and y⌧e#, we know thaty2Se#|x
by Lemma A.1. If y2Se|x, we know thaty2Se#|x by Lemma A.2.
Case 2. y=x.
From the definition of usage, there are two subcases. Case 2.1. When x⌧e#, given thate#= (e\
#x).
This case is analogous to Case 1.
Case 2.2. When9h,(h⌧e#)^h⌘x, given thate#= (e\ #x).
This case is similar to Case 1, except that thelst2 inference rule applies instead ofvar1.
Case 3. y=x¯.
From the definition of update (Definition 4.3.1), ¯x⇠xxholds when there
exists an expressionhsuch thath⌧eandh= f(e1, . . . ,en), where¬(eµ/⇤p x)^(eµ6⌘x)^¬(el⌘x^¬(9e0k,e0k⌧ek^(e0k/⇤px_ek0 = f(e0k1, . . . ,e0kn)))).
Since ¯x2Sh|x, and from therec-appinference rule, we know that ¯x2Sh|x
when ¬(eµ/⇤px)^(eµ6⌘ x)^¬(el ⌘x^¬(9e0k,e0k ⌧ek^(e0k/⇤p x_e0k = f(e0k1, . . . ,ekn0 )))) holds.
By Lemma A.1, we know that when h⌧e and ¯x2Sh|x, ¯x2Se|x.
Consequently, ¯x2Se|x implies that ¯x⇠xe.
Case 4. ¬(y⇠xe).
By inspection, the rules that introduce elements into the slice are var1,
lst2, andrec-app.
It follows from the conditions of var1, that y/⇤pxand therefore that yis
usedine by definition.
It follows from the conditions oflst2, that9h,h⌧e andh=constz zs
If follows from the conditions ofrec-app, that9h,h⌧eandh= f(e1, . . . ,en)
and ¬(eµ /⇤p x)^ (eµ 6⌘ x) ^¬((eµ = constek el ^el ⌘ x ^¬(9e0k,e0k ⌧ ek^(e0k/⇤px_e0
k= f(e0k1, . . . ,e0kn)), therefore ¯x is updated in e by defini-
Appendix
B
Proof for Soundness of
Anti-Unification Algorithm
Theorem B.1(Soundness of Anti-Unification Algorithm). Given the terms t1and t2, we can find t,s1, and s2, such that t1⇠=ts1 and t2⇠=ts2.
Proof Sketch. Given the terms t,t1,t2, and substitutions,s1 and s2. The proof is by case analysis ont1 and t2.
Caset1⇠=t2:
By application of eq with t=t2 and s1=s2 =#, we must show that
t1⇠=t2#and t2⇠=t2#.
By Definition 5.3.2 and reflexivity, botht1⇠=t2 and t2⇠=t2 hold. Caset2= (Varv)^(v6=p):
By application ofvarwhen t= (Varv),s1=Svt1, ands2=#, we must show thatt1⇠= (Varv) (Svt1) and (Varv)⇠= (Varv)#hold.
By Definition 5.3.1 and reflexivity,t1⇠=t1 holds.
Caset1= (Varvfai)^t2= (App(Varu) (Varv p ai))^(u6=p)^(vfai⌘v p ai): By application of idwhere
t= (App(Varu) (Varvp ai)) s1=LSvid,#M
s2=# we must show that:
(Varvfai)⇠= (App(Varu) (Varvpai))LSuid,#M (1) (App(Varu) (Varvp
ai))⇠= (App(Varu) (Varv p
ai))# (2)
For (1):
By Definition 5.3.3, (Varvfai)⇠= (App(Varu)Suid(Varvpai)#).
By Definition 5.3.1 and Definition 5.3.2,
(Varvf
ai)⇠= (App(Varid) (Varv p ai)).
By Definition 5.3.5 and reflexivity,(Varvf
ai)⇠= (Varv p
ai) holds.
For (2):
By Definition 5.3.2 and reflexivity,
(App(Varu) (Varvpai))⇠= (App(Varu) (Varv p
ai)) holds.
Case t22Rp:
By application of rp where t= (Vara), s1 =Sat1, and s2=Sat2, we must show that both t1⇠= (Vara)Sat1 and t2⇠= (Vara)Sat2 hold.
By Definition 5.3.1 and reflexivity, both t1⇠=t1and t2⇠=t2 hold. Case t1= (C t11 . . . t1n)^t2= (C t21 . . . t2n)^
By application of constwhere
t= (C t1 . . . tn) s1=Ls11, . . . ,s1nM s2=Ls21, . . . ,s2nM
we must show that:
(C t11 . . . t1n)⇠= (C t1 . . . tn)Ls1i, . . . ,s1nM (C t21 . . . t2n)⇠= (C t1 . . . tn)Ls2i, . . . ,s2nM
By Definition 5.3.3, (C t11 . . . t1n)⇠= (C(t1s11) . . . (tns1n))
and (C t21 . . . t2n)⇠= (C(t1s21) . . . (tns2n)).
By assumption, substitutivity and reflexivity,
both (C t11 . . . t1n)⇠= (C t11 . . . t1n) and (C t21 . . . t2n) ⇠= (C t21 . . . t2n)
hold.
Caset1=[t11, . . . ,t1n]^t2=[t21, . . . ,t2n]^
8i2[1,n],t1i⇠=tis1i^t2i⇠=tis2i:
By application of listwhere
t=[t1, . . . ,tn] s1=Ls11, . . . ,s1nM s2=Ls21, . . . ,s2nM
we must show that:
([t11 . . . t1n])⇠= ([t1 . . . tn])Ls1i, . . . ,s1nM ([t21 . . . t2n])⇠= ([t1 . . . tn])Ls2i, . . . ,s2nM
By Definition 5.3.3, ([t11 . . . t1n])⇠= ([(t1s11) . . . (tns1n)])
and ([t21 . . . t2n])⇠= ([(t1s21) . . . (tns2n)]).
By assumption, substitutivity and reflexivity,
both ([t11 . . . t1n])⇠= ([t11 . . . t1n]) and ([t21 . . . t2n])⇠= ([t21 . . . t2n])
Otherwise:
By application of otherwisewheret= (Vara), s1=Sat1,
and s2 = Sat2, we must show that both t1 = (⇠ Var a)Sat1 and t2 ⇠=
(Vara)Sat2 hold.
Appendix
C
Patterns Used in the Anti-Unify
Module Refactoring
1 map f [] = [] 2 map f (x:xs) = f x : map f xs 3 4 fold z f [] = z 5 fold z f (x:xs) = f x (fold z f xs) 6 7 foldl f z [] = z 8 foldl f z (x:xs) = foldl f (f z x) xs 9 10 foldlFlip f z [] = z 11 foldlFlip f z (x:xs) = foldlFlip f (f x z) xs 12 13 foldr2 f z ([],[]) = z14 foldr2 f z ((x:xs),(y:ys)) = f x y (foldr2 z (xs,ys))
15
16 foldl2 f z ([],[]) = z
17 foldl2 f z ((x:xs),(y:ys)) =
18 foldl2 f (f z x y) (xs,ys) 19
20 data BTree a = L a | B (BTree a) (BTree a) 21
22 foldBTree f g (L a) = g a
23 foldBTree f g (B l r) =
24 f (foldBTree f g l) (foldBTree f g r) 25
26 data CTree a = E | C a (CTree a) (CTree a) 27 28 fold2CTree f g h z (E,E) = z 29 fold2CTree f g h z ((C x xl xr),E) = 30 h x (fold2CTree f g h z (xl,E)) 31 (fold2CTree f g h z (xr,E)) 32 fold2CTree f g h z (E,(C y yl yr)) = 33 g y (fold2CTree f g h z (E,yl)) 34 (fold2CTree f g h z (E,yr)) 35 fold2CTree f g h z ((C x xl xr),(C y yl yr)) = 36 f x y (fold2CTree f g h z (xl,yl)) 37 (fold2CTree f g h z (xr,yr)) 38 39 scanl f z [] = [z] 40 scanl f z (x:xs) = f x z : scanl f (f x z) xs 41 42 zip ([],[]) = []
43 zip ((x:xs),(y:ys)) = (x,y) : zip (xs,ys) 44
45 zipWith f ([],[]) = []
46 zipWith f ((x:xs),(y:ys)) =
Bibliography
[1] Andreas Abel. ‘Termination checking with types’. In: ITA 38.4 (2004), pp. 277–319.
[2] Joonseon Ahn and Taisook Han. ‘An Analytical Method for Par- allelization of Recursive Functions’. In:Parallel Processing Letters
10.1 (2000), pp. 87–98.
[3] Marco Aldinucci. ‘Automatic program transformation: The Meta tool for skeleton-based languages’. In: Constructive Methods for Parallel Programming, Advances in Computation: Theory and Practice
(2002), pp. 59–78.
[4] Frances E. Allen and John Cocke. ‘A Program Data Flow Analysis Procedure’. In:Commun. ACM19.3 (1976), pp. 137–147.
[5] Randy Allen and Ken Kennedy.Optimizing Compilers for Modern Architectures: A Dependence-based Approach. Morgan Kaufmann, 2001.isbn: 1-55860-286-0.
[6] Corinne Ancourt and François Irigoin. ‘Scanning Polyhedra with DO Loops’. In:Proceedings of the Third ACM SIGPLAN Symposium on Principles & Practice of Parallel Programming (PPOPP), Williams- burg, Virginia, USA, April 21-24, 1991. 1991, pp. 39–50.
[7] Russell R. Atkinson and Carl Hewitt. ‘Parallelism and Synchron- ization in Actor Systems’. In:Conference Record of the Fourth ACM Symposium on Principles of Programming Languages, Los Angeles, California, USA, January 1977. 1977, pp. 267–280.
[8] Emil Axelsson, Koen Claessen et al. ‘The Design and Implement- ation of Feldspar - An Embedded Language for Digital Signal Processing’. In: Implementation and Application of Functional Lan- guages - 22nd International Symposium, IFL 2010, Alphen aan den Rijn, The Netherlands, September 1-3, 2010, Revised Selected Papers. 2010, pp. 121–136.
[9] Adam D. Barwell, Christopher Brown and Kevin Hammond. ‘Find- ing parallel functional pearls: automatic parallel recursion scheme detection in Haskell functions via anti-unification’. In:Future Gen- eration Computer SystemsIn press (2017).issn: 0167-739X.
[10] Adam D. Barwell, Christopher Brown et al. ‘Towards Semi-automatic Data-type Translation for Parallelism in Erlang’. In: Proceedings of the 15th International Workshop on Erlang, Nara, Japan, September 18-22, 2016. 2016, pp. 60–61.
[11] Adam D. Barwell, Christopher Brown et al. ‘Using Program Shap- ing and Algorithmic Skeletons to Parallelise an Evolutionary Multi- Agent System in Erlang’. In:Computing and Informatics35.4 (2016), pp. 792–818.
[12] Adam D. Barwell and Kevin Hammond. ‘In Search of a Map: Us- ing Program Slicing to Discover Potential Parallelism in Recursive Functions’. In:Proceedings of the 6th ACM SIGPLAN International Workshop on Functional High-Performance Computing. FHPC 2017. Oxford, UK: ACM, 2017, pp. 30–41.isbn: 978-1-4503-5181-2. [13] Cédric Bastoul. ‘Code Generation in the Polyhedral Model Is
Easier Than You Think’. In:13th International Conference on Parallel