< prev index next >
src/share/vm/runtime/globals.hpp
Print this page
rev 9473 : [mq]: webrev.00
*** 23,33 ****
*/
#ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
#define SHARE_VM_RUNTIME_GLOBALS_HPP
- #include <float.h>
#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
--- 23,32 ----
*** 625,634 ****
--- 624,634 ----
notproduct(bool, CheckCompressedOops, true, \
"Generate checks in encoding/decoding code in debug VM") \
\
product_pd(size_t, HeapBaseMinAddress, \
"OS specific low limit for heap base address") \
+ constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \
\
product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \
"Heap allocation steps through preferred address regions to find" \
" where it can allocate the heap. Number of steps to take per " \
"region.") \
*** 690,699 ****
--- 690,701 ----
product(bool, UseNUMAInterleaving, false, \
"Interleave memory across NUMA nodes if available") \
\
product(size_t, NUMAInterleaveGranularity, 2*M, \
"Granularity to use for NUMA interleaving on Windows OS") \
+ range(os::vm_allocation_granularity(), max_uintx) \
+ constraint(NUMAInterleaveGranularityConstraintFunc,AfterErgo) \
\
product(bool, ForceNUMA, false, \
"Force NUMA optimizations on single-node/UMA systems") \
\
product(uintx, NUMAChunkResizeWeight, 20, \
*** 702,720 ****
--- 704,724 ----
"AdaptiveNUMAChunkSizing") \
range(0, 100) \
\
product(size_t, NUMASpaceResizeRate, 1*G, \
"Do not reallocate more than this amount per collection") \
+ range(0, max_uintx) \
\
product(bool, UseAdaptiveNUMAChunkSizing, true, \
"Enable adaptive chunk sizing for NUMA") \
\
product(bool, NUMAStats, false, \
"Print NUMA stats in detailed heap information") \
\
product(uintx, NUMAPageScanRate, 256, \
"Maximum number of pages to include in the page scan procedure") \
+ range(0, max_uintx) \
\
product_pd(bool, NeedsDeoptSuspend, \
"True for register window machines (sparc/ia64)") \
\
product(intx, UseSSE, 99, \
*** 731,743 ****
--- 735,749 ----
product(bool, UseGHASHIntrinsics, false, \
"Use intrinsics for GHASH versions of crypto") \
\
product(size_t, LargePageSizeInBytes, 0, \
"Large page size (0 to let VM choose the page size)") \
+ range(0, max_uintx) \
\
product(size_t, LargePageHeapSizeThreshold, 128*M, \
"Use large pages if maximum heap is at least this big") \
+ range(0, max_uintx) \
\
product(bool, ForceTimeHighResolution, false, \
"Using high time resolution (for Win32 only)") \
\
develop(bool, TraceItables, false, \
*** 1530,1542 ****
--- 1536,1550 ----
"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") \
\
*** 1614,1623 ****
--- 1622,1632 ----
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(bool, UseParNewGC, false, \
*** 1668,1677 ****
--- 1677,1687 ----
"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) \
*** 1721,1730 ****
--- 1731,1741 ----
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_pd(size_t, CMSYoungGenPerWorker, \
*** 1749,1758 ****
--- 1760,1770 ----
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) \
*** 1797,1817 ****
--- 1809,1832 ----
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) \
\
*** 1841,1857 ****
--- 1856,1874 ----
"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) \
*** 1935,1944 ****
--- 1952,1962 ----
"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) \
*** 1964,1973 ****
--- 1982,1992 ----
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") \
\
*** 2165,2174 ****
--- 2184,2194 ----
range(0, 0XFFFFFFFFFFFFFFFF) \
\
product(size_t, ErgoHeapSizeLimit, 0, \
"Maximum ergonomically set heap size (in bytes); zero means use " \
"MaxRAM / MaxRAMFraction") \
+ range(0, max_uintx) \
\
product(uintx, MaxRAMFraction, 4, \
"Maximum fraction (1/n) of real memory used for maximum heap " \
"size") \
range(1, max_uintx) \
*** 2189,2198 ****
--- 2209,2219 ----
product(bool, UseAutoGCSelectPolicy, false, \
"Use automatic collection selection policy") \
\
product(uintx, AutoGCSelectPauseMillis, 5000, \
"Automatic GC selection pause threshold in milliseconds") \
+ range(0, max_uintx) \
\
product(bool, UseAdaptiveSizePolicy, true, \
"Use adaptive generation sizing policies") \
\
product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
*** 2221,2236 ****
--- 2242,2259 ----
"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, \
*** 2241,2264 ****
--- 2264,2291 ----
"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) \
\
*** 2293,2325 ****
--- 2320,2357 ----
constraint(GCPauseIntervalMillisConstraintFunc,AfterMemoryInit) \
\
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") \
\
*** 2340,2355 ****
--- 2372,2390 ----
product(bool, PrintAdaptiveSizePolicy, false, \
"Print information about AdaptiveSizePolicy") \
\
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, VerifySilently, false, \
"Do not print the verification progress") \
\
diagnostic(bool, VerifyDuringStartup, false, \
*** 2393,2419 ****
--- 2428,2458 ----
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) \
\
/* gc tracing */ \
manageable(bool, PrintGC, false, \
"Print message at garbage collection") \
\
*** 2558,2571 ****
--- 2597,2612 ----
"-Xloggc:<filename>") \
\
product(uintx, NumberOfGCLogFiles, 0, \
"Number of gclog files in rotation " \
"(default: 0, no rotation)") \
+ range(0, max_uintx) \
\
product(size_t, GCLogFileSize, 8*K, \
"GC log file size, requires UseGCLogFileRotation. " \
"Set to 0 to only trigger rotation via jcmd") \
+ range(0, max_uintx) \
\
/* JVMTI heap profiling */ \
\
diagnostic(bool, TraceJVMTIObjectTagging, false, \
"Trace JVMTI object tagging calls") \
*** 3329,3350 ****
--- 3370,3394 ----
"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(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) \
constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
*** 3372,3385 ****
"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_uintx) \
\
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) \
--- 3416,3431 ----
"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) \
*** 3389,3398 ****
--- 3435,3445 ----
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 size of Metaspaces (in bytes)") \
constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
\
*** 3424,3436 ****
--- 3471,3485 ----
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)") \
+ range(0, max_uintx) \
\
product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
"The minimum expansion of Metaspace (in bytes)") \
+ range(0, max_uintx) \
\
product(uintx, MaxMetaspaceFreeRatio, 70, \
"The maximum percentage of Metaspace free after GC to avoid " \
"shrinking") \
range(0, 100) \
*** 3442,3458 ****
--- 3491,3510 ----
range(0, 99) \
constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \
\
product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
"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) \
\
*** 3486,3504 ****
--- 3538,3559 ----
"space parameters)") \
range(1, max_uintx) \
\
product(intx, PrintCMSStatistics, 0, \
"Statistics for CMS") \
+ range(0, 2) \
\
product(bool, PrintCMSInitiationStatistics, false, \
"Statistics for initiating a CMS collection") \
\
product(intx, PrintFLSStatistics, 0, \
"Statistics for CMS' FreeListSpace") \
+ range(0, 2) \
\
product(intx, PrintFLSCensus, 0, \
"Census for CMS' FreeListSpace") \
+ range(0, 1) \
\
develop(uintx, GCExpandToAllocateDelayMillis, 0, \
"Delay between expansion and allocation (in milliseconds)") \
\
develop(uintx, GCWorkerDelayMillis, 0, \
*** 3521,3530 ****
--- 3576,3586 ----
"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") \
range(MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5)) \
< prev index next >