< prev index next >
src/hotspot/share/gc/g1/g1_globals.hpp
Print this page
@@ -26,298 +26,287 @@
#define SHARE_GC_G1_G1_GLOBALS_HPP
#include "runtime/globals_shared.hpp"
//
-// Defines all globals flags used by the garbage-first compiler.
+// Declare all globals flags used by the garbage-first compiler.
//
-#define GC_G1_FLAGS(develop, \
- develop_pd, \
- product, \
- product_pd, \
- diagnostic, \
- diagnostic_pd, \
- experimental, \
- notproduct, \
- manageable, \
- product_rw, \
- lp64_product, \
- range, \
- constraint) \
- \
- product(bool, G1UseAdaptiveIHOP, true, \
- "Adaptively adjust the initiating heap occupancy from the " \
- "initial value of InitiatingHeapOccupancyPercent. The policy " \
- "attempts to start marking in time based on application " \
- "behavior.") \
- \
- experimental(size_t, G1AdaptiveIHOPNumInitialSamples, 3, \
- "How many completed time periods from initial mark to first " \
- "mixed gc are required to use the input values for prediction " \
- "of the optimal occupancy to start marking.") \
- range(1, max_intx) \
- \
- product(uintx, G1ConfidencePercent, 50, \
- "Confidence level for MMU/pause predictions") \
- range(0, 100) \
- \
- diagnostic(intx, G1SummarizeRSetStatsPeriod, 0, \
- "The period (in number of GCs) at which we will generate " \
- "update buffer processing info " \
- "(0 means do not periodically generate this info); " \
- "it also requires that logging is enabled on the trace" \
- "level for gc+remset") \
- range(0, max_intx) \
- \
- product(double, G1ConcMarkStepDurationMillis, 10.0, \
- "Target duration of individual concurrent marking steps " \
- "in milliseconds.") \
- range(1.0, DBL_MAX) \
- \
- product(uint, G1RefProcDrainInterval, 1000, \
- "The number of discovered reference objects to process before " \
- "draining concurrent marking work queues.") \
- range(1, INT_MAX) \
- \
- experimental(bool, G1UseReferencePrecleaning, true, \
- "Concurrently preclean java.lang.ref.references instances " \
- "before the Remark pause.") \
- \
- experimental(double, G1LastPLABAverageOccupancy, 50.0, \
- "The expected average occupancy of the last PLAB in " \
- "percent.") \
- range(0.001, 100.0) \
- \
- product(size_t, G1SATBBufferSize, 1*K, \
- "Number of entries in an SATB log buffer.") \
- range(1, max_uintx) \
- \
- develop(intx, G1SATBProcessCompletedThreshold, 20, \
- "Number of completed buffers that triggers log processing.") \
- range(0, max_jint) \
- \
- product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60, \
- "Before enqueueing them, each mutator thread tries to do some " \
- "filtering on the SATB buffers it generates. If post-filtering " \
- "the percentage of retained entries is over this threshold " \
- "the buffer will be enqueued for processing. A value of 0 " \
- "specifies that mutator threads should not do such filtering.") \
- range(0, 100) \
- \
- experimental(intx, G1ExpandByPercentOfAvailable, 20, \
- "When expanding, % of uncommitted space to claim.") \
- range(0, 100) \
- \
- product(size_t, G1UpdateBufferSize, 256, \
- "Size of an update buffer") \
- range(1, NOT_LP64(32*M) LP64_ONLY(1*G)) \
- \
- product(size_t, G1ConcRefinementYellowZone, 0, \
- "Number of enqueued update buffers that will " \
- "trigger concurrent processing. Will be selected ergonomically " \
- "by default.") \
- range(0, max_intx) \
- \
- product(size_t, G1ConcRefinementRedZone, 0, \
- "Maximum number of enqueued update buffers before mutator " \
- "threads start processing new ones instead of enqueueing them. " \
- "Will be selected ergonomically by default.") \
- range(0, max_intx) \
- \
- product(size_t, G1ConcRefinementGreenZone, 0, \
- "The number of update buffers that are left in the queue by the " \
- "concurrent processing threads. Will be selected ergonomically " \
- "by default.") \
- range(0, max_intx) \
- \
- product(uintx, G1ConcRefinementServiceIntervalMillis, 300, \
- "The last concurrent refinement thread wakes up every " \
- "specified number of milliseconds to do miscellaneous work.") \
- range(0, max_jint) \
- \
- product(size_t, G1ConcRefinementThresholdStep, 2, \
- "Each time the rset update queue increases by this amount " \
- "activate the next refinement thread if available. " \
- "The actual step size will be selected ergonomically by " \
- "default, with this value used to determine a lower bound.") \
- range(1, SIZE_MAX) \
- \
- product(intx, G1RSetUpdatingPauseTimePercent, 10, \
- "A target percentage of time that is allowed to be spend on " \
- "process RS update buffers during the collection pause.") \
- range(0, 100) \
- \
- product(bool, G1UseAdaptiveConcRefinement, true, \
- "Select green, yellow and red zones adaptively to meet the " \
- "the pause requirements.") \
- \
- product(size_t, G1ConcRSLogCacheSize, 10, \
- "Log base 2 of the length of conc RS hot-card cache.") \
- range(0, 27) \
- \
- product(uintx, G1ConcRSHotCardLimit, 4, \
- "The threshold that defines (>=) a hot card.") \
- range(0, max_jubyte) \
- \
- develop(intx, G1RSetRegionEntriesBase, 256, \
- "Max number of regions in a fine-grain table per MB.") \
- range(1, max_jint/wordSize) \
- \
- product(intx, G1RSetRegionEntries, 0, \
- "Max number of regions for which we keep bitmaps." \
- "Will be set ergonomically by default") \
- range(0, max_jint/wordSize) \
- constraint(G1RSetRegionEntriesConstraintFunc,AfterErgo) \
- \
- develop(intx, G1RSetSparseRegionEntriesBase, 4, \
- "Max number of entries per region in a sparse table " \
- "per MB.") \
- range(1, max_jint/wordSize) \
- \
- product(intx, G1RSetSparseRegionEntries, 0, \
- "Max number of entries per region in a sparse table." \
- "Will be set ergonomically by default.") \
- range(0, max_jint/wordSize) \
- constraint(G1RSetSparseRegionEntriesConstraintFunc,AfterErgo) \
- \
- develop(intx, G1MaxVerifyFailures, -1, \
- "The maximum number of verification failures to print. " \
- "-1 means print all.") \
- range(-1, max_jint) \
- \
- product(uintx, G1ReservePercent, 10, \
- "It determines the minimum reserve we should have in the heap " \
- "to minimize the probability of promotion failure.") \
- range(0, 50) \
- \
- product(size_t, G1HeapRegionSize, 0, \
- "Size of the G1 regions.") \
- range(0, 32*M) \
- constraint(G1HeapRegionSizeConstraintFunc,AfterMemoryInit) \
- \
- product(uint, G1ConcRefinementThreads, 0, \
- "The number of parallel rem set update threads. " \
- "Will be set ergonomically by default.") \
- range(0, (max_jint-1)/wordSize) \
- \
- develop(bool, G1VerifyCTCleanup, false, \
- "Verify card table cleanup.") \
- \
- develop(uintx, G1DummyRegionsPerGC, 0, \
- "The number of dummy regions G1 will allocate at the end of " \
- "each evacuation pause in order to artificially fill up the " \
- "heap and stress the marking implementation.") \
- \
- develop(bool, G1ExitOnExpansionFailure, false, \
- "Raise a fatal VM exit out of memory failure in the event " \
- " that heap expansion fails due to running out of swap.") \
- \
- experimental(uintx, G1MaxNewSizePercent, 60, \
- "Percentage (0-100) of the heap size to use as default " \
- " maximum young gen size.") \
- range(0, 100) \
- constraint(G1MaxNewSizePercentConstraintFunc,AfterErgo) \
- \
- experimental(uintx, G1NewSizePercent, 5, \
- "Percentage (0-100) of the heap size to use as default " \
- "minimum young gen size.") \
- range(0, 100) \
- constraint(G1NewSizePercentConstraintFunc,AfterErgo) \
- \
- experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \
- "Threshold for regions to be considered for inclusion in the " \
- "collection set of mixed GCs. " \
- "Regions with live bytes exceeding this will not be collected.") \
- range(0, 100) \
- \
- product(uintx, G1HeapWastePercent, 5, \
- "Amount of space, expressed as a percentage of the heap size, " \
- "that G1 is willing not to collect to avoid expensive GCs.") \
- range(0, 100) \
- \
- product(uintx, G1MixedGCCountTarget, 8, \
- "The target number of mixed GCs after a marking cycle.") \
- range(0, max_uintx) \
- \
- experimental(bool, G1EagerReclaimHumongousObjects, true, \
- "Try to reclaim dead large objects at every young GC.") \
- \
- experimental(bool, G1EagerReclaimHumongousObjectsWithStaleRefs, true, \
- "Try to reclaim dead large objects that have a few stale " \
- "references at every young GC.") \
- \
- experimental(size_t, G1RebuildRemSetChunkSize, 256 * K, \
- "Chunk size used for rebuilding the remembered set.") \
- range(4 * K, 32 * M) \
- \
- experimental(uintx, G1OldCSetRegionThresholdPercent, 10, \
- "An upper bound for the number of old CSet regions expressed " \
- "as a percentage of the heap size.") \
- range(0, 100) \
- \
- notproduct(bool, G1EvacuationFailureALot, false, \
- "Force use of evacuation failure handling during certain " \
- "evacuation pauses") \
- \
- develop(uintx, G1EvacuationFailureALotCount, 1000, \
- "Number of successful evacuations between evacuation failures " \
- "occurring at object copying") \
- \
- develop(uintx, G1EvacuationFailureALotInterval, 5, \
- "Total collections between forced triggering of evacuation " \
- "failures") \
- \
- develop(bool, G1EvacuationFailureALotDuringConcMark, true, \
- "Force use of evacuation failure handling during evacuation " \
- "pauses when marking is in progress") \
- \
- develop(bool, G1EvacuationFailureALotDuringInitialMark, true, \
- "Force use of evacuation failure handling during initial mark " \
- "evacuation pauses") \
- \
- develop(bool, G1EvacuationFailureALotDuringYoungGC, true, \
- "Force use of evacuation failure handling during young " \
- "evacuation pauses") \
- \
- develop(bool, G1EvacuationFailureALotDuringMixedGC, true, \
- "Force use of evacuation failure handling during mixed " \
- "evacuation pauses") \
- \
- diagnostic(bool, G1VerifyRSetsDuringFullGC, false, \
- "If true, perform verification of each heap region's " \
- "remembered set when verifying the heap during a full GC.") \
- \
- diagnostic(bool, G1VerifyHeapRegionCodeRoots, false, \
- "Verify the code root lists attached to each heap region.") \
- \
- develop(bool, G1VerifyBitmaps, false, \
- "Verifies the consistency of the marking bitmaps") \
- \
- manageable(uintx, G1PeriodicGCInterval, 0, \
- "Number of milliseconds after a previous GC to wait before " \
- "triggering a periodic gc. A value of zero disables periodically "\
- "enforced gc cycles.") \
- \
- product(bool, G1PeriodicGCInvokesConcurrent, true, \
- "Determines the kind of periodic GC. Set to true to have G1 " \
- "perform a concurrent GC as periodic GC, otherwise use a STW " \
- "Full GC.") \
- \
- manageable(double, G1PeriodicGCSystemLoadThreshold, 0.0, \
- "Maximum recent system wide load as returned by the 1m value " \
- "of getloadavg() at which G1 triggers a periodic GC. A load " \
- "above this value cancels a given periodic GC. A value of zero " \
- "disables this check.") \
- range(0.0, (double)max_uintx) \
- \
- experimental(uintx, G1YoungExpansionBufferPercent, 10, \
- "When heterogenous heap is enabled by AllocateOldGenAt " \
- "option, after every GC, young gen is re-sized which " \
- "involves system calls to commit/uncommit memory. To " \
- "reduce these calls, we keep a buffer of extra regions to " \
- "absorb small changes in young gen length. This flag takes " \
- "the buffer size as an percentage of young gen length") \
- range(0, 100) \
+#include "utilities/macros.hpp"
+#if INCLUDE_G1GC
+#include "runtime/flags/jvmFlag.hpp"
+PRODUCT_FLAG(bool, G1UseAdaptiveIHOP, true, JVMFlag::DEFAULT,
+ "Adaptively adjust the initiating heap occupancy from the "
+ "initial value of InitiatingHeapOccupancyPercent. The policy "
+ "attempts to start marking in time based on application "
+ "behavior.");
+PRODUCT_FLAG(size_t, G1AdaptiveIHOPNumInitialSamples, 3, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "How many completed time periods from initial mark to first "
+ "mixed gc are required to use the input values for prediction "
+ "of the optimal occupancy to start marking.");
+ FLAG_RANGE( G1AdaptiveIHOPNumInitialSamples, 1, max_intx);
+
+PRODUCT_FLAG(uintx, G1ConfidencePercent, 50, JVMFlag::RANGE,
+ "Confidence level for MMU/pause predictions");
+ FLAG_RANGE( G1ConfidencePercent, 0, 100);
+
+PRODUCT_FLAG(intx, G1SummarizeRSetStatsPeriod, 0, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
+ "The period (in number of GCs) at which we will generate "
+ "update buffer processing info "
+ "(0 means do not periodically generate this info); "
+ "it also requires that logging is enabled on the trace"
+ "level for gc+remset");
+ FLAG_RANGE( G1SummarizeRSetStatsPeriod, 0, max_intx);
+
+PRODUCT_FLAG(double, G1ConcMarkStepDurationMillis, 10.0, JVMFlag::RANGE,
+ "Target duration of individual concurrent marking steps "
+ "in milliseconds.");
+ FLAG_RANGE( G1ConcMarkStepDurationMillis, 1.0, DBL_MAX);
+
+PRODUCT_FLAG(uint, G1RefProcDrainInterval, 1000, JVMFlag::RANGE,
+ "The number of discovered reference objects to process before "
+ "draining concurrent marking work queues.");
+ FLAG_RANGE( G1RefProcDrainInterval, 1, INT_MAX);
+
+PRODUCT_FLAG(bool, G1UseReferencePrecleaning, true, JVMFlag::EXPERIMENTAL,
+ "Concurrently preclean java.lang.ref.references instances "
+ "before the Remark pause.");
+
+PRODUCT_FLAG(double, G1LastPLABAverageOccupancy, 50.0, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "The expected average occupancy of the last PLAB in "
+ "percent.");
+ FLAG_RANGE( G1LastPLABAverageOccupancy, 0.001, 100.0);
+
+PRODUCT_FLAG(size_t, G1SATBBufferSize, 1*K, JVMFlag::RANGE,
+ "Number of entries in an SATB log buffer.");
+ FLAG_RANGE( G1SATBBufferSize, 1, max_uintx);
+
+DEVELOP_FLAG(intx, G1SATBProcessCompletedThreshold, 20, JVMFlag::RANGE,
+ "Number of completed buffers that triggers log processing.");
+ FLAG_RANGE( G1SATBProcessCompletedThreshold, 0, max_jint);
+
+PRODUCT_FLAG(uintx, G1SATBBufferEnqueueingThresholdPercent, 60, JVMFlag::RANGE,
+ "Before enqueueing them, each mutator thread tries to do some "
+ "filtering on the SATB buffers it generates. If post-filtering "
+ "the percentage of retained entries is over this threshold "
+ "the buffer will be enqueued for processing. A value of 0 "
+ "specifies that mutator threads should not do such filtering.");
+ FLAG_RANGE( G1SATBBufferEnqueueingThresholdPercent, 0, 100);
+
+PRODUCT_FLAG(intx, G1ExpandByPercentOfAvailable, 20, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "When expanding, % of uncommitted space to claim.");
+ FLAG_RANGE( G1ExpandByPercentOfAvailable, 0, 100);
+
+PRODUCT_FLAG(size_t, G1UpdateBufferSize, 256, JVMFlag::RANGE,
+ "Size of an update buffer");
+ FLAG_RANGE( G1UpdateBufferSize, 1, NOT_LP64(32*M) LP64_ONLY(1*G));
+
+PRODUCT_FLAG(size_t, G1ConcRefinementYellowZone, 0, JVMFlag::RANGE,
+ "Number of enqueued update buffers that will "
+ "trigger concurrent processing. Will be selected ergonomically "
+ "by default.");
+ FLAG_RANGE( G1ConcRefinementYellowZone, 0, max_intx);
+
+PRODUCT_FLAG(size_t, G1ConcRefinementRedZone, 0, JVMFlag::RANGE,
+ "Maximum number of enqueued update buffers before mutator "
+ "threads start processing new ones instead of enqueueing them. "
+ "Will be selected ergonomically by default.");
+ FLAG_RANGE( G1ConcRefinementRedZone, 0, max_intx);
+
+PRODUCT_FLAG(size_t, G1ConcRefinementGreenZone, 0, JVMFlag::RANGE,
+ "The number of update buffers that are left in the queue by the "
+ "concurrent processing threads. Will be selected ergonomically "
+ "by default.");
+ FLAG_RANGE( G1ConcRefinementGreenZone, 0, max_intx);
+
+PRODUCT_FLAG(uintx, G1ConcRefinementServiceIntervalMillis, 300, JVMFlag::RANGE,
+ "The last concurrent refinement thread wakes up every "
+ "specified number of milliseconds to do miscellaneous work.");
+ FLAG_RANGE( G1ConcRefinementServiceIntervalMillis, 0, max_jint);
+
+PRODUCT_FLAG(size_t, G1ConcRefinementThresholdStep, 2, JVMFlag::RANGE,
+ "Each time the rset update queue increases by this amount "
+ "activate the next refinement thread if available. "
+ "The actual step size will be selected ergonomically by "
+ "default, with this value used to determine a lower bound.");
+ FLAG_RANGE( G1ConcRefinementThresholdStep, 1, SIZE_MAX);
+
+PRODUCT_FLAG(intx, G1RSetUpdatingPauseTimePercent, 10, JVMFlag::RANGE,
+ "A target percentage of time that is allowed to be spend on "
+ "process RS update buffers during the collection pause.");
+ FLAG_RANGE( G1RSetUpdatingPauseTimePercent, 0, 100);
+
+PRODUCT_FLAG(bool, G1UseAdaptiveConcRefinement, true, JVMFlag::DEFAULT,
+ "Select green, yellow and red zones adaptively to meet the "
+ "the pause requirements.");
+
+PRODUCT_FLAG(size_t, G1ConcRSLogCacheSize, 10, JVMFlag::RANGE,
+ "Log base 2 of the length of conc RS hot-card cache.");
+ FLAG_RANGE( G1ConcRSLogCacheSize, 0, 27);
+
+PRODUCT_FLAG(uintx, G1ConcRSHotCardLimit, 4, JVMFlag::RANGE,
+ "The threshold that defines (>=) a hot card.");
+ FLAG_RANGE( G1ConcRSHotCardLimit, 0, max_jubyte);
+
+DEVELOP_FLAG(intx, G1RSetRegionEntriesBase, 256, JVMFlag::RANGE,
+ "Max number of regions in a fine-grain table per MB.");
+ FLAG_RANGE( G1RSetRegionEntriesBase, 1, max_jint/wordSize);
+
+PRODUCT_FLAG(intx, G1RSetRegionEntries, 0, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+ "Max number of regions for which we keep bitmaps."
+ "Will be set ergonomically by default");
+ FLAG_RANGE( G1RSetRegionEntries, 0, max_jint/wordSize);
+ FLAG_CONSTRAINT( G1RSetRegionEntries, (void*)G1RSetRegionEntriesConstraintFunc, JVMFlag::AfterErgo);
+
+DEVELOP_FLAG(intx, G1RSetSparseRegionEntriesBase, 4, JVMFlag::RANGE,
+ "Max number of entries per region in a sparse table "
+ "per MB.");
+ FLAG_RANGE( G1RSetSparseRegionEntriesBase, 1, max_jint/wordSize);
+
+PRODUCT_FLAG(intx, G1RSetSparseRegionEntries, 0, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+ "Max number of entries per region in a sparse table."
+ "Will be set ergonomically by default.");
+ FLAG_RANGE( G1RSetSparseRegionEntries, 0, max_jint/wordSize);
+ FLAG_CONSTRAINT( G1RSetSparseRegionEntries, (void*)G1RSetSparseRegionEntriesConstraintFunc, JVMFlag::AfterErgo);
+
+DEVELOP_FLAG(intx, G1MaxVerifyFailures, -1, JVMFlag::RANGE,
+ "The maximum number of verification failures to print. "
+ "-1 means print all.");
+ FLAG_RANGE( G1MaxVerifyFailures, -1, max_jint);
+
+PRODUCT_FLAG(uintx, G1ReservePercent, 10, JVMFlag::RANGE,
+ "It determines the minimum reserve we should have in the heap "
+ "to minimize the probability of promotion failure.");
+ FLAG_RANGE( G1ReservePercent, 0, 50);
+
+PRODUCT_FLAG(size_t, G1HeapRegionSize, 0, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+ "Size of the G1 regions.");
+ FLAG_RANGE( G1HeapRegionSize, 0, 32*M);
+ FLAG_CONSTRAINT( G1HeapRegionSize, (void*)G1HeapRegionSizeConstraintFunc, JVMFlag::AfterMemoryInit);
+
+PRODUCT_FLAG(uint, G1ConcRefinementThreads, 0, JVMFlag::RANGE,
+ "The number of parallel rem set update threads. "
+ "Will be set ergonomically by default.");
+ FLAG_RANGE( G1ConcRefinementThreads, 0, (max_jint-1)/wordSize);
+
+DEVELOP_FLAG(bool, G1VerifyCTCleanup, false, JVMFlag::DEFAULT,
+ "Verify card table cleanup.");
+
+DEVELOP_FLAG(uintx, G1DummyRegionsPerGC, 0, JVMFlag::DEFAULT,
+ "The number of dummy regions G1 will allocate at the end of "
+ "each evacuation pause in order to artificially fill up the "
+ "heap and stress the marking implementation.");
+
+DEVELOP_FLAG(bool, G1ExitOnExpansionFailure, false, JVMFlag::DEFAULT,
+ "Raise a fatal VM exit out of memory failure in the event "
+ " that heap expansion fails due to running out of swap.");
+
+PRODUCT_FLAG(uintx, G1MaxNewSizePercent, 60, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+ "Percentage (0-100) of the heap size to use as default "
+ " maximum young gen size.");
+ FLAG_RANGE( G1MaxNewSizePercent, 0, 100);
+ FLAG_CONSTRAINT( G1MaxNewSizePercent, (void*)G1MaxNewSizePercentConstraintFunc, JVMFlag::AfterErgo);
+
+PRODUCT_FLAG(uintx, G1NewSizePercent, 5, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+ "Percentage (0-100) of the heap size to use as default "
+ "minimum young gen size.");
+ FLAG_RANGE( G1NewSizePercent, 0, 100);
+ FLAG_CONSTRAINT( G1NewSizePercent, (void*)G1NewSizePercentConstraintFunc, JVMFlag::AfterErgo);
+
+PRODUCT_FLAG(uintx, G1MixedGCLiveThresholdPercent, 85, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "Threshold for regions to be considered for inclusion in the "
+ "collection set of mixed GCs. "
+ "Regions with live bytes exceeding this will not be collected.");
+ FLAG_RANGE( G1MixedGCLiveThresholdPercent, 0, 100);
+
+PRODUCT_FLAG(uintx, G1HeapWastePercent, 5, JVMFlag::RANGE,
+ "Amount of space, expressed as a percentage of the heap size, "
+ "that G1 is willing not to collect to avoid expensive GCs.");
+ FLAG_RANGE( G1HeapWastePercent, 0, 100);
+
+PRODUCT_FLAG(uintx, G1MixedGCCountTarget, 8, JVMFlag::RANGE,
+ "The target number of mixed GCs after a marking cycle.");
+ FLAG_RANGE( G1MixedGCCountTarget, 0, max_uintx);
+
+PRODUCT_FLAG(bool, G1EagerReclaimHumongousObjects, true, JVMFlag::EXPERIMENTAL,
+ "Try to reclaim dead large objects at every young GC.");
+
+PRODUCT_FLAG(bool, G1EagerReclaimHumongousObjectsWithStaleRefs, true, JVMFlag::EXPERIMENTAL,
+ "Try to reclaim dead large objects that have a few stale "
+ "references at every young GC.");
+
+PRODUCT_FLAG(size_t, G1RebuildRemSetChunkSize, 256 * K, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "Chunk size used for rebuilding the remembered set.");
+ FLAG_RANGE( G1RebuildRemSetChunkSize, 4 * K, 32 * M);
+
+PRODUCT_FLAG(uintx, G1OldCSetRegionThresholdPercent, 10, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "An upper bound for the number of old CSet regions expressed "
+ "as a percentage of the heap size.");
+ FLAG_RANGE( G1OldCSetRegionThresholdPercent, 0, 100);
+
+NOTPROD_FLAG(bool, G1EvacuationFailureALot, false, JVMFlag::DEFAULT,
+ "Force use of evacuation failure handling during certain "
+ "evacuation pauses");
+
+DEVELOP_FLAG(uintx, G1EvacuationFailureALotCount, 1000, JVMFlag::DEFAULT,
+ "Number of successful evacuations between evacuation failures "
+ "occurring at object copying");
+
+DEVELOP_FLAG(uintx, G1EvacuationFailureALotInterval, 5, JVMFlag::DEFAULT,
+ "Total collections between forced triggering of evacuation "
+ "failures");
+
+DEVELOP_FLAG(bool, G1EvacuationFailureALotDuringConcMark, true, JVMFlag::DEFAULT,
+ "Force use of evacuation failure handling during evacuation "
+ "pauses when marking is in progress");
+
+DEVELOP_FLAG(bool, G1EvacuationFailureALotDuringInitialMark, true, JVMFlag::DEFAULT,
+ "Force use of evacuation failure handling during initial mark "
+ "evacuation pauses");
+
+DEVELOP_FLAG(bool, G1EvacuationFailureALotDuringYoungGC, true, JVMFlag::DEFAULT,
+ "Force use of evacuation failure handling during young "
+ "evacuation pauses");
+
+DEVELOP_FLAG(bool, G1EvacuationFailureALotDuringMixedGC, true, JVMFlag::DEFAULT,
+ "Force use of evacuation failure handling during mixed "
+ "evacuation pauses");
+
+PRODUCT_FLAG(bool, G1VerifyRSetsDuringFullGC, false, JVMFlag::DIAGNOSTIC,
+ "If true, perform verification of each heap region's "
+ "remembered set when verifying the heap during a full GC.");
+
+PRODUCT_FLAG(bool, G1VerifyHeapRegionCodeRoots, false, JVMFlag::DIAGNOSTIC,
+ "Verify the code root lists attached to each heap region.");
+
+DEVELOP_FLAG(bool, G1VerifyBitmaps, false, JVMFlag::DEFAULT,
+ "Verifies the consistency of the marking bitmaps");
+
+PRODUCT_FLAG(uintx, G1PeriodicGCInterval, 0, JVMFlag::MANAGEABLE,
+ "Number of milliseconds after a previous GC to wait before "
+ "triggering a periodic gc. A value of zero disables periodically "
+ "enforced gc cycles.");
+
+PRODUCT_FLAG(bool, G1PeriodicGCInvokesConcurrent, true, JVMFlag::DEFAULT,
+ "Determines the kind of periodic GC. Set to true to have G1 "
+ "perform a concurrent GC as periodic GC, otherwise use a STW "
+ "Full GC.");
+
+PRODUCT_FLAG(double, G1PeriodicGCSystemLoadThreshold, 0.0, JVMFlag::MANAGEABLE | JVMFlag::RANGE,
+ "Maximum recent system wide load as returned by the 1m value "
+ "of getloadavg() at which G1 triggers a periodic GC. A load "
+ "above this value cancels a given periodic GC. A value of zero "
+ "disables this check.");
+ FLAG_RANGE( G1PeriodicGCSystemLoadThreshold, 0.0, (double)max_uintx);
+
+PRODUCT_FLAG(uintx, G1YoungExpansionBufferPercent, 10, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
+ "When heterogenous heap is enabled by AllocateOldGenAt "
+ "option, after every GC, young gen is re-sized which "
+ "involves system calls to commit/uncommit memory. To "
+ "reduce these calls, we keep a buffer of extra regions to "
+ "absorb small changes in young gen length. This flag takes "
+ "the buffer size as an percentage of young gen length");
+ FLAG_RANGE( G1YoungExpansionBufferPercent, 0, 100);
+#endif // INCLUDE_G1GC
#endif // SHARE_GC_G1_G1_GLOBALS_HPP
< prev index next >