Download as PDF, PPTX
![References
75
[1] R. Jones et al. “The Garbage Collection Handbook”. Chapman & Hall/CRC, 2012](https://image.slidesharecdn.com/bragaslides-200218135421/85/Demystifying-Garbage-Collection-in-Java-75-320.jpg)
Uploaded byIgor Braga
Demystifying Garbage Collection in Java
This document summarizes key aspects of garbage collection in Java. It begins with an introduction to garbage collection and an overview of OpenJ9, an open source JVM project. It then discusses various garbage collection policies in OpenJ9 including optthruput, optavgpause, gencon, balanced, and metronome. For each policy, it describes the heap layout, garbage collection process, and use of write barriers. It also covers double mapping for improving large array performance in some policies. Throughout it provides code examples and diagrams to illustrate concepts.
![[BGOUG] Java GC - Friend or Foe](https://cdn.slidesharecdn.com/ss_thumbnails/javagcfriendorfoe-101125015602-phpapp01-thumbnail.jpg?width=640&height=640&fit=bounds)
Demystifying Garbage Collection in Java
- 1. Demystifying Garbage Collection inJava Igor Braga
- 2. Important Disclaimers • THEINFORMATION CONTAINED IN THIS PRESENTATION IS PROVIDED FOR INFORMATIONAL PURPOSES ONLY. • WHILST EFFORTS WERE MADE TO VERIFY THE COMPLETENESS AND ACCURACY OF THE INFORMATION CONTAINED IN THIS PRESENTATION, IT IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. • ALL PERFORMANCE DATA INCLUDED IN THIS PRESENTATION HAVE BEEN GATHERED IN A CONTROLLED ENVIRONMENT. YOUR OWN TEST RESULTS MAY VARY BASED ON HARDWARE, SOFTWARE OR INFRASTRUCTURE DIFFERENCES. • ALL DATA INCLUDED IN THIS PRESENTATION ARE MEANT TO BE USED ONLY AS A GUIDE. • IN ADDITION, THE INFORMATION CONTAINED IN THIS PRESENTATION IS BASED ON IBM’S CURRENT PRODUCT PLANS AND STRATEGY, WHICH ARE SUBJECT TO CHANGE BY IBM, WITHOUT NOTICE. • IBM AND ITS AFFILIATED COMPANIES SHALL NOT BE RESPONSIBLE FOR ANY DAMAGES ARISING OUT OF THE USE OF, OR OTHERWISE RELATED TO, THIS PRESENTATION OR ANY OTHER DOCUMENTATION. • NOTHING CONTAINED IN THIS PRESENTATION IS INTENDED TO, OR SHALL HAVE THE EFFECT OF: • CREATING ANY WARRANT OR REPRESENTATION FROM IBM, ITS AFFILIATED COMPANIES OR ITS OR THEIR SUPPLIERS AND/OR LICENSORS 2
- 3. Outline 1. Introduction 2. OpenJ9Project 3. Garbage Collection Overview 4. OpenJ9 GC technologies 5. Double Mapping (Advanced Feature) 6. Summary 3
- 4. 4 Eclipse OpenJ9 Created Sept2017 http://www.eclipse.org/openj9 https://github.com/eclipse/openj9 Dual License: Eclipse Public License v2.0 Apache 2.0 Users and contributors very welcome https://github.com/eclipse/openj9/blob/master/CONTRIBUTING.md
- 5. 5 The place toget OpenJDK builds For both https://adoptopenjdk.net OpenJDK + OpenJ9 OpenJDK + Hotspot or
- 6.
- 7. Garbage Collection 7 “Garbage Collection(GC) is a form of automatic memory management. The garbage collector attempts to reclaim memory occupied by objects that are no longer in use by the application.”
- 8. Garbage Collection 8 Positives v Automaticmemory management v Help reduce certain categories of bugs Negatives v Require additional resources v Causes unpredictable pauses v May introduce runtime costs v Application has little control of when memory is reclaimed
- 9. OpenJ9 GC Goals 9 Implement re-usable technology Useless memory when possible Provide highly scalable GC technology
- 10. Garbage Collection Policies 10 optthruput– stop the world parallel collector optavgpause – concurrent collector gencon – generational copying collector balanced – region based collector metronome – incremental soft realtime collector -Xgcpolicy:
- 11. -Xgcpolicy:optthruput 11 Parallel global collector vGC operations are completed in Stop the world (STW) pauses v Mark, sweep and optional compaction collector v All GC operations are completed in parallel by multiple helper threads GC native memory overhead for mark map and work packets
- 12. -Xgcpolicy:optthruput heap 12 Flat heap-> one continuous block of memory Heap
- 13. -Xgcpolicy:optthruput heap 13 Flat heap-> one continuous block of memory Heap SOA LOA Divided into 2 logical memory areas for allocation SOA – small object area LOA – large object area
- 14. -Xgcpolicy:optthruput GC 14 GC 1 Start GC1 End GC 2 Start GC 2 End Application Threads
- 15. -Xgcpolicy:optthruput GC 15 Each GCis divided into 3 phases Marking finds all of the live objects Sweeping reclaims memory for dead objects Compaction (optional) defragment the heap
- 16.
- 17. -Xgcpolicy:optavgpause 17 Improves STW pausetimes and application responsiveness Introduces the requirement for an object write barrier Concurrent global collector GC native memory overhead for mark map, work packets and card table
- 18. -Xgcpolicy:optavgpause heap 18 Heap layoutis the same as optthruput Heap SOA LOA Allocation is the same as with optthruput Start a concurrent GC before the heap memory is exhausted Application runs during the GC so allocations continue
- 19. -Xgcpolicy:optavgpause GC 19 GC 1 Start GC1 End GC 2 Start GC 2 End Application Threads
- 20.
- 21.
- 22.
- 23.
- 24. -Xgcpolicy:optavgpause GC 24 Write Barrier Howis the write barrier implemented? private void setField(Object A, Object C) { | A.field1 = C; }
- 25. -Xgcpolicy:optavgpause GC 25 Write Barrier Howis the write barrier implemented? private void setField(Object A, Object C) { | A.field1 = C; | if (concurrentGCActive) { | | cardTable->dirtyCard(A); // ß | } }
- 26. -Xgcpolicy:gencon 26 Provides a significantreduction in GC STW pause times Introduces another write barrier for the remembered set Generational copy collector Concurrent global collector from optavgpause
- 27. -Xgcpolicy:gencon heap 27 Heap isdivided into Nursery and Tenure Spaces Tenure Heap Nursery
- 28. -Xgcpolicy:gencon heap 28 Heap isdivided into Nursery and Tenure Spaces Heap The Nursery is divided into 2 logical spaces: Allocate and Survivor TenureAllocate Survivor
- 29.
- 30. -Xgcpolicy:gencon GC 30 CS 1 start Global Start CS1 end CS 2 start CS 2 end Concurrent ScavangerApplication Threads
- 31. -Xgcpolicy:gencon GC 31 Why dowe need a write barrier? The GC needs to be able to find objects in the nursery which are only referenced from tenure space Write Barrier
- 32. -Xgcpolicy:gencon GC 32 How’s thewrite barrier implemented? Write Barrier private void setField(Object A, Object C) { | A.field1 = C; }
- 33. -Xgcpolicy:gencon GC 33 How’s thewrite barrier implemented? Write Barrier private void setField(Object A, Object C) { | A.field1 = C; | if (A is tenured) { | | if (C is NOT tenured) { | | | remember(A); | | } | } }
- 34. -Xgcpolicy:gencon GC 34 Write Barrier privatevoid setField(Object A, Object C) { | A.field1 = C; | if (A is tenured) { | | if (C is NOT tenured) { | | | remember(A); // ß | | } | | if (concurrentGCActive) { | | | cardTable->dirtyCard(A); | | } | } }
- 35. -Xgcpolicy:metronome 35 Provides a significantreduction in max GC STW pause times Uses a Snapshot At The Beginning (SATB) write barrier Incremental soft realtime collector High percentage of floating garbage
- 36. -Xgcpolicy:metronome heap 36 Heap isdivided into a fixed number of regions v Region size is 64k v Bigger heap == more regions Heap
- 37. -Xgcpolicy:metronome heap 37 Cell basedallocation Heap Regions are assigned a cell size on first use v Cell sizes range from 16 bytes to 2048 bytes v Only objects of that cell size can be allocated in a region of a particular cell size
- 38. -Xgcpolicy:metronome heap 38 Objects largerthan 2048 bytes consume contiguous regions v If no contiguous regions a full STW GC is completed before OOM Heap Large arrays are allocated as arraylets v Arraylet leaves are 2048 bytes v Each arraylet leaf region contains 32 arraylet leaves
- 39. -Xgcpolicy:metronome GC 39 GC StartGC End Application Threads
- 40. -Xgcpolicy:metronome 40 Snapshot at thebeginning of the barrier (SATB) Write Barrier Causes a lot of floating garbage The barrier has to be performed before the store
- 41.
- 42.
- 43.
- 44. -Xgcpolicy:metronome 44 private void setField(ObjectA, Object Z) { | A.field1 = Z; } Write Barrier How’s the write barrier implemented?
- 45. -Xgcpolicy:metronome 45 private void setField(ObjectB, Object Z) { | Object temp = B.field1; | if (barrier isActive) { | | remember(temp); | } | B.field1 = Z; // Z = NULL } Write Barrier How’s the write barrier implemented?
- 46. -Xgcpolicy:balanced 46 Provides a significantreduction in max GC STW pause times Introduces a write barrier to track inter region references Region based generational collector Full parallel global as a fall back if the PGCs can not keep up
- 47. -Xgcpolicy:balanced heap 47 Heap isdivided into a fixed number of regions v Region size is always a power of 2 v Attempts to have between 1000-2000 regions v Bigger heap == bigger region size Heap
- 48. -Xgcpolicy:balanced heap 48 Allocate fromEden regions v Eden can be any set of completely free regions v Attempts to pick regions from each NUMA node Heap
- 49. -Xgcpolicy:balanced heap 49 No non-arrayobject can be larger than a region size vIf (object_size > Region_size) throw OutOfMemoryError Large arrays are allocated as arraylets v Arrays less than region size are allocated as normal arrays
- 50. -Xgcpolicy:balanced GC 50 PGC 1 GMP start PGC2 GMP End PGC 3 GMP cycle Application Threads
- 51. -Xgcpolicy:balanced Global MarkPhase (GMP) 51 Does not reclaim any memory Performs a marking phase only Scheduled to run in between PGCs Builds an accurate mark map of the whole heap Mark map is used to predict region ROI for PGC Scrubs RSCL (Remember Set Card List)
- 52. -Xgcpolicy:balanced 52 Why do weneed a write barrier? Write Barrier Balanced PGCs can select any region to be included in the collect phase Similar to the generational barrier, the GC needs to know which regions reference a given region
- 53. -Xgcpolicy:balanced 53 How is thewrite barrier implemented? Write Barrier private void setField(Object A, Object C) { | A.field1 = C; }
- 54. -Xgcpolicy:balanced 54 Write Barrier private voidsetField(Object A, Object C) { | A.field1 = C; | dirtyCard(A); } private void checkCards() { // Beginning of PGC | for(eachCard)… | | if (findRegion(A) != findRegion(C)) { | | | addRSCLEntryFor(C, A); | | } }
- 55. GC Policy QuickGuide 55 GC Policy Generational Concurrent Defragmentation gencon tenure / nursery Concurrent mark tenure / nursery balanced regions have ages Global Mark Phase region based metronome N/A Incremental realtime region based optthruput N/A N/A (STW) SOA / LOA optavgpause N/A Concurrent mark SOA / LOA
- 56. GC Policy QuickGuide 56 GC Policy Domain Memory used in addition to heap (% of Xmx) Throughput gencon Webservers, desktop applications, runs most apps well 9 Highest balanced Very large heaps, large NUMA systems 13.5 High metronome Soft-realtime systems, trading applications, etc. 4.5 Low-Medium optthruput Small heaps with little GC 4.5 Medium optavgpause Why not gencon? 6 Low-Medium
- 57. GC Summary 57 Generational Collectors Regionbased Collectors Write Barriers to keep track of concurrent and inter region allocation
- 58. Arraylets 58 Large Arrays thatcannot fit into a single region vArray is created from construct comprising of an arraylet spine and 1 or more arraylet leaves vAn arraylet spine is allocated like a normal object vEach leaf consumes an entire region**
- 59.
- 60. 60 Arraylets Arraylets were introducedso that arrays were more cleverly stored in the heap for balanced and metronome GC policies. Some APIs require a contiguous view of an array
- 61. 61 Arraylets Some APIs requirea contiguous view of an array The case of Java Native Interface (JNI) JNI Critical is used when the programmer wants direct addressability of the object.
- 62.
- 63.
- 64.
- 65.
- 66. 66 Arraylets Double Mapping Make largearrays (discontiguous arraylets) look contiguous Virtual Memory address space is large in 64 bit systems, 264 in fact compared to 32 bits in 32 bit systems Physical memory is limited
- 67. 67 Arraylets Double Mapping Map 2virtual memory addresses to the same physical memory address Any modifications to the newly mapped address will reflect the original array data, and vice-versa
- 68.
- 69. 69 Arraylets Double Mapping Comparing JNIcritical operations, array operations got up to 30x boost in speedup
- 70.
- 71. Summary 71 v What isGarbage Collection v Different GC Policies v Double mapping to improve large array performance
- 72.
- 73. Appendix 73 Case Study on genconGC (XML validation service) Heap size: 1280 MB Nursery: 320 MB Tenure: 960MB More than 1000 nursery collections (scavange time) and 10 global collections ~ 20% of runtime
- 74. 74 Case Study on genconGC (XML validation service) Heap size: 1280 MB Nursery: 640 MB Tenure: 640 MB Less than 500 nursery collections (scavange time) and no global collections ~ 8% of runtime Appendix Smoother
- 75. References 75 [1] R. Joneset al. “The Garbage Collection Handbook”. Chapman & Hall/CRC, 2012