On Compilation and Call-by-Value Games. Ulrich Schöpp LMU Munich

Transcription

1 On Compilation and Call-by-Value Games Ulrich Schöpp LMU Munich

2 Motivation Understand low-level decompositions of high-level languages. let rec fib x = if x < 1 then 1 else (fib (x - 1)) + (fib (x - 2))... %x6 = phi i32 [ 38, %case1 ], [ %unpack35, %case145 ], [ %add, %case167 ] %add = add i32 %x6, -1 %eq47 = icmp ne i32 %add, 0 switch i1 %eq47, label %case049 [ i1 true, label %case148 ]... Example: Defunctionalisation

3 Motivation Example: Defunctionalisation successful in practical applications surprisingly few theoretical results Need better understanding for: formal verification compositional reasoning resource usage analysis and certification modularity

4 Compilation and Games 1. Low-Level Language 2. Review: Idealized Algol 3. Call-by-Value PCF 4. Call-by-Value Games

5 Low-Level Programs The target is a first-order low-level language. first-order data tail recursion (cf. SSA-form compiler intermediate languages) Example: Factorial fun fac(n) = let f = 1 in loop(n, f) fun loop(n, f) = if n = 0 then ret(f) else body(n, f) fun body(n, f) = let f' = n * f in let n' = n - 1 in loop(n', f')

6 Control Flow Graph int fun fac(n) = let f = 1 in loop(n, f) int int fun loop(n, f) = if n = 0 then ret(f) else body(n, f) int int int int int fun body(n, f) = let f' = n * f in let n' = n - 1 in loop(n', f')

7 Low-Level Code Fragments int int int int int int int int

8 Low-Level Code Fragments int int int int int int int int

9 Low-Level Code Fragments int int int int int int int int int

10 Low-Level Code Fragments int int int int int int int

11 Game Semantics for Compilation Idea: Construct a game semantic model from low-level programs. Interpretation becomes compilation. Developed for compilation to... abstract machines [Mackie] hardware circuits [Ghica, Smith, Singh] logspace Turing Machines [Dal Lago, S.] π-calculus [Honda, Yoshida, Berger] quantum circuits [Hoshino, Hasuo, Yoshimizu, Faggian, Dal Lago]...

12 Game Semantics for Compilation Idea: Construct a game semantic model from low-level programs. Interpretation becomes compilation. Much work focussed on: Algol-like language (call-by-name) Low-Level Language Abramsky-Jagadeesan-Malacaria games Geometry of Interaction

13 Algol-Like Language Types A, B ::= α unit int A B X, Y ::= exp(a) exp(a, B) X Y X Y!X α. X α. X Translation by interpretation in a GoI-style model. A closed term t: X translates to a low-level fragment: X t X +

14 Algol-Like Language Types: A, B ::= α unit int A B µα. A X, Y ::= exp(a) exp(a, B) X Y X Y!X α. X α. X... Translation by interpretation in a GoI-style model. t: exp(a) unit t A

15 Algol-Like Language Types: A, B ::= α unit int A B µα. A X, Y ::= exp(a) exp(a, B) X Y X Y!X α. X α. X... Translation by interpretation in a GoI-style model. t: exp(a) t: exp(b, A) unit t A B t A

16 Algol-Like Language t: X Y Y X + t Y + X

17 Algol-Like Language t: X Y t s: Y Y X + t Y + X Y t Y + s

18 Algol-Like Language t: X Y t s: Y Y X + t Y + X Y t Y + s t:!x N X t N X +

19 Algol-Like Language t: X Y t s: Y Y X + t Y + X Y t Y + s t:!x t: α. X N X t N X + X [N/α] t X + [N/α]

20 Algol-Like Languages Games offer a simple approach to compiling Algol-like languages. efficient implementation possible resource control close to existing compilation techniques Algol-like languages (call-by-name) t: β. exp(β) exp(β int, int) Low-Level Language

21 Call-by-Value Are games good for the compilation of call-by-value languages? Call-by-Value PCF Low-Level Language

22 Call-by-Value Games? The efficient implementation of call-by-value plays by low-level programs is not immediate. (N N) 5 6 (N N) N How should function values be stored? How long do they need to be stored?

23 What do Compilers implement? Call-by-Value PCF Low-Level Language Common idea: For each term, generate code to evaluate the term s value. For abstractions: generate code for the function body. Assemble code fragments suitably.

24 What do Compilers implement? Example let a = 2 in let b = a + 3 in let f = fun x a * x + b in let g = if a < b then f else fun x x + 3 in print (g 5)

25 What do Compilers implement? Example let a = 2 in let b = a + 3 in let f =... in let g = if a < b then f else... in print (apply(g, 5)) fun apply(g, x) =... fun apply1(..., x) = a * x + b fun apply2(..., x) = x + 3

26 What do Compilers implement? Closures let a = 2 in let b = a + 3 in let f = {addr = &apply1; vars = (a, b)} in let g = if a < b then f else {addr = &apply2; vars = ()} in print (apply(g, 5)) fun apply(c, x) = c.addr(c.vars, x) fun apply1((a, b), x) = a * x + b fun apply2((), x) = x + 3

27 What do Compilers implement? Defunctionalisation let a = 2 in let b = a + 3 in let f = (a, b) in let g = if a < b then Left(f) else Right() in print (apply(g, 5)) fun apply(g, x) = case g of Left(f) apply1(f, x) Right() apply2((), x) fun apply1((a, b), x) = a * x + b fun apply2((), x) = x + 3

