A Functional Perspective

Size: px

Start display at page:

Download "A Functional Perspective"

Rosa Horn
5 years ago
Views:

1 A Functional Perspective on SSA Optimization Algorithms Patryk Zadarnowski jotly with Manuel M. T. Chakravarty Gabriele Keller 19 April 2004 University of New South Wales Sydney

2 THE PLAN ➀ Motivation an overview of the status quo ➁ Translatg the static sgle assignment (SSA) form to the admistrative normal form (ANF) of lambda calculus ➂ Applyg the technique to the sparse conditional constant propagation (SCC) algorithm THE PLAN 1

3 MOTIVATION We need a verified optimizg compiler Optimization algorithms are: X complex X adequately specified People tried and failed the past (IBM Vienna project) Functional programmers eat and breathe formal methods! MOTIVATION 2

4 THE APPROACH ➀ Fix the problem, not the tools: If compilers are hard to verify, change them to make it easier! ➁ Fix data structures before fixg algorithms: In every FORTRAN program hides a functional program tryg to break free! THE APPROACH 3

5 CONTRIBUTIONS ➀ Formalize the correspondance between the Static Sgle Assignment form and a direct-style lambda calculus ➁ Redefe Wegman-Zadeck s Sparse Conditional Constant Propagation usg our termediate representation ➂ Formally establish soundness of the new algorithm Also: ➃ Formal operational semantics for the SSA form. ➄ A new flexible data-flow framework. ➅ Solves the multiple-φ problem of the SSA form (Robert Morgan.) ➆ Received very enthusiastic response from both imperative and functional compiler communities. CONTRIBUTIONS 4

6 THE PLAN ➀ Start with the Static Sgle Assignment (SSA) Form Appel showed formally that SSA is fact a variant of lambda calculus Kelsey demonstrated correspondence between SSA and the contuation-passg style (CPS) of lambda calculus However, Flanagan et al. showed that CPS is bad for data flow analysis. ➁ Design an algorithm for translatg SSA programs to the Admistrative Normal Form (ANF) of lambda calculus. ➂ Use the correspondence troduced by the translation function to implement some traditional data-flow algorithms on ANF. ➃ Use formal semantics of ANF to prove properties about those algorithm. THE PLAN 5

7 CONTROL FLOW GRAPHS x put r 1 r r x x x 1 no Summary: Low-level representation Informal semantics Emphasis on control flow x = 0? yes return r CONTROL FLOW GRAPHS 6

8 CONTROL FLOW GRAPHS x put r 1 r r x x x 1 x = 0? yes return r no Summary: Low-level representation Informal semantics Emphasis on control flow However, many (most?) optimizations require data flow formation: Expensive to compute Reusable CONTROL FLOW GRAPHS 6-A

9 CONTROL FLOW GRAPHS & DATAFLOW INFORMATION x put r 1 r r x x x 1 x = 0? yes return r no Summary: Def-Use chas: defs refer to uses and uses refer to defs Analyses need a dense mappg of variables to abstract values X Expensive to represent and update! CONTROL FLOW GRAPHS & DATAFLOW INFORMATION 7

10 STATIC SINGLE ASSIGNMENT FORM x 0 put r 0 1 x 1 φ(x 0, x 2 ) r 1 φ(r 0, r 2 ) r 2 r 1 x 1 x 2 x 1 1 x 2 = 0? no Overview: Each variable has exactly one defg occurence Values from different control flows merged via φ functions φ functions placed by computg the domator tree of the procedure yes return r 2 STATIC SINGLE ASSIGNMENT FORM 8

11 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e procedures Syntax: STATIC SINGLE ASSIGNMENT FORM DETAILS 9

12 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } procedures Syntax: basic blocks STATIC SINGLE ASSIGNMENT FORM DETAILS 9-A

13 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e Syntax: procedures basic blocks copy STATIC SINGLE ASSIGNMENT FORM DETAILS 9-B

14 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e x v( v); e Syntax: procedures basic blocks copy calls STATIC SINGLE ASSIGNMENT FORM DETAILS 9-C

15 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e x v( v); e goto x; Syntax: procedures basic blocks copy calls jumps STATIC SINGLE ASSIGNMENT FORM DETAILS 9-D

16 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e x v( v); e goto x; ret v; ret v( v); Syntax: procedures basic blocks copy calls jumps returns STATIC SINGLE ASSIGNMENT FORM DETAILS 9-E

