Transcription

Java Platform, Standard EditionHotSpot Virtual Machine Garbage CollectionTuning GuideRelease 9E76294-05October 2017

Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide, Release 9E76294-05Copyright 2014, 2017, Oracle and/or its affiliates. All rights reserved.This software and related documentation are provided under a license agreement containing restrictions onuse and disclosure and are protected by intellectual property laws. Except as expressly permitted in yourlicense agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify,license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means.Reverse engineering, disassembly, or decompilation of this software, unless required by law forinteroperability, is prohibited.The information contained herein is subject to change without notice and is not warranted to be error-free. Ifyou find any errors, please report them to us in writing.If this is software or related documentation that is delivered to the U.S. Government or anyone licensing it onbehalf of the U.S. Government, then the following notice is applicable:U.S. GOVERNMENT END USERS: Oracle programs, including any operating system, integrated software,any programs installed on the hardware, and/or documentation, delivered to U.S. Government end users are"commercial computer software" pursuant to the applicable Federal Acquisition Regulation and agencyspecific supplemental regulations. As such, use, duplication, disclosure, modification, and adaptation of theprograms, including any operating system, integrated software, any programs installed on the hardware,and/or documentation, shall be subject to license terms and license restrictions applicable to the programs.No other rights are granted to the U.S. Government.This software or hardware is developed for general use in a variety of information management applications.It is not developed or intended for use in any inherently dangerous applications, including applications thatmay create a risk of personal injury. If you use this software or hardware in dangerous applications, then youshall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure itssafe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of thissoftware or hardware in dangerous applications.Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks oftheir respective owners.Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks areused under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron,the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced MicroDevices. UNIX is a registered trademark of The Open Group.This software or hardware and documentation may provide access to or information about content, products,and services from third parties. Oracle Corporation and its affiliates are not responsible for and expresslydisclaim all warranties of any kind with respect to third-party content, products, and services unless otherwiseset forth in an applicable agreement between you and Oracle. Oracle Corporation and its affiliates will not beresponsible for any loss, costs, or damages incurred due to your access to or use of third-party content,products, or services, except as set forth in an applicable agreement between you and Oracle.

ContentsPreface1234AudienceviDocumentation AccessibilityviRelated DocumentsviConventionsviIntroduction to Garbage Collection TuningWhat Is a Garbage Collector?1-1Why Does the Choice of Garbage Collector Matter?1-2Supported Operating Systems in Documentation1-3ErgonomicsGarbage Collector, Heap, and Runtime Compiler Default Selections2-1Behavior-Based Tuning2-2Maximum Pause-Time Goal2-2Throughput Goal2-2Footprint2-2Tuning Strategy2-3Garbage Collector ImplementationGenerational Garbage Collection3-1Generations3-2Performance Considerations3-3Throughput and Footprint Measurement3-4Factors Affecting Garbage Collection PerformanceTotal Heap4-1Heap Options Affecting Generation Size4-1Default Option Values for Heap Size4-2iii

Conserving Dynamic Footprint by Minimizing Java Heap SizeThe Young Generation564-3Survivor Space Sizing4-4Available CollectorsSerial Collector5-1Parallel Collector5-1The Mostly Concurrent Collectors5-1Selecting a Collector5-2The Parallel CollectorNumber of Parallel Collector Garbage Collector Threads6-1Arrangement of Generations in Parallel Collectors6-2Parallel Collector Ergonomics6-2Options to Specify Parallel Collector Behaviors6-2Priority of Parallel Collector Goals6-3Parallel Collector Generation Size Adjustments6-3Parallel Collector Default Heap Size6-36-4Excessive Parallel Collector Time and OutOfMemoryError6-4Parallel Collector Measurements6-4The Mostly Concurrent CollectorsOverhead of Mostly Concurrent Collectors84-3Young Generation Size OptionsSpecification of Parallel Collector Initial and Maximum Heap Sizes74-37-1Concurrent Mark Sweep (CMS) CollectorConcurrent Mark Sweep Collector Performance and Structure8-1Concurrent Mode Failure8-2Excessive GC Time and OutOfMemoryError8-2Concurrent Mark Sweep Collector and Floating Garbage8-2Concurrent Mark Sweep Collector Pauses8-3Concurrent Mark Sweep Collector Concurrent Phases8-3Starting a Concurrent Collection Cycle8-3Scheduling Pauses8-4Concurrent Mark Sweep Collector Measurements8-4iv

