Garbage Collection Crash Course

Presentation given at Rails Israel 2016.

Transcript

1. Garbage Collection Crash Course @yorickpeterse http://bo0xvn.deviantart.co
2. GitLab https://about.gitlab.com
3. http://gchandbook.org/ Highly recommended for those interested in reading more about garbage collection
4. Memory Management
5. Memory Management 1. Manual (C, C++, Rust, etc) 2. Reference Counting (Python, PHP) 3. Tracing Garbage Collection (Java, Ruby, Go, D, and many more)
6. Tracing Garbage Collection
7. A tracing garbage collector determines object liveness using an object graph. Reachable objects are live, unreachable objects are to be reclaimed
8. Invented in ±1959 by John McCarthy. Also known for inventing parenthesis Lisp, AI development, and much more.
9. Terminology • Mutator: an application thread • Collector: a thread performing garbage collection • Roots: pointers directly reachable from the stack • Precise: all pointers can be identified by default, the opposite being “conservative” • Write barrier: code that runs upon writing a pointer to an object • Stop the world: an event during which all mutators are paused
10. Garbage Collection Steps 1. Determine the roots 2. Traverse the roots and their child pointers 3. Record which objects are reachable 4. Reclaim memory of unreachable objects 5. Optional: compact the heap to prevent fragmentation
11. Mark & Sweep
12. Mark Phase Objects are “marked” as being live when traversing the object graph
13. Marks in Objects Marking is done by setting a flag stored in every object
14. Bitmap Marking Marks are stored in a “bitmap”
15. 0 1 2 3 4 5 6 7 Mark bitmap
16. 0 1 2 3 4 5 6 7 Marked Unmarked Mark bitmap
17. Sweep Phase Collector reclaims unmarked objects
18. Sweeping 1. Linearly traverse the heap 2. Check if an object is marked 3. Reclaim the memory if the object is not marked 4. Continue until the end of the heap
19. Fragmentation Mark/sweep leads to a fragmented heap, thus periodic compacting of the heap is necessary
20. Compacting To combat fragmentation objects are moved to the start of the heap, this is called “compacting”
21. Precise Compacting the heap requires a precise collector as pointers need to be updated
22. Semispace Collector
23. Heap Layout Two chunks of equal size: “from” and “to”
24. “from” space “to” space
25. Marking using Copying Objects are copied to the “from” space instead of being marked
26. “from” space “to” space Reachable
27. Reclaiming Memory The “from” and “to” spaces are swapped, new allocations simply overwrite memory
28. “from” space “to” space Reachable Copied Object
29. “from” space “to” space Reachable
30. “from” space “to” space Reachable
31. “from” space “to” space Reachable
32. Memory Usage Semispace requires 2x the memory usage
33. Fragmentation Fragmentation does not occur due to the copying of objects every collection cycle
34. Precise Copying the objects requires a precise collector as pointers have to be updated
35. Mark Region: Immix
36. Immix A high performance mark-region collector www.cs.utexas.edu/users/speedway/DaCapo/papers/immix-pldi-2008.pdf
37. Heap Layout Heap divided into “blocks”, blocks are divided into “lines”. Multiple free aligned lines are “holes”
38. Allocator Allocates into free lines, skipping full or fragmented blocks. New blocks are requested whenever needed
39. Collection During collection objects and lines are marked, free blocks are returned, recyclable blocks are reused
40. Resuming Allocations The allocator resumes allocations into recyclable blocks, starting at the first one
41. Fragmentation To deal with fragmentation Immix will at times “evacuate” objects
42. Evacuation When a block is marked for evacuation its objects are moved to another block. Once a block is empty it’s returned to the global pool
43. Generational Collection
44. Generational Hypothesis Most objects die young and few survive multiple garbage collection cycles
45. Heap Layout Heap is divided into 2 generations: young and mature
46. Young Generation Objects that have survived only a few collection cycles
47. Eden Space A region of the young generation used for allocating new objects
48. Mature Generation Objects that have survived multiple (potentially many) collection cycles
49. Collection Each generation and its preceding generations are collected separately
50. Young Collection Only collects the young generation
51. Mature Collection Collects both the young and mature generation
52. Young To Mature Writes Young pointers stored in mature objects must be tracked somehow, otherwise a young a collection would miss them
53. Remembered Set A set containing young pointers written to mature objects, updated using a write barrier
54. What To Store? We can either store the young pointer, or a pointer to the mature object
55. Storing Young Pointers Only need to store the pointer that was written, but we may end up storing multiple pointers written to the same mature object.
56. Storing Mature Pointers Multiple writes store only a single mature pointer, but the collector may traverse unrelated mature pointers
57. Scanning Remembered Set When collecting the young generation the collector also scans the remembered set for pointers, just like the roots
58. Incremental Collector
59. Parallel Collector
60. Concurrent Collector
61. Concurrent Writes While the collector runs the mutator may write new objects to objects that have already been traversed. A collector must somehow handle this
62. Tri-color Marking Each object has a color: white, grey, or black
63. White Objects Objects that are unreachable
64. Grey Objects Objects reachable from the roots, not yet scanned
65. Black Objects Reachable objects that have been fully scanned, can’t contain any white objects
66. Tracking Writes When writing an object a write barrier ensures the source/target object have the correct colour
67. Write Barrier Techniques 6 different techniques for two types of write barriers. Object colors are changed or objects are scanned immediately. Too much to cover in this presentation :(
68. Ruby Garbage Collection
69. CRuby • Generational (since 2.1) • Conservative (due to C extensions) • Uses bitmaps for marking • Stop the world • Incremental • Does not compact, instead re-uses reclaimed object slots
70. Questions?