17 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e x v( v); e goto x; ret v; ret v( v); if v then e 1 else e 2 Syntax: procedures basic blocks copy calls jumps returns branches STATIC SINGLE ASSIGNMENT FORM DETAILS 9-F

18 STATIC SINGLE ASSIGNMENT FORM DETAILS p ::= proc x( x) {b} p e b ::= e b; x:e b 1 ; x:{b 2 } e ::= x v; e x v( v); e goto x; ret v; ret v( v); if v then e 1 else e 2 x φ(ḡ); e g ::= l:v l ::= x start Syntax: procedures basic blocks copy calls jumps returns branches phi nodes STATIC SINGLE ASSIGNMENT FORM DETAILS 9-G

19 STRUCTURED SSA FORM proc fac(x) { goto L 1 L 1 : { r 0 φ(start:1, L 1 :r 1 ) x 0 φ(start:x, L 1 :x 1 ) if x 0 then goto L 1 else ret r 0 L 2 : r 1 mul(r 0, x 0 ) x 1 sub(x 0, 1) }... } goto L 1 STRUCTURED SSA FORM 10

20 STATIC SINGLE ASSIGNMENT FORM x 0 put r 0 1 x 1 φ(x 0, x 2 ) r 1 φ(r 0, r 2 ) r 2 r 1 x 1 x 2 x 1 1 x 2 = 0? yes return r 2 no Evaluation I: V Sparse representation V Split variables improve the accuracy of analyses V Significantly reduces complexity of optimizations, such as: constant propagation partial redundancy elimation value numberg... STATIC SINGLE ASSIGNMENT FORM 11

21 STATIC SINGLE ASSIGNMENT FORM x 0 put r 0 1 x 1 φ(x 0, x 2 ) r 1 φ(r 0, r 2 ) r 2 r 1 x 1 x 2 x 1 1 no Evaluation II: X Still no scopg X Still only formal semantics X Difficult to add a type system: x 2 = 0? yes return r 2 STATIC SINGLE ASSIGNMENT FORM 12

22 STATIC SINGLE ASSIGNMENT FORM x 0 put r 0 1 x 1 φ(x 0, x 2 ) r 1 φ(r 0, r 2 ) r 2 r 1 x 1 x 2 x 1 1 x 2 = 0? yes no Evaluation II: X Still no scopg X Still only formal semantics X Difficult to add a type system: φ parameters out of context Analysis requires a large environment V However, there are improved versions, such as Gated SSA return r 2 STATIC SINGLE ASSIGNMENT FORM 12-A

23 ADMINISTRATIVE NORMAL FORM Restricted direct-style lambda calculus: no nested let s no nested function applications no anonymous lambda expressions ADMINISTRATIVE NORMAL FORM 13

24 ADMINISTRATIVE NORMAL FORM e ::= Syntax: ADMINISTRATIVE NORMAL FORM 14

25 ADMINISTRATIVE NORMAL FORM e ::= let x = v e copy Syntax: ADMINISTRATIVE NORMAL FORM 14-A

26 ADMINISTRATIVE NORMAL FORM Syntax: e ::= let x = v e let x = v( v) e copy calls ADMINISTRATIVE NORMAL FORM 14-B

27 ADMINISTRATIVE NORMAL FORM Syntax: e ::= let x = v e let x = v( v) e v copy calls returns ADMINISTRATIVE NORMAL FORM 14-C

28 ADMINISTRATIVE NORMAL FORM Syntax: e ::= let x = v e let x = v( v) e v v( v) copy calls returns jumps ADMINISTRATIVE NORMAL FORM 14-D

29 ADMINISTRATIVE NORMAL FORM Syntax: e ::= let x = v e let x = v( v) e v v( v) if v then e 1 else e 2 copy calls returns jumps branches ADMINISTRATIVE NORMAL FORM 14-E

30 ADMINISTRATIVE NORMAL FORM Syntax: e ::= let x = v e let x = v( v) e v v( v) if v then e 1 else e 2 letrec f e f ::= x( x) = e copy calls returns jumps branches code labels ADMINISTRATIVE NORMAL FORM 14-F

31 ADMINISTRATIVE NORMAL FORM EXAMPLE letrec fac(x) = letrec fac (x 0, r 0 ) = letrec fac () = let r 1 = mul(r 0, x 0 ) let x 1 = sub(x 0, 1) fac (r 1, x 1 )... if x 0 fac () else r 0 fac (x, 1) ADMINISTRATIVE NORMAL FORM EXAMPLE 15

