Compiling Self-Adjusting Programs with Continuations

Transcription

1 Compiling Self-Adjusting Programs with Continuations Ruy Ley-Wild 1 Matthew Fluet 2 Umut Acar 2 1 Carnegie Mellon University 2 Toyota Technological Institute at Chicago September 2,

2 2 Dealin with Input Changes

3 Dealin with Input Changes talk.tex 2

4 Dealin with Input Changes talk.tex First run must process the entire source file 2

5 Dealin with Input Changes talk.tex First run must process the entire source file 2

6 Dealin with Input Changes talk.tex First run must process the entire source file 2

7 Dealing with Input Changes talk.tex First run must process the entire source file 2

8 Dealing with Input Changes talk.tex First run must process the entire source file Second run only has to process the affected frame...but latex processes the entire file again 2

9 Self-Adjusting Computation Self-Adjusting Computation (SAC) = Recompute affected outputs + Reuse unaffected outputs Modes of execution From scratch Update: reuse work from previous runs Track computation that depends on input changes 3

10 Example: Sum of Squares from scratch run: sumofsquares(3,2) same 3 2 change data

11 Example: Sum of Squares from scratch run: sumofsquares(3,2) reuse same change data computation data flow

12 Example: Sum of Squares from scratch run: sumofsquares(3,2) reuse same change recompute data computation data flow control flow

13 Example: Sum of Squares from scratch run: sumofsquares(3,2) same 3 reuse 9 reuse change recompute data computation data flow control flow

14 Example: Sum of Squares from scratch run: update run: sumofsquares(3,2) sumofsquares(3, 2) same 3 reuse 9 reuse change recompute data computation data flow control flow

15 Example: Sum of Squares from scratch run: update run: sumofsquares(3,2) sumofsquares(3, 2) same 3 reuse 9 reuse change recompute data computation data flow control flow

16 Example: Sum of Squares from scratch run: update run: sumofsquares(3,2) sumofsquares(3, 2) same 3 reuse 9 reuse change recompute data computation data flow control flow

17 Example: Sum of Squares from scratch run: update run: sumofsquares(3,2) sumofsquares(3, 2) same 3 reuse 9 reuse change recompute data computation data flow control flow

18 Applications Algorithms (computational geometry, dynamic algorithms) Machine learning (Bayesian inference) Robotics Software verification (dynamic invariant checking) Hardware design (reconfigurable hardware) 5

19 Tracking Dependencies Previous approach: Manually track dependencies monadic destination-passing primitives manual hashing, equality, memoization fun sumofsquares (x, y) = let x2 = read(x, fn m => write(m * m)) y2 = read(y, fn n => write(n * n)) in memo (x2,y2) (fn (x2,y2) => read(x2, fn n2 => read(y2, fn m2 => write(n2 + m2)))) end 6

20 Tracking Dependencies Previous approach: Manually track dependencies monadic destination-passing primitives manual hashing, equality, memoization fun sumofsquares (x, y) = let x2 = read(x, fn m => write(m * m)) y2 = read(y, fn n => write(n * n)) in memo (x2,y2) (fn (x2,y2) => read(x2, fn n2 => read(y2, fn m2 => write(n2 + m2)))) end 6 New approach: Automatically infer dependencies Language support: direct-style annotations Compiler support: infer dependencies from annotations fun sumofsquares (box m, box n) = box(unbox (box(m * m)) + unbox(box (n * n)))

21 Compilation Outline source λ-calculus + SAC annotations compilation target CPS λ-calculus + SAC primitives 7

22 Source Language Pure λ-calculus with SAC annotations Use boxes to mark changeable data τ ::= τ box e ::= box e create unbox e dereference 8

23 Source Language Pure λ-calculus with SAC annotations Use boxes to mark changeable data τ ::= τ box e ::= box e create unbox e dereference datatype a list = nil :: of a * a list map : ( a -> b) -> a list -> b list fun map f ( nil) = nil map f ( (h::t)) = (f h :: map f t) 8

24 Source Language Pure λ-calculus with SAC annotations Use boxes to mark changeable data τ ::= τ box e ::= box e create unbox e dereference datatype a list = nil :: of a * a list box map : ( a -> b) -> a list box -> b list box fun map f (box nil) = box nil map f (box (h::t)) = box (f h :: map f t) 8

25 Challenges of Compilation same e change recompute How to identify control dependencies? + memo 13 9

26 Challenges of Compilation same e change + memo 13 recompute How to identify control dependencies? Use the continuation! = the rest of the computation 9

27 Challenges of Compilation same e change + memo 13 recompute How to identify control dependencies? Use the continuation! = the rest of the computation But continuation is an overapproximation 9

28 Challenges of Compilation same e change + memo 13 recompute How to identify control dependencies? Use the continuation! = the rest of the computation But continuation is an overapproximation Use memoization 9

29 Challenges of Compilation same e change + memo 13 recompute How to identify control dependencies? Use the continuation! = the rest of the computation But continuation is an overapproximation Use memoization How to combine memoization and continuations? 9

30 Target Language Pure CPS λ-calculus with SAC primitives e ::= fun f.x.k.e explicit continuation v f v x v k boxk v v k unboxk v v k memo e attempt reuse Intrinsic support for self-adjusting computation 10

