8201136: Move GC flags from globals.hpp to GC specific files
Reviewed-by: sjohanss, shade, rehn
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/cms/cms_globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_CMS_CMS_GLOBALS_HPP
+#define SHARE_GC_CMS_CMS_GLOBALS_HPP
+
+#define GC_CMS_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ product(bool, UseCMSBestFit, true, \
+ "Use CMS best fit allocation strategy") \
+ \
+ product(size_t, CMSOldPLABMax, 1024, \
+ "Maximum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
+ range(1, max_uintx) \
+ constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
+ \
+ product(size_t, CMSOldPLABMin, 16, \
+ "Minimum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
+ range(1, max_uintx) \
+ constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
+ \
+ product(uintx, CMSOldPLABNumRefills, 4, \
+ "Nominal number of refills of CMS gen promotion LAB cache " \
+ "per worker per block size") \
+ range(1, max_uintx) \
+ \
+ product(bool, CMSOldPLABResizeQuicker, false, \
+ "React on-the-fly during a scavenge to a sudden " \
+ "change in block demand rate") \
+ \
+ product(uintx, CMSOldPLABToleranceFactor, 4, \
+ "The tolerance of the phase-change detector for on-the-fly " \
+ "PLAB resizing during a scavenge") \
+ range(1, max_uintx) \
+ \
+ product(uintx, CMSOldPLABReactivityFactor, 2, \
+ "The gain in the feedback loop for on-the-fly PLAB resizing " \
+ "during a scavenge") \
+ range(1, max_uintx) \
+ \
+ product_pd(size_t, CMSYoungGenPerWorker, \
+ "The maximum size of young gen chosen by default per GC worker " \
+ "thread available") \
+ range(1, max_uintx) \
+ \
+ product(uintx, CMSIncrementalSafetyFactor, 10, \
+ "Percentage (0-100) used to add conservatism when computing the " \
+ "duty cycle") \
+ range(0, 100) \
+ \
+ product(uintx, CMSExpAvgFactor, 50, \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponential averages for CMS statistics") \
+ range(0, 100) \
+ \
+ product(uintx, CMS_FLSWeight, 75, \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying averages for CMS FLS " \
+ "statistics") \
+ range(0, 100) \
+ \
+ product(uintx, CMS_FLSPadding, 1, \
+ "The multiple of deviation from mean to use for buffering " \
+ "against volatility in free list demand") \
+ range(0, max_juint) \
+ \
+ product(uintx, FLSCoalescePolicy, 2, \
+ "CMS: aggressiveness level for coalescing, increasing " \
+ "from 0 to 4") \
+ range(0, 4) \
+ \
+ product(bool, FLSAlwaysCoalesceLarge, false, \
+ "CMS: larger free blocks are always available for coalescing") \
+ \
+ product(double, FLSLargestBlockCoalesceProximity, 0.99, \
+ "CMS: the smaller the percentage the greater the coalescing " \
+ "force") \
+ range(0.0, 1.0) \
+ \
+ product(double, CMSSmallCoalSurplusPercent, 1.05, \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent coalescing with an adjoining block") \
+ range(0.0, DBL_MAX) \
+ \
+ product(double, CMSLargeCoalSurplusPercent, 0.95, \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent coalescing with an adjoining block") \
+ range(0.0, DBL_MAX) \
+ \
+ product(double, CMSSmallSplitSurplusPercent, 1.10, \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
+ range(0.0, DBL_MAX) \
+ \
+ product(double, CMSLargeSplitSurplusPercent, 1.00, \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
+ range(0.0, DBL_MAX) \
+ \
+ product(bool, CMSExtrapolateSweep, false, \
+ "CMS: cushion for block demand during sweep") \
+ \
+ product(uintx, CMS_SweepWeight, 75, \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying average for inter-sweep " \
+ "duration") \
+ range(0, 100) \
+ \
+ product(uintx, CMS_SweepPadding, 1, \
+ "The multiple of deviation from mean to use for buffering " \
+ "against volatility in inter-sweep duration") \
+ range(0, max_juint) \
+ \
+ product(uintx, CMS_SweepTimerThresholdMillis, 10, \
+ "Skip block flux-rate sampling for an epoch unless inter-sweep " \
+ "duration exceeds this threshold in milliseconds") \
+ range(0, max_uintx) \
+ \
+ product(bool, CMSClassUnloadingEnabled, true, \
+ "Whether class unloading enabled when using CMS GC") \
+ \
+ product(uintx, CMSClassUnloadingMaxInterval, 0, \
+ "When CMS class unloading is enabled, the maximum CMS cycle " \
+ "count for which classes may not be unloaded") \
+ range(0, max_uintx) \
+ \
+ product(uintx, CMSIndexedFreeListReplenish, 4, \
+ "Replenish an indexed free list with this number of chunks") \
+ range(1, max_uintx) \
+ \
+ product(bool, CMSReplenishIntermediate, true, \
+ "Replenish all intermediate free-list caches") \
+ \
+ product(bool, CMSSplitIndexedFreeListBlocks, true, \
+ "When satisfying batched demand, split blocks from the " \
+ "IndexedFreeList whose size is a multiple of requested size") \
+ \
+ product(bool, CMSLoopWarn, false, \
+ "Warn in case of excessive CMS looping") \
+ \
+ notproduct(bool, CMSMarkStackOverflowALot, false, \
+ "Simulate frequent marking stack / work queue overflow") \
+ \
+ notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
+ "An \"interval\" counter that determines how frequently " \
+ "to simulate overflow; a smaller number increases frequency") \
+ \
+ product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
+ "Maximum number of abortable preclean iterations, if > 0") \
+ range(0, max_uintx) \
+ \
+ product(intx, CMSMaxAbortablePrecleanTime, 5000, \
+ "Maximum time in abortable preclean (in milliseconds)") \
+ range(0, max_intx) \
+ \
+ product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
+ "Nominal minimum work per abortable preclean iteration") \
+ range(0, max_uintx) \
+ \
+ manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
+ "Time that we sleep between iterations when not given " \
+ "enough work per iteration") \
+ range(0, max_intx) \
+ \
+ /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \
+ product(size_t, CMSRescanMultiple, 32, \
+ "Size (in cards) of CMS parallel rescan task") \
+ range(1, SIZE_MAX / 4096) \
+ constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit) \
+ \
+ /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \
+ product(size_t, CMSConcMarkMultiple, 32, \
+ "Size (in cards) of CMS concurrent MT marking task") \
+ range(1, SIZE_MAX / 4096) \
+ constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit) \
+ \
+ product(bool, CMSAbortSemantics, false, \
+ "Whether abort-on-overflow semantics is implemented") \
+ \
+ product(bool, CMSParallelInitialMarkEnabled, true, \
+ "Use the parallel initial mark.") \
+ \
+ product(bool, CMSParallelRemarkEnabled, true, \
+ "Whether parallel remark enabled (only if ParNewGC)") \
+ \
+ product(bool, CMSParallelSurvivorRemarkEnabled, true, \
+ "Whether parallel remark of survivor space " \
+ "enabled (effective only if CMSParallelRemarkEnabled)") \
+ \
+ product(bool, CMSPLABRecordAlways, true, \
+ "Always record survivor space PLAB boundaries (effective only " \
+ "if CMSParallelSurvivorRemarkEnabled)") \
+ \
+ product(bool, CMSEdenChunksRecordAlways, true, \
+ "Always record eden chunks used for the parallel initial mark " \
+ "or remark of eden") \
+ \
+ product(bool, CMSConcurrentMTEnabled, true, \
+ "Whether multi-threaded concurrent work enabled " \
+ "(effective only if ParNewGC)") \
+ \
+ product(bool, CMSPrecleaningEnabled, true, \
+ "Whether concurrent precleaning enabled") \
+ \
+ product(uintx, CMSPrecleanIter, 3, \
+ "Maximum number of precleaning iteration passes") \
+ range(0, 9) \
+ \
+ product(uintx, CMSPrecleanDenominator, 3, \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
+ range(1, max_uintx) \
+ constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
+ \
+ product(uintx, CMSPrecleanNumerator, 2, \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
+ range(0, max_uintx-1) \
+ constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo) \
+ \
+ product(bool, CMSPrecleanRefLists1, true, \
+ "Preclean ref lists during (initial) preclean phase") \
+ \
+ product(bool, CMSPrecleanRefLists2, false, \
+ "Preclean ref lists during abortable preclean phase") \
+ \
+ product(bool, CMSPrecleanSurvivors1, false, \
+ "Preclean survivors during (initial) preclean phase") \
+ \
+ product(bool, CMSPrecleanSurvivors2, true, \
+ "Preclean survivors during abortable preclean phase") \
+ \
+ product(uintx, CMSPrecleanThreshold, 1000, \
+ "Do not iterate again if number of dirty cards is less than this")\
+ range(100, max_uintx) \
+ \
+ product(bool, CMSCleanOnEnter, true, \
+ "Clean-on-enter optimization for reducing number of dirty cards") \
+ \
+ product(uintx, CMSRemarkVerifyVariant, 1, \
+ "Choose variant (1,2) of verification following remark") \
+ range(1, 2) \
+ \
+ product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
+ "If Eden size is below this, do not try to schedule remark") \
+ range(0, max_uintx) \
+ \
+ product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
+ "The Eden occupancy percentage (0-100) at which " \
+ "to try and schedule remark pause") \
+ range(0, 100) \
+ \
+ product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
+ "Start sampling eden top at least before young gen " \
+ "occupancy reaches 1/<ratio> of the size at which " \
+ "we plan to schedule remark") \
+ range(1, max_uintx) \
+ \
+ product(uintx, CMSSamplingGrain, 16*K, \
+ "The minimum distance between eden samples for CMS (see above)") \
+ range(ObjectAlignmentInBytes, max_uintx) \
+ constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit) \
+ \
+ product(bool, CMSScavengeBeforeRemark, false, \
+ "Attempt scavenge before the CMS remark step") \
+ \
+ product(uintx, CMSWorkQueueDrainThreshold, 10, \
+ "Don't drain below this size per parallel worker/thief") \
+ range(1, max_juint) \
+ constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
+ \
+ manageable(intx, CMSWaitDuration, 2000, \
+ "Time in milliseconds that CMS thread waits for young GC") \
+ range(min_jint, max_jint) \
+ \
+ develop(uintx, CMSCheckInterval, 1000, \
+ "Interval in milliseconds that CMS thread checks if it " \
+ "should start a collection cycle") \
+ \
+ product(bool, CMSYield, true, \
+ "Yield between steps of CMS") \
+ \
+ product(size_t, CMSBitMapYieldQuantum, 10*M, \
+ "Bitmap operations should process at most this many bits " \
+ "between yields") \
+ range(1, max_uintx) \
+ constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit) \
+ \
+ product(bool, CMSPrintChunksInDump, false, \
+ "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
+ "trace level include more detailed information about the" \
+ "free chunks") \
+ \
+ product(bool, CMSPrintObjectsInDump, false, \
+ "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
+ "trace level include more detailed information about the" \
+ "allocated objects") \
+ \
+ diagnostic(bool, FLSVerifyAllHeapReferences, false, \
+ "Verify that all references across the FLS boundary " \
+ "are to valid objects") \
+ \
+ diagnostic(bool, FLSVerifyLists, false, \
+ "Do lots of (expensive) FreeListSpace verification") \
+ \
+ diagnostic(bool, FLSVerifyIndexTable, false, \
+ "Do lots of (expensive) FLS index table verification") \
+ \
+ product(uintx, CMSTriggerRatio, 80, \
+ "Percentage of MinHeapFreeRatio in CMS generation that is " \
+ "allocated before a CMS collection cycle commences") \
+ range(0, 100) \
+ \
+ product(uintx, CMSBootstrapOccupancy, 50, \
+ "Percentage CMS generation occupancy at which to " \
+ "initiate CMS collection for bootstrapping collection stats") \
+ range(0, 100) \
+ \
+ product(intx, CMSInitiatingOccupancyFraction, -1, \
+ "Percentage CMS generation occupancy to start a CMS collection " \
+ "cycle. A negative value means that CMSTriggerRatio is used") \
+ range(min_intx, 100) \
+ \
+ manageable(intx, CMSTriggerInterval, -1, \
+ "Commence a CMS collection cycle (at least) every so many " \
+ "milliseconds (0 permanently, -1 disabled)") \
+ range(-1, max_intx) \
+ \
+ product(bool, UseCMSInitiatingOccupancyOnly, false, \
+ "Only use occupancy as a criterion for starting a CMS collection")\
+ \
+ product(uintx, CMSIsTooFullPercentage, 98, \
+ "An absolute ceiling above which CMS will always consider the " \
+ "unloading of classes when class unloading is enabled") \
+ range(0, 100) \
+ \
+ develop(bool, CMSTestInFreeList, false, \
+ "Check if the coalesced range is already in the " \
+ "free lists as claimed") \
+ \
+ notproduct(bool, CMSVerifyReturnedBytes, false, \
+ "Check that all the garbage collected was returned to the " \
+ "free lists") \
+ \
+ diagnostic(bool, BindCMSThreadToCPU, false, \
+ "Bind CMS Thread to CPU if possible") \
+ \
+ diagnostic(uintx, CPUForCMSThread, 0, \
+ "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
+ range(0, max_juint) \
+ \
+ product(uintx, CMSCoordinatorYieldSleepCount, 10, \
+ "Number of times the coordinator GC thread will sleep while " \
+ "yielding before giving up and resuming GC") \
+ range(0, max_juint) \
+ \
+ product(uintx, CMSYieldSleepCount, 0, \
+ "Number of times a GC thread (minus the coordinator) " \
+ "will sleep while yielding before giving up and resuming GC") \
+ range(0, max_juint) \
+ \
+ product(bool, ParGCUseLocalOverflow, false, \
+ "Instead of a global overflow list, use local overflow stacks") \
+ \
+ product(bool, ParGCTrimOverflow, true, \
+ "Eagerly trim the local overflow lists " \
+ "(when ParGCUseLocalOverflow)") \
+ \
+ notproduct(bool, ParGCWorkQueueOverflowALot, false, \
+ "Simulate work queue overflow in ParNew") \
+ \
+ notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
+ "An `interval' counter that determines how frequently " \
+ "we simulate overflow; a smaller number increases frequency") \
+ \
+ product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
+ "The desired number of objects to claim from the overflow list") \
+ range(0, max_uintx) \
+ \
+ diagnostic(uintx, ParGCStridesPerThread, 2, \
+ "The number of strides per worker thread that we divide up the " \
+ "card table scanning work into") \
+ range(1, max_uintx) \
+ constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
+ \
+ diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
+ "The number of cards in each chunk of the parallel chunks used " \
+ "during card table scanning") \
+ range(1, max_intx) \
+ constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit)
+
+#endif // SHARE_GC_CMS_CMS_GLOBALS_HPP
--- a/src/hotspot/share/gc/g1/g1_globals.cpp Fri Apr 06 13:54:54 2018 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc/g1/g1_globals.hpp"
-
-G1_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
- MATERIALIZE_PD_DEVELOPER_FLAG, \
- MATERIALIZE_PRODUCT_FLAG, \
- MATERIALIZE_PD_PRODUCT_FLAG, \
- MATERIALIZE_DIAGNOSTIC_FLAG, \
- MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
- MATERIALIZE_EXPERIMENTAL_FLAG, \
- MATERIALIZE_NOTPRODUCT_FLAG, \
- MATERIALIZE_MANAGEABLE_FLAG, \
- MATERIALIZE_PRODUCT_RW_FLAG, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
--- a/src/hotspot/share/gc/g1/g1_globals.hpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1_globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -25,25 +25,25 @@
#ifndef SHARE_VM_GC_G1_G1_GLOBALS_HPP
#define SHARE_VM_GC_G1_G1_GLOBALS_HPP
-#include "runtime/globals.hpp"
#include <float.h> // for DBL_MAX
//
// Defines all globals flags used by the garbage-first compiler.
//
-#define G1_FLAGS(develop, \
- develop_pd, \
- product, \
- product_pd, \
- diagnostic, \
- diagnostic_pd, \
- experimental, \
- notproduct, \
- manageable, \
- product_rw, \
- range, \
- constraint, \
- writeable) \
+#define GC_G1_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
\
product(bool, G1UseAdaptiveIHOP, true, \
"Adaptively adjust the initiating heap occupancy from the " \
@@ -303,18 +303,4 @@
develop(bool, G1VerifyBitmaps, false, \
"Verifies the consistency of the marking bitmaps")
-G1_FLAGS(DECLARE_DEVELOPER_FLAG, \
- DECLARE_PD_DEVELOPER_FLAG, \
- DECLARE_PRODUCT_FLAG, \
- DECLARE_PD_PRODUCT_FLAG, \
- DECLARE_DIAGNOSTIC_FLAG, \
- DECLARE_PD_DIAGNOSTIC_FLAG, \
- DECLARE_EXPERIMENTAL_FLAG, \
- DECLARE_NOTPRODUCT_FLAG, \
- DECLARE_MANAGEABLE_FLAG, \
- DECLARE_PRODUCT_RW_FLAG, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
-
#endif // SHARE_VM_GC_G1_G1_GLOBALS_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/parallel/parallel_globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
+#define SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
+
+#define GC_PARALLEL_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ product(uintx, HeapMaximumCompactionInterval, 20, \
+ "How often should we maximally compact the heap (not allowing " \
+ "any dead space)") \
+ range(0, max_uintx) \
+ \
+ product(uintx, HeapFirstMaximumCompactionCount, 3, \
+ "The collection count for the first maximum compaction") \
+ range(0, max_uintx) \
+ \
+ product(bool, UseMaximumCompactionOnSystemGC, true, \
+ "Use maximum compaction in the Parallel Old garbage collector " \
+ "for a system GC") \
+ \
+ product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
+ "The mean used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
+ range(0, 100) \
+ \
+ product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
+ "The standard deviation used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
+ range(0, 100) \
+ \
+ develop(bool, TraceGCTaskManager, false, \
+ "Trace actions of the GC task manager") \
+ \
+ develop(bool, TraceGCTaskQueue, false, \
+ "Trace actions of the GC task queues") \
+ \
+ develop(bool, TraceParallelOldGCMarkingPhase, false, \
+ "Trace marking phase in ParallelOldGC") \
+ \
+ develop(bool, TraceParallelOldGCDensePrefix, false, \
+ "Trace dense prefix computation for ParallelOldGC") \
+ \
+ develop(uintx, GCWorkerDelayMillis, 0, \
+ "Delay in scheduling GC workers (in milliseconds)") \
+ \
+ product(bool, PSChunkLargeArrays, true, \
+ "Process large arrays in chunks")
+
+#endif // SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/serial/serial_globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
+#define SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
+
+#define GC_SERIAL_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable)
+
+#endif // SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/shared/gc_globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
+#define SHARE_GC_SHARED_GC_GLOBALS_HPP
+
+#include "gc/serial/serial_globals.hpp"
+#include "utilities/macros.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc/cms/cms_globals.hpp"
+#include "gc/g1/g1_globals.hpp"
+#include "gc/parallel/parallel_globals.hpp"
+#endif
+
+#define GC_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ \
+ ALL_GCS_ONLY(GC_CMS_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable)) \
+ \
+ ALL_GCS_ONLY(GC_G1_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable)) \
+ \
+ ALL_GCS_ONLY(GC_PARALLEL_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable)) \
+ \
+ GC_SERIAL_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ \
+ /* gc */ \
+ \
+ product(bool, UseConcMarkSweepGC, false, \
+ "Use Concurrent Mark-Sweep GC in the old generation") \
+ \
+ product(bool, UseSerialGC, false, \
+ "Use the Serial garbage collector") \
+ \
+ product(bool, UseG1GC, false, \
+ "Use the Garbage-First garbage collector") \
+ \
+ product(bool, UseParallelGC, false, \
+ "Use the Parallel Scavenge garbage collector") \
+ \
+ product(bool, UseParallelOldGC, false, \
+ "Use the Parallel Old garbage collector") \
+ \
+ product(uint, ParallelGCThreads, 0, \
+ "Number of parallel threads parallel gc will use") \
+ constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
+ \
+ diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
+ "Use semaphore synchronization for the GC Threads, " \
+ "instead of synchronization based on mutexes") \
+ \
+ product(bool, UseDynamicNumberOfGCThreads, true, \
+ "Dynamically choose the number of threads up to a maximum of " \
+ "ParallelGCThreads parallel collectors will use for garbage " \
+ "collection work") \
+ \
+ diagnostic(bool, InjectGCWorkerCreationFailure, false, \
+ "Inject thread creation failures for " \
+ "UseDynamicNumberOfGCThreads") \
+ \
+ diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
+ "Force dynamic selection of the number of " \
+ "parallel threads parallel gc will use to aid debugging") \
+ \
+ product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
+ "Size of heap (bytes) per GC thread used in calculating the " \
+ "number of GC threads") \
+ range((size_t)os::vm_page_size(), (size_t)max_uintx) \
+ \
+ product(uint, ConcGCThreads, 0, \
+ "Number of threads concurrent gc will use") \
+ constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
+ \
+ product(uint, GCTaskTimeStampEntries, 200, \
+ "Number of time stamp entries per gc worker thread") \
+ range(1, max_jint) \
+ \
+ product(bool, AlwaysTenure, false, \
+ "Always tenure objects in eden (ParallelGC only)") \
+ \
+ product(bool, NeverTenure, false, \
+ "Never tenure objects in eden, may tenure on overflow " \
+ "(ParallelGC only)") \
+ \
+ product(bool, ScavengeBeforeFullGC, true, \
+ "Scavenge youngest generation before each full GC.") \
+ \
+ product(bool, ExplicitGCInvokesConcurrent, false, \
+ "A System.gc() request invokes a concurrent collection; " \
+ "(effective only when using concurrent collectors)") \
+ \
+ product(bool, GCLockerInvokesConcurrent, false, \
+ "The exit of a JNI critical section necessitating a scavenge, " \
+ "also kicks off a background concurrent collection") \
+ \
+ product(uintx, GCLockerEdenExpansionPercent, 5, \
+ "How much the GC can expand the eden by while the GC locker " \
+ "is active (as a percentage)") \
+ range(0, 100) \
+ \
+ diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
+ "Number of times to retry allocations when " \
+ "blocked by the GC locker") \
+ range(0, max_uintx) \
+ \
+ product(uintx, ParallelGCBufferWastePct, 10, \
+ "Wasted fraction of parallel allocation buffer") \
+ range(0, 100) \
+ \
+ product(uintx, TargetPLABWastePct, 10, \
+ "Target wasted space in last buffer as percent of overall " \
+ "allocation") \
+ range(1, 100) \
+ \
+ product(uintx, PLABWeight, 75, \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying average for ResizePLAB") \
+ range(0, 100) \
+ \
+ product(bool, ResizePLAB, true, \
+ "Dynamically resize (survivor space) promotion LAB's") \
+ \
+ product(int, ParGCArrayScanChunk, 50, \
+ "Scan a subset of object array and push remainder, if array is " \
+ "bigger than this") \
+ range(1, max_jint/3) \
+ \
+ product(uintx, OldPLABWeight, 50, \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying average for resizing " \
+ "OldPLABSize") \
+ range(0, 100) \
+ \
+ product(bool, ResizeOldPLAB, true, \
+ "Dynamically resize (old gen) promotion LAB's") \
+ \
+ product(bool, AlwaysPreTouch, false, \
+ "Force all freshly committed pages to be pre-touched") \
+ \
+ product(size_t, PreTouchParallelChunkSize, 1 * G, \
+ "Per-thread chunk size for parallel memory pre-touch.") \
+ range(1, SIZE_MAX / 2) \
+ \
+ /* where does the range max value of (max_jint - 1) come from? */ \
+ product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
+ "Maximum size of marking stack") \
+ range(1, (max_jint - 1)) \
+ \
+ product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
+ "Size of marking stack") \
+ constraint(MarkStackSizeConstraintFunc,AfterErgo) \
+ \
+ develop(bool, VerifyBlockOffsetArray, false, \
+ "Do (expensive) block offset array verification") \
+ \
+ diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
+ "Maintain _unallocated_block in BlockOffsetArray " \
+ "(currently applicable only to CMS collector)") \
+ \
+ product(intx, RefDiscoveryPolicy, 0, \
+ "Select type of reference discovery policy: " \
+ "reference-based(0) or referent-based(1)") \
+ range(ReferenceProcessor::DiscoveryPolicyMin, \
+ ReferenceProcessor::DiscoveryPolicyMax) \
+ \
+ product(bool, ParallelRefProcEnabled, false, \
+ "Enable parallel reference processing whenever possible") \
+ \
+ product(bool, ParallelRefProcBalancingEnabled, true, \
+ "Enable balancing of reference processing queues") \
+ \
+ product(uintx, InitiatingHeapOccupancyPercent, 45, \
+ "The percent occupancy (IHOP) of the current old generation " \
+ "capacity above which a concurrent mark cycle will be initiated " \
+ "Its value may change over time if adaptive IHOP is enabled, " \
+ "otherwise the value remains constant. " \
+ "In the latter case a value of 0 will result as frequent as " \
+ "possible concurrent marking cycles. A value of 100 disables " \
+ "concurrent marking. " \
+ "Fragmentation waste in the old generation is not considered " \
+ "free space in this calculation. (G1 collector only)") \
+ range(0, 100) \
+ \
+ notproduct(bool, ScavengeALot, false, \
+ "Force scavenge at every Nth exit from the runtime system " \
+ "(N=ScavengeALotInterval)") \
+ \
+ develop(bool, FullGCALot, false, \
+ "Force full gc at every Nth exit from the runtime system " \
+ "(N=FullGCALotInterval)") \
+ \
+ notproduct(bool, GCALotAtAllSafepoints, false, \
+ "Enforce ScavengeALot/GCALot at all potential safepoints") \
+ \
+ notproduct(bool, PromotionFailureALot, false, \
+ "Use promotion failure handling on every youngest generation " \
+ "collection") \
+ \
+ develop(uintx, PromotionFailureALotCount, 1000, \
+ "Number of promotion failures occurring at PLAB " \
+ "refill attempts (ParNew) or promotion attempts " \
+ "(other young collectors)") \
+ \
+ develop(uintx, PromotionFailureALotInterval, 5, \
+ "Total collections between promotion failures a lot") \
+ \
+ experimental(uintx, WorkStealingSleepMillis, 1, \
+ "Sleep time when sleep is used for yields") \
+ \
+ experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
+ "Number of yields before a sleep is done during work stealing") \
+ \
+ experimental(uintx, WorkStealingHardSpins, 4096, \
+ "Number of iterations in a spin loop between checks on " \
+ "time out of hard spin") \
+ \
+ experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
+ "Ratio of hard spins to calls to yield") \
+ \
+ develop(uintx, ObjArrayMarkingStride, 2048, \
+ "Number of object array elements to push onto the marking stack " \
+ "before pushing a continuation entry") \
+ \
+ develop(bool, MetadataAllocationFailALot, false, \
+ "Fail metadata allocations at intervals controlled by " \
+ "MetadataAllocationFailALotInterval") \
+ \
+ develop(uintx, MetadataAllocationFailALotInterval, 1000, \
+ "Metadata allocation failure a lot interval") \
+ \
+ notproduct(bool, ExecuteInternalVMTests, false, \
+ "Enable execution of internal VM tests") \
+ \
+ notproduct(bool, VerboseInternalVMTests, false, \
+ "Turn on logging for internal VM tests.") \
+ \
+ product(bool, ExecutingUnitTests, false, \
+ "Whether the JVM is running unit tests or not") \
+ \
+ product_pd(bool, UseTLAB, "Use thread-local object allocation") \
+ \
+ product_pd(bool, ResizeTLAB, \
+ "Dynamically resize TLAB size for threads") \
+ \
+ product(bool, ZeroTLAB, false, \
+ "Zero out the newly created TLAB") \
+ \
+ product(bool, TLABStats, true, \
+ "Provide more detailed and expensive TLAB statistics.") \
+ \
+ product_pd(bool, NeverActAsServerClassMachine, \
+ "Never act like a server-class machine") \
+ \
+ product(bool, AlwaysActAsServerClassMachine, false, \
+ "Always act like a server-class machine") \
+ \
+ product_pd(uint64_t, MaxRAM, \
+ "Real memory size (in bytes) used to set maximum heap size") \
+ range(0, 0XFFFFFFFFFFFFFFFF) \
+ \
+ product(bool, AggressiveHeap, false, \
+ "Optimize heap options for long-running memory intensive apps") \
+ \
+ product(size_t, ErgoHeapSizeLimit, 0, \
+ "Maximum ergonomically set heap size (in bytes); zero means use " \
+ "MaxRAM * MaxRAMPercentage / 100") \
+ range(0, max_uintx) \
+ \
+ product(uintx, MaxRAMFraction, 4, \
+ "Maximum fraction (1/n) of real memory used for maximum heap " \
+ "size. " \
+ "Deprecated, use MaxRAMPercentage instead") \
+ range(1, max_uintx) \
+ \
+ product(uintx, MinRAMFraction, 2, \
+ "Minimum fraction (1/n) of real memory used for maximum heap " \
+ "size on systems with small physical memory size. " \
+ "Deprecated, use MinRAMPercentage instead") \
+ range(1, max_uintx) \
+ \
+ product(uintx, InitialRAMFraction, 64, \
+ "Fraction (1/n) of real memory used for initial heap size. " \
+ "Deprecated, use InitialRAMPercentage instead") \
+ range(1, max_uintx) \
+ \
+ product(double, MaxRAMPercentage, 25.0, \
+ "Maximum percentage of real memory used for maximum heap size") \
+ range(0.0, 100.0) \
+ \
+ product(double, MinRAMPercentage, 50.0, \
+ "Minimum percentage of real memory used for maximum heap" \
+ "size on systems with small physical memory size") \
+ range(0.0, 100.0) \
+ \
+ product(double, InitialRAMPercentage, 1.5625, \
+ "Percentage of real memory used for initial heap size") \
+ range(0.0, 100.0) \
+ \
+ product(int, ActiveProcessorCount, -1, \
+ "Specify the CPU count the VM should use and report as active") \
+ \
+ develop(uintx, MaxVirtMemFraction, 2, \
+ "Maximum fraction (1/n) of virtual memory used for ergonomically "\
+ "determining maximum heap size") \
+ \
+ product(bool, UseAdaptiveSizePolicy, true, \
+ "Use adaptive generation sizing policies") \
+ \
+ product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
+ "Use adaptive survivor sizing policies") \
+ \
+ product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
+ "Use adaptive young-old sizing policies at minor collections") \
+ \
+ product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
+ "Use adaptive young-old sizing policies at major collections") \
+ \
+ product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
+ "Include statistics from System.gc() for adaptive size policy") \
+ \
+ product(bool, UseAdaptiveGCBoundary, false, \
+ "Allow young-old boundary to move") \
+ \
+ develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
+ "Resize the virtual spaces of the young or old generations") \
+ range(-1, 1) \
+ \
+ product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
+ "Policy for changing generation size for throughput goals") \
+ range(0, 1) \
+ \
+ product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
+ "Number of steps where heuristics is used before data is used") \
+ range(0, max_uintx) \
+ \
+ develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
+ "Number of collections before the adaptive sizing is started") \
+ \
+ product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
+ "Collection interval for printing information; zero means never") \
+ range(0, max_uintx) \
+ \
+ product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
+ "Use adaptive minimum footprint as a goal") \
+ \
+ product(uintx, AdaptiveSizePolicyWeight, 10, \
+ "Weight given to exponential resizing, between 0 and 100") \
+ range(0, 100) \
+ \
+ product(uintx, AdaptiveTimeWeight, 25, \
+ "Weight given to time in adaptive policy, between 0 and 100") \
+ range(0, 100) \
+ \
+ product(uintx, PausePadding, 1, \
+ "How much buffer to keep for pause time") \
+ range(0, max_juint) \
+ \
+ product(uintx, PromotedPadding, 3, \
+ "How much buffer to keep for promotion failure") \
+ range(0, max_juint) \
+ \
+ product(uintx, SurvivorPadding, 3, \
+ "How much buffer to keep for survivor overflow") \
+ range(0, max_juint) \
+ \
+ product(uintx, ThresholdTolerance, 10, \
+ "Allowed collection cost difference between generations") \
+ range(0, 100) \
+ \
+ product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
+ "If collection costs are within margin, reduce both by full " \
+ "delta") \
+ range(0, 100) \
+ \
+ product(uintx, YoungGenerationSizeIncrement, 20, \
+ "Adaptive size percentage change in young generation") \
+ range(0, 100) \
+ \
+ product(uintx, YoungGenerationSizeSupplement, 80, \
+ "Supplement to YoungedGenerationSizeIncrement used at startup") \
+ range(0, 100) \
+ \
+ product(uintx, YoungGenerationSizeSupplementDecay, 8, \
+ "Decay factor to YoungedGenerationSizeSupplement") \
+ range(1, max_uintx) \
+ \
+ product(uintx, TenuredGenerationSizeIncrement, 20, \
+ "Adaptive size percentage change in tenured generation") \
+ range(0, 100) \
+ \
+ product(uintx, TenuredGenerationSizeSupplement, 80, \
+ "Supplement to TenuredGenerationSizeIncrement used at startup") \
+ range(0, 100) \
+ \
+ product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
+ "Decay factor to TenuredGenerationSizeIncrement") \
+ range(1, max_uintx) \
+ \
+ product(uintx, MaxGCPauseMillis, max_uintx - 1, \
+ "Adaptive size policy maximum GC pause time goal in millisecond, "\
+ "or (G1 Only) the maximum GC time per MMU time slice") \
+ range(1, max_uintx - 1) \
+ constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \
+ \
+ product(uintx, GCPauseIntervalMillis, 0, \
+ "Time slice for MMU specification") \
+ constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \
+ \
+ product(uintx, MaxGCMinorPauseMillis, max_uintx, \
+ "Adaptive size policy maximum GC minor pause time goal " \
+ "in millisecond") \
+ range(0, max_uintx) \
+ \
+ product(uintx, GCTimeRatio, 99, \
+ "Adaptive size policy application time to GC time ratio") \
+ range(0, max_juint) \
+ \
+ product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
+ "Adaptive size scale down factor for shrinking") \
+ range(1, max_uintx) \
+ \
+ product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
+ "Adaptive size decays the major cost for long major intervals") \
+ \
+ product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
+ "Time scale over which major costs decay") \
+ range(0, max_uintx) \
+ \
+ product(uintx, MinSurvivorRatio, 3, \
+ "Minimum ratio of young generation/survivor space size") \
+ range(3, max_uintx) \
+ \
+ product(uintx, InitialSurvivorRatio, 8, \
+ "Initial ratio of young generation/survivor space size") \
+ range(0, max_uintx) \
+ \
+ product(size_t, BaseFootPrintEstimate, 256*M, \
+ "Estimate of footprint other than Java Heap") \
+ range(0, max_uintx) \
+ \
+ product(bool, UseGCOverheadLimit, true, \
+ "Use policy to limit of proportion of time spent in GC " \
+ "before an OutOfMemory error is thrown") \
+ \
+ product(uintx, GCTimeLimit, 98, \
+ "Limit of the proportion of time spent in GC before " \
+ "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
+ range(0, 100) \
+ \
+ product(uintx, GCHeapFreeLimit, 2, \
+ "Minimum percentage of free space after a full GC before an " \
+ "OutOfMemoryError is thrown (used with GCTimeLimit)") \
+ range(0, 100) \
+ \
+ develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
+ "Number of consecutive collections before gc time limit fires") \
+ range(1, max_uintx) \
+ \
+ product(intx, PrefetchCopyIntervalInBytes, -1, \
+ "How far ahead to prefetch destination area (<= 0 means off)") \
+ range(-1, max_jint) \
+ \
+ product(intx, PrefetchScanIntervalInBytes, -1, \
+ "How far ahead to prefetch scan area (<= 0 means off)") \
+ range(-1, max_jint) \
+ \
+ product(intx, PrefetchFieldsAhead, -1, \
+ "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
+ range(-1, max_jint) \
+ \
+ diagnostic(bool, VerifyDuringStartup, false, \
+ "Verify memory system before executing any Java code " \
+ "during VM initialization") \
+ \
+ diagnostic(bool, VerifyBeforeExit, trueInDebug, \
+ "Verify system before exiting") \
+ \
+ diagnostic(bool, VerifyBeforeGC, false, \
+ "Verify memory system before GC") \
+ \
+ diagnostic(bool, VerifyAfterGC, false, \
+ "Verify memory system after GC") \
+ \
+ diagnostic(bool, VerifyDuringGC, false, \
+ "Verify memory system during GC (between phases)") \
+ \
+ diagnostic(ccstrlist, VerifyGCType, "", \
+ "GC type(s) to verify when Verify*GC is enabled." \
+ "Available types are collector specific.") \
+ \
+ diagnostic(ccstrlist, VerifySubSet, "", \
+ "Memory sub-systems to verify when Verify*GC flag(s) " \
+ "are enabled. One or more sub-systems can be specified " \
+ "in a comma separated string. Sub-systems are: " \
+ "threads, heap, symbol_table, string_table, codecache, " \
+ "dictionary, classloader_data_graph, metaspace, jni_handles, " \
+ "codecache_oops") \
+ \
+ diagnostic(bool, GCParallelVerificationEnabled, true, \
+ "Enable parallel memory system verification") \
+ \
+ diagnostic(bool, DeferInitialCardMark, false, \
+ "When +ReduceInitialCardMarks, explicitly defer any that " \
+ "may arise from new_pre_store_barrier") \
+ \
+ product(bool, UseCondCardMark, false, \
+ "Check for already marked card before updating card table") \
+ \
+ diagnostic(bool, VerifyRememberedSets, false, \
+ "Verify GC remembered sets") \
+ \
+ diagnostic(bool, VerifyObjectStartArray, true, \
+ "Verify GC object start array if verify before/after") \
+ \
+ product(bool, DisableExplicitGC, false, \
+ "Ignore calls to System.gc()") \
+ \
+ product(bool, BindGCTaskThreadsToCPUs, false, \
+ "Bind GCTaskThreads to CPUs if possible") \
+ \
+ product(bool, UseGCTaskAffinity, false, \
+ "Use worker affinity when asking for GCTasks") \
+ \
+ product(bool, PrintGC, false, \
+ "Print message at garbage collection. " \
+ "Deprecated, use -Xlog:gc instead.") \
+ \
+ product(bool, PrintGCDetails, false, \
+ "Print more details at garbage collection. " \
+ "Deprecated, use -Xlog:gc* instead.") \
+ \
+ develop(intx, ConcGCYieldTimeout, 0, \
+ "If non-zero, assert that GC threads yield within this " \
+ "number of milliseconds") \
+ range(0, max_intx) \
+ \
+ notproduct(intx, ScavengeALotInterval, 1, \
+ "Interval between which scavenge will occur with +ScavengeALot") \
+ \
+ notproduct(intx, FullGCALotInterval, 1, \
+ "Interval between which full gc will occur with +FullGCALot") \
+ \
+ notproduct(intx, FullGCALotStart, 0, \
+ "For which invocation to start FullGCAlot") \
+ \
+ notproduct(intx, FullGCALotDummies, 32*K, \
+ "Dummy object allocated with +FullGCALot, forcing all objects " \
+ "to move") \
+ \
+ /* gc parameters */ \
+ product(size_t, InitialHeapSize, 0, \
+ "Initial heap size (in bytes); zero means use ergonomics") \
+ constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
+ \
+ product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
+ "Maximum heap size (in bytes)") \
+ constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
+ \
+ product(size_t, OldSize, ScaleForWordSize(4*M), \
+ "Initial tenured generation size (in bytes)") \
+ range(0, max_uintx) \
+ \
+ product(size_t, NewSize, ScaleForWordSize(1*M), \
+ "Initial new generation size (in bytes)") \
+ constraint(NewSizeConstraintFunc,AfterErgo) \
+ \
+ product(size_t, MaxNewSize, max_uintx, \
+ "Maximum new generation size (in bytes), max_uintx means set " \
+ "ergonomically") \
+ range(0, max_uintx) \
+ \
+ product_pd(size_t, HeapBaseMinAddress, \
+ "OS specific low limit for heap base address") \
+ constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \
+ \
+ product(size_t, PretenureSizeThreshold, 0, \
+ "Maximum size in bytes of objects allocated in DefNew " \
+ "generation; zero means no maximum") \
+ range(0, max_uintx) \
+ \
+ product(size_t, MinTLABSize, 2*K, \
+ "Minimum allowed TLAB size (in bytes)") \
+ range(1, max_uintx/2) \
+ constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
+ \
+ product(size_t, TLABSize, 0, \
+ "Starting TLAB size (in bytes); zero means set ergonomically") \
+ constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
+ \
+ product(size_t, YoungPLABSize, 4096, \
+ "Size of young gen promotion LAB's (in HeapWords)") \
+ constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
+ \
+ product(size_t, OldPLABSize, 1024, \
+ "Size of old gen promotion LAB's (in HeapWords), or Number " \
+ "of blocks to attempt to claim when refilling CMS LAB's") \
+ constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
+ \
+ product(uintx, TLABAllocationWeight, 35, \
+ "Allocation averaging weight") \
+ range(0, 100) \
+ \
+ /* Limit the lower bound of this flag to 1 as it is used */ \
+ /* in a division expression. */ \
+ product(uintx, TLABWasteTargetPercent, 1, \
+ "Percentage of Eden that can be wasted") \
+ range(1, 100) \
+ \
+ product(uintx, TLABRefillWasteFraction, 64, \
+ "Maximum TLAB waste at a refill (internal fragmentation)") \
+ range(1, max_juint) \
+ \
+ product(uintx, TLABWasteIncrement, 4, \
+ "Increment allowed waste at slow allocation") \
+ range(0, max_jint) \
+ constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \
+ \
+ product(uintx, SurvivorRatio, 8, \
+ "Ratio of eden/survivor space size") \
+ range(1, max_uintx-2) \
+ constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
+ \
+ product(uintx, NewRatio, 2, \
+ "Ratio of old/new generation sizes") \
+ range(0, max_uintx-1) \
+ \
+ product_pd(size_t, NewSizeThreadIncrease, \
+ "Additional size added to desired new generation size per " \
+ "non-daemon thread (in bytes)") \
+ range(0, max_uintx) \
+ \
+ product(uintx, QueuedAllocationWarningCount, 0, \
+ "Number of times an allocation that queues behind a GC " \
+ "will retry before printing a warning") \
+ range(0, max_uintx) \
+ \
+ diagnostic(uintx, VerifyGCStartAt, 0, \
+ "GC invoke count where +VerifyBefore/AfterGC kicks in") \
+ range(0, max_uintx) \
+ \
+ diagnostic(intx, VerifyGCLevel, 0, \
+ "Generation level at which to start +VerifyBefore/AfterGC") \
+ range(0, 1) \
+ \
+ product(uintx, MaxTenuringThreshold, 15, \
+ "Maximum value for tenuring threshold") \
+ range(0, markOopDesc::max_age + 1) \
+ constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
+ \
+ product(uintx, InitialTenuringThreshold, 7, \
+ "Initial value for tenuring threshold") \
+ range(0, markOopDesc::max_age + 1) \
+ constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
+ \
+ product(uintx, TargetSurvivorRatio, 50, \
+ "Desired percentage of survivor space used after scavenge") \
+ range(0, 100) \
+ \
+ product(uintx, MarkSweepDeadRatio, 5, \
+ "Percentage (0-100) of the old gen allowed as dead wood. " \
+ "Serial mark sweep treats this as both the minimum and maximum " \
+ "value. " \
+ "CMS uses this value only if it falls back to mark sweep. " \
+ "Par compact uses a variable scale based on the density of the " \
+ "generation and treats this as the maximum value when the heap " \
+ "is either completely full or completely empty. Par compact " \
+ "also has a smaller default value; see arguments.cpp.") \
+ range(0, 100) \
+ \
+ product(uint, MarkSweepAlwaysCompactCount, 4, \
+ "How often should we fully compact the heap (ignoring the dead " \
+ "space parameters)") \
+ range(1, max_juint) \
+ \
+ develop(uintx, GCExpandToAllocateDelayMillis, 0, \
+ "Delay between expansion and allocation (in milliseconds)") \
+ \
+ product(uintx, GCDrainStackTargetSize, 64, \
+ "Number of entries we will try to leave on the stack " \
+ "during parallel gc") \
+ range(0, max_juint)
+
+#endif // SHARE_GC_SHARED_GC_GLOBALS_HPP
--- a/src/hotspot/share/runtime/commandLineFlagConstraintList.cpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagConstraintList.cpp Fri Apr 06 13:55:25 2018 +0200
@@ -33,9 +33,6 @@
#include "runtime/commandLineFlagConstraintsRuntime.hpp"
#include "runtime/os.hpp"
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif
#ifdef COMPILER1
#include "c1/c1_globals.hpp"
#endif
@@ -280,20 +277,20 @@
void CommandLineFlagConstraintList::init(void) {
_constraints = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagConstraint*>(INITIAL_CONSTRAINTS_SIZE, true);
- emit_constraint_no(NULL RUNTIME_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
- EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
- EMIT_CONSTRAINT_PRODUCT_FLAG,
- EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
- EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
- EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
- EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
- EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
- EMIT_CONSTRAINT_MANAGEABLE_FLAG,
- EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
- EMIT_CONSTRAINT_LP64_PRODUCT_FLAG,
- IGNORE_RANGE,
- EMIT_CONSTRAINT_CHECK,
- IGNORE_WRITEABLE));
+ emit_constraint_no(NULL VM_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
+ EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
+ EMIT_CONSTRAINT_PRODUCT_FLAG,
+ EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
+ EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
+ EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
+ EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
+ EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
+ EMIT_CONSTRAINT_MANAGEABLE_FLAG,
+ EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
+ EMIT_CONSTRAINT_LP64_PRODUCT_FLAG,
+ IGNORE_RANGE,
+ EMIT_CONSTRAINT_CHECK,
+ IGNORE_WRITEABLE));
EMIT_CONSTRAINTS_FOR_GLOBALS_EXT
@@ -333,22 +330,6 @@
EMIT_CONSTRAINT_CHECK,
IGNORE_WRITEABLE));
#endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
- emit_constraint_no(NULL G1_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
- EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
- EMIT_CONSTRAINT_PRODUCT_FLAG,
- EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
- EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
- EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
- EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
- EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
- EMIT_CONSTRAINT_MANAGEABLE_FLAG,
- EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
- IGNORE_RANGE,
- EMIT_CONSTRAINT_CHECK,
- IGNORE_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
}
CommandLineFlagConstraint* CommandLineFlagConstraintList::find(const char* name) {
--- a/src/hotspot/share/runtime/commandLineFlagRangeList.cpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagRangeList.cpp Fri Apr 06 13:55:25 2018 +0200
@@ -335,20 +335,20 @@
_ranges = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagRange*>(INITIAL_RANGES_SIZE, true);
- emit_range_no(NULL RUNTIME_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
- EMIT_RANGE_PD_DEVELOPER_FLAG,
- EMIT_RANGE_PRODUCT_FLAG,
- EMIT_RANGE_PD_PRODUCT_FLAG,
- EMIT_RANGE_DIAGNOSTIC_FLAG,
- EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
- EMIT_RANGE_EXPERIMENTAL_FLAG,
- EMIT_RANGE_NOTPRODUCT_FLAG,
- EMIT_RANGE_MANAGEABLE_FLAG,
- EMIT_RANGE_PRODUCT_RW_FLAG,
- EMIT_RANGE_LP64_PRODUCT_FLAG,
- EMIT_RANGE_CHECK,
- IGNORE_CONSTRAINT,
- IGNORE_WRITEABLE));
+ emit_range_no(NULL VM_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
+ EMIT_RANGE_PD_DEVELOPER_FLAG,
+ EMIT_RANGE_PRODUCT_FLAG,
+ EMIT_RANGE_PD_PRODUCT_FLAG,
+ EMIT_RANGE_DIAGNOSTIC_FLAG,
+ EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
+ EMIT_RANGE_EXPERIMENTAL_FLAG,
+ EMIT_RANGE_NOTPRODUCT_FLAG,
+ EMIT_RANGE_MANAGEABLE_FLAG,
+ EMIT_RANGE_PRODUCT_RW_FLAG,
+ EMIT_RANGE_LP64_PRODUCT_FLAG,
+ EMIT_RANGE_CHECK,
+ IGNORE_CONSTRAINT,
+ IGNORE_WRITEABLE));
EMIT_RANGES_FOR_GLOBALS_EXT
@@ -401,22 +401,6 @@
IGNORE_CONSTRAINT,
IGNORE_WRITEABLE));
#endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
- emit_range_no(NULL G1_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
- EMIT_RANGE_PD_DEVELOPER_FLAG,
- EMIT_RANGE_PRODUCT_FLAG,
- EMIT_RANGE_PD_PRODUCT_FLAG,
- EMIT_RANGE_DIAGNOSTIC_FLAG,
- EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
- EMIT_RANGE_EXPERIMENTAL_FLAG,
- EMIT_RANGE_NOTPRODUCT_FLAG,
- EMIT_RANGE_MANAGEABLE_FLAG,
- EMIT_RANGE_PRODUCT_RW_FLAG,
- EMIT_RANGE_CHECK,
- IGNORE_CONSTRAINT,
- IGNORE_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
}
CommandLineFlagRange* CommandLineFlagRangeList::find(const char* name) {
--- a/src/hotspot/share/runtime/commandLineFlagWriteableList.cpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagWriteableList.cpp Fri Apr 06 13:55:25 2018 +0200
@@ -23,14 +23,9 @@
*/
#include "precompiled.hpp"
+#include "gc/shared/plab.hpp"
#include "runtime/commandLineFlagWriteableList.hpp"
#include "runtime/os.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
-#include "gc/g1/g1_globals.hpp"
-#include "gc/g1/heapRegionBounds.inline.hpp"
-#include "gc/shared/plab.hpp"
-#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
#include "c1/c1_globals.hpp"
#endif // COMPILER1
@@ -122,20 +117,20 @@
_controls = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagWriteable*>(INITIAL_WRITEABLES_SIZE, true);
- emit_writeable_no(NULL RUNTIME_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
- EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
- EMIT_WRITEABLE_PRODUCT_FLAG,
- EMIT_WRITEABLE_PD_PRODUCT_FLAG,
- EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
- EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
- EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
- EMIT_WRITEABLE_NOTPRODUCT_FLAG,
- EMIT_WRITEABLE_MANAGEABLE_FLAG,
- EMIT_WRITEABLE_PRODUCT_RW_FLAG,
- EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
- IGNORE_RANGE,
- IGNORE_CONSTRAINT,
- EMIT_WRITEABLE));
+ emit_writeable_no(NULL VM_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
+ EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
+ EMIT_WRITEABLE_PRODUCT_FLAG,
+ EMIT_WRITEABLE_PD_PRODUCT_FLAG,
+ EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
+ EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
+ EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
+ EMIT_WRITEABLE_NOTPRODUCT_FLAG,
+ EMIT_WRITEABLE_MANAGEABLE_FLAG,
+ EMIT_WRITEABLE_PRODUCT_RW_FLAG,
+ EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
+ IGNORE_RANGE,
+ IGNORE_CONSTRAINT,
+ EMIT_WRITEABLE));
EMIT_WRITEABLES_FOR_GLOBALS_EXT
@@ -188,22 +183,6 @@
IGNORE_CONSTRAINT,
EMIT_WRITEABLE));
#endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
- emit_writeable_no(NULL G1_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
- EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
- EMIT_WRITEABLE_PRODUCT_FLAG,
- EMIT_WRITEABLE_PD_PRODUCT_FLAG,
- EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
- EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
- EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
- EMIT_WRITEABLE_NOTPRODUCT_FLAG,
- EMIT_WRITEABLE_MANAGEABLE_FLAG,
- EMIT_WRITEABLE_PRODUCT_RW_FLAG,
- IGNORE_RANGE,
- IGNORE_CONSTRAINT,
- EMIT_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
}
CommandLineFlagWriteable* CommandLineFlagWriteableList::find(const char* name) {
--- a/src/hotspot/share/runtime/globals.cpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals.cpp Fri Apr 06 13:55:25 2018 +0200
@@ -39,9 +39,6 @@
#include "utilities/macros.hpp"
#include "utilities/ostream.hpp"
#include "utilities/stringUtils.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
#include "c1/c1_globals.hpp"
#endif
@@ -52,20 +49,20 @@
#include "opto/c2_globals.hpp"
#endif
-RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
- MATERIALIZE_PD_DEVELOPER_FLAG, \
- MATERIALIZE_PRODUCT_FLAG, \
- MATERIALIZE_PD_PRODUCT_FLAG, \
- MATERIALIZE_DIAGNOSTIC_FLAG, \
- MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
- MATERIALIZE_EXPERIMENTAL_FLAG, \
- MATERIALIZE_NOTPRODUCT_FLAG, \
- MATERIALIZE_MANAGEABLE_FLAG, \
- MATERIALIZE_PRODUCT_RW_FLAG, \
- MATERIALIZE_LP64_PRODUCT_FLAG, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
+VM_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
+ MATERIALIZE_PD_DEVELOPER_FLAG, \
+ MATERIALIZE_PRODUCT_FLAG, \
+ MATERIALIZE_PD_PRODUCT_FLAG, \
+ MATERIALIZE_DIAGNOSTIC_FLAG, \
+ MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
+ MATERIALIZE_EXPERIMENTAL_FLAG, \
+ MATERIALIZE_NOTPRODUCT_FLAG, \
+ MATERIALIZE_MANAGEABLE_FLAG, \
+ MATERIALIZE_PRODUCT_RW_FLAG, \
+ MATERIALIZE_LP64_PRODUCT_FLAG, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT, \
+ IGNORE_WRITEABLE)
RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
MATERIALIZE_PD_DEVELOPER_FLAG, \
@@ -870,20 +867,21 @@
#define ARCH_NOTPRODUCT_FLAG_STRUCT( type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_NOT_PRODUCT) },
static Flag flagTable[] = {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
- RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
- RUNTIME_PRODUCT_FLAG_STRUCT, \
- RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
- RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
- RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
- RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
- RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
- RUNTIME_MANAGEABLE_FLAG_STRUCT, \
- RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
- RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
+ VM_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
+ RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
+ RUNTIME_PRODUCT_FLAG_STRUCT, \
+ RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
+ RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
+ RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
+ RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
+ RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
+ RUNTIME_MANAGEABLE_FLAG_STRUCT, \
+ RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
+ RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT, \
+ IGNORE_WRITEABLE)
+
RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
RUNTIME_PRODUCT_FLAG_STRUCT, \
@@ -894,21 +892,6 @@
IGNORE_RANGE, \
IGNORE_CONSTRAINT, \
IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
- RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
- RUNTIME_PRODUCT_FLAG_STRUCT, \
- RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
- RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
- RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
- RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
- RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
- RUNTIME_MANAGEABLE_FLAG_STRUCT, \
- RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
#if INCLUDE_JVMCI
JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \
JVMCI_PD_DEVELOP_FLAG_STRUCT, \
--- a/src/hotspot/share/runtime/globals.hpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -25,6 +25,7 @@
#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
#define SHARE_VM_RUNTIME_GLOBALS_HPP
+#include "gc/shared/gc_globals.hpp"
#include "utilities/align.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
@@ -1385,936 +1386,17 @@
develop(bool, TraceCompiledIC, false, \
"Trace changes of compiled IC") \
\
- /* gc */ \
- \
- product(bool, UseSerialGC, false, \
- "Use the Serial garbage collector") \
- \
- product(bool, UseG1GC, false, \
- "Use the Garbage-First garbage collector") \
- \
- product(bool, UseParallelGC, false, \
- "Use the Parallel Scavenge garbage collector") \
- \
- product(bool, UseParallelOldGC, false, \
- "Use the Parallel Old garbage collector") \
- \
- product(uintx, HeapMaximumCompactionInterval, 20, \
- "How often should we maximally compact the heap (not allowing " \
- "any dead space)") \
- range(0, max_uintx) \
- \
- product(uintx, HeapFirstMaximumCompactionCount, 3, \
- "The collection count for the first maximum compaction") \
- range(0, max_uintx) \
- \
- product(bool, UseMaximumCompactionOnSystemGC, true, \
- "Use maximum compaction in the Parallel Old garbage collector " \
- "for a system GC") \
- \
- product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
- "The mean used by the parallel compact dead wood " \
- "limiter (a number between 0-100)") \
- range(0, 100) \
- \
- product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
- "The standard deviation used by the parallel compact dead wood " \
- "limiter (a number between 0-100)") \
- range(0, 100) \
- \
- product(uint, ParallelGCThreads, 0, \
- "Number of parallel threads parallel gc will use") \
- constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
- \
- diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
- "Use semaphore synchronization for the GC Threads, " \
- "instead of synchronization based on mutexes") \
- \
- product(bool, UseDynamicNumberOfGCThreads, true, \
- "Dynamically choose the number of threads up to a maximum of " \
- "ParallelGCThreads parallel collectors will use for garbage " \
- "collection work") \
- \
- diagnostic(bool, InjectGCWorkerCreationFailure, false, \
- "Inject thread creation failures for " \
- "UseDynamicNumberOfGCThreads") \
- \
- diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
- "Force dynamic selection of the number of " \
- "parallel threads parallel gc will use to aid debugging") \
- \
- product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
- "Size of heap (bytes) per GC thread used in calculating the " \
- "number of GC threads") \
- range((size_t)os::vm_page_size(), (size_t)max_uintx) \
- \
- product(uint, ConcGCThreads, 0, \
- "Number of threads concurrent gc will use") \
- constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
- \
- product(uint, GCTaskTimeStampEntries, 200, \
- "Number of time stamp entries per gc worker thread") \
- range(1, max_jint) \
- \
- product(bool, AlwaysTenure, false, \
- "Always tenure objects in eden (ParallelGC only)") \
- \
- product(bool, NeverTenure, false, \
- "Never tenure objects in eden, may tenure on overflow " \
- "(ParallelGC only)") \
- \
- product(bool, ScavengeBeforeFullGC, true, \
- "Scavenge youngest generation before each full GC.") \
- \
- product(bool, UseConcMarkSweepGC, false, \
- "Use Concurrent Mark-Sweep GC in the old generation") \
- \
- product(bool, ExplicitGCInvokesConcurrent, false, \
- "A System.gc() request invokes a concurrent collection; " \
- "(effective only when using concurrent collectors)") \
- \
- product(bool, GCLockerInvokesConcurrent, false, \
- "The exit of a JNI critical section necessitating a scavenge, " \
- "also kicks off a background concurrent collection") \
- \
- product(uintx, GCLockerEdenExpansionPercent, 5, \
- "How much the GC can expand the eden by while the GC locker " \
- "is active (as a percentage)") \
- range(0, 100) \
- \
- diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
- "Number of times to retry allocations when " \
- "blocked by the GC locker") \
- range(0, max_uintx) \
- \
- product(bool, UseCMSBestFit, true, \
- "Use CMS best fit allocation strategy") \
- \
- product(uintx, ParallelGCBufferWastePct, 10, \
- "Wasted fraction of parallel allocation buffer") \
- range(0, 100) \
- \
- product(uintx, TargetPLABWastePct, 10, \
- "Target wasted space in last buffer as percent of overall " \
- "allocation") \
- range(1, 100) \
- \
- product(uintx, PLABWeight, 75, \
- "Percentage (0-100) used to weight the current sample when " \
- "computing exponentially decaying average for ResizePLAB") \
- range(0, 100) \
- \
- product(bool, ResizePLAB, true, \
- "Dynamically resize (survivor space) promotion LAB's") \
- \
- product(int, ParGCArrayScanChunk, 50, \
- "Scan a subset of object array and push remainder, if array is " \
- "bigger than this") \
- range(1, max_jint/3) \
- \
- product(bool, ParGCUseLocalOverflow, false, \
- "Instead of a global overflow list, use local overflow stacks") \
- \
- product(bool, ParGCTrimOverflow, true, \
- "Eagerly trim the local overflow lists " \
- "(when ParGCUseLocalOverflow)") \
- \
- notproduct(bool, ParGCWorkQueueOverflowALot, false, \
- "Simulate work queue overflow in ParNew") \
- \
- notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
- "An `interval' counter that determines how frequently " \
- "we simulate overflow; a smaller number increases frequency") \
- \
- product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
- "The desired number of objects to claim from the overflow list") \
- range(0, max_uintx) \
- \
- diagnostic(uintx, ParGCStridesPerThread, 2, \
- "The number of strides per worker thread that we divide up the " \
- "card table scanning work into") \
- range(1, max_uintx) \
- constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
- \
- diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
- "The number of cards in each chunk of the parallel chunks used " \
- "during card table scanning") \
- range(1, max_intx) \
- constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit)\
- \
- product(uintx, OldPLABWeight, 50, \
- "Percentage (0-100) used to weight the current sample when " \
- "computing exponentially decaying average for resizing " \
- "OldPLABSize") \
- range(0, 100) \
- \
- product(bool, ResizeOldPLAB, true, \
- "Dynamically resize (old gen) promotion LAB's") \
- \
- product(size_t, CMSOldPLABMax, 1024, \
- "Maximum size of CMS gen promotion LAB caches per worker " \
- "per block size") \
- range(1, max_uintx) \
- constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
- \
- product(size_t, CMSOldPLABMin, 16, \
- "Minimum size of CMS gen promotion LAB caches per worker " \
- "per block size") \
- range(1, max_uintx) \
- constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
- \
- product(uintx, CMSOldPLABNumRefills, 4, \
- "Nominal number of refills of CMS gen promotion LAB cache " \
- "per worker per block size") \
- range(1, max_uintx) \
- \
- product(bool, CMSOldPLABResizeQuicker, false, \
- "React on-the-fly during a scavenge to a sudden " \
- "change in block demand rate") \
- \
- product(uintx, CMSOldPLABToleranceFactor, 4, \
- "The tolerance of the phase-change detector for on-the-fly " \
- "PLAB resizing during a scavenge") \
- range(1, max_uintx) \
- \
- product(uintx, CMSOldPLABReactivityFactor, 2, \
- "The gain in the feedback loop for on-the-fly PLAB resizing " \
- "during a scavenge") \
- range(1, max_uintx) \
- \
- product(bool, AlwaysPreTouch, false, \
- "Force all freshly committed pages to be pre-touched") \
- \
- product(size_t, PreTouchParallelChunkSize, 1 * G, \
- "Per-thread chunk size for parallel memory pre-touch.") \
- range(1, SIZE_MAX / 2) \
- \
- product_pd(size_t, CMSYoungGenPerWorker, \
- "The maximum size of young gen chosen by default per GC worker " \
- "thread available") \
- range(1, max_uintx) \
- \
- product(uintx, CMSIncrementalSafetyFactor, 10, \
- "Percentage (0-100) used to add conservatism when computing the " \
- "duty cycle") \
- range(0, 100) \
- \
- product(uintx, CMSExpAvgFactor, 50, \
- "Percentage (0-100) used to weight the current sample when " \
- "computing exponential averages for CMS statistics") \
- range(0, 100) \
- \
- product(uintx, CMS_FLSWeight, 75, \
- "Percentage (0-100) used to weight the current sample when " \
- "computing exponentially decaying averages for CMS FLS " \
- "statistics") \
- range(0, 100) \
- \
- product(uintx, CMS_FLSPadding, 1, \
- "The multiple of deviation from mean to use for buffering " \
- "against volatility in free list demand") \
- range(0, max_juint) \
- \
- product(uintx, FLSCoalescePolicy, 2, \
- "CMS: aggressiveness level for coalescing, increasing " \
- "from 0 to 4") \
- range(0, 4) \
- \
- product(bool, FLSAlwaysCoalesceLarge, false, \
- "CMS: larger free blocks are always available for coalescing") \
- \
- product(double, FLSLargestBlockCoalesceProximity, 0.99, \
- "CMS: the smaller the percentage the greater the coalescing " \
- "force") \
- range(0.0, 1.0) \
- \
- product(double, CMSSmallCoalSurplusPercent, 1.05, \
- "CMS: the factor by which to inflate estimated demand of small " \
- "block sizes to prevent coalescing with an adjoining block") \
- range(0.0, DBL_MAX) \
- \
- product(double, CMSLargeCoalSurplusPercent, 0.95, \
- "CMS: the factor by which to inflate estimated demand of large " \
- "block sizes to prevent coalescing with an adjoining block") \
- range(0.0, DBL_MAX) \
- \
- product(double, CMSSmallSplitSurplusPercent, 1.10, \
- "CMS: the factor by which to inflate estimated demand of small " \
- "block sizes to prevent splitting to supply demand for smaller " \
- "blocks") \
- range(0.0, DBL_MAX) \
- \
- product(double, CMSLargeSplitSurplusPercent, 1.00, \
- "CMS: the factor by which to inflate estimated demand of large " \
- "block sizes to prevent splitting to supply demand for smaller " \
- "blocks") \
- range(0.0, DBL_MAX) \
- \
- product(bool, CMSExtrapolateSweep, false, \
- "CMS: cushion for block demand during sweep") \
- \
- product(uintx, CMS_SweepWeight, 75, \
- "Percentage (0-100) used to weight the current sample when " \
- "computing exponentially decaying average for inter-sweep " \
- "duration") \
- range(0, 100) \
- \
- product(uintx, CMS_SweepPadding, 1, \
- "The multiple of deviation from mean to use for buffering " \
- "against volatility in inter-sweep duration") \
- range(0, max_juint) \
- \
- product(uintx, CMS_SweepTimerThresholdMillis, 10, \
- "Skip block flux-rate sampling for an epoch unless inter-sweep " \
- "duration exceeds this threshold in milliseconds") \
- range(0, max_uintx) \
- \
- product(bool, CMSClassUnloadingEnabled, true, \
- "Whether class unloading enabled when using CMS GC") \
- \
- product(uintx, CMSClassUnloadingMaxInterval, 0, \
- "When CMS class unloading is enabled, the maximum CMS cycle " \
- "count for which classes may not be unloaded") \
- range(0, max_uintx) \
- \
- product(uintx, CMSIndexedFreeListReplenish, 4, \
- "Replenish an indexed free list with this number of chunks") \
- range(1, max_uintx) \
- \
- product(bool, CMSReplenishIntermediate, true, \
- "Replenish all intermediate free-list caches") \
- \
- product(bool, CMSSplitIndexedFreeListBlocks, true, \
- "When satisfying batched demand, split blocks from the " \
- "IndexedFreeList whose size is a multiple of requested size") \
- \
- product(bool, CMSLoopWarn, false, \
- "Warn in case of excessive CMS looping") \
- \
- /* where does the range max value of (max_jint - 1) come from? */ \
- product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
- "Maximum size of marking stack") \
- range(1, (max_jint - 1)) \
- \
- product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
- "Size of marking stack") \
- constraint(MarkStackSizeConstraintFunc,AfterErgo) \
- \
- notproduct(bool, CMSMarkStackOverflowALot, false, \
- "Simulate frequent marking stack / work queue overflow") \
- \
- notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
- "An \"interval\" counter that determines how frequently " \
- "to simulate overflow; a smaller number increases frequency") \
- \
- product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
- "Maximum number of abortable preclean iterations, if > 0") \
- range(0, max_uintx) \
- \
- product(intx, CMSMaxAbortablePrecleanTime, 5000, \
- "Maximum time in abortable preclean (in milliseconds)") \
- range(0, max_intx) \
- \
- product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
- "Nominal minimum work per abortable preclean iteration") \
- range(0, max_uintx) \
- \
- manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
- "Time that we sleep between iterations when not given " \
- "enough work per iteration") \
- range(0, max_intx) \
- \
- /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \
- product(size_t, CMSRescanMultiple, 32, \
- "Size (in cards) of CMS parallel rescan task") \
- range(1, SIZE_MAX / 4096) \
- constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit) \
- \
- /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \
- product(size_t, CMSConcMarkMultiple, 32, \
- "Size (in cards) of CMS concurrent MT marking task") \
- range(1, SIZE_MAX / 4096) \
- constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit) \
- \
- product(bool, CMSAbortSemantics, false, \
- "Whether abort-on-overflow semantics is implemented") \
- \
- product(bool, CMSParallelInitialMarkEnabled, true, \
- "Use the parallel initial mark.") \
- \
- product(bool, CMSParallelRemarkEnabled, true, \
- "Whether parallel remark enabled (only if ParNewGC)") \
- \
- product(bool, CMSParallelSurvivorRemarkEnabled, true, \
- "Whether parallel remark of survivor space " \
- "enabled (effective only if CMSParallelRemarkEnabled)") \
- \
- product(bool, CMSPLABRecordAlways, true, \
- "Always record survivor space PLAB boundaries (effective only " \
- "if CMSParallelSurvivorRemarkEnabled)") \
- \
- product(bool, CMSEdenChunksRecordAlways, true, \
- "Always record eden chunks used for the parallel initial mark " \
- "or remark of eden") \
- \
- product(bool, CMSConcurrentMTEnabled, true, \
- "Whether multi-threaded concurrent work enabled " \
- "(effective only if ParNewGC)") \
- \
- product(bool, CMSPrecleaningEnabled, true, \
- "Whether concurrent precleaning enabled") \
- \
- product(uintx, CMSPrecleanIter, 3, \
- "Maximum number of precleaning iteration passes") \
- range(0, 9) \
- \
- product(uintx, CMSPrecleanDenominator, 3, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
- "ratio") \
- range(1, max_uintx) \
- constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
- \
- product(uintx, CMSPrecleanNumerator, 2, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
- "ratio") \
- range(0, max_uintx-1) \
- constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo) \
- \
- product(bool, CMSPrecleanRefLists1, true, \
- "Preclean ref lists during (initial) preclean phase") \
- \
- product(bool, CMSPrecleanRefLists2, false, \
- "Preclean ref lists during abortable preclean phase") \
- \
- product(bool, CMSPrecleanSurvivors1, false, \
- "Preclean survivors during (initial) preclean phase") \
- \
- product(bool, CMSPrecleanSurvivors2, true, \
- "Preclean survivors during abortable preclean phase") \
- \
- product(uintx, CMSPrecleanThreshold, 1000, \
- "Do not iterate again if number of dirty cards is less than this")\
- range(100, max_uintx) \
- \
- product(bool, CMSCleanOnEnter, true, \
- "Clean-on-enter optimization for reducing number of dirty cards") \
- \
- product(uintx, CMSRemarkVerifyVariant, 1, \
- "Choose variant (1,2) of verification following remark") \
- range(1, 2) \
- \
- product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
- "If Eden size is below this, do not try to schedule remark") \
- range(0, max_uintx) \
- \
- product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
- "The Eden occupancy percentage (0-100) at which " \
- "to try and schedule remark pause") \
- range(0, 100) \
- \
- product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
- "Start sampling eden top at least before young gen " \
- "occupancy reaches 1/<ratio> of the size at which " \
- "we plan to schedule remark") \
- range(1, max_uintx) \
- \
- product(uintx, CMSSamplingGrain, 16*K, \
- "The minimum distance between eden samples for CMS (see above)") \
- range(ObjectAlignmentInBytes, max_uintx) \
- constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit) \
- \
- product(bool, CMSScavengeBeforeRemark, false, \
- "Attempt scavenge before the CMS remark step") \
- \
- product(uintx, CMSWorkQueueDrainThreshold, 10, \
- "Don't drain below this size per parallel worker/thief") \
- range(1, max_juint) \
- constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
- \
- manageable(intx, CMSWaitDuration, 2000, \
- "Time in milliseconds that CMS thread waits for young GC") \
- range(min_jint, max_jint) \
- \
- develop(uintx, CMSCheckInterval, 1000, \
- "Interval in milliseconds that CMS thread checks if it " \
- "should start a collection cycle") \
- \
- product(bool, CMSYield, true, \
- "Yield between steps of CMS") \
- \
- product(size_t, CMSBitMapYieldQuantum, 10*M, \
- "Bitmap operations should process at most this many bits " \
- "between yields") \
- range(1, max_uintx) \
- constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit) \
- \
- product(bool, CMSPrintChunksInDump, false, \
- "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
- "trace level include more detailed information about the" \
- "free chunks") \
- \
- product(bool, CMSPrintObjectsInDump, false, \
- "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
- "trace level include more detailed information about the" \
- "allocated objects") \
- \
- diagnostic(bool, FLSVerifyAllHeapReferences, false, \
- "Verify that all references across the FLS boundary " \
- "are to valid objects") \
- \
- diagnostic(bool, FLSVerifyLists, false, \
- "Do lots of (expensive) FreeListSpace verification") \
- \
- diagnostic(bool, FLSVerifyIndexTable, false, \
- "Do lots of (expensive) FLS index table verification") \
- \
develop(bool, FLSVerifyDictionary, false, \
"Do lots of (expensive) FLS dictionary verification") \
\
- develop(bool, VerifyBlockOffsetArray, false, \
- "Do (expensive) block offset array verification") \
- \
- diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
- "Maintain _unallocated_block in BlockOffsetArray " \
- "(currently applicable only to CMS collector)") \
- \
- product(intx, RefDiscoveryPolicy, 0, \
- "Select type of reference discovery policy: " \
- "reference-based(0) or referent-based(1)") \
- range(ReferenceProcessor::DiscoveryPolicyMin, \
- ReferenceProcessor::DiscoveryPolicyMax) \
- \
- product(bool, ParallelRefProcEnabled, false, \
- "Enable parallel reference processing whenever possible") \
- \
- product(bool, ParallelRefProcBalancingEnabled, true, \
- "Enable balancing of reference processing queues") \
- \
- product(uintx, CMSTriggerRatio, 80, \
- "Percentage of MinHeapFreeRatio in CMS generation that is " \
- "allocated before a CMS collection cycle commences") \
- range(0, 100) \
- \
- product(uintx, CMSBootstrapOccupancy, 50, \
- "Percentage CMS generation occupancy at which to " \
- "initiate CMS collection for bootstrapping collection stats") \
- range(0, 100) \
- \
- product(intx, CMSInitiatingOccupancyFraction, -1, \
- "Percentage CMS generation occupancy to start a CMS collection " \
- "cycle. A negative value means that CMSTriggerRatio is used") \
- range(min_intx, 100) \
- \
- product(uintx, InitiatingHeapOccupancyPercent, 45, \
- "The percent occupancy (IHOP) of the current old generation " \
- "capacity above which a concurrent mark cycle will be initiated " \
- "Its value may change over time if adaptive IHOP is enabled, " \
- "otherwise the value remains constant. " \
- "In the latter case a value of 0 will result as frequent as " \
- "possible concurrent marking cycles. A value of 100 disables " \
- "concurrent marking. " \
- "Fragmentation waste in the old generation is not considered " \
- "free space in this calculation. (G1 collector only)") \
- range(0, 100) \
- \
- manageable(intx, CMSTriggerInterval, -1, \
- "Commence a CMS collection cycle (at least) every so many " \
- "milliseconds (0 permanently, -1 disabled)") \
- range(-1, max_intx) \
- \
- product(bool, UseCMSInitiatingOccupancyOnly, false, \
- "Only use occupancy as a criterion for starting a CMS collection")\
- \
- product(uintx, CMSIsTooFullPercentage, 98, \
- "An absolute ceiling above which CMS will always consider the " \
- "unloading of classes when class unloading is enabled") \
- range(0, 100) \
- \
- develop(bool, CMSTestInFreeList, false, \
- "Check if the coalesced range is already in the " \
- "free lists as claimed") \
- \
- notproduct(bool, CMSVerifyReturnedBytes, false, \
- "Check that all the garbage collected was returned to the " \
- "free lists") \
- \
- notproduct(bool, ScavengeALot, false, \
- "Force scavenge at every Nth exit from the runtime system " \
- "(N=ScavengeALotInterval)") \
- \
- develop(bool, FullGCALot, false, \
- "Force full gc at every Nth exit from the runtime system " \
- "(N=FullGCALotInterval)") \
- \
- notproduct(bool, GCALotAtAllSafepoints, false, \
- "Enforce ScavengeALot/GCALot at all potential safepoints") \
- \
- notproduct(bool, PromotionFailureALot, false, \
- "Use promotion failure handling on every youngest generation " \
- "collection") \
- \
- develop(uintx, PromotionFailureALotCount, 1000, \
- "Number of promotion failures occurring at PLAB " \
- "refill attempts (ParNew) or promotion attempts " \
- "(other young collectors)") \
- \
- develop(uintx, PromotionFailureALotInterval, 5, \
- "Total collections between promotion failures a lot") \
- \
- experimental(uintx, WorkStealingSleepMillis, 1, \
- "Sleep time when sleep is used for yields") \
- \
- experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
- "Number of yields before a sleep is done during work stealing") \
- \
- experimental(uintx, WorkStealingHardSpins, 4096, \
- "Number of iterations in a spin loop between checks on " \
- "time out of hard spin") \
- \
- experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
- "Ratio of hard spins to calls to yield") \
- \
- develop(uintx, ObjArrayMarkingStride, 2048, \
- "Number of object array elements to push onto the marking stack " \
- "before pushing a continuation entry") \
- \
- develop(bool, MetadataAllocationFailALot, false, \
- "Fail metadata allocations at intervals controlled by " \
- "MetadataAllocationFailALotInterval") \
- \
- develop(uintx, MetadataAllocationFailALotInterval, 1000, \
- "Metadata allocation failure a lot interval") \
- \
- notproduct(bool, ExecuteInternalVMTests, false, \
- "Enable execution of internal VM tests") \
- \
- notproduct(bool, VerboseInternalVMTests, false, \
- "Turn on logging for internal VM tests.") \
- \
- product(bool, ExecutingUnitTests, false, \
- "Whether the JVM is running unit tests or not") \
- \
- product_pd(bool, UseTLAB, "Use thread-local object allocation") \
- \
- product_pd(bool, ResizeTLAB, \
- "Dynamically resize TLAB size for threads") \
- \
- product(bool, ZeroTLAB, false, \
- "Zero out the newly created TLAB") \
- \
- product(bool, TLABStats, true, \
- "Provide more detailed and expensive TLAB statistics.") \
- \
- product_pd(bool, NeverActAsServerClassMachine, \
- "Never act like a server-class machine") \
- \
- product(bool, AlwaysActAsServerClassMachine, false, \
- "Always act like a server-class machine") \
- \
- product_pd(uint64_t, MaxRAM, \
- "Real memory size (in bytes) used to set maximum heap size") \
- range(0, 0XFFFFFFFFFFFFFFFF) \
- \
- product(bool, AggressiveHeap, false, \
- "Optimize heap options for long-running memory intensive apps") \
- \
- product(size_t, ErgoHeapSizeLimit, 0, \
- "Maximum ergonomically set heap size (in bytes); zero means use " \
- "MaxRAM * MaxRAMPercentage / 100") \
- range(0, max_uintx) \
- \
- product(uintx, MaxRAMFraction, 4, \
- "Maximum fraction (1/n) of real memory used for maximum heap " \
- "size. " \
- "Deprecated, use MaxRAMPercentage instead") \
- range(1, max_uintx) \
- \
- product(uintx, MinRAMFraction, 2, \
- "Minimum fraction (1/n) of real memory used for maximum heap " \
- "size on systems with small physical memory size. " \
- "Deprecated, use MinRAMPercentage instead") \
- range(1, max_uintx) \
- \
- product(uintx, InitialRAMFraction, 64, \
- "Fraction (1/n) of real memory used for initial heap size. " \
- "Deprecated, use InitialRAMPercentage instead") \
- range(1, max_uintx) \
- \
- product(double, MaxRAMPercentage, 25.0, \
- "Maximum percentage of real memory used for maximum heap size") \
- range(0.0, 100.0) \
- \
- product(double, MinRAMPercentage, 50.0, \
- "Minimum percentage of real memory used for maximum heap" \
- "size on systems with small physical memory size") \
- range(0.0, 100.0) \
- \
- product(double, InitialRAMPercentage, 1.5625, \
- "Percentage of real memory used for initial heap size") \
- range(0.0, 100.0) \
- \
- product(int, ActiveProcessorCount, -1, \
- "Specify the CPU count the VM should use and report as active") \
- \
- develop(uintx, MaxVirtMemFraction, 2, \
- "Maximum fraction (1/n) of virtual memory used for ergonomically "\
- "determining maximum heap size") \
- \
- product(bool, UseAdaptiveSizePolicy, true, \
- "Use adaptive generation sizing policies") \
- \
- product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
- "Use adaptive survivor sizing policies") \
- \
- product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
- "Use adaptive young-old sizing policies at minor collections") \
- \
- product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
- "Use adaptive young-old sizing policies at major collections") \
- \
- product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
- "Include statistics from System.gc() for adaptive size policy") \
- \
- product(bool, UseAdaptiveGCBoundary, false, \
- "Allow young-old boundary to move") \
- \
- develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
- "Resize the virtual spaces of the young or old generations") \
- range(-1, 1) \
- \
- product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
- "Policy for changing generation size for throughput goals") \
- range(0, 1) \
- \
- product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
- "Number of steps where heuristics is used before data is used") \
- range(0, max_uintx) \
- \
- develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
- "Number of collections before the adaptive sizing is started") \
- \
- product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
- "Collection interval for printing information; zero means never") \
- range(0, max_uintx) \
- \
- product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
- "Use adaptive minimum footprint as a goal") \
- \
- product(uintx, AdaptiveSizePolicyWeight, 10, \
- "Weight given to exponential resizing, between 0 and 100") \
- range(0, 100) \
- \
- product(uintx, AdaptiveTimeWeight, 25, \
- "Weight given to time in adaptive policy, between 0 and 100") \
- range(0, 100) \
- \
- product(uintx, PausePadding, 1, \
- "How much buffer to keep for pause time") \
- range(0, max_juint) \
- \
- product(uintx, PromotedPadding, 3, \
- "How much buffer to keep for promotion failure") \
- range(0, max_juint) \
- \
- product(uintx, SurvivorPadding, 3, \
- "How much buffer to keep for survivor overflow") \
- range(0, max_juint) \
- \
- product(uintx, ThresholdTolerance, 10, \
- "Allowed collection cost difference between generations") \
- range(0, 100) \
- \
- product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
- "If collection costs are within margin, reduce both by full " \
- "delta") \
- range(0, 100) \
- \
- product(uintx, YoungGenerationSizeIncrement, 20, \
- "Adaptive size percentage change in young generation") \
- range(0, 100) \
- \
- product(uintx, YoungGenerationSizeSupplement, 80, \
- "Supplement to YoungedGenerationSizeIncrement used at startup") \
- range(0, 100) \
- \
- product(uintx, YoungGenerationSizeSupplementDecay, 8, \
- "Decay factor to YoungedGenerationSizeSupplement") \
- range(1, max_uintx) \
- \
- product(uintx, TenuredGenerationSizeIncrement, 20, \
- "Adaptive size percentage change in tenured generation") \
- range(0, 100) \
- \
- product(uintx, TenuredGenerationSizeSupplement, 80, \
- "Supplement to TenuredGenerationSizeIncrement used at startup") \
- range(0, 100) \
- \
- product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
- "Decay factor to TenuredGenerationSizeIncrement") \
- range(1, max_uintx) \
- \
- product(uintx, MaxGCPauseMillis, max_uintx - 1, \
- "Adaptive size policy maximum GC pause time goal in millisecond, "\
- "or (G1 Only) the maximum GC time per MMU time slice") \
- range(1, max_uintx - 1) \
- constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \
- \
- product(uintx, GCPauseIntervalMillis, 0, \
- "Time slice for MMU specification") \
- constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \
- \
- product(uintx, MaxGCMinorPauseMillis, max_uintx, \
- "Adaptive size policy maximum GC minor pause time goal " \
- "in millisecond") \
- range(0, max_uintx) \
- \
- product(uintx, GCTimeRatio, 99, \
- "Adaptive size policy application time to GC time ratio") \
- range(0, max_juint) \
- \
- product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
- "Adaptive size scale down factor for shrinking") \
- range(1, max_uintx) \
- \
- product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
- "Adaptive size decays the major cost for long major intervals") \
- \
- product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
- "Time scale over which major costs decay") \
- range(0, max_uintx) \
- \
- product(uintx, MinSurvivorRatio, 3, \
- "Minimum ratio of young generation/survivor space size") \
- range(3, max_uintx) \
- \
- product(uintx, InitialSurvivorRatio, 8, \
- "Initial ratio of young generation/survivor space size") \
- range(0, max_uintx) \
- \
- product(size_t, BaseFootPrintEstimate, 256*M, \
- "Estimate of footprint other than Java Heap") \
- range(0, max_uintx) \
- \
- product(bool, UseGCOverheadLimit, true, \
- "Use policy to limit of proportion of time spent in GC " \
- "before an OutOfMemory error is thrown") \
- \
- product(uintx, GCTimeLimit, 98, \
- "Limit of the proportion of time spent in GC before " \
- "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
- range(0, 100) \
- \
- product(uintx, GCHeapFreeLimit, 2, \
- "Minimum percentage of free space after a full GC before an " \
- "OutOfMemoryError is thrown (used with GCTimeLimit)") \
- range(0, 100) \
- \
- develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
- "Number of consecutive collections before gc time limit fires") \
- range(1, max_uintx) \
- \
- product(intx, PrefetchCopyIntervalInBytes, -1, \
- "How far ahead to prefetch destination area (<= 0 means off)") \
- range(-1, max_jint) \
- \
- product(intx, PrefetchScanIntervalInBytes, -1, \
- "How far ahead to prefetch scan area (<= 0 means off)") \
- range(-1, max_jint) \
- \
- product(intx, PrefetchFieldsAhead, -1, \
- "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
- range(-1, max_jint) \
- \
- diagnostic(bool, VerifyDuringStartup, false, \
- "Verify memory system before executing any Java code " \
- "during VM initialization") \
- \
- diagnostic(bool, VerifyBeforeExit, trueInDebug, \
- "Verify system before exiting") \
- \
- diagnostic(bool, VerifyBeforeGC, false, \
- "Verify memory system before GC") \
- \
- diagnostic(bool, VerifyAfterGC, false, \
- "Verify memory system after GC") \
- \
- diagnostic(bool, VerifyDuringGC, false, \
- "Verify memory system during GC (between phases)") \
- \
- diagnostic(ccstrlist, VerifyGCType, "", \
- "GC type(s) to verify when Verify*GC is enabled." \
- "Available types are collector specific.") \
- \
- diagnostic(ccstrlist, VerifySubSet, "", \
- "Memory sub-systems to verify when Verify*GC flag(s) " \
- "are enabled. One or more sub-systems can be specified " \
- "in a comma separated string. Sub-systems are: " \
- "threads, heap, symbol_table, string_table, codecache, " \
- "dictionary, classloader_data_graph, metaspace, jni_handles, " \
- "codecache_oops") \
- \
- diagnostic(bool, GCParallelVerificationEnabled, true, \
- "Enable parallel memory system verification") \
- \
- diagnostic(bool, DeferInitialCardMark, false, \
- "When +ReduceInitialCardMarks, explicitly defer any that " \
- "may arise from new_pre_store_barrier") \
- \
- product(bool, UseCondCardMark, false, \
- "Check for already marked card before updating card table") \
- \
- diagnostic(bool, VerifyRememberedSets, false, \
- "Verify GC remembered sets") \
- \
- diagnostic(bool, VerifyObjectStartArray, true, \
- "Verify GC object start array if verify before/after") \
- \
- product(bool, DisableExplicitGC, false, \
- "Ignore calls to System.gc()") \
\
notproduct(bool, CheckMemoryInitialization, false, \
"Check memory initialization") \
\
- diagnostic(bool, BindCMSThreadToCPU, false, \
- "Bind CMS Thread to CPU if possible") \
- \
- diagnostic(uintx, CPUForCMSThread, 0, \
- "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
- range(0, max_juint) \
- \
- product(bool, BindGCTaskThreadsToCPUs, false, \
- "Bind GCTaskThreads to CPUs if possible") \
- \
- product(bool, UseGCTaskAffinity, false, \
- "Use worker affinity when asking for GCTasks") \
- \
product(uintx, ProcessDistributionStride, 4, \
"Stride through processors when distributing processes") \
range(0, max_juint) \
\
- product(uintx, CMSCoordinatorYieldSleepCount, 10, \
- "Number of times the coordinator GC thread will sleep while " \
- "yielding before giving up and resuming GC") \
- range(0, max_juint) \
- \
- product(uintx, CMSYieldSleepCount, 0, \
- "Number of times a GC thread (minus the coordinator) " \
- "will sleep while yielding before giving up and resuming GC") \
- range(0, max_juint) \
- \
- product(bool, PrintGC, false, \
- "Print message at garbage collection. " \
- "Deprecated, use -Xlog:gc instead.") \
- \
- product(bool, PrintGCDetails, false, \
- "Print more details at garbage collection. " \
- "Deprecated, use -Xlog:gc* instead.") \
- \
- develop(intx, ConcGCYieldTimeout, 0, \
- "If non-zero, assert that GC threads yield within this " \
- "number of milliseconds") \
- range(0, max_intx) \
- \
develop(bool, TraceFinalizerRegistration, false, \
"Trace registration of final references") \
\
@@ -2336,18 +1418,6 @@
manageable(bool, PrintClassHistogram, false, \
"Print a histogram of class instances") \
\
- develop(bool, TraceGCTaskManager, false, \
- "Trace actions of the GC task manager") \
- \
- develop(bool, TraceGCTaskQueue, false, \
- "Trace actions of the GC task queues") \
- \
- develop(bool, TraceParallelOldGCMarkingPhase, false, \
- "Trace marking phase in ParallelOldGC") \
- \
- develop(bool, TraceParallelOldGCDensePrefix, false, \
- "Trace dense prefix computation for ParallelOldGC") \
- \
develop(bool, IgnoreLibthreadGPFault, false, \
"Suppress workaround for libthread GP fault") \
\
@@ -2982,19 +2052,6 @@
"(+ProfileIntervals)") \
range(0, max_intx) \
\
- notproduct(intx, ScavengeALotInterval, 1, \
- "Interval between which scavenge will occur with +ScavengeALot") \
- \
- notproduct(intx, FullGCALotInterval, 1, \
- "Interval between which full gc will occur with +FullGCALot") \
- \
- notproduct(intx, FullGCALotStart, 0, \
- "For which invocation to start FullGCAlot") \
- \
- notproduct(intx, FullGCALotDummies, 32*K, \
- "Dummy object allocated with +FullGCALot, forcing all objects " \
- "to move") \
- \
develop(intx, DontYieldALotInterval, 10, \
"Interval between which yields will be dropped (milliseconds)") \
\
@@ -3064,88 +2121,6 @@
"Size in K to allocate for the Profile Nodes of each thread") \
range(0, 1024) \
\
- /* gc parameters */ \
- product(size_t, InitialHeapSize, 0, \
- "Initial heap size (in bytes); zero means use ergonomics") \
- constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
- \
- product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
- "Maximum heap size (in bytes)") \
- constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
- \
- product(size_t, OldSize, ScaleForWordSize(4*M), \
- "Initial tenured generation size (in bytes)") \
- range(0, max_uintx) \
- \
- product(size_t, NewSize, ScaleForWordSize(1*M), \
- "Initial new generation size (in bytes)") \
- constraint(NewSizeConstraintFunc,AfterErgo) \
- \
- product(size_t, MaxNewSize, max_uintx, \
- "Maximum new generation size (in bytes), max_uintx means set " \
- "ergonomically") \
- range(0, max_uintx) \
- \
- product_pd(size_t, HeapBaseMinAddress, \
- "OS specific low limit for heap base address") \
- constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \
- \
- product(size_t, PretenureSizeThreshold, 0, \
- "Maximum size in bytes of objects allocated in DefNew " \
- "generation; zero means no maximum") \
- range(0, max_uintx) \
- \
- product(size_t, MinTLABSize, 2*K, \
- "Minimum allowed TLAB size (in bytes)") \
- range(1, max_uintx/2) \
- constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
- \
- product(size_t, TLABSize, 0, \
- "Starting TLAB size (in bytes); zero means set ergonomically") \
- constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
- \
- product(size_t, YoungPLABSize, 4096, \
- "Size of young gen promotion LAB's (in HeapWords)") \
- constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
- \
- product(size_t, OldPLABSize, 1024, \
- "Size of old gen promotion LAB's (in HeapWords), or Number " \
- "of blocks to attempt to claim when refilling CMS LAB's") \
- constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
- \
- product(uintx, TLABAllocationWeight, 35, \
- "Allocation averaging weight") \
- range(0, 100) \
- \
- /* Limit the lower bound of this flag to 1 as it is used */ \
- /* in a division expression. */ \
- product(uintx, TLABWasteTargetPercent, 1, \
- "Percentage of Eden that can be wasted") \
- range(1, 100) \
- \
- product(uintx, TLABRefillWasteFraction, 64, \
- "Maximum TLAB waste at a refill (internal fragmentation)") \
- range(1, max_juint) \
- \
- product(uintx, TLABWasteIncrement, 4, \
- "Increment allowed waste at slow allocation") \
- range(0, max_jint) \
- constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \
- \
- product(uintx, SurvivorRatio, 8, \
- "Ratio of eden/survivor space size") \
- range(1, max_uintx-2) \
- constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
- \
- product(uintx, NewRatio, 2, \
- "Ratio of old/new generation sizes") \
- range(0, max_uintx-1) \
- \
- product_pd(size_t, NewSizeThreadIncrease, \
- "Additional size added to desired new generation size per " \
- "non-daemon thread (in bytes)") \
- range(0, max_uintx) \
- \
product_pd(size_t, MetaspaceSize, \
"Initial threshold (in bytes) at which a garbage collection " \
"is done to reduce Metaspace usage") \
@@ -3208,63 +2183,6 @@
"The maximum expansion of Metaspace without full GC (in bytes)") \
range(0, max_uintx) \
\
- product(uintx, QueuedAllocationWarningCount, 0, \
- "Number of times an allocation that queues behind a GC " \
- "will retry before printing a warning") \
- range(0, max_uintx) \
- \
- diagnostic(uintx, VerifyGCStartAt, 0, \
- "GC invoke count where +VerifyBefore/AfterGC kicks in") \
- range(0, max_uintx) \
- \
- diagnostic(intx, VerifyGCLevel, 0, \
- "Generation level at which to start +VerifyBefore/AfterGC") \
- range(0, 1) \
- \
- product(uintx, MaxTenuringThreshold, 15, \
- "Maximum value for tenuring threshold") \
- range(0, markOopDesc::max_age + 1) \
- constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
- \
- product(uintx, InitialTenuringThreshold, 7, \
- "Initial value for tenuring threshold") \
- range(0, markOopDesc::max_age + 1) \
- constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
- \
- product(uintx, TargetSurvivorRatio, 50, \
- "Desired percentage of survivor space used after scavenge") \
- range(0, 100) \
- \
- product(uintx, MarkSweepDeadRatio, 5, \
- "Percentage (0-100) of the old gen allowed as dead wood. " \
- "Serial mark sweep treats this as both the minimum and maximum " \
- "value. " \
- "CMS uses this value only if it falls back to mark sweep. " \
- "Par compact uses a variable scale based on the density of the " \
- "generation and treats this as the maximum value when the heap " \
- "is either completely full or completely empty. Par compact " \
- "also has a smaller default value; see arguments.cpp.") \
- range(0, 100) \
- \
- product(uint, MarkSweepAlwaysCompactCount, 4, \
- "How often should we fully compact the heap (ignoring the dead " \
- "space parameters)") \
- range(1, max_juint) \
- \
- develop(uintx, GCExpandToAllocateDelayMillis, 0, \
- "Delay between expansion and allocation (in milliseconds)") \
- \
- develop(uintx, GCWorkerDelayMillis, 0, \
- "Delay in scheduling GC workers (in milliseconds)") \
- \
- product(bool, PSChunkLargeArrays, true, \
- "Process large arrays in chunks") \
- \
- product(uintx, GCDrainStackTargetSize, 64, \
- "Number of entries we will try to leave on the stack " \
- "during parallel gc") \
- range(0, max_juint) \
- \
/* stack parameters */ \
product_pd(intx, StackYellowPages, \
"Number of yellow zone (recoverable overflows) pages of size " \
@@ -4066,7 +2984,52 @@
"On internal errors, include registers in error report.") \
\
-
+#define VM_FLAGS(develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ \
+ RUNTIME_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
+ \
+ GC_FLAGS( \
+ develop, \
+ develop_pd, \
+ product, \
+ product_pd, \
+ diagnostic, \
+ diagnostic_pd, \
+ experimental, \
+ notproduct, \
+ manageable, \
+ product_rw, \
+ lp64_product, \
+ range, \
+ constraint, \
+ writeable) \
/*
* Macros for factoring of globals
@@ -4126,20 +3089,20 @@
#define IGNORE_WRITEABLE(type)
-RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, \
- DECLARE_PD_DEVELOPER_FLAG, \
- DECLARE_PRODUCT_FLAG, \
- DECLARE_PD_PRODUCT_FLAG, \
- DECLARE_DIAGNOSTIC_FLAG, \
- DECLARE_PD_DIAGNOSTIC_FLAG, \
- DECLARE_EXPERIMENTAL_FLAG, \
- DECLARE_NOTPRODUCT_FLAG, \
- DECLARE_MANAGEABLE_FLAG, \
- DECLARE_PRODUCT_RW_FLAG, \
- DECLARE_LP64_PRODUCT_FLAG, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
+VM_FLAGS(DECLARE_DEVELOPER_FLAG, \
+ DECLARE_PD_DEVELOPER_FLAG, \
+ DECLARE_PRODUCT_FLAG, \
+ DECLARE_PD_PRODUCT_FLAG, \
+ DECLARE_DIAGNOSTIC_FLAG, \
+ DECLARE_PD_DIAGNOSTIC_FLAG, \
+ DECLARE_EXPERIMENTAL_FLAG, \
+ DECLARE_NOTPRODUCT_FLAG, \
+ DECLARE_MANAGEABLE_FLAG, \
+ DECLARE_PRODUCT_RW_FLAG, \
+ DECLARE_LP64_PRODUCT_FLAG, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT, \
+ IGNORE_WRITEABLE)
RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, \
DECLARE_PD_DEVELOPER_FLAG, \
--- a/src/hotspot/share/runtime/globals_extension.hpp Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals_extension.hpp Fri Apr 06 13:55:25 2018 +0200
@@ -28,9 +28,6 @@
#include "runtime/globals.hpp"
#include "utilities/macros.hpp"
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif
#if INCLUDE_JVMCI
#include "jvmci/jvmci_globals.hpp"
#endif
@@ -96,21 +93,22 @@
#define ARCH_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc) FLAG_MEMBER(name),
typedef enum {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
- RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
- RUNTIME_PRODUCT_FLAG_MEMBER, \
- RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
- RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
- RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
- RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
- RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
- RUNTIME_MANAGEABLE_FLAG_MEMBER, \
- RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
- RUNTIME_LP64_PRODUCT_FLAG_MEMBER, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
- RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
+ VM_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
+ RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
+ RUNTIME_PRODUCT_FLAG_MEMBER, \
+ RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
+ RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
+ RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
+ RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
+ RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
+ RUNTIME_MANAGEABLE_FLAG_MEMBER, \
+ RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
+ RUNTIME_LP64_PRODUCT_FLAG_MEMBER, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT, \
+ IGNORE_WRITEABLE)
+
+ RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
RUNTIME_PRODUCT_FLAG_MEMBER, \
RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
@@ -120,21 +118,6 @@
IGNORE_RANGE, \
IGNORE_CONSTRAINT, \
IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
- RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
- RUNTIME_PRODUCT_FLAG_MEMBER, \
- RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
- RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
- RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
- RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
- RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
- RUNTIME_MANAGEABLE_FLAG_MEMBER, \
- RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
- IGNORE_RANGE, \
- IGNORE_CONSTRAINT, \
- IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
#if INCLUDE_JVMCI
JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_MEMBER, \
JVMCI_PD_DEVELOP_FLAG_MEMBER, \
@@ -239,20 +222,21 @@
#define ARCH_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc) FLAG_MEMBER_WITH_TYPE(name,type),
typedef enum {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE,
- IGNORE_RANGE,
- IGNORE_CONSTRAINT,
- IGNORE_WRITEABLE)
+ VM_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
+ RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+ IGNORE_RANGE,
+ IGNORE_CONSTRAINT,
+ IGNORE_WRITEABLE)
+
RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
@@ -263,21 +247,6 @@
IGNORE_RANGE,
IGNORE_CONSTRAINT,
IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
- RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
- IGNORE_RANGE,
- IGNORE_CONSTRAINT,
- IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
#if INCLUDE_JVMCI
JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_MEMBER_WITH_TYPE,
JVMCI_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,