32 ADMINISTRATIVE NORMAL FORM e ::= let x = v e let x = v( v) e v v( v) if v then e 1 else e 2 letrec f e f ::= x( x) = e Evaluation: V Natural scopg V Clean operational semantics V Easily type-checked V Yet still close to assembly language! ADMINISTRATIVE NORMAL FORM 16

33 ADMINISTRATIVE NORMAL FORM So where do I get some? ADMINISTRATIVE NORMAL FORM 17

34 ADMINISTRATIVE NORMAL FORM So where do I get some? Translate an SSA program! Semi-formal correspondence between programs SSA form and CPS [Kelsey, 1995] Semi-formal translation from SSA form to lambda calculus [Appel, 1998] We present a formal translation from SSA form to ANF (based on domator trees) ADMINISTRATIVE NORMAL FORM 17-A

35 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { letrec fac(x) = } TRANSLATING STRUCTURED SSA TO ANF 18

36 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { L 1 :{ letrec fac(x) = letrec fac ( ) = letrec fac () = L 2 : }... }... TRANSLATING STRUCTURED SSA TO ANF 18-A

37 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { L 1 :{ if x 0 else ret r 0 L 2 :r 1 mul(r 0, x 0 ) x 1 sub(x 0, 1) letrec fac(x) = letrec fac ( ) = letrec fac () = let r 1 = mul(r 0, x 0 ) let x 1 = sub(x 0, 1) if x 0 else r 0 }... }... TRANSLATING STRUCTURED SSA TO ANF 18-B

38 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { goto L 1 L 1 :{ if x 0 goto L 1 else ret r 0 L 2 :r 1 mul(r 0, x 0 ) x 1 sub(x 0, 1) goto L 1 } }... letrec fac(x) = letrec fac ( ) = letrec fac () = let r 1 = mul(r 0, x 0 ) let x 1 = sub(x 0, 1) fac ( ) if x 0 fac () else r 0 fac ( )... TRANSLATING STRUCTURED SSA TO ANF 18-C

39 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { goto L 1 L 1 :{ r 0 φ( ) x 0 φ( ) if x 0 goto L 1 else ret r 0 L 2 :r 1 mul(r 0, x 0 ) x 1 sub(x 0, 1) goto L 1 } }... letrec fac(x) = letrec fac (x 0, r 0 ) = letrec fac () = let r 1 = mul(r 0, x 0 ) let x 1 = sub(x 0, 1) fac ( ) if x 0 fac () else r 0 fac ( )... TRANSLATING STRUCTURED SSA TO ANF 18-D

40 TRANSLATING STRUCTURED SSA TO ANF proc fac(x) { goto L 1 L 1 :{ r 0 φ(start:1, L 1 :r 1 ) x 0 φ(start:x, L 1 :x 1 ) if x 0 goto L 1 else ret r 0 L 2 :r 1 mul(r 0, x 0 ) x 1 sub(x 0, 1) goto L 1 } }... letrec fac(x) = letrec fac (x 0, r 0 ) = letrec fac () = let r 1 = mul(r 0, x 0 ) let x 1 = sub(x 0, 1) fac (r 1, x 1 ) if x 0 fac () else r 0 fac (x, 1)... TRANSLATING STRUCTURED SSA TO ANF 18-E

41 WHAT HAVE WE GAINED? A way of trickg hackers to writg functional programs A way of thkg about functional programs as SSA programs applyg SSA algorithms to functional programs A way of thkg about SSA programs as functional programs applyg formal techniques to SSA programs So, let s have a look at a concrete algorithm... WHAT HAVE WE GAINED? 19

42 SPARSE CONDITIONAL CONSTANT PROPAGATION proc seven(x) { goto L 1 L 1 :x 0 φ(start:1, L 1 :x 1 ) } x 1 sub(x 0, 1) if x 1 then goto L 1 else ret 7 proc seven(x) { } ret 7 The origal SSA algorithm (Wegman & Zadeck, 1991) rather formally presented... SPARSE CONDITIONAL CONSTANT PROPAGATION 20

43 SPARSE CONDITIONAL CONSTANT PROPAGATION 21

