Upgrade to Pro — share decks privately, control downloads, hide ads and more …

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

alblue
April 15, 2020

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.

alblue

April 15, 2020
Tweet

More Decks by alblue

Other Decks in Technology

Transcript

  1. ©2020 Alex Blewitt
    Taking out the garbage
    An overview of GCs in the JVM

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  9. ©2020 Alex Blewitt
    Application Pause Time
    b
    c
    d
    a
    Application

    Threads

    View full-size slide

  10. ©2020 Alex Blewitt
    Application Pause Time
    a
    b
    c
    d
    Application

    Threads
    Safepoint

    Trigger
    Safepoint

    Start

    View full-size slide

  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

    View full-size slide

  12. ©2020 Alex Blewitt
    Parallel GC
    a
    b
    c
    d
    a
    a
    a
    a
    Application

    Threads
    GC

    Threads
    GC

    Threads

    View full-size slide

  13. ©2020 Alex Blewitt
    Serial GC
    a
    b
    c
    d
    a
    Application

    Threads
    GC

    Threads
    GC

    Threads

    View full-size slide

  14. ©2020 Alex Blewitt
    Concurrent GC
    a
    b
    c
    d
    a
    Application

    Threads
    GC

    Threads
    GC

    Threads
    a

    View full-size slide

  15. ©2020 Alex Blewitt
    Concurrent Parallel GC
    a
    b
    c
    d
    a
    Application

    Threads
    GC

    Threads
    GC

    Threads
    a
    a
    a
    a

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  20. ©2020 Alex Blewitt
    Shenandoah algorithm
    https://wiki.openjdk.java.net/display/shenandoah/Main

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide

  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

    View full-size slide