9Garbage-First Garbage CollectorIntroduction to Garbage-First Garbage Collector9-1Enabling G19-2Basic Concepts9-2Heap Layout9-2Garbage Collection Cycle9-3Garbage-First Internals10119-5Determining Initiating Heap Occupancy9-5Marking9-5Behavior in Very Tight Heap Situations9-5Humongous Objects9-6Young-Only Phase Generation Sizing9-6Space-Reclamation Phase Generation Sizing9-6Ergonomic Defaults for G1 GC9-7Comparison to Other Collectors9-8Garbage-First Garbage Collector TuningGeneral Recommendations for G110-1Moving to G1 from Other Collectors10-2Improving G1 Performance10-2Observing Full Garbage Collections10-2Humongous Object Fragmentation10-3Tuning for Latency10-3Unusual System or Real-Time Usage10-3Reference Object Processing Takes Too Long10-4Young-Only Collections Take Too Long10-4Mixed Collections Take Too Long10-4High Update RS and Scan RS Times10-5Tuning for Throughput10-6Tuning for Heap Size10-7Tunable Defaults10-7Other ConsiderationsFinalization and Weak, Soft, and Phantom References11-1Explicit Garbage Collection11-1Soft References11-2Class Metadata11-2v

PrefacePrefaceThe Java Platform, Standard Edition HotSpot Virtual Machine Garbage CollectionTuning Guide describes the garbage collection methods included in the Java HotSpotVirtual Machine (Java HotSpot VM) and helps you determine which one is the best foryour needs.AudienceThis document is intended for users, application developers and system administratorsof the Java HotSpot VM that want to improve their understanding of the Java HotSpotVM garbage collectors. This document further provides help with analysis andsolutions for common problems with garbage collection to make the application meetthe users' requirements.Documentation AccessibilityFor information about Oracle's commitment to accessibility, visit the OracleAccessibility Program website at http://www.oracle.com/pls/topic/lookup?ctx acc&id docacc.Access to Oracle SupportOracle customers that have purchased support have access to electronic supportthrough My Oracle Support. For information, visit http://www.oracle.com/pls/topic/lookup?ctx acc&id info or visit http://www.oracle.com/pls/topic/lookup?ctx acc&id trsif you are hearing impaired.Related DocumentsFor more information, see the following documents: Garbage Collection: Algorithms for Automatic Dynamic Memory Management.Wiley, Chichester, July 1996. With a chapter on Distributed Garabge Collection byR. Lins. Richard Jones, Anony Hosking, and Elliot Moss. The Garbage Collection Handbook: The Art of Automatic Memory Managmenet.CRC Applied Algorithms and Data Structures. Chapman & Hall, January 2012ConventionsThe following text conventions are used in this document:vi

PrefaceConventionMeaningboldfaceBoldface type indicates graphical user interface elements associatedwith an action, or terms defined in text or the glossary.italicItalic type indicates book titles, emphasis, or placeholder variables forwhich you supply particular values.monospaceMonospace type indicates commands within a paragraph, URLs, codein examples, text that appears on the screen, or text that you enter.vii