44 A FRAGMENT OF SCC ANF A v Γ Ω = Γv, Γ, Ω A f (v 1,...,vn ) Γ Ω f Prim = E f (Γv Abs 1,...,Γvn ) otherwise = Γ f, Γ,if changed then Ω {f } else Ω where f is defed as f(x 1,...,xn) = e Γ = Γ [f, x 1 Γv 1,..., xn Γvn] changed = i.γx i Γv i -- dicates whether Γ changed A letrec f 1,..., fn e Γ Ω = let a, Γ, Ω = A e Γ{} Γ, Ω = A fix f 1,..., fn Γ (Ω Ω ) if Γ == Γ then a, Γ, Ω else A letrec f 1,..., fn e Γ Ω A fix fun 1,...,funn ΓΩ i.f i Ω = Γ, Ω otherwise = let a, Γ, Ω = A e Γ{} Γ = Γ [f i a] Ω = Ω Ω \ {f i } A fix fun 1,..., funn Γ (if Γf i Γa then Ω (Occ f i Dom Γ) else Ω ) where (f i (x 1,...,xm )=e) = fun i A FRAGMENT OF SCC ANF 22

45 AN OVERVIEW OF SCC ANF Denoted T E X-ised Haskell Operates on programs ANF Split to analysis and simplification stages Operates over the standard lattice N for constant propagation: (not a constant) n (no formation available) AN OVERVIEW OF SCC ANF 23

46 SO, HOW DOES IT WORK? Analysis proceeds by abstract terpretation under an environment Γ mappg variables to lattice values Matas a work list Ω of functions to visit by spectg call sites and trackg free variables for changes to abstract variables Functions added to the work list whenever any of its free variables is refed the environment letrec s are processed recursively until the work list is emptied The resultg abstract environment contas all formation obtaed about any constants Simplification phase replaces variables by constant values and elimates redundant branches SO, HOW DOES IT WORK? 24

47 letrec f(x) = let x = sub(x, x) if x then f(x ) else x f(7) SO, HOW DOES IT WORK? 25

48 letrec f(x) = let x = sub(x, x) if x then f(x ) else x f(7) Γ = {f,x 7},Ω = {f} SO, HOW DOES IT WORK? 25-A

49 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, x) if x then f(x ) else x f(7) Γ = {f,x 7},Ω = {f} SO, HOW DOES IT WORK? 25-B

50 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, x) Γ = {f, x 7,x 0},Ω = {} if x then f(x ) else x f(7) Γ = {f,x 7},Ω = {f} SO, HOW DOES IT WORK? 25-C

51 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, x) Γ = {f, x 7,x 0},Ω = {} if x then f(x ) else x Γ = {f 7, x 7,x 0},Ω = {f} f(7) Γ = {f,x 7},Ω = {f} SO, HOW DOES IT WORK? 25-D

52 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, x) Γ = {f, x 7,x 0},Ω = {} if x then f(x ) else x Γ = {f 7, x 7,x 0},Ω = {f} f(7) Γ = {f,x 7},Ω = {f} Γ = {f 7, x 7,x 0},Ω = {f} SO, HOW DOES IT WORK? 25-E

53 letrec f(x) = let x = sub(x, x) if x then f(x ) else x f(7) Γ = {f,x 7},Ω = {} Γ = {f 7,x 7,x 0},Ω = {} Γ = {f, x 7,x 0},Ω = {} Γ = {f 7,x 7,x 0},Ω = {} Γ = {f 7, x 7,x 0},Ω = {f} Γ = {f 7,x 7,x 0},Ω = {} Γ = {f,x 7},Ω = {f} Γ = {f 7, x 7,x 0},Ω = {f} SO, HOW DOES IT WORK? 25-F

54 letrec f(x) = let x = sub(x, 1) if x then f(x ) else x f(7) SO, HOW DOES IT WORK? 26

55 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, 1) if x then f(x ) else x f(7) SO, HOW DOES IT WORK? 26-A

56 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, 1) Γ = {f, x 7,x 6},Ω = {} if x then f(x ) else x f(7) SO, HOW DOES IT WORK? 26-B

57 letrec f(x) = Γ = {f,x 7},Ω = {} let x = sub(x, 1) Γ = {f, x 7,x 6},Ω = {} if x then f(x ) Γ = {f, x, x 6},Ω = {f} else x f(7) SO, HOW DOES IT WORK? 26-C

58 letrec f(x) = let x = sub(x, 1) Γ = {f,x 7},Ω = {} Γ = {f, x, x 6},Ω = {} Γ = {f, x 7,x 6},Ω = {} if x then f(x ) Γ = {f, x, x 6},Ω = {f} else x f(7) SO, HOW DOES IT WORK? 26-D

59 letrec f(x) = let x = sub(x, 1) if x then f(x ) Γ = {f,x 7},Ω = {} Γ = {f, x, x 6},Ω = {} Γ = {f, x 7,x 6},Ω = {} Γ = {f, x, x },Ω = {} Γ = {f, x, x 6},Ω = {f} else x f(7) SO, HOW DOES IT WORK? 26-E

