< prev index next >
src/share/vm/runtime/globals.hpp
Print this page
*** 24,34 ****
#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
#define SHARE_VM_RUNTIME_GLOBALS_HPP
#include "utilities/debug.hpp"
- #include <float.h> // for DBL_MAX
// use this for flags that are true per default in the tiered build
// but false in non-tiered builds, and vice versa
#ifdef TIERED
#define trueInTiered true
--- 24,33 ----
*** 1546,1556 ****
"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") \
\
--- 1545,1554 ----
*** 1578,1588 ****
"How often to provoke splitting a young gen space") \
range(0, max_uintx) \
\
product(uint, ConcGCThreads, 0, \
"Number of threads concurrent gc will use") \
! constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
range(1, max_uintx) \
\
--- 1576,1593 ----
"How often to provoke splitting a young gen space") \
range(0, max_uintx) \
\
product(uint, ConcGCThreads, 0, \
"Number of threads concurrent gc will use") \
! \
! 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") \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
range(1, max_uintx) \
\
*** 1686,1696 ****
\
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) \
--- 1691,1700 ----
*** 1709,1725 ****
\
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) \
--- 1713,1728 ----
\
product(size_t, CMSOldPLABMax, 1024, \
"Maximum size of CMS gen promotion LAB caches per worker " \
"per block size") \
range(1, max_uintx) \
\
product(size_t, CMSOldPLABMin, 16, \
"Minimum size of CMS gen promotion LAB caches per worker " \
"per block size") \
range(1, max_uintx) \
! constraint(CMSOldPLABMinConstraintFunc,AfterErgo) \
\
product(uintx, CMSOldPLABNumRefills, 4, \
"Nominal number of refills of CMS gen promotion LAB cache " \
"per worker per block size") \
range(1, max_uintx) \
*** 1774,1806 ****
"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, \
--- 1777,1804 ----
*** 1824,1838 ****
"When CMS class unloading is enabled, the maximum CMS cycle " \
"count for which classes may not be unloaded") \
\
develop(intx, CMSDictionaryChoice, 0, \
"Use BinaryTreeDictionary as default in the CMS generation") \
- range(0, 2) \
\
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, \
--- 1822,1834 ----
*** 1843,1861 ****
"Warn in case of excessive CMS looping") \
\
develop(bool, CMSOverflowEarlyRestoration, false, \
"Restore preserved marks early") \
\
/* 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 " \
--- 1839,1856 ----
"Warn in case of excessive CMS looping") \
\
develop(bool, CMSOverflowEarlyRestoration, false, \
"Restore preserved marks early") \
\
+ product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
+ "Size of marking stack") \
+ \
/* 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)) \
\
notproduct(bool, CMSMarkStackOverflowALot, false, \
"Simulate frequent marking stack / work queue overflow") \
\
notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
"An \"interval\" counter that determines how frequently " \
*** 1864,1882 ****
product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
"Maximum number of abortable preclean iterations, if > 0") \
\
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") \
\
manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
"Time that we sleep between iterations when not given " \
"enough work per iteration") \
- range(0, max_intx) \
\
product(size_t, CMSRescanMultiple, 32, \
"Size (in cards) of CMS parallel rescan task") \
range(1, max_uintx) \
\
--- 1859,1875 ----
*** 1979,1990 ****
develop(bool, CMSTraceSweeper, false, \
"Trace some actions of the CMS sweeper") \
\
product(uintx, CMSWorkQueueDrainThreshold, 10, \
"Don't drain below this size per parallel worker/thief") \
- range(0, max_juint) \
- constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
\
manageable(intx, CMSWaitDuration, 2000, \
"Time in milliseconds that CMS thread waits for young GC") \
\
develop(uintx, CMSCheckInterval, 1000, \
--- 1972,1981 ----
*** 2237,2251 ****
develop(bool, TraceAdaptiveGCBoundary, false, \
"Trace young-old boundary moves") \
\
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) \
\
develop(bool, PSAdjustTenuredGenForMinorPause, false, \
"Adjust tenured generation to achieve a minor pause goal") \
\
develop(bool, PSAdjustYoungGenForMajorPause, false, \
--- 2228,2240 ----
*** 2313,2328 ****
range(1, max_uintx) \
\
product(uintx, MaxGCPauseMillis, max_uintx, \
"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) \
- 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") \
\
--- 2302,2314 ----
*** 2339,2349 ****
product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
"Time scale over which major costs decay") \
\
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") \
\
product(size_t, BaseFootPrintEstimate, 256*M, \
--- 2325,2334 ----
*** 2363,2373 ****
"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(bool, PrintAdaptiveSizePolicy, false, \
"Print information about AdaptiveSizePolicy") \
\
product(intx, PrefetchCopyIntervalInBytes, -1, \
--- 2348,2357 ----
*** 2463,2473 ****
"Print timestamps for individual gc worker thread tasks") \
\
develop(intx, ConcGCYieldTimeout, 0, \
"If non-zero, assert that GC threads yield within this " \
"number of milliseconds") \
- range(0, max_intx) \
\
product(bool, PrintReferenceGC, false, \
"Print times spent handling reference objects during GC " \
"(enabled only when PrintGCDetails)") \
\
--- 2447,2456 ----
*** 2502,2513 ****
"Trace class loader loader_data lifetime") \
\
product(size_t, InitialBootClassLoaderMetaspaceSize, \
NOT_LP64(2200*K) LP64_ONLY(4*M), \
"Initial size of the boot class loader data metaspace") \
- range(BytesPerWord, max_uintx) \
- constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
\
product(bool, TraceYoungGenTime, false, \
"Trace accumulated time for young collection") \
\
product(bool, TraceOldGenTime, false, \
--- 2485,2494 ----
*** 2580,2590 ****
"by JNI critical section") \
\
experimental(double, ObjectCountCutOffPercent, 0.5, \
"The percentage of the used heap that the instances of a class " \
"must occupy for the class to generate a trace event") \
- range(0.0, 100.0) \
\
/* GC log rotation setting */ \
\
product(bool, UseGCLogFileRotation, false, \
"Rotate gclog files (for long running applications). It requires "\
--- 2561,2570 ----
*** 3291,3339 ****
"Size in K to allocate for the Profile Nodes of each thread") \
\
/* gc parameters */ \
product(size_t, InitialHeapSize, 0, \
"Initial heap size (in bytes); zero means use ergonomics") \
- range(0, max_uintx) \
- 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)") \
\
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") \
\
product(size_t, PretenureSizeThreshold, 0, \
"Maximum size in bytes of objects allocated in DefNew " \
"generation; zero means no maximum") \
\
- product(size_t, MinTLABSize, 2*K, \
- "Minimum allowed TLAB size (in bytes)") \
- range(1, max_uintx) \
- 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) \
\
--- 3271,3304 ----
"Size in K to allocate for the Profile Nodes of each thread") \
\
/* gc parameters */ \
product(size_t, InitialHeapSize, 0, \
"Initial heap size (in bytes); zero means use ergonomics") \
\
product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
"Maximum heap size (in bytes)") \
\
product(size_t, OldSize, ScaleForWordSize(4*M), \
"Initial tenured generation size (in bytes)") \
\
product(size_t, NewSize, ScaleForWordSize(1*M), \
"Initial new generation size (in bytes)") \
\
product(size_t, MaxNewSize, max_uintx, \
"Maximum new generation size (in bytes), max_uintx means set " \
"ergonomically") \
\
product(size_t, PretenureSizeThreshold, 0, \
"Maximum size in bytes of objects allocated in DefNew " \
"generation; zero means no maximum") \
\
product(size_t, TLABSize, 0, \
"Starting TLAB size (in bytes); zero means set ergonomically") \
\
! product(size_t, MinTLABSize, 2*K, \
! "Minimum allowed TLAB size (in bytes)") \
! range(1, max_uintx) \
\
product(uintx, TLABAllocationWeight, 35, \
"Allocation averaging weight") \
range(0, 100) \
\
*** 3350,3377 ****
product(uintx, TLABWasteIncrement, 4, \
"Increment allowed waste at slow allocation") \
\
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)") \
\
product_pd(size_t, MetaspaceSize, \
"Initial size of Metaspaces (in bytes)") \
- constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
\
product(size_t, MaxMetaspaceSize, max_uintx, \
"Maximum size of Metaspaces (in bytes)") \
- constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \
\
product(size_t, CompressedClassSpaceSize, 1*G, \
"Maximum size of class area in Metaspace when compressed " \
"class pointers are used") \
range(1*M, 3*G) \
--- 3315,3337 ----
*** 3390,3401 ****
range(0, 100) \
constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \
\
product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
"Number of milliseconds per MB of free space in the heap") \
- range(0, max_intx) \
- constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \
\
product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
"The minimum change in heap space due to GC (in bytes)") \
\
product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
--- 3350,3359 ----
*** 3423,3433 ****
diagnostic(uintx, VerifyGCStartAt, 0, \
"GC invoke count where +VerifyBefore/AfterGC kicks in") \
\
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) \
--- 3381,3390 ----
*** 3482,3492 ****
product(intx, DeferPollingPageLoopCount, -1, \
"(Unsafe,Unstable) Number of iterations in safepoint loop " \
"before changing safepoint polling page to RO ") \
\
product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
- range(0, max_intx) \
\
product(bool, PSChunkLargeArrays, true, \
"Process large arrays in chunks") \
\
product(uintx, GCDrainStackTargetSize, 64, \
--- 3439,3448 ----
< prev index next >