Continuations, Processes, and Sharing. Paul Downen, Luke Maurer, Zena M. Ariola, Daniele Varacca. September 8, 2014

Transcription

1 Continuations, Processes, and Sharing Paul Downen, Luke Maurer, Zena M. Ariola, Daniele Varacca University of Oregon, Université Paris Diderot September 8, 2014

2 The plethora of semantic artifacts Many ways to understand programming languages: small-step semantics big-step semantics (natural semantics) abstract machines continuation-passing style transformations... Different tools; different views High-level reasoning Low-level reasoning Proof development

3 Getting along together Q But which one to choose?

4 Getting along together Q But which one to choose? A All of them!

5 Getting along together Q But which one to choose? A All of them! Q But how do we know that they agree?

6 Getting along together Q But which one to choose? A All of them! Q But how do we know that they agree? A Systematic inter-derivation; correct by construction (Danvy et al.)

7 Processes as a semantic tool Embedding into processes (π-calculus) Computation as communication Strong resemblance to continuation-passing

8 Processes as a semantic tool Embedding into processes (π-calculus) Computation as communication Strong resemblance to continuation-passing

9 What do processes have to offer? Some computations more direct in π- than λ-calculus Concurrency Non-determinism Change over time Simple story for memoization Reveals techniques in implementations of lazy languages Black holes in GHC

10 From continuations to processes

11 Example: function composition Transform the function composition into a process f (g 1)

12 Result-named style Name intermediate results of serious computations: f (g 1) goes to let y = g 1 in f y

13 Continuation-passing style Rewrite into continuations: let y = g 1 in f y goes to g(1, (λy. f (y, ret)))

14 Value-named style Name all serious values: g(1, (λy. f (y, ret))) goes to let k = λy. f (y, ret) in g(1, k)

15 Environment-based CPS Rewrite into explicit environment: let k = λy. f (y, ret) in g(1, k) goes to νk. k := λy. f (y, ret) in g(1, k)

16 Process encoding Rewrite into processes: νk. k := λy. f (y, ret) in g(1, k) goes to νk (!k(y). f y, ret g 1, k )

17 Uniform CPS transform (CBN and CBV) C x λk. x k C λx. M λk. k (λ(x, k ). C M k ) Call-by-name C MN λk. C M (λv. v (λk. C N k, k)) Call-by-value C MN λk. C M (λv. C N (λw. v (λk. k w, k)))

18 Uniform CPS to Uniform π-encoding C x k = x k N C x k = x k P N C x k = x k C λx. M k = k (λ(x, k ). C M k ) N C λx. M k = νf. f := λ(x, k ). N C M k in k f P N C λx. M k = νf (!f (x, k ). P N C M k k f )...

19 Interlude: Of variables and values

20 A mismatch Soundness: steps in source are steps in target (λx. λy. y)z = λy. y This is invalid by CBV transform of application: C (λx. λy. y)z = λk. z (λw. C λy. y k) C λy. y

21 Variables are not values C x λk. x k In CBN we need to execute a computation In CBV we need to lookup or fetch the value Plotkin CBV Restricted CBV Values: V ::= x λx. M V ::= λx. M Evaluation Contexts: E ::= [ ] EM VE E ::= [ ] EM VE (λx. M)V = M{V /x} (β v )

22 Correctness bisimulation

23 Criteria for correctness A transformation should preserve observable results of a program: Termination: the program reaches an answer Divergence: the program loops forever Getting stuck: the program cannot proceed

24 How the proof should go T preserves immediate results If M is an answer then T M is an answer... T preserves reduction M T M N T N

25 How the proof actually goes T preserves immediate results If M is an answer then T M reaches an answer... T preserves reduction M T M N T N

26 How the proof actually goes T preserves immediate results If M is an answer then T M reaches an answer... T preserves reduction? M N T M T N P

27 How the proof actually goes T preserves immediate results If M is an answer then T M reaches an answer... T preserves reduction??? M T M N T N? Q

28 Out-of-synch computations: administration Source: (λx. x)(λy. y) λy. y Target: C (λx. x)(λy. y) ret ret (λ(y, k). (λk. y k ) k) C λy. y ret ret (λ(y, k). (λk. y k ) k)

