“Show Me the Garbage!”, Understanding Garbage Collection

“Just leave the garbage outside and we will take care of it for you”. This is the panacea promised by garbage collection mechanisms built into most software stacks available today. So, we don’t need to think about it anymore, right? Wrong! When misused, garbage collectors can fail miserably. When this happens they slow down your application and lead to unacceptable pauses. In this talk we will go over different garbage collectors approaches in different software runtimes and what are the conditions which enable them to function well.

Transcript

1. Show Me the Garbage Haim Yadid
2. This is Me (Cicra 2015)
5. Today
6. Today
7. Memory Heap Stack Static
8. Participants Allocator - Allocate memory Collector - the GC threads
9. Mutator
10. Participants Allocator - Allocate memory Mutator - the application threads Collector - the GC threads
11. malloc / free • new / malloc () to create object • delete() / free() release an object
12. I don’t miss it • Dangling pointers / Double free • Memory leaks • Fragmentation / Degradation • Locality
13. Automatic Reference Counting (ARC)
14. Automatic Reference Counting (ARC) 1 1 Heap 2 1 1 1 1 Non Heap
15. Automatic Reference Counting - Cycles 1 1 Heap 2 1 1 1 1
16. Reference Counting Concurrency Concurrency - Every change to reference requires a memory barrier Very bad for highly concurrent systems Mostly relevant for single threaded
17. The (Tracing) Garbage Collector
19. GC Overhead The amount of resources the GC consumes ◦ Memory ◦ CPU
20. Latency What is the possibility that the GC will affect your transaction time and for how long
21. Terminology
22. To Heap or not to Heap Heap Static/ Stack
23. Root Set Heap
24. Live Set (Reachable objects) Heap Stack
25. Garbage (Unreachable Objects) Heap Stack
26. Garbage (Unreachable Objects) Heap Stack
27. Free List Heap Stack
28. Collectors Attributes Single Threaded Stop the World Concurrent Parallel VS VS Monolithic Incremental VS Conservative Precise VS
29. STW Collectors - Serial (single threaded) - Monolith
30. STW Collectors - Incremental
31. STW Collectors - Parallel
32. Concurrent Collectors - Serial
33. Concurrent Collectors -Parallel
34. Let’s Talk about Mostly
35. When do we want to collect Garbage?
37. Conservative Precise VS Gets help from the compiler regarding whether a word is a reference
38. Regional Heap Non Heap
39. Building Blocks & Algorithms
40. Root Scanning & Safe Points Heap
41. Mark & Sweep : Marking (a.k.a. tracing) Heap Work: O(#Objects in LiveSet) Stack
42. Mark & Sweep : Sweep Sweep through the heap and collect all unmarked objects Maintain a list of free memory portions Work: O(#Objects and fragments in Heap) Heap Unreachable Reachable Free
43. Mark & Sweep: Fragmentation
44. Mark Compact Moving objects to make bigger free contiguous spaces Heap Heap Work: O(#Objects and fragments in Heap)
45. Thread Local Bump allocation
46. Copy collector Move all live objects to another space From Space To Space Work: O(Size of live set) Memory: x2
47. Generational collectors Weak Generational Hypothesis - Most object die young The surviving ones tend to live for a long time
48. New/ Old Generation Old Non Heap From To
49. Generational collectors Higher throughput Short new generation collection
50. Not Moving Moving Non generational Generational Low latency Latency can be high* High Overhead (up to 25%) Lower overhead (5% considered normal) Precise Precise Memory overhead *2 Memory overhead configurable * with the exception of Azul C4 zGC and Shenandoah
51. Additional Reading
52. Q&A Q: Are you Hiring ? A: Yes we do !