1Introduction to Garbage Collection TuningA wide variety of applications, from small applets on desktops to web services on largeservers, use the Java Platform, Standard Edition (Java SE). In support of this diverserange of deployments, the Java HotSpot VM provides multiple garbage collectors,each designed to satisfy different requirements. Java SE selects the most appropriategarbage collector based on the class of the computer on which the application is run.However, this selection may not be optimal for every application. Users, developers,and administrators with strict performance goals or other requirements may need toexplicitly select the garbage collector and tune certain parameters to achieve thedesired level of performance. This document provides information to help with thesetasks.First, general features of a garbage collector and basic tuning options are described inthe context of the serial, stop-the-world collector. Then specific features of the othercollectors are presented along with factors to consider when selecting a collector.Topics What Is a Garbage Collector? Why Does the Choice of Garbage Collector Matter? Supported Operating Systems in DocumentationWhat Is a Garbage Collector?The garbage collector (GC) automatically manages the application's dynamic memoryallocation requests.A garbage collector performs automatic dynamic memory management through thefollowing operations: Allocates from and gives back memory to the operating system. Hands out that memory to the application as it requests it. Determines which parts of that memory is still in use by the application. Reclaims the unused memory for reuse by the application.The Java HotSpot garbage collectors employ various techniques to improve theefficiency of these operations: Use generational scavenging in conjunction with aging to concentrate their effortson areas in the heap that most likely contain a lot of reclaimable memory areas. Use multiple threads to aggressively make operations parallel, or perform somelong-running operations in the background concurrent to the application. Try to recover larger contiguous free memory by compacting live objects.1-1

Chapter 1Why Does the Choice of Garbage Collector Matter?Why Does the Choice of Garbage Collector Matter?The purpose of a garbage collector is to free the application developer from manualdynamic memory management. The developer is freed of the requirement to matchallocations with deallocations and closely take care of the lifetimes of allocateddynamic memory. This completely eliminates some classes of errors related tomemory management at the cost of some additional runtime overhead. The JavaHotSpot VM provides a selection of garbage collection algorithms to choose from.When does the choice of a garbage collector matter? For some applications, theanswer is never. That is, the application can perform well in the presence of garbagecollection with pauses of modest frequency and duration. However, this isn't the casefor a large class of applications, particularly those with large amounts of data (multiplegigabytes), many threads, and high transaction rates.Amdahl's law (parallel speedup in a given problem is limited by the sequential portionof the problem) implies that most workloads can't be perfectly parallelized; someportion is always sequential and doesn't benefit from parallelism. In the Java platform,there are currently four supported garbage collection alternatives and all but one ofthem, the serial GC, parallelize the work to improve performance. It's very important tokeep the overhead of doing garbage collection as low as possible. This can be seen inthe following example.The graph in Figure 1-1 models an ideal system that's perfectly scalable with theexception of garbage collection. The red line is an application spending only 1% of thetime in garbage collection on a uniprocessor system. This translates to more than a20% loss in throughput on systems with 32 processors. The magenta line shows thatfor an application at 10% of the time in garbage collection (not considered anoutrageous amount of time in garbage collection in uniprocessor applications), morethan 75% of throughput is lost when scaling up to 32 processors.Figure 1-1Comparing Percentage of Time Spent in Garbage Collection10.81% GC2% GC0.63% GC0.4Throughput10% GC0.220% GC30% GC005101520252530Processors1-2

Chapter 1Supported Operating Systems in DocumentationThis figure shows that negligible throughput issues when developing on small systemsmay become principal bottlenecks when scaling up to large systems. However, smallimprovements in reducing such a bottleneck can produce large gains in performance.For a sufficiently large system, it becomes worthwhile to select the right garbagecollector and to tune it if necessary.The serial collector is usually adequate for most small applications, in particular thoserequiring heaps of up to approximately 100 megabytes on modern processors. Theother collectors have additional overhead or complexity, which is the price forspecialized behavior. If the application does not need the specialized behavior of analternate collector, use the serial collector. One situation where the serial collector isn'texpected to be the best choice is a large, heavily threaded application that runs on amachine with a large amount of memory and two or more processors. Whenapplications are run on such server-class machines, the Garbage-First (G1) collectoris selected by default; see Ergonomics.Supported Operating Systems in DocumentationThis document and its recommendations apply to all JDK 9 supported systemconfigurations, limited by actual availability of some garbage collectors in a particularconfiguration. See Oracle JDK 9 and JRE 9 Certified System Configurations.1-3