28 Capture such Translations Compositionally Can we capture such translations compositionally? formal verification resource usage analysis and certification modularity Study formalisations of the general approach: For each term, generate code to evaluate the term s value. For each term, generate code needed to make use of its value (e.g. function application). Assemble code fragments suitably.

29 Typed Closure Conversion Call-by-Value PCF t: X Typed Closure Conversion Algol-like Language t : α. exp(c X α ) I X α Low-Level Language

30 Typed Closure Conversion Idea: Translate a PCF v term t: X to a term of type α.!exp(c X α ) I X α

31 Typed Closure Conversion Idea: Translate a PCF v term t: X to a term of type α.!exp(c X α ) I X α Base type C N α = int I N α = I α.!exp(c N α ) I N α =!exp(int)

32 Typed Closure Conversion Idea: Translate a PCF v term t: X to a term of type α.!exp(c X α ) I X α Function types C X Y α := α I X Y α := β. I X β γ.!exp(α C X β, C Y γ ) I Y γ Example: α.!exp(c N N α ) I N N α = α.!exp(α)!exp(α int, int)

33 Typed Closure Conversion Idea: Translate a PCF v term t: X to a term of type α.!exp(c X α ) I X α Terms A PCF v term x 1 :X 1,..., x k :X k t: Y translates to a term of type α 1... α k. I X 1 α1... I X k αk M Y C X1 α C X k α where M Y A := β.!exp(a, C Y β ) I Y β.

34 Translation Application app Γ s: X Y t: X Γ, s t: Y where s t := Λ α β. λ x. λ y. let pack(α s, e s, i s ) = s α x in let pack(α t, e t, i t ) = t β y in let pack(ρ, apply, i ) = i s α t i t in pack(ρ, e, i ) e := fn ( x, y) let v s = e s ( x) in let v t = e t ( y) in apply(v s, v t )

35 Translation Application app Γ s: X Y t: X Γ, s t: Y where s t := Λ α β. λ x. λ y. let pack(α s, e s, i s ) = s α x in let pack(α t, e t, i t ) = t β y in let pack(ρ, apply, i ) = i s α t i t in pack(ρ, e, i ) e := fn ( x, y) let v s = e s ( x) in let v t = e t ( y) in t apply(v s, v t ) s

36 Translation Abstraction Γ, x:x t: Y abs Γ fn x t: X Y fn x t := Λ α. λ x. pack(c Γ α, fn c return c, Λβ. λx:i X β. t α β x x )

37 Case Distinction Case distinction tags function values like defunctionalisation. Example if t: B s 1 : N N s 2 : N N if t then s 1 else s 2 : N N Up to isomorphism: t :!exp(bool) s 1 : α.!exp(α)!exp(α int, int) s 2 : β.!exp(β)!exp(β int, int) =!exp(α + β)!exp((α + β) int, int) = γ.!exp(γ)!exp(γ int, int)

38 What does the Translation implement? With a suitable Algol-like language, one obtains a variant of defunctionalisation. Example let a = 2 in let b = a + 3 in let f = fun x a * x + b in let g = if a < b then f else fun x x + 3 in print (g 5)

39 What does the Translation implement? Example let a = 2 in let b = a + 3 in let f = (a, b) in let g = if a < b then Left(f) else Right() in case g of Left(f) apply1(f, x) Right() apply2((), x) fun apply1((a, b), x) = h(a * x + b) fun apply2((), x) = h(x + 3) fun h(x) = print(x); return

40 Implementation A suitable Algol-like language is developed in [S. 2016]. PCF t: X Algol-like language t : α A. (S exp(c X α )) I X α Low-Level Language Assembly Language xorl %eax, %eax popq %rdx

41 Call-by-Value Games In which order can values appear in low-level program traces? M X = α.!exp(c X α ) I X α : n, N unit n, x N C X A I X A

42 Call-by-Value Games In which order can values appear in low-level program traces? I N A : empty I X Y A : n, f, x N (A C X B ) n, y N C Y D I X B I Y D

43 Call-by-Value Games Compare to arenas in Honda-Yoshida games: M(X): x C(X) I(N) : empty I(X Y ) : x C(X) y C(Y ) I(X) I(X) I(Y ) C(N) = N C(X Y ) = { }

44 Call-by-Value Games (N N) (N N) N

45 Call-by-Value Games (N N) (N N) N i, f i, f j, f, g j, g, f, 5 j, g, 6 j, g, 7 j, 8 j, 8

46 Call-by-Value Games (N N) (N N) N i, f i, f j, f, g j, g, f, 5 j, g, 6 j, g, 7 j, 8 j, 8

47 Call-by-Value Games Abramsky and McCusker s construction of call-by-value games from Hyland-Ong games. Model types by families of games, e.g. {1 n n N} for N. Map from {X i i I} to T {Y j j J} is a strict strategy i I!X i q i I strict j J!Y j q j J!X i!y j Compare: ( α.!exp(c X α ) I X α ) strict ( β.!exp(c Y β ) I Y β )

48 Conclusion Study call-by-value games as a theory of compiled machine code! Directions Establish precise connections for various translations. defunctionalisation heap-allocated closures Apply results from game semantics to real machine code. verification specification resource analysis (length of plays as an approximation of program run-time)