Liveness based Garbage Collection

Size: px

Start display at page:

Download "Liveness based Garbage Collection"

Warren Williamson
5 years ago
Views:

1 CS738: Advanced Compiler Optimizations Liveness based Garbage Collection Amey Karkare Department of CSE, IIT Kanpur

2 Ideal Garbage Collection... garbage collection (GC) is a form of automatic memory management. The garbage collector, or just collector, attempts to reclaim garbage, or memory occupied by objects that are no longer in use by the program.... From Wikipedia

3 Real Garbage Collection... All garbage collectors use some efficient approximation to liveness. In tracing garbage collection, the approximation is that an object can t be live unless it is reachable.... From Memory Management Glossary

4 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live.

5 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data.

6 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea:

7 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result.

8 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live.

9 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences:

10 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences: Fewer cells marked.

11 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences: Fewer cells marked.

12 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences: Fewer cells marked. More garbage collected per collection.

13 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences: Fewer cells marked. More garbage collected per collection. Fewer garbage collections.

14 Liveness based GC During execution, there are significant amounts of heap allocated data that are reachable but not live. Current GCs will retain such data. Our idea: We do a liveness analysis of heap data and provide GC with its result. Modify GC to mark data for retention only if it is live. Consequences: Fewer cells marked. More garbage collected per collection. Fewer garbage collections. Programs expected to run faster and with smaller heap.

15 The language analyzed First order eager Scheme-like functional language. In Administrative Normal Form (ANF). p Prog ::= d 1...d n e main

16 The language analyzed First order eager Scheme-like functional language. p Prog ::= d 1...d n e main d Fdef ::= (define (f x 1... x n) e) In Administrative Normal Form (ANF).

17 The language analyzed First order eager Scheme-like functional language. In Administrative Normal Form (ANF). p Prog ::= d 1...d n e main d Fdef ::= (define (f x 1... x n) e) (if x e 1 e 2 ) e Expr ::= (let x a in e) (return x)

18 The language analyzed First order eager Scheme-like functional language. In Administrative Normal Form (ANF). p Prog ::= d 1...d n e main d Fdef ::= (define (f x 1... x n) e) (if x e 1 e 2 ) e Expr ::= (let x a in e) (return x) a App ::= k (cons x 1 x 2 ) (car x) (cdr x) (null? x) (+ x 1 x 2 ) (f x 1... x n)

19 An Example (define (appendl1l2) (if (null?l1)l2 (cons (carl1) (append (cdrl1)l2)))) (letz (cons (cons 4 (cons 5 nil)) (cons 6 nil)) in (lety (cons 3 nil) in (letw (appendyz) in π:(car (cdrw)))))

20 An Example (define (appendl1l2) (if (null?l1)l2 (cons (carl1) (append (cdrl1)l2)))) y 3 w z (letz (cons (cons 4 (cons 5 nil)) (cons 6 nil)) in (lety (cons 3 nil) in (letw (appendyz) in π:(car (cdrw))))) 4 6 5

21 An Example (define (appendl1l2) (if (null?l1)l2 (cons (carl1) (append (cdrl1)l2)))) y 3 w z (letz (cons (cons 4 (cons 5 nil)) (cons 6 nil)) in (lety (cons 3 nil) in (letw (appendyz) in π:(car (cdrw))))) Though all cells are reachable at π, a liveness-based GC will retain only the cells pointed by thick arrows.

22 Liveness Basic Concepts and Notations Access paths: Strings over {0, 1}. 0 access car field 1 access cdr field y z w

23 Liveness Basic Concepts and Notations Access paths: Strings over {0, 1}. 0 access car field 1 access cdr field Denote traversals over the heap graph y z w

24 Liveness Basic Concepts and Notations Access paths: Strings over {0, 1}. 0 access car field 1 access cdr field Denote traversals over the heap graph y z w Liveness environment: Maps root variables to set of access paths. y L i : z {ǫ} w {ǫ, 1, 10, 100} Notation: We write L i (x) as L x i

25 Liveness Basic Concepts and Notations Access paths: Strings over {0, 1}. 0 access car field 1 access cdr field Denote traversals over the heap graph y z w Liveness environment: Alternate representation. L i : {z.ǫ} {w.ǫ, w.1, w.10, w.100} Notation: We write L i (x) as L x i

26 Demand (car (cdrw)) y w z Demand (notation: σ) is a description of intended use of the result of an expression.