2ErgonomicsErgonomics is the process by which the Java Virtual Machine (JVM) and garbagecollection heuristics, such as behavior-based heuristics, improve applicationperformance.The JVM provides platform-dependent default selections for the garbage collector,heap size, and runtime compiler. These selections match the needs of different typesof applications while requiring less command-line tuning. In addition, behavior-basedtuning dynamically optimizes the sizes of the heap to meet a specified behavior of theapplication.This section describes these default selections and behavior-based tuning. Use thesedefaults before using the more detailed controls described in subsequent sections.Topics Garbage Collector, Heap, and Runtime Compiler Default Selections Behavior-Based Tuning –Maximum Pause-Time Goal–Throughput Goal–FootprintTuning StrategyGarbage Collector, Heap, and Runtime Compiler DefaultSelectionsThe following is information about the garbage collector, heap size, and runtimecompiler default selections.A class of machine referred to as a server-class machine has been defined as amachine with the following: Two or more physical processors Two or more GB of physical memoryOn server-class machines, the following are selected by default: Garbage-First (G1) collector Initial heap size of 1/64 of physical memory Maximum heap size of 1/4 of physical memory Tiered compiler, using both C1 and C22-1

Chapter 2Behavior-Based TuningBehavior-Based TuningThe Java HotSpot VM garbage collectors can be configured to preferentially meet oneof two goals: maximum pause-time and application throughput. If the preferred goal ismet, the collectors will try to maximize the other. Naturally, these goals can't always bemet: Applications require a minimum heap to hold at least all of the live data, and otherconfiguration might preclude reaching some or all of the desired goals.Maximum Pause-Time GoalThe pause time is the duration during which the garbage collector stops the applicationand recovers space that's no longer in use. The intent of the maximum pause-timegoal is to limit the longest of these pauses.An average time for pauses and a variance on that average is maintained by thegarbage collector. The average is taken from the start of the execution, but it'sweighted so that more recent pauses count more heavily. If the average plus thevariance of the pause-time is greater than the maximum pause-time goal, then thegarbage collector considers that the goal isn't being met.The maximum pause-time goal is specified with the command-line option XX:MaxGCPauseMillis nnn . This is interpreted as a hint to the garbage collector that apause-time of nnn milliseconds or fewer is desired. The garbage collector adjuststhe Java heap size and other parameters related to garbage collection in an attempt tokeep garbage collection pauses shorter than nnn milliseconds. The default for themaximum pause-time goal varies by collector. These adjustments may cause garbagecollection to occur more frequently, reducing the overall throughput of the application.In some cases, though, the desired pause-time goal can't be met.Throughput GoalThe throughput goal is measured in terms of the time spent collecting garbage, andthe time spent outside of garbage collection is theapplication time.The goal is specified by the command-line option -XX:GCTimeRatio nnn. The ratio ofgarbage collection time to application time is 1/ (1 nnn). For example, XX:GCTimeRatio 19 sets a goal of 1/20th or 5% of the total time for garbage collection.The time spent in garbage collection is the total time for all garbage collection inducedpauses. If the throughput goal isn't being met, then one possible action for the garbagecollector is to increase the size of the heap so that the time spent in the applicationbetween collection pauses can be longer.FootprintIf the throughput and maximum pause-time goals have been met, then the garbagecollector reduces the size of the heap until one of the goals (invariably the throughputgoal) can't be met. The minimum and maximum heap sizes that the garbage collectorcan use can be set using -Xms nnn and -Xmx mmm for minimum and maximumheap size respectively.2-2

Chapter 2Tuning StrategyTuning StrategyThe heap grows or shrinks to a size that supports the chosen throughput goal. Learnabout heap tuning strategies such as choosing a maximum heap size, and choosingmaximum pause-time goal.Don't choose a maximum value for the heap unless you know that you need a heapgreater than the default maximum heap size. Choose a throughput goal that'ssufficient for your application.A change in the application's behavior can cause the heap to grow or shrink. Forexample, if the application starts allocating at a higher rate, then the heap grows tomaintain the same throughput.If the heap grows to its maximum size and the throughput goal isn't being met, thenthe maximum heap size is too small for the throughput goal. Set the maximum heapsize to a value that's close to the total physical memory on the platform, but doesn'tcause swapping of the application. Execute the application again. If the throughputgoal still isn't met, then the goal for the application time is too high for the availablememory on the platform.If the throughput goal can be met, but pauses are too long, then select a maximumpause-time goal. Choosing a maximum pause-time goal may mean that yourthroughput goal won't be met, so choose values that are an acceptable compromi