Simone Bordet Concurrent Garbage Collectors ZGC Shenandoah

Concurrent GCs
ZGC & Shenandoah

@simonebordet
sbordet@webtide.com
Simone Bordet
● @simonebordet
● sbordet@webtide.com
● Works @ Webtide
○ The company behind Jetty and CometD
● JVM Tuning Expert
simone.bordet@gmail.com 2
Introduction
3
Introduction Stop-The-World
Concurrent
Young Generation Old Generation
Parallel Copy Mark Compact
Concurrent
CMS Copy Conc Mark Conc Sweep
Concurrent
G1 Copy Conc Mark Compact
Concurrent
G1 Copy Conc Mark Compact
ZGC Conc Mark Conc Compact
Shenandoah Conc Mark Conc Compact
Introduction
● Concurrent GCs
○ GC runs concurrently with the application
● GC races with Application

○ Marking an object “alive”
○ Compacting / Moving objects
Introduction
● Concurrent copying example
Region Region
Header
Header
a=1
Introduction
● Garbage Collector compacts object
Region Region Region
Header Header
f a=1
Header
a=1
Introduction
Header Header
f a=1
Header
a=1
"From Space" "To Space"
Introduction
● Application writes concurrently
Header Header
f a=1
Header
a=3
Introduction
● Garbage Collector updates references
Header Header
f a=1
Header
a=3
LOST WRITE!
Introduction
● Concurrent GCs store object metadata
○ E.g. whether an object has been marked
● Concurrent GCs require JIT support
● JIT injects code that helps the GC

○ GC barriers
ZGC
15
ZGC
● Present in OpenJDK 11+
○ Available in AdoptOpenJDK builds
○ Available in Oracle OpenJDK builds
■ From https://jdk.java.net
● Scalable Low Latency GC
● Concurrent Compaction, Single Generation

ZGC
● Only for Linux x86 64-bit
○ No compressed pointers
○ ARM port underway
● Region Based
○ ZPages - similar to G1 regions
■ Small (2 MiB - object size up to 256 KiB)
■ Medium (32 MiB - object size up to 4 MiB)
■ Large (4+ MiB - object size > 4 MiB)
ZGC GC Thread
App Thread
STW
Mark Start
Scan threads stacks

Mark object roots
ZGC GC Thread
App Thread
Concurrent
Marking
Mark object graph

Gather liveness information
ZGC GC Thread
App Thread
STW
Mark End
Housekeeping
ZGC GC Thread
App Thread
Concurrent
Processing
Weak Reference Processing

Free Memory Pages
Unload Classes
Prepare Relocation Set
ZGC GC Thread
App Thread
STW
Relocate Start
Relocate Roots
ZGC GC Thread
App Thread
Concurrent
Relocation
Relocate Objects
(Compact Heap)
ZGC GC Thread
App Thread
Concurrent
Remapping
Remapping pointers
(Happens During Next Mark)
ZGC
● ZGC solution
○ To avoid races with the application
● Colored Pointers
● Load GC barrier
ZGC
● ZGC colored pointers
○ Color indicates GC metadata
4 color bits
Object address - 44 bits (16 TiB) Unused - 16 bits
64 bits pointer address
● Check pointer color against GC phase

○ Wrong color => take action
ZGC
● ZGC load GC barrier
Object f = obj.field;
<load_barrier>
ZGC
if (addr_of(f) & wrong_gc_color) {
slow_path()
}
ZGC
<load_barrier>
mov 0x10(%rdi), %rsi

test %rsi, 0x20(%r15)
jne slow_path
ZGC
● ZGC load GC barrier tests for the right color
● Wrong color -> take slow_path

○ Fix color & Run some action - atomically
● The action depends on the GC phase
ZGC
● ZGC Multi-Mapping
Virtual Memory 001<addr> 010<addr> 100<addr>
Physical Memory
ZGC
● ZGC Multi-Mapping
● RSS shows 3x size

○ E.g. -Xmx=16G -> RSS~=50G
○ On Linux, use smem and track PSS
● Watch out for OOM Killers in clouds