31 Dynamic Semantics for Evaluation and Replay expression evaluation σ; e σ ; v ; T state value trace replay σ; T σ ; v ; T trace 11

32 Dynamic Semantics for Evaluation and Replay expression evaluation σ; e σ ; v ; T state value trace replay σ; T σ ; v ; T trace from scratch evaluation-only 11

33 Dynamic Semantics for Evaluation and Replay expression evaluation σ; e σ ; v ; T state value trace replay σ; T σ ; v ; T trace from scratch evaluation-only update interleaving replay when possible evaluate when necessary 11

34 Dynamic Semantics for Evaluation and Replay evaluation expression σ; e σ ; v ; T state value trace replay σ; T σ ; v ; T trace Correctness: from scratch update evaluation-only interleaving replay when possible evaluate when necessary 11

35 Alternating between Evaluation and Replay a memo can adapt a similar execution previous run {}}{ σ ; e ; ; T σ; T σ ; v ; T σ; memo e σ ; v ; T 12

36 Alternating between Evaluation and Replay a memo can adapt a similar execution previous run {}}{ σ ; e ; ; T σ; T σ ; v ; T σ; memo e σ ; v ; T an invalid unboxk must be reevaluated σ(l) = v v σ; v k v σ ; v ; T σ; unboxk l v v k }{{} record result T σ ; v ; unboxk l v v k T 12

37 Adaptive CPS Translation e src v tgt k = e tgt compile term e with continuation v k box translation: straightforward fun translation: subtle box e v k = e (λy.boxk y v k ) unbox e v k = e (λy.unboxk y v k ) fun f.x.e v k =??? e 1 e 2 v k = e 1 (λy f. e 2 (λy x.y f y x v k )) 13

38 Function Compilation: standard translation 1 m 1 k 1 a 2 m 2 k 2 b 3 m 3 k 3 c fun f.x.e v k = v k (fun f.x.k. ( e k )) 1

39 Function Compilation: standard translation 1 m 1 k 1 a m 2 k 2 b 3 m 3 k 3 c fun f.x.e v k = v k (fun f.x.k. ( e k )) 1

40 Function Compilation: standard translation redo 1 m 1 k 1 How to reuse work? a m k d 3 m 3 k 3 c fun f.x.e v k = v k (fun f.x.k. ( e k )) 1

41 Function Compilation: memo d call 1 memo fn m 1 k 1 a How to reuse work? Memo the function call m 2 k 2 b 3 m 3 k 3 c fun f.x.e v k = v k (fun f.x.k. memo ( e k )) memo body 1

42 Function Compilation: memo d call 1 m 1 reuse m redo k 1 k a d How to reuse work? Memo the function call How to memo despite continuation? 3 m 3 k 3 c fun f.x.e v k = v k (fun f.x.k. memo ( e k )) memo body 1

43 Function Compilation: memo d call + boxed cont 1 m 1 m 2 box cont k 1 k 2 k 1 k 2 a b How to reuse work? Memo the function call How to memo despite continuation? Box the continuation 3 m 3 k 3 k 3 c 1 fun f.x.e v k = v k (fun f.x.k. let y k = boxk k in box cont let k = λy r.unboxk y k (λk.k y r ) in unbox cont memo ( e k )) memo body

44 Function Compilation: memo d call + boxed cont 1 3 m 1 reuse k 1 m redo k m 3 reuse k 3 k 1 a redo k d k 3 c How to reuse work? Memo the function call How to memo despite continuation? Box the continuation How to avoid reexecuting continuation? 1 fun f.x.e v k = v k (fun f.x.k. let y k = boxk k in box cont let k = λy r.unboxk y k (λk.k y r ) in unbox cont memo ( e k )) memo body

45 Function Compilation: memo d call/cont + boxed cont 1 3 m 1 m 2 m 3 memo cont k 1 k 2 k 3 k 1 k 2 k 3 a b c How to reuse work? Memo the function call How to memo despite continuation? Box the continuation How to avoid reexecuting continuation? Memoizing continuations fun f.x.e v k = v k (fun f.x.k. let k m = λy r.memo (k y r ) in memo cont let y k = boxk k m in box cont let k = λy r.unboxk y k (λk.k y r ) in unbox cont memo ( e k )) memo body 1

46 Function Compilation: memo d call/cont + boxed cont 1 3 m 1 memo k 1 m redo k m 3 reuse k 3 reuse k 1 a redo k d k 3 c How to reuse work? Memo the function call How to memo despite continuation? Box the continuation How to avoid reexecuting continuation? Memoizing continuations Uses existing primitives! fun f.x.e v k = v k (fun f.x.k. let k m = λy r.memo (k y r ) in memo cont let y k = boxk k m in box cont let k = λy r.unboxk y k (λk.k y r ) in unbox cont memo ( e k )) memo body 1

47 Summary Adaptive CPS for compiling self-adjusting programs Boxes = track dependencies + isolate continuations Memoization = identify reuse + optimize continuations More natural programming style SML implementation in MLton Selective CPS Reconcile memoization with allocation Interacting with self-adjusting subprograms Experimental evaluation Efficient update Competitive against manual approach See paper! 15

48 Thanks! pl/sa-sml 16

49 Future Work Reasoning principles for asymptotic performance Automate annotations Combine with effects (imperative references, I/O,...) Larger applications Self-adjusting latex? 17