27 Demand Demand (notation: σ) is a description of intended use of the result of an expression.

28 Demand Demand (notation: σ) is a description of intended use of the result of an expression. We assume the demand on the main expression to be (0+1), which we call σ all.

29 Demand Demand (notation: σ) is a description of intended use of the result of an expression. We assume the demand on the main expression to be (0+1), which we call σ all. The demands on each function body, σ f, have to be computed.

30 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans))))))))

31 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L 1 =... L 2 = L 9 =... L 10 =...

32 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: Demand summaries: L 1 =... L 2 = L 9 =... L 10 =... σ main = σ all σ append =...

33 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: Demand summaries: Function summaries: L 1 =... L 2 = L 9 =... L 10 =... σ main = σ all σ append =...

34 Liveness analysis GOAL: Compute Liveness Environment at various program points, statically.

35 Liveness analysis GOAL: Compute Liveness Environment at various program points, statically. Lapp(a,σ) Liveness environment generated by an application a, given a demand σ. Lexp(e,σ) Liveness environment before an expression e, given a demand σ.

36 Liveness analysis of Expressions Lexp((return x), σ) = {x.σ}

37 Liveness analysis of Expressions Lexp((return x), σ) = {x.σ} Lexp((if x e 1 e 2 ),σ) = {x.ǫ} Lexp(e 1,σ) Lexp(e 2,σ)

38 Liveness analysis of Expressions Lexp((return x), σ) = {x.σ} Lexp((if x e 1 e 2 ),σ) = {x.ǫ} Lexp(e 1,σ) Lexp(e 2,σ) Lexp((let x s in e),σ) = L\{x. } Lapp(s, L(x)) where L = Lexp(e,σ)

39 Liveness analysis of Expressions Lexp((return x), σ) = {x.σ} Lexp((if x e 1 e 2 ),σ) = {x.ǫ} Lexp(e 1,σ) Lexp(e 2,σ) Lexp((let x s in e),σ) = L\{x. } Lapp(s, L(x)) where L = Lexp(e,σ) Notice the similarity with: live in (B) = live out (B)\kill(B) gen(b) in classical dataflow analysis for imperative languages.

40 Liveness analysis of Primitive Applications x (car x) σ 0

41 Liveness analysis of Primitive Applications x (car x) σ 0 α

42 Liveness analysis of Primitive Applications x (car x) σ 0 Lapp((car x), σ) = {x.ǫ, x.0σ} α

43 Liveness analysis of Primitive Applications (cons x y) σ x y

44 Liveness analysis of Primitive Applications (cons x y) σ x 0 1 y α β

45 Liveness analysis of Primitive Applications (cons x y) σ Lapp((cons x y),σ) = {x.α 0α σ} x 0 1 y {y.β 1β σ} α β

46 Liveness analysis of Primitive Applications (cons x y) σ Lapp((cons x y),σ) = {x.α 0α σ} x 0 1 y {y.β 1β σ} α β 0 Removal of a leading 0 1 Removal of a leading 1 Lapp((cons x y), σ) = x.0σ y.1σ

47 Liveness Analysis of Function Applications (f x y) σ x y Lapp((f x y),σ) =

48 Liveness Analysis of Function Applications (f x y) σ x ψ x ψ y y Lapp((f x y),σ) = x.ψ x σ y.ψ y σ α β

49 Liveness Analysis of Function Applications (f x y) σ x LF 1 f(α) LF 2 f(β) y Lapp((f x y),σ) = x.lf 1 f(σ) y.lf 2 f(σ) We use LF f : context independent summary of f.

50 Liveness Analysis of Function Applications (f x y) σ x LF 1 f(α) LF 2 f(β) y Lapp((f x y),σ) = x.lf 1 f(σ) y.lf 2 f(σ) We use LF f : context independent summary of f. To find LF i f (...): Assume a symbolic demand σ sym. Let e f be the body of f. Set LF i f(σ sym ) to Lexp(e f,σ sym )(x i ).

51 Liveness Analysis of Function Applications (f x y) σ x LF 1 f(α) LF 2 f(β) y Lapp((f x y),σ) = x.lf 1 f(σ) y.lf 2 f(σ) We use LF f : context independent summary of f. To find LF i f (...): Assume a symbolic demand σ sym. Let e f be the body of f. Set LF i f(σ sym ) to Lexp(e f,σ sym )(x i ). How to handle recursive calls?