○ E.g. AWS
ZGC
● Relocation
E F
A
C
B
D
ZGC
● Relocation
E F MetaData
B -> B’
C -> C’
A
D -> D’
C
C’
B
B’ D
D’
ZGC
● Relocation Load Barrier
E F MetaData
E’
B -> B’
C -> C’
A
D -> D’
C
E -> E’
C’
B
B’ D
D’
ZGC
● Relocation
E F MetaData
E’
B -> B’
C -> C’
A
E” D -> D’
C
E -> E’
C’
B
B’ D
D’
ZGC
● Relocation
E F MetaData
E’
B -> B’
C -> C’
A
E” D -> D’
C
E -> E’ E -> E”
C’
B
B’ D
D’
ZGC
● Relocation
E F MetaData
E’ F’
B -> B’
C -> C’
A
D -> D’
C
E -> E’
F -> F’
C’
B
B’ D
D’
ZGC
● Remapping
E’ F’
C’
B’
D’
ZGC
● References
○ Per Lidén, Erik Österlund et al.
■ https://www.youtube.com/watch?v=7cWiwu7kYkE
■ https://www.youtube.com/watch?v=kF_r3GE3zOo
○ Project Wiki
■ https://wiki.openjdk.java.net/display/zgc/Main
○ Mailing List
■ zgc-dev@openjdk.java.net
ShenandoahGC
41
ShenandoahGC
● Present in OpenJDK 12+ repository
○ Available in AdoptOpenJDK builds
○ NOT available in Oracle’s OpenJDK builds
○ Present in RedHat OpenJDK 8, 11+
● Scalable low latency GC
● Concurrent Compaction, Single Generation

ShenandoahGC
● Available for x86 32-bit and 64-bit
○ ARM ports available
● Linux, MacOS, Windows

○ JDK 8, 11 & Latest
● Region Based
○ Derived from G1
ShenandoahGC GC Thread
App Thread
STW
Mark Start
Scan threads stacks

Mark object roots
App Thread
Concurrent
Marking
Mark object graph

Gather liveness information
App Thread
STW
Mark End
Weak Reference Processing

Unload Classes
Evacuate Roots
Housekeeping
App Thread
Concurrent
Evacuation
Evacuate Objects
(Compact Heap)
App Thread
Concurrent
Update References
Remapping pointers
(Happens During Next Mark)
ShenandoahGC
● ShenandoahGC solution
○ To avoid races with the application
● Brooks (Forward) Pointers
● Load & Store GC Barriers
ShenandoahGC
● HotSpot Object Header
○ "Word" == 32 bits on i386; 64 bits on x86-64
Mark Word Class Word Field 1 Field 2
Mark Word Class Word Array Length Slot 1 Slot 2
ShenandoahGC 1.0
● ShenandoahGC 1.0
Mark Mark
Class Class
Field1 Field1
Field2 Field2
ShenandoahGC 1.0
Fwd Ptr Fwd Ptr
Mark Mark Mark Mark
Class Class Class Class
Field1 Field1 Field1 Field1
Field2 Field2 Field2 Field2
ShenandoahGC 1.0
● Maintains weak to-space invariant

○ Reads from both from-space to-space copies
○ Writes only to to-space copy
ShenandoahGC 1.0
● Load GC barrier: dereference forward pointer
<load_barrier>
ShenandoahGC
f = deref(addr_of(f) - 8);
ShenandoahGC 1.0
<load_barrier>
mov 0x10(%rdi), %rsi

mov -0x08(%rsi), %rsi
ShenandoahGC
● Store GC barrier
○ Runs some action depending on GC phase
obj.f = o;
<store_barrier>
ShenandoahGC
obj.f = o;
if (in_evac_phase &&
in_collection_set(obj) &&
!is_forwarded(obj))
slow_path();
ShenandoahGC
obj.f = o;
mov 0x3d8(%r15), %r11
test %r11, %r11
...
jne <slow_path>
ShenandoahGC
● ShenandoahGC 1.0 Problems
● More memory needed (due to the forward pointer)

○ Worst case 50%, common case 5-10%
● Complicated (exotic) GC barriers

○ Load & Store GC barriers to maintain invariants
ShenandoahGC
Mark Mark
Class Class
Field1 Field1
Field2 Field2
ShenandoahGC
From Space To Space
Mark Mark Mark Fwd Ptr Mark
Class Class Class Class Class
Field1 Field1 Field1 Field1 Field1
Field2 Field2 Field2 Field2 Field2
ShenandoahGC
● Maintains a strong to-space invariant

○ Reads only possible from to-space copy
○ Writes only possible from to-space copy
ShenandoahGC 2.0
● Load Barrier (LRB - Load Reference Barrier)
○ Checks whether there may be forwarded objects
■ And whether in c-set and whether is forwarded
Object f = obj.f;
<load_barrier>
ShenandoahGC 2.0
Object f = obj.f;
if (in_evac_phase &&
in_collection_set(obj) &&
!is_forwarded(obj))
slow_path();
ShenandoahGC 2.0
Object f = obj.f;
test $0x1,0x20(%r15)
...
jne <slow_path>
ShenandoahGC 2.0
● Shenandoah 2.0
● Load and Store GC barrier are the same!

