1. Garbage Collection Mooly Sagiv html://www.math.tau.ac.il/~msagiv/courses/wcc02.html

2. Garbage Collection HEAP ROOT SET a b c d e f

3. What is garbage collection The runtime environment reuse records that were allocated but are not subsequently used garbage records –not live It is undecidable to find the garbage records: –Decidability of liveness –Decidability of type information conservative collection –every live record is identified –some garbage run-time records are not identified Find the reachable records via pointer chains Often done in the allocation function

4. let type list = {link: list, key: int} type tree = {key: int, left: tree, right: tree} let var x := list {link=nil, key=7} var y := list {link=x, key=9} in x.link := y end; in let var p := maketree()` var r := p.right var q := r.key in showtree(r) end stackheap 7 link xyxy 9

5. let type list = {link: list, key: int} type tree = {key: int, left: tree, right: tree} let var x := list {link=nil, key=7} var y := list {link=x, key=9} in x.link := y end; in let var p := maketree()` var r := p.right var q := r.key in showtree(r) end stackheap 7 link key xyxy link 9

6. let type list = {link: list, key: int} type tree = {key: int, left: tree, right: tree} let var x := list {link=nil, key=7} var y := list {link=x, key=9} in x.link := y end; in let var p := maketree() var r := p.right var q := r.key in showtree(r) end 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right stackheap

7. Outline Why is it needed? Why is it taught? Mark-and-Sweep Collection Reference Counts Copying Collection Generational Collection Incremental Collection Interfaces to the Compiler

8. A Pathological C Program a = malloc(…) ; b = a; free (a); c = malloc (…); if (b == c) printf(“unexpected equality”);

9. Garbage Collection vs. Explicit Memory Deallocation Faster program development Less error prone Can lead to faster programs Support very general programming styles, e.g. higher order and OO programming Standard in ML, Java, C# Supported in C and C++ via separate libraries Can improve locality of references May require more space Needs a large memory Can lead to long pauses Can change locality of references Effectiveness depends on programming language and style Hides documentation More trusted code

10. Interesting Aspects of Garbage Collection Data structures Non constant time costs Amortized algorithms Constant factors matter Interfaces between compilers and run-time environments Interfaces between compilers and virtual memory management

11. Mark-and-Sweep Collection Mark the records reachable from the roots (stack, static variables and machine registers) Sweep the heap space by moving unreachable records to the freelist

12. The Mark Phase for each root v DFS(v) function DFS(x) if x is a pointer and record x is not marked mark x for each field f i of record x DFS(x.f i )

13. The Sweep Phase p := first address in heap while p < last address in the heap if record p is marked unmark p else let f 1 be the first pointer field in p p.f 1 := freelist freelist := p p := p + size of record p

14. 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right Mark

15. 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right freelist Sweep

16. 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right freelist

17. Cost of GC The cost of a single garbage collection can be linear in the size of the store –may cause quadratic program slowdown Amortized cost –collection-time/storage reclaimed –Cost of one garbage collection c 1 R + c 2 H –H - R Reclaimed records –Cost per reclaimed record (c 1 R + c 2 H)/ (H - R) –If R/H > 0.5 increase H –if R/H < 0.5 cost per reclaimed word is c 1 + 2c 2 ~16 –There is no lower bound

18. Efficient implementation of DFS Explicit stack Pointer reversal Other data structures

19. Fragmentation External –Too many small records Internal – A use of too big record without splitting the record Freelist may be implemented as an array of lists

20. Reference Counts Maintain a counter per record The compiler generates code to update counter Constant overhead per instruction Cannot reclaim cyclic elements Many instructions for destructive updates z := x.f i ;c := z.count z.count := c if (--c = 0) goto putonFreeList x.f i := p ; p.count++; x.f i := p

21. 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right 1 1 1 2 1 1 1

22. Copying Collection Maintains two separate heaps –from-space –to-space pointer next to the next free record in from-space A pointer limit to the last record in from-space If next = limit copy the reachable records from from-space into to-space –set next and limit –Switch from-space and to-space Requires type information From-spaceTo-Space

23. Breadth-first Copying Garbage Collection next := beginning of to-space scan := next for each root r r := Forward(r) while scan < next for each field f i of record at scan scan.f i := Forward(scan.f i ) scan := scan + size of record at scan

