< 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 >