Taking out the Garbage: an overview of GCs in the JVM

Taking out the Garbage: an overview of garbage collectors in Java, and what new garbage collectors bring to the JVM.

Transcript

1. ©2020 Alex Blewitt Taking out the garbage An overview of GCs in the JVM
2. ©2020 Alex Blewitt Generational Garbage Collection From Young to Old • Generational Hypothesis: Most objects die young • Have a young generation which is cleared periodically • Promote long-lived objects to older generations Eden Survivor Old Young
3. ©2020 Alex Blewitt Eden • The Eden space is where (most) objects are allocated • Split into different thread sections called TLABs • When a thread allocates, it does so into the TLAB and bumps pointer • When out of space requests a new TLAB from Eden • If no new TLAB is available, triggers a minor collection Eden TLAB TLAB TLAB TLAB TLAB TLAB TLAB
4. ©2020 Alex Blewitt Allocations outside TLAB • Some allocations are handled outside of a TLAB • If the TLAB cannot accommodate size but would waste TLAB space • If the allocation is too large for Eden and stored straight in the Old region • Small allocations outside TLAB are infrequent • Can be used to do periodic monitoring of object creation • Waste TLAB space and waste Eden space filled with dummy object • Makes parsing heaps easier
5. ©2020 Alex Blewitt Minor GC • A Minor GC collects the objects in the young generation • Eden survivors are swept into the Survivor To space • Survivor From survivors are swept into the Survivor To space • Oldest objects overflow into Old space Eden Old Survivor
6. ©2020 Alex Blewitt Minor GC • A Minor GC collects the objects in the young generation • Eden survivors are swept into the Survivor To space • Survivor From survivors are swept into the Survivor To space • Oldest objects overflow into Old space Eden To Old From
7. ©2020 Alex Blewitt Object age • Each object has an age – the number of GCs that it has survived • Objects older than this age "Tenuring threshold" are moved into Old gen • Typically objects of a particular class have high or low ages • Objects with all ages may indicate a memory leak
8. ©2020 Alex Blewitt Garbage Collection Algorithms • Young and Old gen can have different garbage collection algorithms • Young: Serial, ParallelNew, ParallelScavenge • Old: Serial, ParallelOld, ConcurrentMarkSweep* • May have a combined collector which handles everything • G1, Shenandoah, Z • Some combinations are deprecated and will be removed in future
9. ©2020 Alex Blewitt Application Pause Time b c d a Application Threads
10. ©2020 Alex Blewitt Application Pause Time a b c d Application Threads Safepoint Trigger Safepoint Start
11. ©2020 Alex Blewitt Application Pause Time a b c d a a a a Application Threads Safepoint Trigger Safepoint Start Safepoint End GC Threads GC Threads GC time Application Stopped Time Time To Safepoint
12. ©2020 Alex Blewitt Parallel GC a b c d a a a a Application Threads GC Threads GC Threads
13. ©2020 Alex Blewitt Serial GC a b c d a Application Threads GC Threads GC Threads
14. ©2020 Alex Blewitt Concurrent GC a b c d a Application Threads GC Threads GC Threads a
15. ©2020 Alex Blewitt Concurrent Parallel GC a b c d a Application Threads GC Threads GC Threads a a a a
16. ©2020 Alex Blewitt Root sets • Live objects begin with the root sets • Thread roots (local variables, stack slots, oops used in methods) • Interned Strings • JNI references • These then point to other references • Class roots (ClassLoader(s), classes and static variables) • Instances
17. ©2020 Alex Blewitt Regional concurrent collectors • Regional collectors split the memory into different regions (or pages) • Collection will process a subset of them in one go • Pause times can be adjusted by collecting different numbers of regions • Regions have flavours of 'Eden', 'To' and GCs operate similarly • ZGC uses multiply mapped virtual memory tags to identify mapped/marked objs • Updating references can co-opt application threads to fix on the fly • By moving more work into concurrent/application threads, reduce pause time
18. ©2020 Alex Blewitt Garbage First collector • G1 tries to collect as much garbage first as it can • Collects Eden and Survivor regions, and some Old regions as well • Concurrently marks objects • Stops the world for relocations (evacuations) E S O H E S O E S O H O E S O H S O O O H O
19. ©2020 Alex Blewitt Shenandoah forwarding pointers • Shenandoah concurrently evacuates objects from the 'From' to 'To' spaces • Needs to store old/new but ensure that users only use new copy • Stores a forwarding pointer during GC evacuation in old object mark word • Load barriers used to correctly identify new object location • Only when GC is operational and object is in collection set • Load barrier can heal stale references in application thread upon load • When all references to old object are updated it can be released • Can run on 64-bit or 32-bit systems
20. ©2020 Alex Blewitt Shenandoah algorithm https://wiki.openjdk.java.net/display/shenandoah/Main
21. ©2020 Alex Blewitt ZGC coloured/tagged pointers • ZGC has a similar from/to space but uses pointer colours to distinguish • High order bits have from/to encoded in them • Bitmask says if coloured pointer is correct for this phase • Correction taken by application thread to update incorrect pointer • Same physical memory is mapped in to multiple virtual address spaces • Read barrier can be hit by marking virtual memory as non-readable • Requires 64-bit VM memory to operate
22. ©2020 Alex Blewitt ZGC memory mapping Mem Mem Mem Mem O O O O O References are repaired on load Memory mapped multiple times Memory split into pages like G1/Shenandoah regions
23. ©2020 Alex Blewitt Comparison G1 Shenandoah Z Regional ✅ ✅ ✅ Generational ✅ Young STW ✅ Concurrent Evacuation ✅ ✅ x86_32 ✅ ✅ x86_64 ✅ ✅ ✅ Compressed Oops ✅ ✅ Return Memory 12+ ✅ 13+ Memory 2M-? 8M-? 8M-16T Max Pause ~1s ~1ms ~1ms Supported 8-14 8u,11u,12-14 11-14 8u and 11u Backports Both Shenandoah and ZGC need UnlockExperimentalVMOptions but plan to graduate to non-experimental in JDK 15
24. ©2020 Alex Blewitt Summary • Java GCs continue to evolve to provide larger memory and lower pauses • Pauses are now limited by root set (number of threads, size of stack) • Most operations are performed concurrently in regional GCs • G1 evacuation is still stop-the-world • Edge cases continue to improve and push more concurrent operations • Still some stop-the-world pauses in modern GCs but getting smaller
25. ©2020 Alex Blewitt Thank you https://alblue.bandlem.com https://twitter.com/alblue https://github.com/alblue https://vimeo.com/alblue https://speakerdeck.com/alblue