24. The Forwarding Procedure function Forward(p) if p points to from-space then if p.f 1 points to to-space return p.f 1 else for each field f i of p next.f i := p.f i p.f 1 := next next := next size of record p return p.f 1 else return p

25. 7 link 9 p q r 37 right 12 left right 15 left 20 left right 37 59 left right

26. 7 link 9 p q r 37 right 12 left right left 20 left right 37 59 left right 15 left scan next

27. 7 link 9 p q r 37 right 12 left right left 20 left right 59 left right 1 15 left right 37 left scan next

28. 7 link 9 p q r 37 right left right left 20 left right 37 59 left right 15 left right 37 left scan next 12 left right

29. 7 link 9 p q r 37 right 12 left right left 20 left right 37 59 left right 15 left right 37 left scan next 12 left right

30. Amortized Cost of Copy Collection c 3 R / (H/2 - R)

31. Locality of references Copy collection does not create fragmentation Cheney's algorithm may lead to subfields that point to far away records –poor virtual memory and cache performance DFS normally yields better locality but is harder to implement DFS may also be bad for locality for records with more than one pointer fields A compromise is a hybrid breadth first search with two levels down (Semi-depth first forwarding) Results can be improved using dynamic information

32. The New Forwarding Procedure function Forward(p) if p points to from-space then if p.f 1 points to to-space return p.f 1 else Chase(p); return p.f 1 else return p function Chase(p) repeat q := next next := next +size of record p r := nil for each field f i of p q.f i := p.f i if q.f i points to from-space and q.f i.f 1 does not point to to-space then r := q.f i p.f 1 := q p := r until p = nil

33. Generational Garbage Collection Newly created objects contain higher percentage of garbage Partition the heap into generations G 1 and G 2 First garbage collect the G 1 heap –records which are reachable After two or three collections records are promoted to G 2 Once a while garbage collect G 2 Can be generalized to more than two heaps But how can we garbage collect in G 1 ?

34. Scanning roots from older generations remembered list –The compiler generates code after each destructive update b.f i := a to put b into a vector of updated objects scanned by the garbage collector remembered set –remembered-list + “set-bit”' Card marking –Divide the memory into 2 k cards Page marking –k = page size –virtual memory system catches updates to old- generations using the dirty-bit

35. Incremental Collection Even the most efficient garbage collection can interrupt the program for quite a while Under certain conditions the collector can run concurrently with the program (mutator) Need to guarantee that mutator leaves the records in consistent state, e.g., may need to restart collection Two solutions –compile-time Generate extra instructions at store/load –virtual-memory Mark certain pages as read(write)-only a write into (read from) this page by the program restart mutator

36. Tricolor marking Generalized GC Three kinds of records –White Not visited (not marked or not copied) –Grey Marked or copied but children have not been examined –Black Marked and their children are marked

37. Basic Tricolor marking while there are any grey objects select a grey record p for each field f i of record p if record p.f i is white color record p.f i grey color record p black Invariants No black points to white Every grey is on the collector's (stack or queue) data structure

38. Establishing the invariants Dijkstra, Lamport, et al – Mutator stores a white pointer a into a black pointer b color a grey (compile-time) Steele –Mutator stores a white pointer a into a black pointer b color b grey (compile-time) Boehm, Demers, Shenker –All black pages are marked read-only –A store into black page mark all the objects in this page grey (virtual memory system) Baker –Whenever the mutator fetches a pointer b to a grey or white object color b grey (compile-time) Appel, Ellis, Li –Whenever the mutator fetches a pointer b from a page containing a non black object color every object on this page black and children grey (virtual memory system)

39. Interfaces to the Compiler The semantic analysis identifies record fields which are pointers and their size Generate runtime descriptors at the beginning of the records Pass the descriptors to the allocation function The compiler also passes pointer-map –the set of live pointer locals, temporaries, and registers Recorded at ?-time for every procedure Pointer-map can be keyed by return-address

40. Allocation of a Records Call the allocate function Test next + N < limit and maybe call garbage collector Move next into result Clear M[next], M[next+1],…, M[next+N-1] next := next + N Return from the allocate function Move result into some computationally useful place Store useful values into the record

41. Summary Garbage collection is an effective technique Leads to more secure programs Tolerable cost But is not used in certain applications –Realtime May be improved