○ Big codebase simplification
○ Improved performance
ShenandoahGC
● Evacuation
Mark
Class
Field1
Field2
ShenandoahGC
● Evacuation (GC Copy)
From Space To Space
Mark
Mark
Class
Class
Field1
Field1
Field2
Field2
ShenandoahGC
● Evacuation (Application triggers LRB)
From Space To Space
Mark
Class
Field1
Mark
Mark Field2
Class
Class
Field1
Field1
Field2
Field2
ShenandoahGC
● Evacuation (Atomic Fwd Ptr Update)
From Space To Space
Mark
Class
Field1
Mark
Mark Field2
Class
Class
Field1
Field1
Field2
Field2
ShenandoahGC
● Evacuation (Application Wins)
From Space To Space
Mark
Class
Field1
Fwd Ptr
Mark Field2
Class
Class
Field1
Field1
Field2
Field2
ShenandoahGC
● Evacuation (Application Read/Write)
From Space To Space
Mark
Class
Field1
Fwd Ptr
Field2
Class
Field1
Field2
ShenandoahGC
● Update References
From Space To Space
Mark
Class
Field1
Fwd Ptr
Field2
Class
Field1
Field2
ShenandoahGC
● Shenandoah Heuristics
○ Adaptive (default)
■ Maintains free heap amount
○ Static
■ Starts GC when tripping thresholds
○ Compact
■ Small footprint
○ Aggressive
■ Back to back GCs
○ Passive
■ Non concurrent, only Full GCs
○ Traversal
ShenandoahGC
● References
○ Project Wiki
■ https://wiki.openjdk.java.net/display/shenandoah/Main
○ Aleksey Shipilëv, Roman Kennke et al.
■ https://www.youtube.com/watch?v=VCeHkcwfF9Q
■ https://www.youtube.com/watch?v=E1M3hNlhQCg
○ Mailing List
■ shenandoah-dev@openjdk.java.net
Shenandoah
Questions?
77
Conclusions
78
Conclusions
● Give Concurrent GCs a go
● Stuck with JDK 8?

○ Use Shenandoah
Already using JDK 11+?
○ ZGC or Shenandoah
● Report your feedback!


Simone Bordet Concurrent Garbage Collectors ZGC Shenandoah

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Simone Bordet Concurrent Garbage Collectors ZGC Shenandoah

Uploaded by

Copyright:

Available Formats

Concurrent GCs

ZGC & Shenandoah

● JVM Tuning Expert

Young Generation Old Generation

Parallel Copy Mark Compact

Young Generation Old Generation

Parallel Copy Mark Compact

CMS Copy Conc Mark Conc Sweep

Young Generation Old Generation

Parallel Copy Mark Compact

CMS Copy Conc Mark Conc Sweep

G1 Copy Conc Mark Compact

Young Generation Old Generation

Parallel Copy Mark Compact

CMS Copy Conc Mark Conc Sweep

G1 Copy Conc Mark Compact

ZGC Conc Mark Conc Compact

Shenandoah Conc Mark Conc Compact

● GC races with Application

Region Region Region

"From Space" "To Space"

● Concurrent GCs require JIT support

● JIT injects code that helps the GC

● Scalable Low Latency GC

● Concurrent Compaction, Single Generation

Scan threads stacks

Mark object graph

Weak Reference Processing

64 bits pointer address

● Check pointer color against GC phase

mov 0x10(%rdi), %rsi

● Wrong color -> take slow_path

● The action depends on the GC phase

● RSS shows 3x size

● Watch out for OOM Killers in clouds

● Scalable low latency GC

● Concurrent Compaction, Single Generation

● Linux, MacOS, Windows

Scan threads stacks

Mark object graph

Weak Reference Processing

● Brooks (Forward) Pointers

● Load & Store GC Barriers

Mark Word Class Word Field 1 Field 2

Mark Word Class Word Array Length Slot 1 Slot 2

Fwd Ptr Fwd Ptr

Mark Mark Mark Mark

Class Class Class Class

Field1 Field1 Field1 Field1

Field2 Field2 Field2 Field2

● Maintains weak to-space invariant

mov 0x10(%rdi), %rsi

● More memory needed (due to the forward pointer)

● Complicated (exotic) GC barriers

From Space To Space

Mark Mark Mark Fwd Ptr Mark

Class Class Class Class Class

Field1 Field1 Field1 Field1 Field1

Field2 Field2 Field2 Field2 Field2

● Maintains a strong to-space invariant

● Load and Store GC barrier are the same!

● Stuck with JDK 8?