52 Liveness Analysis of Function Applications (f x y) σ x LF 1 f(α) LF 2 f(β) y Lapp((f x y),σ) = x.lf 1 f(σ) y.lf 2 f(σ) We use LF f : context independent summary of f. To find LF i f (...): Assume a symbolic demand σ sym. Let e f be the body of f. Set LF i f(σ sym ) to Lexp(e f,σ sym )(x i ). How to handle recursive calls? Use LF f with appropriate demand!!

53 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

54 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) σ Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

55 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) inσ π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) σ Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

56 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) inσ π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in 1σ π 8 : (returnans)))))))) σ Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

57 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) inσ π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in 1σ π 8 : (returnans)))))))) σ LF 2 append(1σ) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

58 Liveness analysis The big picture π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) inσ π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in 1σ π 8 : (returnans)))))))) σ LF 2 append(1σ) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

59 Liveness analysis Demand Summary σ main = σ all π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

60 Liveness analysis Demand Summary σ main = σ all π main : (letz... in (lety... in σ 1 π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

61 Liveness analysis Demand Summary σ main = σ all π main : (letz... in (lety... in σ 1 π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) σ append = σ 1... (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

62 Liveness analysis Demand Summary σ main = σ all π main : (letz... in (lety... in σ 1 π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) σ append = σ 1... (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in σ 2 π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

63 Liveness analysis Demand Summary σ main = σ all π main : (letz... in (lety... in σ 1 π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) σ append = σ 1 σ 2 (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in σ 2 π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

64 Liveness analysis Demand Summary π main : (letz... in (lety... in π 9 : (letw (appendyz) in π 10 : (leta (cdrw) in π 11 : (letb (cara) in π 12 : (returnb))))))) (define (appendl1l2) π 1 : (lettest (null?l1) in π 2 : (iftest π 3 :(returnl2) π 4 : (lettl (cdrl1) in π 5 : (letrec (append tl l2) in π 6 : (lethd (carl1) in π 7 : (letans (cons hd rec) in π 8 : (returnans)))))))) Liveness environments: L l1 1 = {ǫ} 00σ append 1LF 1 append (1σ append) L l2 1 = σ LF 2 append (1σ append)... L y 9 = LF1 append ({ǫ, 1} 10σ all) Demand summaries: σ main = σ all σ append = {ǫ, 1} 10σ all 1σ append Function summaries: LF 1 append (σ) = {ǫ} 00σ 1LF 1 append (1σ) LF 2 append (σ) = σ LF2 append (1σ)

65 Obtaining a closed form solution for LF Function summaries will always have the form: LF i f (σ) = Ii f Di f σ

66 Obtaining a closed form solution for LF Function summaries will always have the form: LF i f (σ) = Ii f Di f σ Consider the equation for LF 1 append LF 1 append (σ) = {ǫ} 00σ 1LF1 append (1σ)

67 Obtaining a closed form solution for LF Function summaries will always have the form: LF i f (σ) = Ii f Di f σ Consider the equation for LF 1 append LF 1 append (σ) = {ǫ} 00σ 1LF1 append (1σ) Substitute the assumed form in the equation: I 1 append D1 append σ = {ǫ} 00σ 1(I1 append D1 append 1σ) Equating the terms without and with σ, we get: I 1 append = {ǫ} 1I1 append D 1 append = 00 1D1 append 1

68 Summary of Analysis Results Liveness at program points: Demand summaries: Function summaries: L l1 1 = {ǫ} 00σ 1(I 1 append D1 append 1σ append) L l2 1 = {ǫ} I 2 append D 2 append 1σ append L l1 5 = {ǫ} 00σ append L tl 5 = I 1 append D1 append 1σ append L l2 5 = I 2 append D2 append 1σ append... σ append = {ǫ, 1} 1σ append 10σ all I 1 append = {ǫ} 1I1 append D 1 append = 00 1D1 append 1 I 2 append = I2 append D 2 append = {ǫ} D2 append 0

69 Solution of the equations View the equations as grammar rules: L l1 1 ǫ 00σ 1(I 1 append D1 append 1σ append) I 1 append ǫ 1I 1 append D 1 append 00 1D 1 append 1 The solution of L l1 1 is the language L(L l1 1 ) generated by it.

70 Working of Liveness-based GC (Mark phase) GC invoked at a program point π GC traverses a path α starting from a root variable x. GC consults L x π: Does α L(L x π)? If yes, then mark the current cell

71 Working of Liveness-based GC (Mark phase) GC invoked at a program point π GC traverses a path α starting from a root variable x. GC consults L x π: Does α L(L x π)? If yes, then mark the current cell Note that α is a forward-only access path consisting only of edges 0 and 1, but not 0 or 1 But L(L x π) has access paths marked with 0/1 for 0/1 removal arising from the cons rule.

72 0/1 handling 0 removal from a set of access paths: α 1 00α 2 α 1 α 2 α 1 01α 2 drop α 1 01α 2 from the set 1 removal from a set of access paths: α 1 11α 2 α 1 α 2 α 1 10α 2 drop α 1 10α 2 from the set

73 GC decision problem Deciding the membership in a CFG augmented with a fixed set of unrestricted productions. 00 ǫ 11 ǫ The problem shown to be undecidable 1. Reduction from Halting problem. 1 Prasanna, Sanyal, and Karkare. Liveness-Based Garbage Collection for Lazy Languages, ISMM 2016.

74 Practical 0/1 simplification The simplification is possible to do on a finite state automaton. Over-approximate the CFG by an automaton (Mohri-Nederhoff transformation). Perform 0/1 removal on the automaton.

75 Example Grammar for L y 9 After Mohri-Nederhoff transformation L y 9 I 1 append D1 append (ǫ 1 10σ all) L y 9 I 1 append D1 append (ǫ 1 10σ all) I 1 append ǫ 1I 1 append I 1 append ǫ 1I 1 append D 1 append 00 1D 1 append 1 σ all ǫ 0σ all 1σ all D 1 append D 1 append σ all 00 D 1 append 1D1 append 1 D 1 append ǫ ǫ 0σ all 1σ all

76 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ 1 0

77 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4

78 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ

79 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2

80 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2 ǫ

81 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2 ǫ 1 0/1 1/1 L y 9 q 0 0 q 0 6 q 5 0

82 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2 ǫ 1 0/1 1/1 L y 9 q 0 0 q 0 6 q 5 0

83 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2 ǫ 1 0/1 1 L y 9 q 0 0 q 6 q 5 0

84 Automaton for L y 9 1 L y 9 ǫ 1 1 0/1 ǫ 0 0 ǫ /1 L y 9 q 0 0 q 0 1 q 1 2 q 0 3 q 4 ǫ 1 1/1 0/1 L y 9 q 0 0 q 0 1 q 0 5 q 2 ǫ 1 0/1 1 L y 9 q 0 0 q 6 q 5 1 0/1 L y 9 q 0 0 q 6 0

85 Experimental Setup Built a prototype consisting of: An ANF-scheme interpreter Liveness analyzer A single-generation copying collector. The collector optionally uses liveness Marks a link during GC only if it is live. Benchmark programs are mostly from the no-fib suite.

86 GC behavior as a graph Cells in active semi-space (LGC) 1.89e+06 Cells in active semi-space (RGC) 1.68e e e e No. of reachable cells No. of live cells e+06 6e+06 9e e e+07 nqueens

87 Results as Tables Analysis Performance: Program sudoku lcss gc_bench knightstour treejoin nqueens lambda Time (msec) DFA size Precision(%)

88 Results as Tables Garbage collection performance # Collected MinHeap GC time cells per GC #GCs (#cells) (sec) Program RGC LGC RGC LGC RGC LGC RGC LGC sudoku lcss gc_bench nperm fibheap knightstour treejoin nqueens lambda LGC collects more garbage than RGC.

89 Results as Tables Garbage collection performance # Collected MinHeap GC time cells per GC #GCs (#cells) (sec) Program RGC LGC RGC LGC RGC LGC RGC LGC sudoku lcss gc_bench nperm fibheap knightstour treejoin nqueens lambda # collections of LGC no higher than RGC. Often, smaller.

90 Results as Tables Garbage collection performance # Collected MinHeap GC time cells per GC #GCs (#cells) (sec) Program RGC LGC RGC LGC RGC LGC RGC LGC sudoku lcss gc_bench nperm fibheap knightstour treejoin nqueens lambda Programs require smaller heaps to execute with LGC.

91 Results as Tables Garbage collection performance # Collected MinHeap GC time cells per GC #GCs (#cells) (sec) Program RGC LGC RGC LGC RGC LGC RGC LGC sudoku lcss gc_bench nperm fibheap knightstour treejoin nqueens lambda GC time is smaller for LGC in some cases...

92 Results as Tables Garbage collection performance # Collected MinHeap GC time cells per GC #GCs (#cells) (sec) Program RGC LGC RGC LGC RGC LGC RGC LGC sudoku lcss gc_bench nperm fibheap knightstour treejoin nqueens lambda and larger in some.

93 Lazy evaluation An evaluation strategy in which evaluation of an expression is postponed until its value is needed

94 Lazy evaluation An evaluation strategy in which evaluation of an expression is postponed until its value is needed Binding of a variable to an expression does not force evaluation of the expression

95 Lazy evaluation An evaluation strategy in which evaluation of an expression is postponed until its value is needed Binding of a variable to an expression does not force evaluation of the expression Every expression is evaluated at most once

96 Laziness: Example (define (lengthl) (if (null?l) return 0 return (+ 1 (length (cdrl))))) (define (main) (leta ( a BIG closure ) in (letb (+a1) in (letc (consbnil) in (letw (lengthc) in (returnw))))))

97 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself.

98 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures

99 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined

100 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined Liveness-based garbage collector significantly more complicated than that for an eager language.

101 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined Liveness-based garbage collector significantly more complicated than that for an eager language. Need to track liveness of closures

102 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined Liveness-based garbage collector significantly more complicated than that for an eager language. Need to track liveness of closures But a closure can escape the scope in which it was created

103 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined Liveness-based garbage collector significantly more complicated than that for an eager language. Need to track liveness of closures But a closure can escape the scope in which it was created Solution: carry the liveness information in the closure itself

104 Handling lazy semantics: Challenges Laziness complicates liveness analysis itself. Data is made live by evaluation of closures In lazy languages, the place in the program where this evaluation takes place cannot be statically determined Liveness-based garbage collector significantly more complicated than that for an eager language. Need to track liveness of closures But a closure can escape the scope in which it was created Solution: carry the liveness information in the closure itself For precision: need to update the liveness information as execution progresses

105 Handling possible non-evaluation Liveness no longer remains independent of demand σ

106 Handling possible non-evaluation Liveness no longer remains independent of demand σ If (carx) is not evaluated at all, it does not generate any liveness forx

107 Handling possible non-evaluation Liveness no longer remains independent of demand σ If (carx) is not evaluated at all, it does not generate any liveness forx Require a new terminal 2 with following semantics { if σ = 2σ {ǫ} otherwise Lapp((carx),σ) =x.{2, 0}σ

108 Scope for future work Reducing GC-time.

109 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes.

110 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme

111 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method.

112 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016)

113 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions.

114 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification)

115 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program

116 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function

117 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function Using the notion of demand for other analysis.

118 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function Using the notion of demand for other analysis. Program Slicing (Under Review as of September 2016)

119 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function Using the notion of demand for other analysis. Program Slicing (Under Review as of September 2016) Strictness Analysis

120 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function Using the notion of demand for other analysis. Program Slicing (Under Review as of September 2016) Strictness Analysis All path problem, requires doing intersection of demands

121 Scope for future work Reducing GC-time. Reducing re-visits to heap nodes. Basing the implementation on full Scheme, not ANF-Scheme Increasing the scope of the method. Lazy languages. (ISMM 2016) Higher order functions. Specialize all higher order functions (Firstification) Analysis on the firstified program For partial applications, carry information about the base function Using the notion of demand for other analysis. Program Slicing (Under Review as of September 2016) Strictness Analysis All path problem, requires doing intersection of demands intersection of CFGs under-approximation

122 Conclusions Proposed a liveness-based GC scheme. Not covered in this talk: The soundness of liveness analysis. Details of undecidability proof. Details of handling lazy languages. A prototype implementation to demonstrate: the precision of the analysis. reduced heap requirement. reduced GC time for a majority of programs. Unfinished agenda: Improving GC time for a larger fraction of programs. Extending scope of the method.

Liveness based Garbage Collection

CS618: Program Analsis 2016-17 I st Semester Ideal Garbage Collection Liveness based Garbage Collection Ame Karkare karkare@cse.iitk.ac.in karkare@cse.iitb.ac.in Department of CSE, IIT Kanpur/Bomba...