29 Out-of-synch computations: aliasing Source: (λf. g(f, f ))(λx. x) g((λx. x), (λx. x)) Target: N (λf. g(f, f ))(λx. x) = νi. i := λx. x in (λf. g(f, f )) i νi. i := λx. x in g(i, i) N g((λx. x), (λx. x)) = νi. i := λx. x in νj. j := λx. x in g(i, j)

30 Reasoning up to out-of-synch administration Define an administrative free transform (Danvy and Nielsen TCS 2003) M N T M P ad T N Q ad

31 Reasoning up to out-of-synch administration Reason up to bisimulation M N P Q M P iff T M ret ad P

32 Reasoning up to out-of-synch aliasing Reason up to bisimulation M N P Q M P iff M N 1 P

33 Bisimulation technique Start out similar Keep being similar M T M M N M N P Q P Q End up similar M M N P Q Q

34 One direction suffices The forward direction sufficient if (Leroy): The source language is deterministic; No infinite loop in source terminates in target Dichotomy of source reductions (Danvy and Zerny, PPDP 13) guarantees point 2: Proper reduction must cause work in target Administrative reduction must terminate

35 Sharing

36 Call-by-need evaluation let x = in x x

37 Call-by-need evaluation let x = in x x

38 Call-by-need evaluation let x = in x x

39 Call-by-need evaluation let x = in x x 7 let x = 3 in x x

40 Call-by-need evaluation let x = in x x let x = 3 in x x let x = 3 in 3 x

41 Call-by-need evaluation let x = in x x 7 let x = 3 in x x 7 let x = 3 in 3 x

42 Call-by-need evaluation let x = in x x 7 let x = 3 in x x 7 let x = 3 in 3 x

43 Call-by-need evaluation let x = in x x let x = 3 in x x let x = 3 in 3 x let x = 3 in 3 3

44 Call-by-need evaluation let x = in x x 7 let x = 3 in x x 7 let x = 3 in 3 x 7 let x = 3 in 3 3

45 Call-by-need evaluation let x = in x x let x = 3 in x x let x = 3 in 3 x let x = 3 in 3 3 let x = 3 in 9

46 Call-by-need and stateful CPS Okasaki call-by-need CPS using assignment C x λk. x k C λx. M λk. k (λ(x, k ). C M k ) C MN λk. C M (λv. νx. x := memo x (N) in v(x, k)) memo x (N) λk. C N (λw. x := (λk. k w) in k w)

47 On liveness of variables I First evaluate M, with N assigned to x let x = N in M I When x is forced, evaluate N and x is no longer in scope let x = N in E [x] I When N becomes V, continue in body with V assigned to x let x = V in E [V ]

48 Constructive update Initial binding is ephemeral, disappears on lookup νf. f := 1 memo f (N) in f k νf. memo f (N)k Updated binding is permanent, always available and can never be changed νf. f := V in f k νf. f := V in V k

49 Call-by-need and constructive update CPS Thunking protocol strictly enforced (thunks only evaluated once): C x λk. x k C λx. M λk. k (λ(x, k ). C M k ) C MN λk. C M (λv. νx. x := 1 memo x (N) in v(x, k)) memo x (N) λk. C N (λw. x := (λk. k w) in k w)

50 Constructive update in the π-calculus Permanent assignment: replicated server P x := λy. M in N =!x(y). P M P N Ephemeral assignment: unreplicated server P x := 1 λy. M in N = x(y). P M P N Processes can now responsively change their behavior

51 Constructive update in machines Suspended computations removed on retrieval (Sestoft) Thunks become dead when forced Black holes in GHC Practical implementation techniques reflected by theory

52 Conclusions Program transformation from CPS to processes Unite CBN and CBV with CBNeed Constructive update model of memoization CPS λ-calculus for change over time

53 Conclusions Program transformation from CPS to processes Unite CBN and CBV with CBNeed Constructive update model of memoization CPS λ-calculus for change over time Reminder: Decisions have consequences; live with them

54 Questions?