/* * 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/ 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(size_t, 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