Shenandoah: An ultra-low pause time garbage collector for OpenJDK. Christine Flood Principal Software Engineer Red Hat

Transcription

1 Shenandoah: An ultra-low pause time garbage collector for OpenJDK Christine Flood Principal Software Engineer Red Hat 1

2 Why do we need another Garbage Collector? OpenJDK currently has: SerialGC ParallelGC ParNew/Concurrent Mark Sweep(CMS) Garbage First (G1) 2

3 Why do we need another Garbage Collector? OpenJDK currently has: SerialGC ParallelGC ParNew/Concurrent Mark Sweep(CMS) Garbage First (G1) Shenandoah Pause times similar to CMS. Region based like G1. Concurrent Compaction 3

4 Why is concurrent compaction difficult? Reference Stack Frame Method Foo Heap Value Reference Reference 42 B Reference Stack Frame Method Bar Value Reference Reference Object A C 4

5 Pause to update the roots, and have heap object accesses go through a forwarding pointer. Reference Stack Frame Method Foo Heap Value Reference Reference 42 Forwarding ptr Forwarding ptr B Reference Stack Frame Method Bar Value Reference Reference C' A Forwarding ptr Forwarding ptr C 5

6 Forwarding Pointers Foo indirection pointer Foo Bar indirection pointer You can still walk the heap. You can still choose your GC at runtime. Software only solution. Bar 6

7 Shenandoah divides the heap into regions. Region 1 Region 2 Region 3 Region 4 Region 5 7

8 We use concurrent marking to keep track of the live data in each region. Regions Region 1 Live Data 20k Regions Region 6 Live Data 200k Region 2 100k Region 7 100k Region 3 500k Region 8 empty Region 4 10k Region 9 empty Region 5 70k Region 10 empty 8

9 We pick the most garbage-y regions for evacuation. Regions Region 1 Region 2 Live Data 20k Fromregion 100k Regions Region 6 Region 7 Live Data 20k 100k Region 3 500k Region 8 to-region Region 4 Region 5 10k Fromregion 70k Region 9 Region 10 empty empty 9

10 Concurrent Marking tells us which objects need to be copied. Reference Stack Frame Method Foo Heap Value Reference 42 Object Array Reference Stack Frame Method Bar Value Reference Object Object Reference Reference Object Object 10

11 We evacuate the live objects while the Java threads are running. FOO FOO' BAR' BAR 11

12 Reclaiming free space Eagerly Run another pass over the data to update references. Lazily Wait for the next concurrent mark to update references. Once the references have been updated we can free the now empty regions. 12

13 Shenandoah Java Init Mark Java Final Mark Java Concurrent Mark Concurrent Evacuation We use as many threads as are available to do concurrent phases. 13

14 From-Region To-Region FOO A B A' 14

15 Added benefit to forwarding pointers Object We can be lazy about updating references to objects in from regions. We no longer need remembered sets. 15

16 Concurrent Marking SATB Snapshot At The Beginning Anything live at Initial Marking is considered live. Anything allocated since Initial Marking is considered live. Used to update references, keep track of amount of live data for each region, and tell us which objects are live and need to be evacuated. 16

17 What's tricky about SATB? Start of Concurrent Marking X Y Sometime during marking Requires a write barrier to ensure overwritten values get marked. z y X w 17

18 How to move an object while the program is running. Read the forwarding pointer to the from-region. Allocate a temporary copy of the object in a toregion. Speculatively copy the data. CAS the forwarding pointer to point to the new copy. If the CAS fails, another thread already copied the object and you can roll back your speculative copy. 18

19 Forwarding Pointers - reads From-Region To-Region A B Reading an object in a From-region doesn't trigger an evacuation. 19 Note: If reads were to cause copying we might have a read storm where every operation required copying an object. Our intention is that since we are only copying on writes we will have less bursty behavior.

20 Forwarding Pointers - writes From-Region To-Region A A' B Writing an object in a From-Region will trigger an evacuation of that object to a To-Region and the write will occur in there. Invariant: Writes never occur in from-regions. 20

21 Forwarding Pointers writes of references From-Region To-Region A A' B B We resolve all references before we write them. Invariant: Never write a reference to a fromregion object into a to-region object. 21

22 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region To-Region A Foo Bar 22

23 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region A To-Region A' Foo Bar 23

24 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region A To-Region A' Foo Foo' Bar 24

25 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region A To-Region A' Foo Foo' Bar 25

26 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region A To-Region A' Foo Foo' Bar Bar' 26 Now we can CAS.

27 Forwarding Pointers - CAS CompareAndSwap(A.X, Foo, Bar) From-Region A To-Region A' Foo Foo' Bar Bar' 27

28 Does that mean a write could keep a Java thread from making progress for an unbounded amount of time? No Copies are bounded by region size. Objects that are larger than a region are treated specially. 28

29 Read Barriers? Unconditional Read Barrier movq R10, [R10 + #-8 (8-bit)] # ptr movq RBX, [R10 + #16 (8-bit)] # ptr! Field: java/lang/classloader.parent 29

30 Write Barriers? We need the SATB write barrier which adds previous reference values onto a queue to be scanned. We also need write barriers on all writes (even base types) to ensure we copy objects in targeted regions before we write to them. 30

31 Costs and Benefits Costs Space An extra word / object can be expensive if you have a lot of small objects. Time Benefits Ultra-low pause times which can be important to interactive and SLA applications. Reads and Writes require barriers 31

32 Current status We have something working. We can pass small tests specjvm, specjbb We have passed the smoke test for Eclipse, Thermostat We are working on performance tuning Radargun, Elastic Search/Lucene 32

33 Performance Tuning One very important area for application specific performance tuning will be Shenandoah heuristics. Lazy Heuristics GC as little as possible Aggressive Heuristics... GC as frequently as possible to maintain minimum heap size. 33

34 Encouraging preliminary results SpecJVM2008 compiler Not our target application. We are just starting performance tuning. Shenandoah Initial Mark (avg=5.65ms,max=9.53ms, total=1.40s) Final Mark (avg=8.74ms,max=15.43ms,total=2.17s) As compared to G1 (avg=31.38ms, max=75.48ms, total=6.84s) 34

35 References Trading Data Space for Reduced Time and Code Space in Real-Time Garbage Collection on Stock Hardware - Brooks Garbage-first garbage collection - Detlefs, Flood, Heller, Printezis. 35

36 Future Work Finish big application testing. Move the barriers to right before code generation. Heuristics tuning. Round Robbin Thread Stopping? NUMA Aware? 36

37 More information Download the code and try it. Blogs