60 letrec f(x) = let x = sub(x, 1) if x then f(x ) else x f(7) Γ = {f,x 7},Ω = {} Γ = {f, x, x 6},Ω = {} Γ = {f, x 7,x 6},Ω = {} Γ = {f, x, x },Ω = {} Γ = {f, x, x 6},Ω = {f} Γ = {f, x, x },Ω = {} Γ = {f,x, x },Ω = {f} SO, HOW DOES IT WORK? 26-F

61 WORK COMPLEXITY ➀ Each variable updated at most three times (same as SCC SSA ) ➁ Each function processed once for each change to its free variables ( SCC SSA, processed once for each comg SSA edge) ➂ Number of free variables corresponds directly to number of SSA edges ➃ Therefore, SCC ANF has the same work comlexity as SCC SSA. WORK COMPLEXITY 27

62 OBSERVATIONS ➀ SCC ANF performs ter-procedural analysis transparently, although alias analysis and performance still a problem ➁ Vanilla SCC ANF cannot handle higher-order functions ➂ The algorithm does not preserve non-termation ➃ Optimistic algorithms are difficult to analyze: environment valid until fixpot reached very complex variants OBSERVATIONS 28

63 CONCLUSIONS Benefits of ANF: Simplifies the operational semantics, the environment and therefore static analysis and formal reasong Allows us to view imperative programs as encodgs of functional programs Allows us to adopt SSA algorithms for compilation of functional programs Integrates tra- and ter-procedural analysis Straight forward extension to higher-order functions CONCLUSIONS 29

64 THE PAPER patrykz/papers/ssa-lambda/ THE PAPER 30

65 THE ANALYSIS FUNCTION: VALUES A v Γ Ω = Γ v, Γ, Ω THE ANALYSIS FUNCTION: VALUES 31

66 THE ANALYSIS FUNCTION: VALUES & APPLICATIONS A v Γ Ω = Γ v, Γ, Ω A f (v 1,...,v n ) Γ Ω f Prim = E Abs f (Γ v 1,..., Γ v n ) otherwise = Γ f, Γ, if changed then Ω {f } else Ω where f is defed as f(x 1,...,x n ) = e Γ = Γ [f, x 1 Γ v 1,..., x n Γ v n ] changed = i. Γ x i Γ v i -- dicates whether Γ changed THE ANALYSIS FUNCTION: VALUES & APPLICATIONS 31-A

67 THE ANALYSIS FUNCTION: let A let x=e 1 e 2 Γ Ω = let a, Γ, Ω = A e 1 Γ Ω Γ = Γ [x a] changed = Γ x Γ a affected = Occ x DomΓ -- DomΓ removes not yet used func A e 2 Γ (if changed then Ω affected else Ω) THE ANALYSIS FUNCTION: let 32

68 THE ANALYSIS FUNCTION: if-then A if v then e 1 else e 2 Γ Ω Γ v == =, Γ, Ω Γ v == True = A e 1 Γ Ω Γ v == False = A e 2 Γ Ω Γ v == = let a 1, Γ 1, Ω 1 = A e 1 Γ Ω a 2, Γ 2, Ω 2 = A e 2 Γ 1 Ω 1 a 1 a 2, Γ 2, Ω 2 THE ANALYSIS FUNCTION: if-then 33

69 THE ANALYSIS FUNCTION: letrec A fix fun 1,..., fun n Γ (if Γ f i Γ a then Ω (Occ f i DomΓ) else Ω A letrec f 1,...,f n e Γ Ω = let a, Γ, Ω = A e Γ {} Γ, Ω = A fix f 1,..., f n Γ (Ω Ω ) if Γ == Γ then a, Γ, Ω else A letrec f 1,..., f n e Γ Ω A fix fun 1,..., fun n Γ Ω i.f i Ω = Γ, Ω otherwise = let a, Γ, Ω = A e Γ {} Γ = Γ [f i a] Ω = Ω Ω \ {f i } THE ANALYSIS FUNCTION: letrec 34

70 where (f i (x 1,..., x m ) = e) = fun i THE ANALYSIS FUNCTION: letrec 35

Value Range Propagation

Value Range Propagation LLVM Adam Wiggs Patryk Zadarnowski {awiggs,patrykz}@cse.unsw.edu.au 17 June 2003 University of New South Wales Sydney MOTIVATION The Problem: X Layout of basic blocks LLVM is bra-dead.