Java JVM XX Options
虚拟机jvm的参数解释
虚拟机优化的时候需要知道怎么去设置参数，编译了一个openjdk slowdebug版本，然后通过
java -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -XX:+PrintFlagsFinal -XX:+PrintFlagsWithComments -version
打印了全部参数如下，方便查阅(滚动到右边👉)
ccstrlist AOTLibrary = {product} {default} AOT library
bool AbortVMOnCompilationFailure = false {diagnostic} {default} Abort VM when method had failed to compile.
ccstr AbortVMOnException = {diagnostic} {default} Call fatal if this exception is thrown. Example: java -XX:AbortVMOnException=java.lang.NullPointerException Foo
ccstr AbortVMOnExceptionMessage = {diagnostic} {default} Call fatal if the exception pointed by AbortVMOnException has this message
bool AbortVMOnSafepointTimeout = false {diagnostic} {default} Abort upon failure to reach safepoint (see SafepointTimeout)
bool AbortVMOnVMOperationTimeout = false {diagnostic} {default} Abort upon failure to complete VM operation promptly
intx AbortVMOnVMOperationTimeoutDelay = 1000 {diagnostic} {default} Delay in milliseconds for option AbortVMOnVMOperationTimeout
int ActiveProcessorCount = -1 {product} {default} Specify the CPU count the VM should use and report as active
uintx AdaptiveSizeDecrementScaleFactor = 4 {product} {default} Adaptive size scale down factor for shrinking
uintx AdaptiveSizeMajorGCDecayTimeScale = 10 {product} {default} Time scale over which major costs decay
uintx AdaptiveSizePolicyCollectionCostMargin = 50 {product} {default} If collection costs are within margin, reduce both by full delta
uintx AdaptiveSizePolicyGCTimeLimitThreshold = 5 {develop} {default} Number of consecutive collections before gc time limit fires
uintx AdaptiveSizePolicyInitializingSteps = 20 {product} {default} Number of steps where heuristics is used before data is used
uintx AdaptiveSizePolicyOutputInterval = 0 {product} {default} Collection interval for printing information; zero means never
uintx AdaptiveSizePolicyReadyThreshold = 5 {develop} {default} Number of collections before the adaptive sizing is started
uintx AdaptiveSizePolicyWeight = 10 {product} {default} Weight given to exponential resizing, between 0 and 100
uintx AdaptiveSizeThroughPutPolicy = 0 {product} {default} Policy for changing generation size for throughput goals
uintx AdaptiveTimeWeight = 25 {product} {default} Weight given to time in adaptive policy, between 0 and 100
bool AggressiveHeap = false {product} {default} Optimize heap options for long-running memory intensive apps
intx AliasLevel = 3 {C2 product} {default} 0 for no aliasing, 1 for oop/field/static/array split, 2 for class split, 3 for unique instances
bool AlignVector = true {C2 product} {default} Perform vector store/load alignment in loop
ccstr AllocateHeapAt = {product} {default} Path to the directoy where a temporary file will be created to use as the backing store for Java Heap.
intx AllocateInstancePrefetchLines = 1 {product} {default} Number of lines to prefetch ahead of instance allocation pointer
intx AllocatePrefetchDistance = -1 {product} {default} Distance to prefetch ahead of allocation pointer. -1: use system-specific value (automatically determined
intx AllocatePrefetchInstr = 0 {product} {default} Select instruction to prefetch ahead of allocation pointer
intx AllocatePrefetchLines = 3 {product} {default} Number of lines to prefetch ahead of array allocation pointer
intx AllocatePrefetchStepSize = 16 {product} {default} Step size in bytes of sequential prefetch instructions
intx AllocatePrefetchStyle = 1 {product} {default} 0 = no prefetch, 1 = generate prefetch instructions for each allocation, 2 = use TLAB watermark to gate allocation prefetch, 3 = generate one prefetch instruction per cache line
bool AllowArchivingWithJavaAgent = false {diagnostic} {default} Allow Java agent to be run with CDS dumping
bool AllowJNIEnvProxy = false {product} {default} Allow JNIEnv proxies for jdbx
bool AllowParallelDefineClass = false {product} {default} Allow parallel defineClass requests for class loaders registering as parallel capable
bool AllowUserSignalHandlers = false {product} {default} Do not complain if the application installs signal handlers (Solaris & Linux only)
bool AllowVectorizeOnDemand = true {C2 product} {default} Globally supress vectorization set in VectorizeMethod
bool AlwaysActAsServerClassMachine = false {product} {default} Always act like a server-class machine
bool AlwaysCompileLoopMethods = false {product} {default} When using recompilation, never interpret methods containing loops
bool AlwaysIncrementalInline = false {C2 develop} {default} do all inlining incrementally
bool AlwaysLockClassLoader = false {product} {default} Require the VM to acquire the class loader lock before calling loadClass() even for class loaders registering as parallel capable
bool AlwaysPreTouch = false {product} {default} Force all freshly committed pages to be pre-touched
bool AlwaysRestoreFPU = false {product} {default} Restore the FPU control word after every JNI call (expensive)
bool AlwaysTenure = false {product} {default} Always tenure objects in eden (ParallelGC only)
intx ArrayCopyLoadStoreMaxElem = 8 {C2 product} {default} Maximum number of arraycopy elements inlined as a sequence ofloads/stores
bool AssertOnSuspendWaitFailure = false {product} {default} Assert/Guarantee on external suspend wait failure
bool AssertRangeCheckElimination = false {C1 develop} {default} Assert Range Check Elimination
intx AutoBoxCacheMax = 128 {C2 product} {default} Sets max value cached by the java.lang.Integer autobox cache
intx BCEATraceLevel = 0 {product} {default} How much tracing to do of bytecode escape analysis estimates (0-3)
bool BackgroundCompilation = true {pd product} {default} A thread requesting compilation is not blocked during compilation
bool BailoutAfterHIR = false {C1 develop} {default} bailout of compilation after building of HIR
bool BailoutAfterLIR = false {C1 develop} {default} bailout of compilation after building of LIR
bool BailoutOnExceptionHandlers = false {C1 develop} {default} bailout of compilation for methods with exception handlers
bool BailoutToInterpreterForThrows = false {C2 develop} {default} Compiled methods which throws/catches exceptions will be deopt and intp.
size_t BaseFootPrintEstimate = 268435456 {product} {default} Estimate of footprint other than Java Heap
intx BciProfileWidth = 2 {develop} {default} Number of return bci\'s to record in ret profile
intx BiasedLockingBulkRebiasThreshold = 20 {product} {default} Threshold of number of revocations per type to try to rebias all objects in the heap of that type
intx BiasedLockingBulkRevokeThreshold = 40 {product} {default} Threshold of number of revocations per type to permanently revoke biases of all objects in the heap of that type
intx BiasedLockingDecayTime = 25000 {product} {default} Decay time (in milliseconds) to re-enable bulk rebiasing of a type after previous bulk rebias
intx BiasedLockingStartupDelay = 0 {product} {default} Number of milliseconds to wait before enabling biased locking
intx BinarySwitchThreshold = 5 {develop} {default} Minimal number of lookupswitch entries for rewriting to binary switch
bool BindCMSThreadToCPU = false {diagnostic} {default} Bind CMS Thread to CPU if possible
bool BindGCTaskThreadsToCPUs = false {product} {default} Bind GCTaskThreads to CPUs if possible
bool BlockLayoutByFrequency = true {C2 product} {default} Use edge frequencies to drive block ordering
intx BlockLayoutMinDiamondPercentage = 20 {C2 product} {default} Miniumum %% of a successor (predecessor) for which block layout a will allow a fork (join) in a single chain
bool BlockLayoutRotateLoops = true {C2 product} {default} Allow back branches to be fall throughs in the block layout
bool BlockOffsetArrayUseUnallocatedBlock = false {diagnostic} {default} Maintain _unallocated_block in BlockOffsetArray (currently applicable only to CMS collector)
bool BranchOnRegister = false {C2 product} {default} Use Sparc V9 branch-on-register opcodes
intx BreakAtNode = 0 {C2 notproduct} {default} Break at construction of this Node (either _idx or _debug_idx)
bool BreakAtWarning = false {develop} {default} Execute breakpoint upon encountering VM warning
bool BytecodeVerificationLocal = false {product} {default} Enable the Java bytecode verifier for local classes
bool BytecodeVerificationRemote = true {product} {default} Enable the Java bytecode verifier for remote classes
bool C1Breakpoint = false {C1 develop} {default} Sets a breakpoint at entry of each compiled method
bool C1OptimizeVirtualCallProfiling = true {C1 product} {default} Use CHA and exact type results at call sites when updating MDOs
bool C1ProfileBranches = true {C1 product} {default} Profile branches when generating code for updating MDOs
bool C1ProfileCalls = true {C1 product} {default} Profile calls when generating code for updating MDOs
bool C1ProfileCheckcasts = true {C1 product} {default} Profile checkcasts when generating code for updating MDOs
bool C1ProfileInlinedCalls = true {C1 product} {default} Profile inlined calls when generating code for updating MDOs
bool C1ProfileVirtualCalls = true {C1 product} {default} Profile virtual calls when generating code for updating MDOs
bool C1UpdateMethodData = true {C1 product} {default} Update MethodData*s in Tier1-generated code
intx CIBreakAt = -1 {develop} {default} The id of compilation to break at
intx CIBreakAtOSR = -1 {develop} {default} The id of osr compilation to break at
bool CICompileNatives = true {develop} {default} compile native methods if supported by the compiler
bool CICompileOSR = true {pd develop} {default} compile on stack replacement methods if supported by the compiler
intx CICompilerCount = 2 {product} {default} Number of compiler threads to run
bool CICompilerCountPerCPU = false {product} {default} 1 compiler thread for log(N CPUs)
bool CICountOSR = false {develop} {default} use a separate counter when assigning ids to osr compilations
intx CICrashAt = -1 {notproduct} {default} id of compilation to trigger assert in compiler thread for the purpose of testing, e.g. generation of replay data
intx CIFireOOMAt = -1 {develop} {default} Fire OutOfMemoryErrors throughout CI for testing the compiler (non-negative value throws OOM after this many CI accesses in each compile)
bool CIObjectFactoryVerify = false {notproduct} {default} enable potentially expensive verification in ciObjectFactory
bool CIPrintCompileQueue = false {diagnostic} {default} display the contents of the compile queue whenever a compilation is enqueued
bool CIPrintCompilerName = false {develop} {default} when CIPrint is active, print the name of the active compiler
bool CIPrintMethodCodes = false {develop} {default} print method bytecodes of the compiled code
bool CIPrintRequests = false {develop} {default} display every request for compilation
bool CIPrintTypeFlow = false {develop} {default} print the results of ciTypeFlow analysis
intx CIStart = 0 {develop} {default} The id of the first compilation to permit
intx CIStartOSR = 0 {develop} {default} The id of the first osr compilation to permit (CICountOSR must be on)
intx CIStop = 2147483647 {develop} {default} The id of the last compilation to permit
intx CIStopOSR = 2147483647 {develop} {default} The id of the last osr compilation to permit (CICountOSR must be on)
bool CITime = false {product} {default} collect timing information for compilation
bool CITimeEach = false {develop} {default} display timing information after each successful compilation
bool CITimeVerbose = false {develop} {default} be more verbose in compilation timings
bool CITraceTypeFlow = false {develop} {default} detailed per-bytecode tracing of ciTypeFlow analysis
bool CMSAbortSemantics = false {product} {default} Whether abort-on-overflow semantics is implemented
uintx CMSAbortablePrecleanMinWorkPerIteration = 100 {product} {default} Nominal minimum work per abortable preclean iteration
intx CMSAbortablePrecleanWaitMillis = 100 {manageable} {default} Time that we sleep between iterations when not given enough work per iteration
size_t CMSBitMapYieldQuantum = 10485760 {product} {default} Bitmap operations should process at most this many bits between yields
uintx CMSBootstrapOccupancy = 50 {product} {default} Percentage CMS generation occupancy at which to initiate CMS collection for bootstrapping collection stats
uintx CMSCheckInterval = 1000 {develop} {default} Interval in milliseconds that CMS thread checks if it should start a collection cycle
bool CMSClassUnloadingEnabled = true {product} {default} Whether class unloading enabled when using CMS GC
uintx CMSClassUnloadingMaxInterval = 0 {product} {default} When CMS class unloading is enabled, the maximum CMS cycle count for which classes may not be unloaded
bool CMSCleanOnEnter = true {product} {default} Clean-on-enter optimization for reducing number of dirty cards
size_t CMSConcMarkMultiple = 32 {product} {default} Size (in cards) of CMS concurrent MT marking task
bool CMSConcurrentMTEnabled = true {product} {default} Whether multi-threaded concurrent work enabled (effective only if ParNewGC)
uintx CMSCoordinatorYieldSleepCount = 10 {product} {default} Number of times the coordinator GC thread will sleep while yielding before giving up and resuming GC
bool CMSEdenChunksRecordAlways = true {product} {default} Always record eden chunks used for the parallel initial mark or remark of eden
uintx CMSExpAvgFactor = 50 {product} {default} Percentage (0-100) used to weight the current sample when computing exponential averages for CMS statistics
bool CMSExtrapolateSweep = false {product} {default} CMS: cushion for block demand during sweep
uintx CMSIncrementalSafetyFactor = 10 {product} {default} Percentage (0-100) used to add conservatism when computing the duty cycle
uintx CMSIndexedFreeListReplenish = 4 {product} {default} Replenish an indexed free list with this number of chunks
intx CMSInitiatingOccupancyFraction = -1 {product} {default} Percentage CMS generation occupancy to start a CMS collection cycle. A negative value means that CMSTriggerRatio is used
uintx CMSIsTooFullPercentage = 98 {product} {default} An absolute ceiling above which CMS will always consider the unloading of classes when class unloading is enabled
double CMSLargeCoalSurplusPercent = 0.950000 {product} {default} CMS: the factor by which to inflate estimated demand of large block sizes to prevent coalescing with an adjoining block
double CMSLargeSplitSurplusPercent = 1.000000 {product} {default} CMS: the factor by which to inflate estimated demand of large block sizes to prevent splitting to supply demand for smaller blocks
bool CMSLoopWarn = false {product} {default} Warn in case of excessive CMS looping
bool CMSMarkStackOverflowALot = false {notproduct} {default} Simulate frequent marking stack / work queue overflow
uintx CMSMarkStackOverflowInterval = 1000 {notproduct} {default} An "interval" counter that determines how frequently to simulate overflow; a smaller number increases frequency
uintx CMSMaxAbortablePrecleanLoops = 0 {product} {default} Maximum number of abortable preclean iterations, if > 0
intx CMSMaxAbortablePrecleanTime = 5000 {product} {default} Maximum time in abortable preclean (in milliseconds)
size_t CMSOldPLABMax = 1024 {product} {default} Maximum size of CMS gen promotion LAB caches per worker per block size
size_t CMSOldPLABMin = 16 {product} {default} Minimum size of CMS gen promotion LAB caches per worker per block size
uintx CMSOldPLABNumRefills = 4 {product} {default} Nominal number of refills of CMS gen promotion LAB cache per worker per block size
uintx CMSOldPLABReactivityFactor = 2 {product} {default} The gain in the feedback loop for on-the-fly PLAB resizing during a scavenge
bool CMSOldPLABResizeQuicker = false {product} {default} React on-the-fly during a scavenge to a sudden change in block demand rate
uintx CMSOldPLABToleranceFactor = 4 {product} {default} The tolerance of the phase-change detector for on-the-fly PLAB resizing during a scavenge
bool CMSPLABRecordAlways = true {product} {default} Always record survivor space PLAB boundaries (effective only if CMSParallelSurvivorRemarkEnabled)
bool CMSParallelInitialMarkEnabled = true {product} {default} Use the parallel initial mark.
bool CMSParallelRemarkEnabled = true {product} {default} Whether parallel remark enabled (only if ParNewGC)
bool CMSParallelSurvivorRemarkEnabled = true {product} {default} Whether parallel remark of survivor space enabled (effective only if CMSParallelRemarkEnabled)
uintx CMSPrecleanDenominator = 3 {product} {default} CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence ratio
uintx CMSPrecleanIter = 3 {product} {default} Maximum number of precleaning iteration passes
uintx CMSPrecleanNumerator = 2 {product} {default} CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence ratio
bool CMSPrecleanRefLists1 = true {product} {default} Preclean ref lists during (initial) preclean phase
bool CMSPrecleanRefLists2 = false {product} {default} Preclean ref lists during abortable preclean phase
bool CMSPrecleanSurvivors1 = false {product} {default} Preclean survivors during (initial) preclean phase
bool CMSPrecleanSurvivors2 = true {product} {default} Preclean survivors during abortable preclean phase
uintx CMSPrecleanThreshold = 1000 {product} {default} Do not iterate again if number of dirty cards is less than this
bool CMSPrecleaningEnabled = true {product} {default} Whether concurrent precleaning enabled
bool CMSPrintChunksInDump = false {product} {default} If logging for the "gc" and "promotion" tags is enabled ontrace level include more detailed information about thefree chunks
bool CMSPrintObjectsInDump = false {product} {default} If logging for the "gc" and "promotion" tags is enabled ontrace level include more detailed information about theallocated objects
uintx CMSRemarkVerifyVariant = 1 {product} {default} Choose variant (1,2) of verification following remark
bool CMSReplenishIntermediate = true {product} {default} Replenish all intermediate free-list caches
size_t CMSRescanMultiple = 32 {product} {default} Size (in cards) of CMS parallel rescan task
uintx CMSSamplingGrain = 16384 {product} {default} The minimum distance between eden samples for CMS (see above)
bool CMSScavengeBeforeRemark = false {product} {default} Attempt scavenge before the CMS remark step
uintx CMSScheduleRemarkEdenPenetration = 50 {product} {default} The Eden occupancy percentage (0-100) at which to try and schedule remark pause
size_t CMSScheduleRemarkEdenSizeThreshold = 2097152 {product} {default} If Eden size is below this, do not try to schedule remark
uintx CMSScheduleRemarkSamplingRatio = 5 {product} {default} Start sampling eden top at least before young gen occupancy reaches 1/<ratio> of the size at which we plan to schedule remark
double CMSSmallCoalSurplusPercent = 1.050000 {product} {default} CMS: the factor by which to inflate estimated demand of small block sizes to prevent coalescing with an adjoining block
double CMSSmallSplitSurplusPercent = 1.100000 {product} {default} CMS: the factor by which to inflate estimated demand of small block sizes to prevent splitting to supply demand for smaller blocks
bool CMSSplitIndexedFreeListBlocks = true {product} {default} When satisfying batched demand, split blocks from the IndexedFreeList whose size is a multiple of requested size
bool CMSTestInFreeList = false {develop} {default} Check if the coalesced range is already in the free lists as claimed
intx CMSTriggerInterval = -1 {manageable} {default} Commence a CMS collection cycle (at least) every so many milliseconds (0 permanently, -1 disabled)
uintx CMSTriggerRatio = 80 {product} {default} Percentage of MinHeapFreeRatio in CMS generation that is allocated before a CMS collection cycle commences
bool CMSVerifyReturnedBytes = false {notproduct} {default} Check that all the garbage collected was returned to the free lists
intx CMSWaitDuration = 2000 {manageable} {default} Time in milliseconds that CMS thread waits for young GC
uintx CMSWorkQueueDrainThreshold = 10 {product} {default} Don\'t drain below this size per parallel worker/thief
bool CMSYield = true {product} {default} Yield between steps of CMS
uintx CMSYieldSleepCount = 0 {product} {default} Number of times a GC thread (minus the coordinator) will sleep while yielding before giving up and resuming GC
size_t CMSYoungGenPerWorker = 67108864 {pd product} {default} The maximum size of young gen chosen by default per GC worker thread available
uintx CMS_FLSPadding = 1 {product} {default} The multiple of deviation from mean to use for buffering against volatility in free list demand
uintx CMS_FLSWeight = 75 {product} {default} Percentage (0-100) used to weight the current sample when computing exponentially decaying averages for CMS FLS statistics
uintx CMS_SweepPadding = 1 {product} {default} The multiple of deviation from mean to use for buffering against volatility in inter-sweep duration
uintx CMS_SweepTimerThresholdMillis = 10 {product} {default} Skip block flux-rate sampling for an epoch unless inter-sweep duration exceeds this threshold in milliseconds
uintx CMS_SweepWeight = 75 {product} {default} Percentage (0-100) used to weight the current sample when computing exponentially decaying average for inter-sweep duration
uintx CPUForCMSThread = 0 {diagnostic} {default} When BindCMSThreadToCPU is true, the CPU to bind CMS thread to
bool CSEArrayLength = false {C1 pd develop} {default} Create separate nodes for length in array accesses
bool CalculateClassFingerprint = false {product} {default} Calculate class fingerprint
bool CanonicalizeNodes = true {C1 develop} {default} Canonicalize graph nodes
bool CheckCompressedOops = true {notproduct} {default} Generate checks in encoding/decoding code in debug VM
bool CheckIntrinsics = true {diagnostic} {default} When a class C is loaded, check that (1) all intrinsics defined by the VM for class C are present in the loaded class file and are marked with the @HotSpotIntrinsicCandidate annotation, that (2) there is an intrinsic registered for all loaded methods that are annotated with the @HotSpotIntrinsicCandidate annotation, and that (3) no orphan methods exist for class C (i.e., methods for which the VM declares an intrinsic but that are not declared in the loaded class C. Check (3) is available only in debug builds.
bool CheckJNICalls = false {product} {default} Verify all arguments to JNI calls
bool CheckMemoryInitialization = false {notproduct} {default} Check memory initialization
bool CheckUnhandledOops = false {develop} {default} Check for unhandled oops in VM code
bool CheckZapUnusedHeapArea = false {develop} {default} Check zapping of unused heap space
bool ClassUnloading = true {product} {default} Do unloading of classes
bool ClassUnloadingWithConcurrentMark = true {product} {default} Do unloading of classes with a concurrent marking cycle
bool CleanChunkPoolAsync = true {develop} {default} Clean the chunk pool asynchronously
bool ClipInlining = true {product} {default} Clip inlining if aggregate method exceeds DesiredMethodLimit
uintx CodeCacheExpansionSize = 65536 {pd product} {default} Code cache expansion size (in bytes)
uintx CodeCacheMinBlockLength = 4 {pd diagnostic} {default} Minimum number of segments in a code cache block
uintx CodeCacheMinimumUseSpace = 409600 {pd develop} {default} Minimum code cache size (in bytes) required to start VM.
uintx CodeCacheSegmentSize = 128 {pd develop} {default} Code cache segment size (in bytes) - smallest unit of allocation
intx CodeEntryAlignment = 32 {pd develop} {default} Code entry alignment for generated code (in bytes)
bool CollectIndexSetStatistics = false {notproduct} {default} Collect information about IndexSets
bool CommentedAssembly = true {C1 develop} {default} Show extra info in PrintNMethods output
bool CompactFields = true {product} {default} Allocate nonstatic fields in gaps between previous fields
bool CompactStrings = true {pd product} {default} Enable Strings to use single byte chars in backing store
intx CompilationPolicyChoice = 0 {product} {default} which compilation policy (0-2)
ccstrlist CompileCommand = {product} {default} Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>
ccstr CompileCommandFile = {product} {default} Read compiler commands from this file [.hotspot_compiler]
ccstrlist CompileOnly = {product} {default} List of methods (pkg/class.name) to restrict compilation to
intx CompileThreshold = 10000 {pd product} {default} number of interpreted method invocations before (re-)compiling
double CompileThresholdScaling = 1.000000 {product} {default} Factor to control when first compilation happens (both with and without tiered compilation): values greater than 1.0 delay counter overflow, values between 0 and 1.0 rush counter overflow, value of 1.0 leaves compilation thresholds unchanged value of 0.0 is equivalent to -Xint. Flag can be set as per-method option. If a value is specified for a method, compilation thresholds for that method are scaled by both the value of the global flag and the value of the per-method flag.
ccstr CompilerDirectivesFile = {diagnostic} {default} Read compiler directives from this file
bool CompilerDirectivesIgnoreCompileCommands = false {diagnostic} {default} Disable backwards compatibility for compile commands.
int CompilerDirectivesLimit = 50 {diagnostic} {default} Limit on number of compiler directives.
bool CompilerDirectivesPrint = false {diagnostic} {default} Print compiler directives on installation.
intx CompilerThreadPriority = -1 {product} {default} The native priority at which compiler threads should run (-1 means no change)
intx CompilerThreadStackSize = 1024 {pd product} {default} Compiler Thread Stack Size (in Kbytes)
size_t CompressedClassSpaceSize = 1073741824 {product} {default} Maximum size of class area in Metaspace when compressed class pointers are used
bool ComputeExactFPURegisterUsage = true {C1 develop} {default} Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)
uint ConcGCThreads = 0 {product} {default} Number of threads concurrent gc will use
intx ConcGCYieldTimeout = 0 {develop} {default} If non-zero, assert that GC threads yield within this number of milliseconds
intx ConditionalMoveLimit = 3 {C2 pd product} {default} Limit of ops to make speculative when using CMOVE
intx ContendedPaddingWidth = 128 {product} {default} How many bytes to pad the fields/classes marked @Contended with
bool ConvertCmpD2CmpF = true {C2 develop} {default} Convert cmpD to cmpF when one input is constant in float range
bool ConvertFloat2IntClipping = true {C2 develop} {default} Convert float2int clipping idiom to integer clipping
bool CountBytecodes = false {develop} {default} Count number of bytecodes executed
bool CountCompiledCalls = false {develop} {default} Count method invocations
bool CountJNICalls = false {develop} {default} Count jni method invocations
bool CountJVMCalls = false {notproduct} {default} Count jvm method invocations
bool CountLinearScan = false {C1 develop} {default} collect statistic counters during LinearScan
bool CountRemovableExceptions = false {notproduct} {default} Count exceptions that could be replaced by branches due to inlining
bool CountRuntimeCalls = false {notproduct} {default} Count VM runtime calls
intx CounterDecayMinIntervalLength = 500 {develop} {default} The minimum interval (in milliseconds) between invocation of CounterDecay
intx CounterHalfLifeTime = 30 {develop} {default} Half-life time of invocation counters (in seconds)
bool CrashGCForDumpingJavaThread = false {notproduct} {default} Manually make GC thread crash then dump java stack trace; Test only
bool CrashOnOutOfMemoryError = false {product} {default} JVM aborts, producing an error log and core/mini dump, on the first occurrence of an out-of-memory error
bool CreateCoredumpOnCrash = true {product} {default} Create core/mini dump on VM fatal error
bool CriticalJNINatives = true {product} {default} Check for critical JNI entry points
bool DTraceAllocProbes = false {product} {default} Enable dtrace probes for object allocation
bool DTraceMethodProbes = false {product} {default} Enable dtrace probes for method-entry and method-exit
bool DTraceMonitorProbes = false {product} {default} Enable dtrace probes for monitor events
bool DebugDeoptimization = false {develop} {default} Tracing various information while debugging deoptimization
bool DebugInlinedCalls = true {C2 diagnostic} {default} If false, restricts profiled locations to the root method only
bool DebugNonSafepoints = true {diagnostic} {default} Generate extra debugging information for non-safepoints in nmethods
bool DebugVtables = false {develop} {default} add debugging code to vtable dispatch
bool Debugging = false {product} {default} Set when executing debug methods in debug.cpp (to prevent triggering assertions)
bool DeferInitialCardMark = false {diagnostic} {default} When +ReduceInitialCardMarks, explicitly defer any that may arise from new_pre_store_barrier
bool DelayCompilationDuringStartup = true {develop} {default} Delay invoking the compiler until main application class is loaded
bool DeoptC1 = true {C1 develop} {default} Use deoptimization in C1
bool DeoptimizeALot = false {develop} {default} Deoptimize at every exit from the runtime system
intx DeoptimizeALotInterval = 5 {notproduct} {default} Number of exits until DeoptimizeALot kicks in
ccstrlist DeoptimizeOnlyAt = {notproduct} {default} A comma separated list of bcis to deoptimize at
bool DeoptimizeRandom = false {product} {default} Deoptimize random frames on random exit from the runtime system
intx DesiredMethodLimit = 8000 {develop} {default} The desired maximum method size (in bytecodes) after inlining
bool DisableAttachMechanism = false {product} {default} Disable mechanism that allows tools to attach to this VM
bool DisableExplicitGC = false {product} {default} Ignore calls to System.gc()
ccstrlist DisableIntrinsic = {diagnostic} {default} do not expand intrinsics whose (internal) names appear here
bool DisableStartThread = false {develop} {default} Disable starting of additional Java threads (for debugging only)
bool DisplayVMOutput = true {diagnostic} {default} Display all VM output on the tty, independently of LogVMOutput
bool DisplayVMOutputToStderr = false {product} {default} If DisplayVMOutput is true, display all VM output to stderr
bool DisplayVMOutputToStdout = false {product} {default} If DisplayVMOutput is true, display all VM output to stdout
bool DoCEE = true {C1 develop} {default} Do Conditional Expression Elimination to simplify CFG
bool DoEscapeAnalysis = true {C2 product} {default} Perform escape analysis
bool DoReserveCopyInSuperWord = true {C2 product} {default} Create reserve copy of graph in SuperWord.
intx DominatorSearchLimit = 1000 {C2 diagnostic} {default} Iterations limit in Node::dominates
bool DontCompileHugeMethods = true {product} {default} Do not compile methods > HugeMethodLimit
bool DontYieldALot = false {pd product} {default} Throw away obvious excess yield calls
intx DontYieldALotInterval = 10 {develop} {default} Interval between which yields will be dropped (milliseconds)
ccstr DumpLoadedClassList = {product} {default} Dump the names all loaded classes, that could be stored into the CDS archive, in the specified file
bool DumpReplayDataOnError = true {product} {default} Record replay data for crashing compiler threads
bool DumpSharedSpaces = false {product} {default} Special mode: JVM reads a class list, loads classes, builds shared spaces, and dumps the shared spaces to a file to be used in future JVM runs
bool DynamicallyResizeSystemDictionaries = true {diagnostic} {default} Dynamically resize system dictionaries as needed
bool EagerInitialization = false {develop} {default} Eagerly initialize classes if possible
bool EagerXrunInit = false {product} {default} Eagerly initialize -Xrun libraries; allows startup profiling, but not all -Xrun libraries may support the state of the VM at this time
intx EliminateAllocationArraySizeLimit = 64 {C2 product} {default} Array size (number of elements) limit for scalar replacement
bool EliminateAllocations = true {C2 product} {default} Use escape analysis to eliminate allocations
bool EliminateAutoBox = true {C2 product} {default} Control optimizations for autobox elimination
bool EliminateBlocks = true {C1 develop} {default} Eliminate unneccessary basic blocks
bool EliminateFieldAccess = true {C1 develop} {default} Optimize field loads and stores
bool EliminateLocks = true {C2 product} {default} Coarsen locks when possible
bool EliminateNestedLocks = true {C2 product} {default} Eliminate nested locks of the same object when possible
bool EliminateNullChecks = true {C1 develop} {default} Eliminate unneccessary null checks
bool EnableContended = true {product} {default} Enable @Contended annotation support
bool EnableDynamicAgentLoading = true {product} {default} Allow tools to load agents with the attach mechanism
bool EnableThreadSMRExtraValidityChecks = true {diagnostic} {default} Enable Thread SMR extra validity checks
bool EnableThreadSMRStatistics = true {diagnostic} {default} Enable Thread SMR Statistics
size_t ErgoHeapSizeLimit = 0 {product} {default} Maximum ergonomically set heap size (in bytes); zero means use MaxRAM * MaxRAMPercentage / 100
ccstr ErrorFile = {product} {default} If an error occurs, save the error data to this file [default: ./hs_err_pid%p.log] (%p replaced with pid)
uintx ErrorHandlerTest = 0 {notproduct} {default} If > 0, provokes an error after VM initialization; the value determines which error to provoke. See test_error_handler() in vmError.cpp.
uint64_t ErrorLogTimeout = 120 {product} {default} Timeout, in seconds, to limit the time spent on writing an error log in case of a crash.
double EscapeAnalysisTimeout = 60.000000 {C2 product} {default} Abort EA when it reaches time limit (in sec)
bool EstimateArgEscape = true {product} {default} Analyze bytecodes to estimate escape state of arguments
bool ExecutingUnitTests = false {product} {default} Whether the JVM is running unit tests or not
bool ExitEscapeAnalysisOnTimeout = true {C2 develop} {default} Exit or throw assert in EA when it reaches time limit
bool ExitOnFullCodeCache = false {notproduct} {default} Exit the VM if we fill the code cache
bool ExitOnOutOfMemoryError = false {product} {default} JVM exits on the first occurrence of an out-of-memory error
bool ExitVMOnVerifyError = false {notproduct} {default} standard exit from VM if bytecode verify error (only in debug mode)
bool ExplicitGCInvokesConcurrent = false {product} {default} A System.gc() request invokes a concurrent collection; (effective only when using concurrent collectors)
bool ExtendedDTraceProbes = false {product} {default} Enable performance-impacting dtrace probes
bool ExtensiveErrorReports = true {product} {default} Error reports are more extensive.
ccstr ExtraSharedClassListFile = {product} {default} Extra classlist for building the CDS archive file
intx FLOATPRESSURE = 14 {C2 pd develop} {default} Number of float LRG\'s that constitute high register pressure
bool FLSAlwaysCoalesceLarge = false {product} {default} CMS: larger free blocks are always available for coalescing
uintx FLSCoalescePolicy = 2 {product} {default} CMS: aggressiveness level for coalescing, increasing from 0 to 4
double FLSLargestBlockCoalesceProximity = 0.990000 {product} {default} CMS: the smaller the percentage the greater the coalescing force
bool FLSVerifyAllHeapReferences = false {diagnostic} {default} Verify that all references across the FLS boundary are to valid objects
bool FLSVerifyDictionary = false {develop} {default} Do lots of (expensive) FLS dictionary verification
bool FLSVerifyIndexTable = false {diagnostic} {default} Do lots of (expensive) FLS index table verification
bool FLSVerifyLists = false {diagnostic} {default} Do lots of (expensive) FreeListSpace verification
bool FailOverToOldVerifier = true {product} {default} Fail over to old verifier when split verifier fails
intx FastAllocateSizeLimit = 131072 {develop} {default} Inline allocations larger than this in doublewords must go slow
intx FastSuperclassLimit = 8 {develop} {default} Depth of hardwired instanceof accelerator array
intx FieldsAllocationStyle = 1 {product} {default} 0 - type based with oops first, 1 - with oops last, 2 - oops in super and sub classes are together
bool FillDelaySlots = true {develop} {default} Fill delay slots (on SPARC only)
bool FilterSpuriousWakeups = true {product} {default} When true prevents OS-level spurious, or premature, wakeups from Object.wait (Ignored for Windows)
bool FlightRecorder = false {product} {default} Enable Flight Recorder
ccstr FlightRecorderOptions = {product} {default} Flight Recorder options
bool FoldStableValues = true {diagnostic} {default} Optimize loads from stable fields (marked w/ @Stable)
bool ForceDynamicNumberOfGCThreads = false {diagnostic} {default} Force dynamic selection of the number of parallel threads parallel gc will use to aid debugging
bool ForceFloatExceptions = true {develop} {default} Force exceptions on FP stack under/overflow
bool ForceNUMA = false {product} {default} Force NUMA optimizations on single-node/UMA systems
bool ForceTimeHighResolution = false {product} {default} Using high time resolution (for Win32 only)
bool ForceUnreachable = false {diagnostic} {default} Make all non code cache addresses to be unreachable by forcing use of 64bit literal fixups
intx FreqCountInvocations = 1 {C2 develop} {default} Scaling factor for branch frequencies (deprecated)
intx FreqInlineSize = 325 {pd product} {default} The maximum bytecode size of a frequent method to be inlined
bool FullGCALot = false {develop} {default} Force full gc at every Nth exit from the runtime system (N=FullGCALotInterval)
intx FullGCALotDummies = 32768 {notproduct} {default} Dummy object allocated with +FullGCALot, forcing all objects to move
intx FullGCALotInterval = 1 {notproduct} {default} Interval between which full gc will occur with +FullGCALot
intx FullGCALotStart = 0 {notproduct} {default} For which invocation to start FullGCAlot
double G1ConcMarkStepDurationMillis = 10.000000 {product} {default} Target duration of individual concurrent marking steps in milliseconds.
uintx G1ConcRSHotCardLimit = 4 {product} {default} The threshold that defines (>=) a hot card.
size_t G1ConcRSLogCacheSize = 10 {product} {default} Log base 2 of the length of conc RS hot-card cache.
size_t G1ConcRefinementGreenZone = 0 {product} {default} The number of update buffers that are left in the queue by the concurrent processing threads. Will be selected ergonomically by default.
size_t G1ConcRefinementRedZone = 0 {product} {default} Maximum number of enqueued update buffers before mutator threads start processing new ones instead of enqueueing them. Will be selected ergonomically by default.
uintx G1ConcRefinementServiceIntervalMillis = 300 {product} {default} The last concurrent refinement thread wakes up every specified number of milliseconds to do miscellaneous work.
uint G1ConcRefinementThreads = 0 {product} {default} The number of parallel rem set update threads. Will be set ergonomically by default.
size_t G1ConcRefinementThresholdStep = 2 {product} {default} Each time the rset update queue increases by this amount activate the next refinement thread if available. The actual step size will be selected ergonomically by default, with this value used to determine a lower bound.
size_t G1ConcRefinementYellowZone = 0 {product} {default} Number of enqueued update buffers that will trigger concurrent processing. Will be selected ergonomically by default.
uintx G1ConfidencePercent = 50 {product} {default} Confidence level for MMU/pause predictions
uintx G1DummyRegionsPerGC = 0 {develop} {default} The number of dummy regions G1 will allocate at the end of each evacuation pause in order to artificially fill up the heap and stress the marking implementation.
bool G1EvacuationFailureALot = false {notproduct} {default} Force use of evacuation failure handling during certain evacuation pauses
uintx G1EvacuationFailureALotCount = 1000 {develop} {default} Number of successful evacuations between evacuation failures occurring at object copying
bool G1EvacuationFailureALotDuringConcMark = true {develop} {default} Force use of evacuation failure handling during evacuation pauses when marking is in progress
bool G1EvacuationFailureALotDuringInitialMark = true {develop} {default} Force use of evacuation failure handling during initial mark evacuation pauses
bool G1EvacuationFailureALotDuringMixedGC = true {develop} {default} Force use of evacuation failure handling during mixed evacuation pauses
bool G1EvacuationFailureALotDuringYoungGC = true {develop} {default} Force use of evacuation failure handling during young evacuation pauses
uintx G1EvacuationFailureALotInterval = 5 {develop} {default} Total collections between forced triggering of evacuation failures
bool G1ExitOnExpansionFailure = false {develop} {default} Raise a fatal VM exit out of memory failure in the event that heap expansion fails due to running out of swap.
size_t G1HeapRegionSize = 0 {product} {default} Size of the G1 regions.
uintx G1HeapWastePercent = 5 {product} {default} Amount of space, expressed as a percentage of the heap size, that G1 is willing not to collect to avoid expensive GCs.
intx G1MaxVerifyFailures = -1 {develop} {default} The maximum number of verification failures to print. -1 means print all.
uintx G1MixedGCCountTarget = 8 {product} {default} The target number of mixed GCs after a marking cycle.
uintx G1PeriodicGCInterval = 0 {manageable} {default} Number of milliseconds after a previous GC to wait before triggering a periodic gc. A value of zero disables periodically enforced gc cycles.
bool G1PeriodicGCInvokesConcurrent = true {product} {default} Determines the kind of periodic GC. Set to true to have G1 perform a concurrent GC as periodic GC, otherwise use a STW Full GC.
double G1PeriodicGCSystemLoadThreshold = 0.000000 {manageable} {default} Maximum recent system wide load as returned by the 1m value of getloadavg() at which G1 triggers a periodic GC. A load above this value cancels a given periodic GC. A value of zero disables this check.
intx G1RSetRegionEntries = 0 {product} {default} Max number of regions for which we keep bitmaps.Will be set ergonomically by default
intx G1RSetRegionEntriesBase = 256 {develop} {default} Max number of regions in a fine-grain table per MB.
size_t G1RSetScanBlockSize = 64 {product} {default} Size of a work unit of cards claimed by a worker threadduring RSet scanning.
intx G1RSetSparseRegionEntries = 0 {product} {default} Max number of entries per region in a sparse table.Will be set ergonomically by default.
intx G1RSetSparseRegionEntriesBase = 4 {develop} {default} Max number of entries per region in a sparse table per MB.
intx G1RSetUpdatingPauseTimePercent = 10 {product} {default} A target percentage of time that is allowed to be spend on process RS update buffers during the collection pause.
uint G1RefProcDrainInterval = 1000 {product} {default} The number of discovered reference objects to process before draining concurrent marking work queues.
uintx G1ReservePercent = 10 {product} {default} It determines the minimum reserve we should have in the heap to minimize the probability of promotion failure.
uintx G1SATBBufferEnqueueingThresholdPercent = 60 {product} {default} Before enqueueing them, each mutator thread tries to do some filtering on the SATB buffers it generates. If post-filtering the percentage of retained entries is over this threshold the buffer will be enqueued for processing. A value of 0 specifies that mutator threads should not do such filtering.
size_t G1SATBBufferSize = 1024 {product} {default} Number of entries in an SATB log buffer.
intx G1SATBProcessCompletedThreshold = 20 {develop} {default} Number of completed buffers that triggers log processing.
intx G1SummarizeRSetStatsPeriod = 0 {diagnostic} {default} The period (in number of GCs) at which we will generate update buffer processing info (0 means do not periodically generate this info); it also requires that logging is enabled on the tracelevel for gc+remset
size_t G1UpdateBufferSize = 256 {product} {default} Size of an update buffer
bool G1UseAdaptiveConcRefinement = true {product} {default} Select green, yellow and red zones adaptively to meet the the pause requirements.
bool G1UseAdaptiveIHOP = true {product} {default} Adaptively adjust the initiating heap occupancy from the initial value of InitiatingHeapOccupancyPercent. The policy attempts to start marking in time based on application behavior.
bool G1VerifyBitmaps = false {develop} {default} Verifies the consistency of the marking bitmaps
bool G1VerifyCTCleanup = false {develop} {default} Verify card table cleanup.
bool G1VerifyHeapRegionCodeRoots = false {diagnostic} {default} Verify the code root lists attached to each heap region.
bool G1VerifyRSetsDuringFullGC = false {diagnostic} {default} If true, perform verification of each heap region\'s remembered set when verifying the heap during a full GC.
bool GCALotAtAllSafepoints = false {notproduct} {default} Enforce ScavengeALot/GCALot at all potential safepoints
uintx GCDrainStackTargetSize = 64 {product} {default} Number of entries we will try to leave on the stack during parallel gc
uintx GCExpandToAllocateDelayMillis = 0 {develop} {default} Delay between expansion and allocation (in milliseconds)
uintx GCHeapFreeLimit = 2 {product} {default} Minimum percentage of free space after a full GC before an OutOfMemoryError is thrown (used with GCTimeLimit)
uintx GCLockerEdenExpansionPercent = 5 {product} {default} How much the GC can expand the eden by while the GC locker is active (as a percentage)
bool GCLockerInvokesConcurrent = false {product} {default} The exit of a JNI critical section necessitating a scavenge, also kicks off a background concurrent collection
uintx GCLockerRetryAllocationCount = 2 {diagnostic} {default} Number of times to retry allocations when blocked by the GC locker
bool GCParallelVerificationEnabled = true {diagnostic} {default} Enable parallel memory system verification
uintx GCPauseIntervalMillis = 0 {product} {default} Time slice for MMU specification
uint GCTaskTimeStampEntries = 200 {product} {default} Number of time stamp entries per gc worker thread
uintx GCTimeLimit = 98 {product} {default} Limit of the proportion of time spent in GC before an OutOfMemoryError is thrown (used with GCHeapFreeLimit)
uintx GCTimeRatio = 99 {product} {default} Adaptive size policy application time to GC time ratio
uintx GCWorkerDelayMillis = 0 {develop} {default} Delay in scheduling GC workers (in milliseconds)
bool GenerateArrayStoreCheck = true {C1 develop} {default} Generates code for array store checks
bool GenerateRangeChecks = true {develop} {default} Generate range checks for array accesses
bool GenerateSynchronizationCode = true {develop} {default} generate locking/unlocking code for synchronized methods and monitors
intx GuaranteedSafepointInterval = 1000 {diagnostic} {default} Guarantee a safepoint (at least) every so many milliseconds (0 means none)
uint HandshakeTimeout = 0 {diagnostic} {default} If nonzero set a timeout in milliseconds for handshakes
size_t HeapBaseMinAddress = 2147483648 {pd product} {default} OS specific low limit for heap base address
bool HeapDumpAfterFullGC = false {manageable} {default} Dump heap to file after any major stop-the-world GC
bool HeapDumpBeforeFullGC = false {manageable} {default} Dump heap to file before any major stop-the-world GC
bool HeapDumpOnOutOfMemoryError = false {manageable} {default} Dump heap to file when java.lang.OutOfMemoryError is thrown
ccstr HeapDumpPath = {manageable} {default} When HeapDumpOnOutOfMemoryError is on, the path (filename or directory) of the dump file (defaults to java_pid<pid>.hprof in the working directory)
uintx HeapFirstMaximumCompactionCount = 3 {product} {default} The collection count for the first maximum compaction
uintx HeapMaximumCompactionInterval = 20 {product} {default} How often should we maximally compact the heap (not allowing any dead space)
uintx HeapSearchSteps = 3 {product} {default} Heap allocation steps through preferred address regions to find where it can allocate the heap. Number of steps to take per region.
size_t HeapSizePerGCThread = 43620760 {product} {default} Size of heap (bytes) per GC thread used in calculating the number of GC threads
intx HotCallCountThreshold = 999999 {C2 develop} {default} large numbers of calls (per method invocation) force hotness
intx HotCallProfitThreshold = 999999 {C2 develop} {default} highly profitable inlining opportunities force hotness
intx HotCallTrivialSize = -1 {C2 develop} {default} trivial methods (no larger than this) force calls to be hot
intx HotCallTrivialWork = -1 {C2 develop} {default} trivial execution time (no larger than this) forces hotness
intx HotMethodDetectionLimit = 100000 {diagnostic} {default} Number of compiled code invocations after which the method is considered as hot by the flusher
intx HugeMethodLimit = 8000 {develop} {default} Don\'t compile methods larger than this if +DontCompileHugeMethods
bool ICMissHistogram = false {notproduct} {default} Produce histogram of IC misses
bool IEEEPrecision = true {ARCH develop} {default} Enables IEEE precision (for INTEL only)
intx INTPRESSURE = 13 {C2 pd develop} {default} Number of integer LRG\'s that constitute high register pressure
bool IdealizeClearArrayNode = true {C2 pd diagnostic} {default} Replace ClearArrayNode by subgraph of basic operations.
bool IdealizedNumerics = false {C2 develop} {default} Check performance difference allowing FP associativity and commutativity...
bool IgnoreEmptyClassPaths = false {product} {default} Ignore empty path elements in -classpath
bool IgnoreLibthreadGPFault = false {develop} {default} Suppress workaround for libthread GP fault
bool IgnoreLockingAssertions = false {notproduct} {default} disable locking assertions (for speed)
bool IgnoreRewrites = false {develop} {default} Suppress rewrites of bytecodes in the oopmap generator. This is unsafe!
bool IgnoreUnrecognizedVMOptions = false {product} {default} Ignore unrecognized VM options
bool ImplicitDiv0Checks = true {C1 develop} {default} Use implicit division by zero checks
intx ImplicitNullCheckThreshold = 3 {C2 develop} {default} Don\'t do implicit null checks if NPE\'s in a method exceeds limit
bool ImplicitNullChecks = true {pd diagnostic} {default} Generate code for implicit null checks
uintx IncreaseFirstTierCompileThresholdAt = 50 {product} {default} Increase the compile threshold for C1 compilation if the code cache is filled by the specified percentage
bool IncrementalInline = true {C2 product} {default} do post parse inlining
intx IndexSetWatch = 0 {C2 notproduct} {default} Trace all operations on this IndexSet (-1 means all, 0 none)
intx InitArrayShortSize = 64 {pd diagnostic} {default} Threshold small size (in bytes) for clearing arrays. Anything this size or smaller may get converted to discrete scalar stores.
size_t InitialBootClassLoaderMetaspaceSize = 4194304 {product} {default} Initial size of the boot class loader data metaspace
uintx InitialCodeCacheSize = 2555904 {pd product} {default} Initial code cache size (in bytes)
size_t InitialHeapSize = 0 {product} {default} Initial heap size (in bytes); zero means use ergonomics
uintx InitialRAMFraction = 64 {product} {default} Fraction (1/n) of real memory used for initial heap size. Deprecated, use InitialRAMPercentage instead
double InitialRAMPercentage = 1.562500 {product} {default} Percentage of real memory used for initial heap size
uintx InitialSurvivorRatio = 8 {product} {default} Initial ratio of young generation/survivor space size
uintx InitialTenuringThreshold = 7 {product} {default} Initial value for tenuring threshold
uintx InitiatingHeapOccupancyPercent = 45 {product} {default} 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)
bool InjectCompilerCreationFailure = false {develop} {default} Inject thread creation failures for UseDynamicNumberOfCompilerThreads
bool InjectGCWorkerCreationFailure = false {diagnostic} {default} Inject thread creation failures for UseDynamicNumberOfGCThreads
bool Inline = true {product} {default} Enable inlining
bool InlineAccessors = true {C2 develop} {default} inline accessor methods (get/set)
bool InlineArrayCopy = true {diagnostic} {default} Inline arraycopy native that is known to be part of base library DLL
bool InlineClassNatives = true {diagnostic} {default} Inline Class.isInstance, etc
ccstr InlineDataFile = {product} {default} File containing inlining replay information[default: ./inline_pid%p.log] (%p replaced with pid)
intx InlineFrequencyCount = 100 {pd diagnostic} {default} Count of call site execution necessary to trigger frequent inlining
intx InlineFrequencyRatio = 20 {develop} {default} Ratio of call site execution to caller method invocation
bool InlineIntrinsics = true {pd develop} {default} Inline intrinsics that can be statically resolved
bool InlineMathNatives = true {diagnostic} {default} Inline SinD, CosD, etc.
bool InlineMethodsWithExceptionHandlers = true {C1 develop} {default} Inline methods containing exception handlers (NOTE: does not work with current backend)
bool InlineNIOCheckIndex = true {C1 diagnostic} {default} Intrinsify java.nio.Buffer.checkIndex
bool InlineNatives = true {diagnostic} {default} Inline natives that are known to be part of base library DLL
bool InlineObjectCopy = true {C2 diagnostic} {default} inline Object.clone and Arrays.copyOf[Range] intrinsics
bool InlineObjectHash = true {diagnostic} {default} Inline Object::hashCode() native that is known to be part of base library DLL
bool InlineReflectionGetCallerClass = true {C2 diagnostic} {default} inline sun.reflect.Reflection.getCallerClass(), known to be part of base library DLL
intx InlineSmallCode = 1000 {pd product} {default} Only inline already compiled methods if their code size is less than this
bool InlineSynchronizedMethods = true {C1 product} {default} Inline synchronized methods
bool InlineThreadNatives = true {diagnostic} {default} Inline Thread.currentThread, etc
intx InlineThrowCount = 50 {develop} {default} Force inlining of interpreted methods that throw this often
intx InlineThrowMaxSize = 200 {develop} {default} Force inlining of throwing methods smaller than this
bool InlineUnsafeOps = true {diagnostic} {default} Inline memory ops (native methods) from Unsafe
bool InlineWarmCalls = false {C2 develop} {default} Use a heat-based priority queue to govern inlining
bool InsertMemBarAfterArraycopy = true {C2 product} {default} Insert memory barrier after arraycopy call
bool InstallMethods = true {C1 develop} {default} Install methods at the end of successful compilations
intx InstructionCountCutoff = 37000 {C1 develop} {default} If GraphBuilder adds this many instructions, bails out
bool InterceptOSException = false {develop} {default} Start debugger when an implicit OS (e.g. NULL) exception happens
intx InteriorEntryAlignment = 16 {C2 pd product} {default} Code alignment for interior entry points in generated code (in bytes)
intx InterpreterProfilePercentage = 33 {product} {default} NON_TIERED number of method invocations/branches (expressed as % of CompileThreshold) before profiling in the interpreter
bool JVMCIUseFastLocking = true {JVMCI develop} {default} Use fast inlined locking code
size_t JVMInvokeMethodSlack = 8192 {pd develop} {default} Stack space (bytes) required for JVM_InvokeMethod to complete
bool JavaMonitorsInStackTrace = true {product} {default} Print information about Java monitor locks when the stacks aredumped
intx JavaPriority10_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority1_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority2_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority3_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority4_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority5_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority6_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority7_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority8_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
intx JavaPriority9_To_OSPriority = -1 {product} {default} Map Java priorities to OS priorities
bool LIRFillDelaySlots = false {C1 pd product} {default} fill delays on on SPARC with LIR
bool LIRTraceExecution = false {C1 develop} {default} add LIR code which logs the execution of blocks
bool LIRTracePeephole = false {C1 develop} {default} Trace peephole optimizer
size_t LargePageHeapSizeThreshold = 134217728 {product} {default} Use large pages if maximum heap is at least this big
size_t LargePageSizeInBytes = 0 {product} {default} Large page size (0 to let VM choose the page size)
bool LargePagesIndividualAllocationInjectError = false {develop} {default} Fail large pages individual allocation
intx LiveNodeCountInliningCutoff = 40000 {C2 product} {default} max number of live nodes in a method
bool LoadLineNumberTables = true {develop} {default} Tell whether the class file parser loads line number tables
bool LoadLocalVariableTables = true {develop} {default} Tell whether the class file parser loads local variable tables
bool LoadLocalVariableTypeTables = true {develop} {default} Tell whether the class file parser loads local variable typetables
bool LogCompilation = false {diagnostic} {default} Log compilation activity in detail to LogFile
bool LogEvents = true {diagnostic} {default} Enable the various ring buffer event logs
uintx LogEventsBufferEntries = 10 {diagnostic} {default} Number of ring buffer event logs
ccstr LogFile = {diagnostic} {default} If LogVMOutput or LogCompilation is on, save VM output to this file [default: ./hotspot_pid%p.log] (%p replaced with pid)
bool LogSweeper = false {notproduct} {default} Keep a ring buffer of sweeper activity
bool LogTouchedMethods = false {diagnostic} {default} Log methods which have been ever touched in runtime
bool LogVMOutput = false {diagnostic} {default} Save VM output to LogFile
intx LongCompileThreshold = 50 {develop} {default} Used with +TraceLongCompiles
intx LoopMaxUnroll = 16 {C2 product} {default} Maximum number of unrolls for main loop
intx LoopOptsCount = 43 {C2 product} {default} Set level of loop optimization for tier 1 compiles
intx LoopPercentProfileLimit = 30 {C2 pd product} {default} Unroll loop bodies with % node count of profile limit
uintx LoopStripMiningIter = 0 {C2 product} {default} Number of iterations in strip mined loop
uintx LoopStripMiningIterShortLoop = 0 {C2 product} {default} Loop with fewer iterations are not strip mined
intx LoopUnrollLimit = 60 {C2 pd product} {default} Unroll loop bodies with node count less than this
intx LoopUnrollMin = 4 {C2 product} {default} Minimum number of unroll loop bodies before checking progressof rounds of unroll,optimize,..
bool LoopUnswitching = true {C2 product} {default} Enable loop unswitching (a form of invariant test hoisting)
intx MallocCatchPtr = -1 {develop} {default} Hit breakpoint when mallocing/freeing this pointer
uintx MallocMaxTestWords = 0 {diagnostic} {default} If non-zero, maximum number of words that malloc/realloc can allocate (for testing only)
bool ManagementServer = false {product} {default} Create JMX Management Server
size_t MarkStackSize = 4194304 {product} {default} Size of marking stack
size_t MarkStackSizeMax = 536870912 {product} {default} Maximum size of marking stack
uint MarkSweepAlwaysCompactCount = 4 {product} {default} How often should we fully compact the heap (ignoring the dead space parameters)
uintx MarkSweepDeadRatio = 5 {product} {default} 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.
intx MaxBCEAEstimateLevel = 5 {product} {default} Maximum number of nested calls that are analyzed by BC EA
intx MaxBCEAEstimateSize = 150 {product} {default} Maximum bytecode size of a method to be analyzed by BC EA
uint64_t MaxDirectMemorySize = 0 {product} {default} Maximum total size of NIO direct-buffer allocations
intx MaxElementPrintSize = 256 {notproduct} {default} maximum number of elements to print
bool MaxFDLimit = true {product} {default} Bump the number of file descriptors to maximum in Solaris
intx MaxForceInlineLevel = 100 {develop} {default} maximum number of nested calls that are forced for inlining (using CompileCommand or marked w/ @ForceInline)
uintx MaxGCMinorPauseMillis = 18446744073709551615 {product} {default} Adaptive size policy maximum GC minor pause time goal in millisecond
uintx MaxGCPauseMillis = 18446744073709551614 {product} {default} Adaptive size policy maximum GC pause time goal in millisecond, or (G1 Only) the maximum GC time per MMU time slice
uintx MaxHeapFreeRatio = 70 {manageable} {default} The maximum percentage of heap free after GC to avoid shrinking. For most GCs this applies to the old generation. In G1 and ParallelGC it applies to the whole heap.
size_t MaxHeapSize = 130862280 {product} {default} Maximum heap size (in bytes)
intx MaxInlineLevel = 9 {product} {default} maximum number of nested calls that are inlined
intx MaxInlineSize = 35 {product} {default} The maximum bytecode size of a method to be inlined
intx MaxInterpretedSearchLength = 3 {develop} {default} The maximum number of interpreted frames to skip when searching for recompilee
intx MaxJNILocalCapacity = 65536 {product} {default} Maximum allowable local JNI handle capacity to EnsureLocalCapacity() and PushLocalFrame(), where <= 0 is unlimited, default: 65536
intx MaxJavaStackTraceDepth = 1024 {product} {default} The maximum number of lines in the stack trace for Java exceptions (0 means all)
intx MaxJumpTableSize = 65000 {C2 product} {default} Maximum number of targets in a generated jump table
intx MaxJumpTableSparseness = 5 {C2 product} {default} Maximum sparseness for jumptables
intx MaxLabelRootDepth = 1100 {C2 product} {default} Maximum times call Label_Root to prevent stack overflow
intx MaxLoopPad = 15 {C2 product} {default} Align a loop if padding size in bytes is less or equal to this value
size_t MaxMetaspaceExpansion = 5452592 {product} {default} The maximum expansion of Metaspace without full GC (in bytes)
uintx MaxMetaspaceFreeRatio = 70 {product} {default} The maximum percentage of Metaspace free after GC to avoid shrinking
size_t MaxMetaspaceSize = 18446744073709551615 {product} {default} Maximum size of Metaspaces (in bytes)
size_t MaxNewSize = 18446744073709551615 {product} {default} Maximum new generation size (in bytes), max_uintx means set ergonomically
intx MaxNodeLimit = 80000 {C2 product} {default} Maximum number of nodes
uint64_t MaxRAM = 137438953472 {pd product} {default} Real memory size (in bytes) used to set maximum heap size
uintx MaxRAMFraction = 4 {product} {default} Maximum fraction (1/n) of real memory used for maximum heap size. Deprecated, use MaxRAMPercentage instead
double MaxRAMPercentage = 25.000000 {product} {default} Maximum percentage of real memory used for maximum heap size
intx MaxRecompilationSearchLength = 10 {develop} {default} The maximum number of frames to inspect when searching for recompilee
intx MaxRecursiveInlineLevel = 1 {product} {default} maximum number of nested recursive calls that are inlined
intx MaxSubklassPrintSize = 4 {notproduct} {default} maximum number of subklasses to print when printing klass
uintx MaxTenuringThreshold = 15 {product} {default} Maximum value for tenuring threshold
intx MaxTrivialSize = 6 {product} {default} The maximum bytecode size of a trivial method to be inlined
intx MaxVectorSize = 64 {C2 product} {default} Max vector size in bytes, actual size could be less depending on elements type
uintx MaxVirtMemFraction = 2 {develop} {default} Maximum fraction (1/n) of virtual memory used for ergonomically determining maximum heap size
bool MemProfiling = false {develop} {default} Write memory usage profiling to log file
intx MemProfilingInterval = 500 {notproduct} {default} Time between each invocation of the MemProfiler
bool MetadataAllocationFailALot = false {develop} {default} Fail metadata allocations at intervals controlled by MetadataAllocationFailALotInterval
uintx MetadataAllocationFailALotInterval = 1000 {develop} {default} Metadata allocation failure a lot interval
size_t MetaspaceSize = 21810376 {pd product} {default} Initial threshold (in bytes) at which a garbage collection is done to reduce Metaspace usage
bool MethodFlushing = true {product} {default} Reclamation of zombie and not-entrant methods
intx MethodHistogramCutoff = 100 {develop} {default} The cutoff value for method invocation histogram (+CountCalls)
size_t MinHeapDeltaBytes = 170392 {product} {default} The minimum change in heap space due to GC (in bytes)
uintx MinHeapFreeRatio = 40 {manageable} {default} The minimum percentage of heap free after GC to avoid expansion. For most GCs this applies to the old generation. In G1 and ParallelGC it applies to the whole heap.
intx MinInliningThreshold = 250 {product} {default} The minimum invocation count a method needs to have to be inlined
intx MinJumpTableSize = 10 {C2 pd product} {default} Minimum number of targets in a generated jump table
size_t MinMetaspaceExpansion = 340784 {product} {default} The minimum expansion of Metaspace (in bytes)
uintx MinMetaspaceFreeRatio = 40 {product} {default} The minimum percentage of Metaspace free after GC to avoid expansion
intx MinOopMapAllocation = 8 {develop} {default} Minimum number of OopMap entries in an OopMapSet
intx MinPassesBeforeFlush = 10 {diagnostic} {default} Minimum number of sweeper passes before an nmethod can be flushed
uintx MinRAMFraction = 2 {product} {default} Minimum fraction (1/n) of real memory used for maximum heap size on systems with small physical memory size. Deprecated, use MinRAMPercentage instead
double MinRAMPercentage = 50.000000 {product} {default} Minimum percentage of real memory used for maximum heapsize on systems with small physical memory size
uintx MinSurvivorRatio = 3 {product} {default} Minimum ratio of young generation/survivor space size
size_t MinTLABSize = 2048 {product} {default} Minimum allowed TLAB size (in bytes)
intx MonitorBound = 0 {product} {default} Bound Monitor population
bool MonomorphicArrayCheck = true {C2 develop} {default} Uncommon-trap array store checks that require full type check
intx MultiArrayExpandLimit = 6 {C2 product} {default} Maximum number of individual allocations in an inline-expanded multianewarray instruction
intx NMethodSizeLimit = 524288 {C1 develop} {default} Maximum size of a compiled method.
uintx NUMAChunkResizeWeight = 20 {product} {default} Percentage (0-100) used to weight the current sample when computing exponentially decaying average for AdaptiveNUMAChunkSizing
size_t NUMAInterleaveGranularity = 2097152 {product} {default} Granularity to use for NUMA interleaving on Windows OS
uintx NUMAPageScanRate = 256 {product} {default} Maximum number of pages to include in the page scan procedure
size_t NUMASpaceResizeRate = 1073741824 {product} {default} Do not reallocate more than this amount per collection
bool NUMAStats = false {product} {default} Print NUMA stats in detailed heap information
ccstr NativeMemoryTracking = off {product} {default} Native memory tracking options
bool NeedsDeoptSuspend = false {pd product} {default} True for register window machines (sparc/ia64)
intx NestedInliningSizeRatio = 90 {C1 develop} {default} Percentage of prev. allowed inline size in recursive inlining
bool NeverActAsServerClassMachine = false {pd product} {default} Never act like a server-class machine
bool NeverTenure = false {product} {default} Never tenure objects in eden, may tenure on overflow (ParallelGC only)
intx NewCodeParameter = 0 {develop} {default} Testing Only: Create a dedicated integer parameter before putback
uintx NewRatio = 2 {product} {default} Ratio of old/new generation sizes
size_t NewSize = 1363144 {product} {default} Initial new generation size (in bytes)
size_t NewSizeThreadIncrease = 5320 {pd product} {default} Additional size added to desired new generation size per non-daemon thread (in bytes)
intx NmethodSweepActivity = 10 {product} {default} Removes cold nmethods from code cache if > 0. Higher values result in more aggressive sweeping
intx NodeCountInliningCutoff = 18000 {C2 develop} {default} If parser node generation exceeds limit stop inlining
intx NodeCountInliningStep = 1000 {C2 develop} {default} Target size of warm calls inlined between optimization passes
intx NodeLimitFudgeFactor = 2000 {C2 product} {default} Fudge Factor for certain optimizations
uintx NonNMethodCodeHeapSize = 5242880 {pd product} {default} Size of code heap with non-nmethods (in bytes)
uintx NonProfiledCodeHeapSize = 22020096 {pd product} {default} Size of code heap with non-profiled methods (in bytes)
intx NumberOfLoopInstrToAlign = 4 {C2 product} {default} Number of first instructions in a loop to align
intx OSROnlyBCI = -1 {develop} {default} OSR only at this bci. Negative values mean exclude that bci
uintx ObjArrayMarkingStride = 2048 {develop} {default} Number of object array elements to push onto the marking stack before pushing a continuation entry
intx ObjectAlignmentInBytes = 8 {lp64_product} {default} Default object alignment in bytes, 8 is minimum
size_t OldPLABSize = 1024 {product} {default} Size of old gen promotion LAB\'s (in HeapWords), or Number of blocks to attempt to claim when refilling CMS LAB\'s
uintx OldPLABWeight = 50 {product} {default} Percentage (0-100) used to weight the current sample when computing exponentially decaying average for resizing OldPLABSize
size_t OldSize = 5452592 {product} {default} Initial tenured generation size (in bytes)
bool OmitStackTraceInFastThrow = true {product} {default} Omit backtraces for some 'hot' exceptions in optimized code
ccstrlist OnError = {product} {default} Run user-defined commands on fatal error; see VMError.cpp for examples
ccstrlist OnOutOfMemoryError = {product} {default} Run user-defined commands on first java.lang.OutOfMemoryError
intx OnStackReplacePercentage = 140 {pd product} {default} NON_TIERED number of method invocations/branches (expressed as % of CompileThreshold) before (re-)compiling OSR code
bool OptimizeExpensiveOps = true {C2 diagnostic} {default} Find best control for expensive operations
bool OptimizeFill = true {C2 product} {default} convert fill/copy loops into intrinsic
bool OptimizeIfOps = true {C1 develop} {default} Optimize multiple IfOps
bool OptimizePtrCompare = true {C2 product} {default} Use escape analysis to optimize pointers compare
bool OptimizeStringConcat = true {C2 product} {default} Optimize the construction of Strings by StringBuilder
bool OptimizeUnsafes = true {C1 develop} {default} Optimize raw unsafe ops
intx OptoBlockListSize = 8 {C2 develop} {default} Starting allocation size of Block_List data structures
bool OptoBreakpoint = false {C2 develop} {default} insert breakpoint at method entry
bool OptoBreakpointC2R = false {C2 notproduct} {default} insert breakpoint at runtime stub entry
bool OptoBreakpointOSR = false {C2 notproduct} {default} insert breakpoint at osr method entry
bool OptoBundling = false {C2 pd product} {default} Generate nops to fill i-cache lines
bool OptoCoalesce = true {C2 develop} {default} Use Conservative Copy Coalescing in the Register Allocator
intx OptoLoopAlignment = 16 {pd product} {default} Align inner loops to zero relative to this modulus
bool OptoNoExecute = false {C2 notproduct} {default} Attempt to parse and compile but do not execute generated code
intx OptoNodeListSize = 4 {C2 develop} {default} Starting allocation size of Node_List data structures
bool OptoPeephole = true {C2 pd develop} {default} Apply peephole optimizations after register allocation
intx OptoPeepholeAt = -1 {C2 develop} {default} Apply peephole optimizations to this peephole rule
intx OptoPrologueNops = 0 {C2 develop} {default} Insert this many extra nop instructions in the prologue of every nmethod
bool OptoRegScheduling = true {C2 pd product} {default} Instruction Scheduling before register allocation for pressure
bool OptoRemoveUseless = true {C2 develop} {default} Remove useless nodes after parsing
bool OptoScheduling = false {C2 pd product} {default} Instruction Scheduling after register allocation
uintx PLABWeight = 75 {product} {default} Percentage (0-100) used to weight the current sample when computing exponentially decaying average for ResizePLAB
intx PSAdaptiveSizePolicyResizeVirtualSpaceAlot = -1 {develop} {default} Resize the virtual spaces of the young or old generations
bool PSChunkLargeArrays = true {product} {default} Process large arrays in chunks
int ParGCArrayScanChunk = 50 {product} {default} Scan a subset of object array and push remainder, if array is bigger than this
intx ParGCCardsPerStrideChunk = 256 {diagnostic} {default} The number of cards in each chunk of the parallel chunks used during card table scanning
uintx ParGCDesiredObjsFromOverflowList = 20 {product} {default} The desired number of objects to claim from the overflow list
uintx ParGCStridesPerThread = 2 {diagnostic} {default} The number of strides per worker thread that we divide up the card table scanning work into
bool ParGCTrimOverflow = true {product} {default} Eagerly trim the local overflow lists (when ParGCUseLocalOverflow)
bool ParGCUseLocalOverflow = false {product} {default} Instead of a global overflow list, use local overflow stacks
bool ParGCWorkQueueOverflowALot = false {notproduct} {default} Simulate work queue overflow in ParNew
uintx ParGCWorkQueueOverflowInterval = 1000 {notproduct} {default} An 'interval' counter that determines how frequently we simulate overflow; a smaller number increases frequency
uintx ParallelGCBufferWastePct = 10 {product} {default} Wasted fraction of parallel allocation buffer
uint ParallelGCThreads = 0 {product} {default} Number of parallel threads parallel gc will use
size_t ParallelOldDeadWoodLimiterMean = 50 {product} {default} The mean used by the parallel compact dead wood limiter (a number between 0-100)
size_t ParallelOldDeadWoodLimiterStdDev = 80 {product} {default} The standard deviation used by the parallel compact dead wood limiter (a number between 0-100)
bool ParallelRefProcBalancingEnabled = true {product} {default} Enable balancing of reference processing queues
bool ParallelRefProcEnabled = false {product} {default} Enable parallel reference processing whenever possible
bool PartialPeelAtUnsignedTests = true {C2 product} {default} Partial peel at unsigned tests if no signed test exists
bool PartialPeelLoop = true {C2 product} {default} Partial peel (rotate) loops
intx PartialPeelNewPhiDelta = 0 {C2 product} {default} Additional phis that can be created by partial peeling
bool PatchALot = false {C1 develop} {default} Marks all fields as having unloaded classes
bool PauseAtExit = false {diagnostic} {default} Pause and wait for keypress on exit if a debugger is attached
bool PauseAtStartup = false {diagnostic} {default} Causes the VM to pause at startup time and wait for the pause file to be removed (default: ./vm.paused.<pid>)
ccstr PauseAtStartupFile = {diagnostic} {default} The file to create and for whose removal to await when pausing at startup. (default: ./vm.paused.<pid>)
uintx PausePadding = 1 {product} {default} How much buffer to keep for pause time
intx PerBytecodeRecompilationCutoff = 200 {product} {default} Per-BCI limit on repeated recompilation (-1=>'Inf')
intx PerBytecodeTrapLimit = 4 {product} {default} Limit on traps (of one kind) at a particular BCI
intx PerMethodRecompilationCutoff = 400 {product} {default} After recompiling N times, stay in the interpreter (-1=>'Inf')
intx PerMethodTrapLimit = 100 {product} {default} Limit on traps (of one kind) in a method (includes inlines)
bool PerfAllowAtExitRegistration = false {product} {default} Allow registration of atexit() methods
bool PerfBypassFileSystemCheck = false {product} {default} Bypass Win32 file system criteria checks (Windows Only)
intx PerfDataMemorySize = 32768 {product} {default} Size of performance data memory region. Will be rounded up to a multiple of the native os page size.
intx PerfDataSamplingInterval = 50 {product} {default} Data sampling interval (in milliseconds)
ccstr PerfDataSaveFile = {product} {default} Save PerfData memory to the specified absolute pathname. The string %p in the file name (if present) will be replaced by pid
bool PerfDataSaveToFile = false {product} {default} Save PerfData memory to hsperfdata_<pid> file on exit
bool PerfDisableSharedMem = false {product} {default} Store performance data in standard memory
intx PerfMaxStringConstLength = 1024 {product} {default} Maximum PerfStringConstant string length before truncation
bool PinAllInstructions = false {C1 develop} {default} All instructions are pinned
bool PoisonOSREntry = true {C2 develop} {default} Detect abnormal calls to OSR code
size_t PreTouchParallelChunkSize = 1073741824 {product} {default} Per-thread chunk size for parallel memory pre-touch.
uintx PreallocatedOutOfMemoryErrorCount = 4 {develop} {default} Number of OutOfMemoryErrors preallocated with backtrace
bool PreferInterpreterNativeStubs = false {pd product} {default} Use always interpreter stubs for native methods invoked via interpreter
intx PrefetchCopyIntervalInBytes = -1 {product} {default} How far ahead to prefetch destination area (<= 0 means off)
intx PrefetchFieldsAhead = -1 {product} {default} How many fields ahead to prefetch in oop scan (<= 0 means off)
intx PrefetchScanIntervalInBytes = -1 {product} {default} How far ahead to prefetch scan area (<= 0 means off)
bool PreserveAllAnnotations = false {product} {default} Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations
bool PreserveFramePointer = false {pd product} {default} Use the FP register for holding the frame pointer and not as a general purpose register.
size_t PretenureSizeThreshold = 0 {product} {default} Maximum size in bytes of objects allocated in DefNew generation; zero means no maximum
bool PrintAOT = false {product} {default} Print used AOT klasses and methods
bool PrintAOTStatistics = false {notproduct} {default} Print AOT statistics
bool PrintAdapterHandlers = false {diagnostic} {default} Print code generated for i2c/c2i adapters
bool PrintAssembly = false {diagnostic} {default} Print assembly code (using external disassembler.so)
ccstr PrintAssemblyOptions = {diagnostic} {default} Print options string passed to disassembler.so
bool PrintBailouts = false {C1 develop} {default} Print bailout and its reason
bool PrintBiasedLockingStatistics = false {diagnostic} {default} Print statistics of biased locking in JVM
bool PrintBlockElimination = false {C1 develop} {default} Print basic block elimination
bool PrintBytecodeHistogram = false {develop} {default} Print histogram of the executed bytecodes
bool PrintBytecodePairHistogram = false {develop} {default} Print histogram of the executed bytecode pairs
bool PrintC1Statistics = false {C1 notproduct} {default} Print Compiler1 statistics
bool PrintCEE = false {C1 develop} {default} Print Conditional Expression Elimination
bool PrintCFG = false {C1 notproduct} {default} Print control flow graph after each change
bool PrintCFG0 = false {C1 notproduct} {default} Print control flow graph after construction
bool PrintCFG1 = false {C1 notproduct} {default} Print control flow graph after optimizations
bool PrintCFG2 = false {C1 notproduct} {default} Print control flow graph before code generation
bool PrintCFGBlockFreq = false {C2 develop} {default} Print CFG block freqencies
bool PrintCFGToFile = false {C1 develop} {default} print control flow graph to a separate file during compilation
bool PrintCanonicalization = false {C1 develop} {default} Print graph node canonicalization
bool PrintClassHistogram = false {manageable} {default} Print a histogram of class instances
bool PrintCodeCache = false {product} {default} Print the code cache memory usage when exiting
bool PrintCodeCache2 = false {develop} {default} Print detailed usage information on the code cache when exiting
bool PrintCodeCacheExtension = false {develop} {default} Print extension of code cache
bool PrintCodeCacheOnCompilation = false {product} {default} Print the code cache memory usage each time a method is compiled
bool PrintCodeHeapAnalytics = false {diagnostic} {default} Print code heap usage statistics on exit and on full condition
bool PrintCommandLineFlags = false {product} {default} Print flags specified on command line or set by ergonomics
bool PrintCompilation = false {product} {default} Print compilations
bool PrintCompilation2 = false {diagnostic} {default} Print additional statistics per compilation
bool PrintConcurrentLocks = false {manageable} {default} Print java.util.concurrent locks in thread dump
bool PrintDebugInfo = false {develop} {default} Print debug information for all nmethods when generated
bool PrintDeoptimizationDetails = false {develop} {default} Print more information about deoptimization
bool PrintDependencies = false {develop} {default} Print dependency information for all nmethods when generated
bool PrintDominators = false {C2 develop} {default} Print out dominator trees for GVN
bool PrintEliminateAllocations = false {C2 notproduct} {default} Print out when allocations are eliminated
bool PrintEliminateLocks = false {C2 notproduct} {default} Print out when locks are eliminated
bool PrintEscapeAnalysis = false {C2 notproduct} {default} Print the results of escape analysis
bool PrintExceptionHandlers = false {develop} {default} Print exception handler tables for all nmethods when generated
bool PrintExtendedThreadInfo = false {product} {default} Print more information in thread dump
bool PrintFieldLayout = false {notproduct} {default} Print field layout for each class
bool PrintFlagsFinal = false {product} {default} Print all VM flags after argument and ergonomic processing
bool PrintFlagsInitial = false {product} {default} Print all VM flags before argument processing and exit VM
bool PrintFlagsRanges = false {product} {default} Print VM flags and their ranges and exit VM
bool PrintFlagsWithComments = false {notproduct} {default} Print all VM flags with default values and descriptions and exit
bool PrintFrameConverterAssembly = false {C2 notproduct} {default} Print New compiler assembly output for frame converters
bool PrintGC = false {product} {default} Print message at garbage collection. Deprecated, use -Xlog:gc instead.
bool PrintGCDetails = false {product} {default} Print more details at garbage collection. Deprecated, use -Xlog:gc* instead.
bool PrintHeapAtSIGBREAK = true {product} {default} Print heap layout in response to SIGBREAK
bool PrintIR = false {C1 notproduct} {default} Print full intermediate representation after each change
bool PrintIR0 = false {C1 notproduct} {default} Print full intermediate representation after construction
bool PrintIR1 = false {C1 notproduct} {default} Print full intermediate representation after optimizations
bool PrintIR2 = false {C1 notproduct} {default} Print full intermediate representation before code generation
bool PrintIRDuringConstruction = false {C1 notproduct} {default} Print IR as it\'s being constructed (helpful for debugging frontend)
bool PrintIRWithLIR = false {C1 notproduct} {default} Print IR instructions with generated LIR
bool PrintIdeal = false {C2 notproduct} {default} Print ideal graph before code generation
bool PrintIdealGraph = false {C2 notproduct} {default} Print ideal graph to XML file / network interface. By default attempts to connect to the visualizer on a socket.
ccstr PrintIdealGraphAddress = 127.0.0.1 {C2 notproduct} {default} IP address to connect to visualizer
ccstr PrintIdealGraphFile = {C2 notproduct} {default} File to dump ideal graph to. If set overrides the use of the network
intx PrintIdealGraphLevel = 0 {C2 notproduct} {default} Level of detail of the ideal graph printout. System-wide value, 0=nothing is printed, 4=all details printed. Level of detail of printouts can be set on a per-method level as well by using CompileCommand=option.
intx PrintIdealGraphPort = 4444 {C2 notproduct} {default} Ideal graph printer to network port
bool PrintIdealNodeCount = false {C2 notproduct} {default} Print liveness counts of ideal nodes
bool PrintInitialBlockList = false {C1 notproduct} {default} Print block list of BlockListBuilder
bool PrintInlining = false {diagnostic} {default} Print inlining optimizations
bool PrintInterpreter = false {diagnostic} {default} Print the generated interpreter code
bool PrintIntrinsics = false {C2 diagnostic} {default} prints attempted and successful inlining of intrinsics
bool PrintJNIResolving = false {product} {default} Used to implement -v:jni
bool PrintLIR = false {C1 develop} {default} print low-level IR
bool PrintLIRWithAssembly = false {C1 notproduct} {default} Show LIR instruction with generated assembly
bool PrintLockStatistics = false {C2 notproduct} {default} Print precise statistics on the dynamic lock usage
bool PrintMallocStatistics = false {develop} {default} Print malloc/free statistics
bool PrintMethodData = false {diagnostic} {default} Print the results of +ProfileInterpreter at end of run
bool PrintMethodFlushing = false {develop} {default} Print the nmethods being flushed
bool PrintMethodFlushingStatistics = false {diagnostic} {default} print statistics about method flushing
bool PrintMethodHandleStubs = false {diagnostic} {default} Print generated stub code for method handles
bool PrintMiscellaneous = false {develop} {default} Print uncategorized debugging information (requires +Verbose)
bool PrintNMTStatistics = false {diagnostic} {default} Print native memory tracking summary data if it is on
bool PrintNMethodStatistics = false {notproduct} {default} Print a summary statistic for the generated nmethods
bool PrintNMethods = false {diagnostic} {default} Print assembly code for nmethods when generated
bool PrintNativeNMethods = false {diagnostic} {default} Print assembly code for native nmethods when generated
bool PrintNotLoaded = false {C1 develop} {default} Prints where classes are not loaded during code generation
bool PrintNullCheckElimination = false {C1 develop} {default} Print null check elimination
bool PrintOptimizePtrCompare = false {C2 notproduct} {default} Print information about optimized pointers compare
bool PrintOptimizeStringConcat = false {C2 notproduct} {default} Print information about transformations performed on Strings
bool PrintOpto = false {C2 notproduct} {default} Print compiler2 attempts
bool PrintOptoAssembly = false {C2 diagnostic} {default} Print New compiler assembly output
bool PrintOptoInlining = false {C2 notproduct} {default} Print compiler2 inlining decisions
bool PrintOptoPeephole = false {C2 notproduct} {default} Print New compiler peephole replacements
bool PrintOptoStatistics = false {C2 notproduct} {default} Print New compiler statistics
bool PrintParseStatistics = false {C2 notproduct} {default} Print nodes, transforms and new values made per bytecode parsed
bool PrintPhiFunctions = false {C1 notproduct} {default} Print phi functions when they are created and simplified
bool PrintPreciseBiasedLockingStatistics = false {C2 diagnostic} {default} Print per-lock-site statistics of biased locking in JVM
bool PrintPreciseRTMLockingStatistics = false {C2 diagnostic} {default} Print per-lock-site statistics of rtm locking in JVM
bool PrintRelocations = false {develop} {default} Print relocation information for all nmethods when generated
bool PrintRewrites = false {notproduct} {default} Print methods that are being rewritten
bool PrintSharedArchiveAndExit = false {product} {default} Print shared archive file contents
bool PrintSharedDictionary = false {product} {default} If PrintSharedArchiveAndExit is true, also print the shared dictionary
bool PrintSignatureHandlers = false {diagnostic} {default} Print code generated for native method signature handlers
bool PrintSimpleStubs = false {C1 notproduct} {default} Print SimpleStubs
bool PrintStringTableStatistics = false {product} {default} print statistics about the StringTable and SymbolTable
bool PrintStubCode = false {diagnostic} {default} Print generated stub code
bool PrintSymbolTableSizeHistogram = false {notproduct} {default} print histogram of the symbol table
bool PrintSystemDictionaryAtExit = false {notproduct} {default} Print the system dictionary at exit
bool PrintTieredEvents = false {product} {default} Print tiered events notifications
bool PrintTouchedMethodsAtExit = false {diagnostic} {default} Print all methods that have been ever touched in runtime
bool PrintUnsafeOptimization = false {C1 develop} {default} Print optimization of raw unsafe ops
bool PrintVMMessages = true {develop} {default} Print VM messages on console
bool PrintVMOptions = false {product} {default} Print flags that appeared on the command line
bool PrintVMQWaitTime = false {product} {default} Print out the waiting time in VM operation queue
bool PrintValueNumbering = false {C1 develop} {default} Print Value Numbering
bool PrintVtableStats = false {notproduct} {default} print vtables stats at end of run
bool PrintWarnings = true {product} {default} Print JVM warnings to output stream
uintx ProcessDistributionStride = 4 {product} {default} Stride through processors when distributing processes
bool ProfileDynamicTypes = true {C2 diagnostic} {default} do extra type profiling and use it more aggressively
bool ProfileInterpreter = true {pd product} {default} Profile at the bytecode level during interpretation
bool ProfileIntervals = false {product} {default} Print profiles for each interval (see ProfileIntervalsTicks)
intx ProfileIntervalsTicks = 100 {product} {default} Number of ticks between printing of interval profile (+ProfileIntervals)
intx ProfileMaturityPercentage = 20 {product} {default} number of method invocations/branches (expressed as % of CompileThreshold) before using the method\'s profile
bool ProfileTraps = true {pd develop} {default} Profile deoptimization traps at the bytecode level
bool ProfileVM = false {product} {default} Profile ticks that fall within VM (either in the VM Thread or VM code called through stubs)
uintx ProfiledCodeHeapSize = 23068672 {pd product} {default} Size of code heap with profiled methods (in bytes)
bool ProfilerCheckIntervals = false {notproduct} {default} Collect and print information on spacing of profiler ticks
intx ProfilerNodeSize = 1024 {develop} {default} Size in K to allocate for the Profile Nodes of each thread
intx ProfilerNumberOfCompiledMethods = 25 {diagnostic} {default} Number of compiled methods to show in profile
intx ProfilerNumberOfInterpretedMethods = 25 {diagnostic} {default} Number of interpreted methods to show in profile
intx ProfilerNumberOfRuntimeStubNodes = 25 {diagnostic} {default} Number of runtime stub nodes to show in profile
intx ProfilerNumberOfStubMethods = 25 {diagnostic} {default} Number of stub methods to show in profile
intx ProfilerPCTickThreshold = 15 {develop} {default} Number of ticks in a PC buckets to be a hotspot
bool ProfilerPrintByteCodeStatistics = false {product} {default} Print bytecode statistics when dumping profiler output
bool ProfilerRecordPC = false {product} {default} Collect ticks for each 16 byte interval of compiled code
uintx PromotedPadding = 3 {product} {default} How much buffer to keep for promotion failure
bool PromotionFailureALot = false {notproduct} {default} Use promotion failure handling on every youngest generation collection
uintx PromotionFailureALotCount = 1000 {develop} {default} Number of promotion failures occurring at PLAB refill attempts (ParNew) or promotion attempts (other young collectors)
uintx PromotionFailureALotInterval = 5 {develop} {default} Total collections between promotion failures a lot
bool ProtectionDomainVerification = true {develop} {default} Verify protection domain before resolution in system dictionary
uintx QueuedAllocationWarningCount = 0 {product} {default} Number of times an allocation that queues behind a GC will retry before printing a warning
int RTMRetryCount = 5 {ARCH product} {default} Number of RTM retries on lock abort or busy
bool RangeCheckElimination = true {product} {default} Eliminate range checks
bool ReassociateInvariants = true {C2 product} {default} Enable reassociation of expressions with loop invariants.
bool ReduceBulkZeroing = true {C2 product} {default} When bulk-initializing, try to avoid needless zeroing
bool ReduceFieldZeroing = true {C2 product} {default} When initializing fields, try to avoid needless zeroing
bool ReduceInitialCardMarks = true {C2 product} {default} When initializing fields, try to avoid needless card marks
bool ReduceNumberOfCompilerThreads = true {diagnostic} {default} Reduce the number of parallel compiler threads when they are not used
bool ReduceSignalUsage = false {product} {default} Reduce the use of OS signals in Java and/or the VM
intx RefDiscoveryPolicy = 0 {product} {default} Select type of reference discovery policy: reference-based(0) or referent-based(1)
intx RegisterCostAreaRatio = 16000 {C2 pd develop} {default} Spill selection in reg allocator: scale area by (X/64K) before adding cost
bool RegisterFinalizersAtInit = true {product} {default} Register finalizable objects at end of Object.<init> or after allocation
bool RegisterReferences = true {develop} {default} Tell whether the VM should register soft/weak/final/phantom references
bool RelaxAccessControlCheck = false {product} {default} Relax the access control checks in the verifier
bool RenumberLiveNodes = true {C2 develop} {default} Renumber live nodes
bool ReplayCompiles = false {develop} {default} Enable replay of compilations from ReplayDataFile
ccstr ReplayDataFile = {product} {default} File containing compilation replay information[default: ./replay_pid%p.log] (%p replaced with pid)
bool ReplayIgnoreInitErrors = false {develop} {default} Ignore exceptions thrown during initialization for replay
intx ReplaySuppressInitializers = 2 {develop} {default} Control handling of class initialization during replay: 0 - don\'t do anything special; 1 - treat all class initializers as empty; 2 - treat class initializers for application classes as empty; 3 - allow all class initializers to run during bootstrap but pretend they are empty after starting replay
bool RequireSharedSpaces = false {product} {default} Require shared spaces for metadata
uintx ReservedCodeCacheSize = 50331648 {pd product} {default} Reserved code cache size (in bytes) - maximum code cache size
bool ResizeOldPLAB = true {product} {default} Dynamically resize (old gen) promotion LAB\'s
bool ResizePLAB = true {product} {default} Dynamically resize (survivor space) promotion LAB\'s
bool ResizeTLAB = true {pd product} {default} Dynamically resize TLAB size for threads
bool RestoreMXCSROnJNICalls = false {product} {default} Restore MXCSR when returning from JNI calls
bool RestrictContended = true {product} {default} Restrict @Contended to trusted classes
bool RestrictReservedStack = true {product} {default} Restrict @ReservedStackAccess to trusted classes
bool RewriteBytecodes = true {pd product} {default} Allow rewriting of bytecodes (bytecodes are not immutable)
bool RewriteFrequentPairs = true {pd product} {default} Rewrite frequently used bytecode pairs into a single bytecode
bool RoundFPResults = true {C1 pd develop} {default} Indicates whether rounding is needed for floating point results
bool SafepointALot = false {develop} {default} Generate a lot of safepoints. This works with GuaranteedSafepointInterval
bool SafepointTimeout = false {product} {default} Time out and warn or fail after SafepointTimeoutDelay milliseconds if failed to reach safepoint
intx SafepointTimeoutDelay = 10000 {product} {default} Delay in milliseconds for option SafepointTimeout
bool ScavengeALot = false {notproduct} {default} Force scavenge at every Nth exit from the runtime system (N=ScavengeALotInterval)
intx ScavengeALotInterval = 1 {notproduct} {default} Interval between which scavenge will occur with +ScavengeALot
bool ScavengeBeforeFullGC = true {product} {default} Scavenge youngest generation before each full GC.
intx ScavengeRootsInCode = 2 {diagnostic} {default} 0: do not allow scavengable oops in the code cache; 1: allow scavenging from the code cache; 2: emit as many constants as the compiler can see
bool SegmentedCodeCache = false {product} {default} Use a segmented code cache
bool SelectivePhiFunctions = true {C1 develop} {default} create phi functions at loop headers only when necessary
intx SelfDestructTimer = 0 {product} {default} Will cause VM to terminate after a given time (in minutes) (0 means off)
bool SerializeVMOutput = true {diagnostic} {default} Use a mutex to serialize output to tty and LogFile
bool ShareVtableStubs = true {pd develop} {default} Share vtable stubs (smaller code but worse branch prediction
ccstr SharedArchiveConfigFile = {product} {default} Data to add to the CDS archive file
ccstr SharedArchiveFile = {product} {default} Override the default location of the CDS archive file
size_t SharedBaseAddress = 34359738368 {product} {default} Address to allocate shared memory region for class data
ccstr SharedClassListFile = {product} {default} Override the default CDS class list
uintx SharedSymbolTableBucketSize = 4 {product} {default} Average number of symbols per bucket in shared table
bool ShenandoahAcmpBarrier = true {diagnostic} {default} Turn on/off acmp barriers in Shenandoah
bool ShenandoahAllocFailureALot = false {diagnostic} {default} Make lots of artificial allocation failures.
intx ShenandoahAllocationStallThreshold = 10000 {diagnostic} {default} When allocation tracing is enabled, the allocation stalls larger than this threshold would be reported as warnings. Time is in microseconds.
bool ShenandoahAllocationTrace = false {diagnostic} {default} Trace allocation latencies and stalls. Can be expensive when lots of allocations happen, and may introduce scalability bottlenecks.
bool ShenandoahAllowMixedAllocs = true {diagnostic} {default} Allow mixing mutator and collector allocations in a single region
bool ShenandoahAlwaysPreTouch = false {diagnostic} {default} Pre-touch heap memory, overrides global AlwaysPreTouch
bool ShenandoahCASBarrier = true {diagnostic} {default} Turn on/off CAS barriers in Shenandoah
bool ShenandoahCloneBarrier = true {diagnostic} {default} Turn on/off clone barriers in Shenandoah
bool ShenandoahDecreaseRegisterPressure = false {diagnostic} {default} Try to reuse after-barrier values to reduce register pressure
bool ShenandoahDegeneratedGC = true {diagnostic} {default} Use Degenerated GC as the graceful degradation step. Disabling this leads to degradation to Full GC
bool ShenandoahElasticTLAB = true {diagnostic} {default} Use Elastic TLABs with Shenandoah
bool ShenandoahKeepAliveBarrier = true {diagnostic} {default} Turn on/off keep alive barriers in Shenandoah
bool ShenandoahOOMDuringEvacALot = false {diagnostic} {default} Simulate OOM during evacuation frequently.
bool ShenandoahReadBarrier = true {diagnostic} {default} Turn on/off read barriers in Shenandoah
bool ShenandoahSATBBarrier = true {diagnostic} {default} Turn on/off SATB barriers in Shenandoah
bool ShenandoahStoreCheck = false {diagnostic} {default} Emit additional code that checks objects are written to only in to-space
bool ShenandoahStoreValEnqueueBarrier = false {diagnostic} {default} Turn on/off enqueuing of oops for storeval barriers
bool ShenandoahStoreValReadBarrier = true {diagnostic} {default} Turn on/off store val read barriers in Shenandoah
bool ShenandoahTerminationTrace = false {diagnostic} {default} Tracing task termination timings
bool ShenandoahVerify = false {diagnostic} {default} Verify the Shenandoah garbage collector
intx ShenandoahVerifyLevel = 4 {diagnostic} {default} Shenandoah verification level: 0 = basic heap checks; 1 = previous level, plus basic region checks; 2 = previous level, plus all roots; 3 = previous level, plus all reachable objects; 4 = previous level, plus all marked objects
bool ShenandoahVerifyObjectEquals = false {develop} {default} Verify that == and != are not used on oops. Only in fastdebug
bool ShenandoahVerifyOptoBarriers = false {develop} {default} Verify no missing barriers in C2
bool ShenandoahWriteBarrier = true {diagnostic} {default} Turn on/off write barriers in Shenandoah
bool ShowHiddenFrames = false {diagnostic} {default} show method handle implementation frames (usually hidden)
bool ShowMessageBoxOnError = false {product} {default} Keep process alive on VM fatal error
bool ShowRegistersOnAssert = true {diagnostic} {default} On internal errors, include registers in error report.
bool ShrinkHeapInSteps = true {product} {default} When disabled, informs the GC to shrink the java heap directly to the target size at the next full GC rather than requiring smaller steps during multiple full GCs.
bool SoftMatchFailure = false {C2 develop} {default} If the DFA fails to match a node, print a message and bail out
intx SoftRefLRUPolicyMSPerMB = 1000 {product} {default} Number of milliseconds per MB of free space in the heap
bool SparcV9RegsHiBitsZero = true {C2 develop} {default} Assume Sparc V9 I&L registers on V8+ systems are zero-extended
bool SpecialArraysEquals = true {C2 diagnostic} {default} special version of Arrays.equals(char[],char[])
bool SpecialEncodeISOArray = true {C2 diagnostic} {default} special version of ISO_8859_1$Encoder.encodeISOArray
bool SpecialStringCompareTo = true {C2 diagnostic} {default} special version of string compareTo
bool SpecialStringEquals = true {C2 diagnostic} {default} special version of string equals
bool SpecialStringIndexOf = true {C2 diagnostic} {default} special version of string indexOf
bool SplitIfBlocks = true {C2 product} {default} Clone compares and control flow through merge points to fold some branches
intx StackPrintLimit = 100 {develop} {default} number of stack frames to print in VM-level stack dump
intx StackRedPages = 1 {pd product} {default} Number of red zone (unrecoverable overflows) pages of size 4KB. If pages are bigger red zone is aligned up.
intx StackReservedPages = 1 {pd product} {default} Number of reserved zone (reserved to annotated methods) pages of size 4KB. If pages are bigger reserved zone is aligned up.
intx StackShadowPages = 22 {pd product} {default} Number of shadow zone (for overflow checking) pages of size 4KB. If pages are bigger shadow zone is aligned up. This should exceed the depth of the VM and native call stack.
bool StackTraceInThrowable = true {product} {default} Collect backtrace in throwable when exception happens
intx StackYellowPages = 2 {pd product} {default} Number of yellow zone (recoverable overflows) pages of size 4KB. If pages are bigger yellow zone is aligned up.
uintx StartAggressiveSweepingAt = 10 {product} {default} Start aggressive sweeping if X[%] of the code cache is free.Segmented code cache: X[%] of the non-profiled heap.Non-segmented code cache: X[%] of the total code cache
bool StartAttachListener = false {product} {default} Always start Attach Listener at VM startup
ccstr StartFlightRecording = {product} {default} Start flight recording with options
intx StopInterpreterAt = 0 {develop} {default} Stop interpreter execution at specified bytecode number
bool StressArrayCopyMacroNode = false {C2 develop} {default} Perform ArrayCopy load/store replacement during IGVN only
bool StressCodeAging = false {diagnostic} {default} Start with counters compiled in
bool StressCodeBuffers = false {develop} {default} Exercise code buffer expansion and other rare state changes
bool StressCompiledExceptionHandlers = false {develop} {default} Exercise compiled exception handlers
bool StressCriticalJNINatives = false {notproduct} {default} Exercise register saving code in critical natives
bool StressDerivedPointers = false {notproduct} {default} Force scavenge when a derived pointer is detected on stack after rtm call
bool StressGCM = false {C2 diagnostic} {default} Randomize instruction scheduling in GCM
bool StressLCM = false {C2 diagnostic} {default} Randomize instruction scheduling in LCM
bool StressLdcRewrite = false {product} {default} Force ldc -> ldc_w rewrite during RedefineClasses
bool StressLinearScan = false {C1 develop} {default} scramble block order used by LinearScan (stress test)
bool StressLoopInvariantCodeMotion = false {C1 develop} {default} stress loop invariant code motion
bool StressMethodHandleLinkerInlining = false {C2 develop} {default} Stress inlining through method handle linkers
bool StressRangeCheckElimination = false {C1 develop} {default} stress Range Check Elimination
bool StressRecompilation = false {C2 develop} {default} Recompile each compiled method without subsuming loads or escape analysis.
bool StressReflectiveCode = false {C2 develop} {default} Use inexact types at allocations, etc., to test reflection
bool StressRewriter = false {develop} {default} Stress linktime bytecode rewriting
bool StrictSafepointChecks = true {notproduct} {default} Enable strict checks that safepoints cannot happen for threads that use NoSafepointVerifier
uintx StringDeduplicationAgeThreshold = 3 {product} {default} A string must reach this age (or be promoted to an old region) to be considered for deduplication
bool StringDeduplicationRehashALot = false {diagnostic} {default} Force table rehash every time the table is scanned
bool StringDeduplicationResizeALot = false {diagnostic} {default} Force table resize every time the table is scanned
uintx StringTableSize = 65536 {product} {default} Number of buckets in the interned String table (will be rounded to nearest higher power of 2)
bool SubsumeLoads = true {C2 develop} {default} Attempt to compile while subsuming loads into machine instructions.
bool SuperWordLoopUnrollAnalysis = true {C2 pd product} {default} Map number of unrolls for main loop via Superword Level Parallelism analysis
bool SuperWordRTDepCheck = false {C2 develop} {default} Enable runtime dependency checks.
bool SuperWordReductions = true {C2 product} {default} Enable reductions support in superword.
ccstrlist SuppressErrorAt = {notproduct} {default} List of assertions (file:line) to muzzle
bool SuppressFatalErrorMessage = false {product} {default} Report NO fatal error message (avoid deadlock)
uintx SurvivorPadding = 3 {product} {default} How much buffer to keep for survivor overflow
uintx SurvivorRatio = 8 {product} {default} Ratio of eden/survivor space size
intx SuspendRetryCount = 50 {product} {default} Maximum retry count for an external suspend request
intx SuspendRetryDelay = 5 {product} {default} Milliseconds to delay per retry (* current_retry_count)
intx SweeperLogEntries = 1024 {notproduct} {default} Number of records in the ring buffer of sweeper activity
uintx TLABAllocationWeight = 35 {product} {default} Allocation averaging weight
uintx TLABRefillWasteFraction = 64 {product} {default} Maximum TLAB waste at a refill (internal fragmentation)
size_t TLABSize = 0 {product} {default} Starting TLAB size (in bytes); zero means set ergonomically
bool TLABStats = true {product} {default} Provide more detailed and expensive TLAB statistics.
uintx TLABWasteIncrement = 4 {product} {default} Increment allowed waste at slow allocation
uintx TLABWasteTargetPercent = 1 {product} {default} Percentage of Eden that can be wasted
uintx TargetPLABWastePct = 10 {product} {default} Target wasted space in last buffer as percent of overall allocation
uintx TargetSurvivorRatio = 50 {product} {default} Desired percentage of survivor space used after scavenge
uintx TenuredGenerationSizeIncrement = 20 {product} {default} Adaptive size percentage change in tenured generation
uintx TenuredGenerationSizeSupplement = 80 {product} {default} Supplement to TenuredGenerationSizeIncrement used at startup
uintx TenuredGenerationSizeSupplementDecay = 2 {product} {default} Decay factor to TenuredGenerationSizeIncrement
uintx TestCrashInErrorHandler = 0 {notproduct} {default} If > 0, provokes an error inside VM error handler (a secondary crash). see test_error_handler() in vmError.cpp
bool TestSafeFetchInErrorHandler = false {notproduct} {default} If true, tests SafeFetch inside error handler.
bool TestUnresponsiveErrorHandler = false {notproduct} {default} If true, simulates an unresponsive error handler.
bool ThreadLocalHandshakes = true {pd product} {default} Use thread-local polls instead of global poll for safepoints.
intx ThreadPriorityPolicy = 0 {product} {default} 0 : Normal. VM chooses priorities that are appropriate for normal applications. On Solaris NORM_PRIORITY and above are mapped to normal native priority. Java priorities below NORM_PRIORITY map to lower native priority values. On Windows applications are allowed to use higher native priorities. However, with ThreadPriorityPolicy=0, VM will not use the highest possible native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with system threads. On Linux thread priorities are ignored because the OS does not support static priority in SCHED_OTHER scheduling class which is the only choice for non-root, non-realtime applications. 1 : Aggressive. Java thread priorities map over to the entire range of native thread priorities. Higher Java thread priorities map to higher native thread priorities. This policy should be used with care, as sometimes it can cause performance degradation in the application and/or the entire system. On Linux this policy requires root privilege.
bool ThreadPriorityVerbose = false {product} {default} Print priority changes
intx ThreadStackSize = 1024 {pd product} {default} Thread Stack Size (in Kbytes)
uintx ThresholdTolerance = 10 {product} {default} Allowed collection cost difference between generations
intx Tier0BackedgeNotifyFreqLog = 10 {product} {default} Interpreter (tier 0) invocation notification frequency
intx Tier0InvokeNotifyFreqLog = 7 {product} {default} Interpreter (tier 0) invocation notification frequency
intx Tier0ProfilingStartPercentage = 200 {product} {default} Start profiling in interpreter if the counters exceed tier 3 thresholds by the specified percentage
intx Tier23InlineeNotifyFreqLog = 20 {product} {default} Inlinee invocation (tiers 2 and 3) notification frequency
intx Tier2BackEdgeThreshold = 0 {product} {default} Back edge threshold at which tier 2 compilation is invoked
intx Tier2BackedgeNotifyFreqLog = 14 {product} {default} C1 without MDO (tier 2) invocation notification frequency
intx Tier2CompileThreshold = 0 {product} {default} threshold at which tier 2 compilation is invoked
intx Tier2InvokeNotifyFreqLog = 11 {product} {default} C1 without MDO (tier 2) invocation notification frequency
intx Tier3AOTBackEdgeThreshold = 120000 {product} {default} Back edge threshold at which tier 3 OSR compilation is invoked if coming from AOT
intx Tier3AOTCompileThreshold = 15000 {product} {default} Threshold at which tier 3 compilation is invoked (invocation minimum must be satisfied) if coming from AOT
intx Tier3AOTInvocationThreshold = 10000 {product} {default} Compile if number of method invocations crosses this threshold if coming from AOT
intx Tier3AOTMinInvocationThreshold = 1000 {product} {default} Minimum invocation to compile at tier 3 if coming from AOT
intx Tier3BackEdgeThreshold = 60000 {product} {default} Back edge threshold at which tier 3 OSR compilation is invoked
intx Tier3BackedgeNotifyFreqLog = 13 {product} {default} C1 with MDO profiling (tier 3) invocation notification frequency
intx Tier3CompileThreshold = 2000 {product} {default} Threshold at which tier 3 compilation is invoked (invocation minimum must be satisfied)
intx Tier3DelayOff = 2 {product} {default} If C2 queue size is less than this amount per compiler thread allow methods compiled at tier 2 transition to tier 3
intx Tier3DelayOn = 5 {product} {default} If C2 queue size grows over this amount per compiler thread stop compiling at tier 3 and start compiling at tier 2
intx Tier3InvocationThreshold = 200 {product} {default} Compile if number of method invocations crosses this threshold
intx Tier3InvokeNotifyFreqLog = 10 {product} {default} C1 with MDO profiling (tier 3) invocation notification frequency
intx Tier3LoadFeedback = 5 {product} {default} Tier 3 thresholds will increase twofold when C1 queue size reaches this amount per compiler thread
intx Tier3MinInvocationThreshold = 100 {product} {default} Minimum invocation to compile at tier 3
intx Tier4BackEdgeThreshold = 40000 {product} {default} Back edge threshold at which tier 4 OSR compilation is invoked
intx Tier4CompileThreshold = 15000 {product} {default} Threshold at which tier 4 compilation is invoked (invocation minimum must be satisfied
intx Tier4InvocationThreshold = 5000 {product} {default} Compile if number of method invocations crosses this threshold
intx Tier4LoadFeedback = 3 {product} {default} Tier 4 thresholds will increase twofold when C2 queue size reaches this amount per compiler thread
intx Tier4MinInvocationThreshold = 600 {product} {default} Minimum invocation to compile at tier 4
bool TieredCompilation = true {pd product} {default} Enable tiered compilation
intx TieredCompileTaskTimeout = 50 {product} {default} Kill compile task if method was not used within given timeout in milliseconds
intx TieredRateUpdateMaxTime = 25 {product} {default} Maximum rate sampling interval (in milliseconds)
intx TieredRateUpdateMinTime = 1 {product} {default} Minimum rate sampling interval (in milliseconds)
intx TieredStopAtLevel = 4 {product} {default} Stop at given compilation level
bool TimeCompilationPolicy = false {develop} {default} Time the compilation policy
bool TimeEachLinearScan = false {C1 develop} {default} print detailed timing of each LinearScan run
bool TimeLinearScan = false {C1 product} {default} detailed timing of LinearScan phases
bool TimeLivenessAnalysis = false {develop} {default} Time computation of bytecode liveness analysis
bool TimeOopMap = false {develop} {default} Time calls to GenerateOopMap::compute_map() in sum
bool TimeOopMap2 = false {develop} {default} Time calls to GenerateOopMap::compute_map() individually
bool TraceBytecodes = false {develop} {default} Trace bytecode execution
intx TraceBytecodesAt = 0 {develop} {default} Trace bytecodes starting with specified bytecode number
bool TraceCISCSpill = false {C2 notproduct} {default} Trace allocators use of cisc spillable instructions
bool TraceCallFixup = false {develop} {default} Trace all call fixups
bool TraceCodeBlobStacks = false {notproduct} {default} Trace stack-walk of codeblobs
bool TraceCompilationPolicy = false {develop} {default} Trace compilation policy
bool TraceCompiledIC = false {develop} {default} Trace changes of compiled IC
bool TraceCompilerThreads = false {diagnostic} {default} Trace creation and removal of compiler threads
bool TraceCreateZombies = false {develop} {default} trace creation of zombie nmethods
bool TraceDeoptimization = false {develop} {default} Trace deoptimization
bool TraceDependencies = false {develop} {default} Trace dependencies
bool TraceDerivedPointers = false {develop} {default} Trace traversal of derived pointers on stack
bool TraceFPURegisterUsage = false {C1 develop} {default} Trace usage of FPU registers at start of blocks (intel only)
bool TraceFPUStack = false {C1 develop} {default} Trace emulation of the FPU stack (intel only)
bool TraceFinalizerRegistration = false {develop} {default} Trace registration of final references
bool TraceFrequencyInlining = false {develop} {default} Trace frequency based inlining
bool TraceGCTaskManager = false {develop} {default} Trace actions of the GC task manager
bool TraceGCTaskQueue = false {develop} {default} Trace actions of the GC task queues
bool TraceICBuffer = false {develop} {default} Trace usage of IC buffer
bool TraceICs = false {develop} {default} Trace inline cache changes
bool TraceInlineCacheClearing = false {develop} {default} Trace clearing of inline caches in nmethods
bool TraceInvocationCounterOverflow = false {notproduct} {default} Trace method invocation counter overflow
bool TraceInvokeDynamic = false {develop} {default} trace internal invoke dynamic operations
bool TraceIterativeGVN = false {C2 develop} {default} Print progress during Iterative Global Value Numbering
ccstr TraceJVMTI = {product} {default} Trace flags for JVMTI functions and events
bool TraceJVMTIObjectTagging = false {diagnostic} {default} Trace JVMTI object tagging calls
bool TraceJavaAssertions = false {develop} {default} Trace java language assertions
intx TraceLinearScanLevel = 0 {C1 develop} {default} Debug levels for the linear scan allocator
bool TraceLivenessGen = false {develop} {default} Trace the generation of liveness analysis information
bool TraceLivenessQuery = false {notproduct} {default} Trace queries of liveness analysis information
bool TraceLongCompiles = false {develop} {default} Print out every time compilation is longer than a given threshold
bool TraceLoopLimitCheck = false {C2 develop} {default} Trace generation of loop limits checks
bool TraceLoopOpts = false {C2 develop} {default} Trace executed loop optimizations
bool TraceLoopPredicate = false {C2 develop} {default} Trace generation of loop predicates
bool TraceLoopUnswitching = false {C2 notproduct} {default} Trace loop unswitching
bool TraceMethodHandles = false {develop} {default} trace internal method handle operations
bool TraceMethodReplacement = false {develop} {default} Print when methods are replaced do to recompilation
bool TraceNMethodInstalls = false {diagnostic} {default} Trace nmethod installation
bool TraceNewOopMapGeneration = false {develop} {default} Trace OopMapGeneration
bool TraceNewOopMapGenerationDetailed = false {develop} {default} Trace OopMapGeneration: print detailed cell states
bool TraceNewVectors = false {C2 notproduct} {default} Trace creation of Vector nodes
bool TraceOnStackReplacement = false {notproduct} {default} Trace on stack replacement
bool TraceOopMapRewrites = false {develop} {default} Trace rewriting of method oops during oop map generation
bool TraceOptimizeFill = false {C2 develop} {default} print detailed information about fill conversion
bool TraceOptoOutput = false {C2 notproduct} {default} Trace pipelining information
bool TraceOptoParse = false {C2 develop} {default} Trace bytecode parse and control-flow merge
bool TraceOptoPipelining = false {C2 notproduct} {default} Trace pipelining information
bool TraceParallelOldGCDensePrefix = false {develop} {default} Trace dense prefix computation for ParallelOldGC
bool TraceParallelOldGCMarkingPhase = false {develop} {default} Trace marking phase in ParallelOldGC
bool TracePartialPeeling = false {C2 notproduct} {default} Trace partial peeling (loop rotation) information
bool TracePatching = false {C1 develop} {default} Trace patching of field access on uninitialized classes
bool TracePcPatching = false {develop} {default} Trace usage of frame::patch_pc
bool TracePhaseCCP = false {C2 notproduct} {default} Print progress during Conditional Constant Propagation
bool TracePostallocExpand = false {C2 develop} {default} Trace expanding nodes after register allocation.
bool TracePredicateFailedTraps = false {C1 develop} {default} trace runtime traps caused by predicate failure
bool TraceProfileInterpreter = false {develop} {default} Trace profiling at the bytecode level during interpretation. This outputs the profiling information collected to improve jit compilation.
bool TraceProfileTripCount = false {C2 notproduct} {default} Trace profile loop trip count information
bool TraceRangeCheckElimination = false {C1 develop} {default} Trace Range Check Elimination
bool TraceRangeLimitCheck = false {C2 develop} {default} Trace additional overflow checks in RCE
bool TraceRelocator = false {develop} {default} Trace the bytecode relocator
bool TraceSpilling = false {C2 diagnostic} {default} Trace spilling
bool TraceSuperWord = false {C2 notproduct} {default} Trace superword transforms
bool TraceSuperWordLoopUnrollAnalysis = false {C2 notproduct} {default} Trace what Superword Level Parallelism analysis applies
bool TraceSuspendWaitFailures = false {product} {default} Trace external suspend wait failures
bool TraceTypeProfile = false {C2 diagnostic} {default} Trace type profile
bool TraceUncollectedSpeculations = false {JVMCI develop} {default} Print message when a failed speculation was not collected
intx TrackedInitializationLimit = 50 {C2 product} {default} When initializing fields, track up to this many words
bool TrapBasedNullChecks = false {pd product} {default} Generate code for null checks that uses a cmp and trap instruction raising SIGTRAP. This is only used if an access tonull (+offset) will not raise a SIGSEGV, i.e.,ImplicitNullChecks don\'t work (PPC64).
bool TrapBasedRangeChecks = false {C2 pd product} {default} Generate code for range checks that uses a cmp and trap instruction raising SIGTRAP. Used on PPC64.
bool TwoOperandLIRForm = true {C1 pd develop} {default} true if LIR requires src1 and dst to match in binary LIR ops
intx TypeProfileArgsLimit = 2 {product} {default} max number of call arguments to consider for type profiling
bool TypeProfileCasts = true {develop} {default} treat casts like calls for purposes of type profiling
uintx TypeProfileLevel = 111 {pd product} {default} =XYZ, with Z: Type profiling of arguments at call; Y: Type profiling of return value at call; X: Type profiling of parameters to methods; X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods
intx TypeProfileMajorReceiverPercent = 90 {C2 product} {default} % of major receiver type to all profiled receivers
intx TypeProfileParmsLimit = 2 {product} {default} max number of incoming parameters to consider for type profiling, -1 for all
intx TypeProfileWidth = 2 {product} {default} Number of receiver types to record in call/cast profile
bool UncommonNullCast = true {pd develop} {default} track occurrences of null in casts; adjust compiler tactics
intx UnguardOnExecutionViolation = 0 {product} {default} Unguard page and retry on no-execute fault (Win32 only) 0=off, 1=conservative, 2=aggressive
bool UnlockDiagnosticVMOptions = true {diagnostic} {default} Enable normal processing of flags relating to field diagnostics
intx UnrollLimitForProfileCheck = 1 {C2 develop} {default} Don\'t use profile_trip_cnt() to restrict unrolling until unrolling would push the number of unrolled iterations above UnrollLimitForProfileCheck. A higher value allows more unrolling. Zero acts as a very large value.
bool Use24BitFP = true {C2 develop} {default} use FP instructions that produce 24-bit precise results
bool Use24BitFPMode = true {C2 develop} {default} Set 24-bit FPU mode on a per-compile basis
bool UseAES = false {product} {default} Control whether AES instructions are used when available
bool UseAESCTRIntrinsics = false {diagnostic} {default} Use intrinsics for the paralleled version of AES/CTR crypto
bool UseAESIntrinsics = false {diagnostic} {default} Use intrinsics for AES versions of crypto
bool UseAOT = true {product} {default} Use AOT compiled files
bool UseAOTStrictLoading = false {diagnostic} {default} Exit the VM if any of the AOT libraries has invalid config
intx UseAVX = 3 {ARCH product} {default} Highest supported AVX instructions set on x86/x64
bool UseAdaptiveGCBoundary = false {product} {default} Allow young-old boundary to move
bool UseAdaptiveGenerationSizePolicyAtMajorCollection = true {product} {default} Use adaptive young-old sizing policies at major collections
bool UseAdaptiveGenerationSizePolicyAtMinorCollection = true {product} {default} Use adaptive young-old sizing policies at minor collections
bool UseAdaptiveNUMAChunkSizing = true {product} {default} Enable adaptive chunk sizing for NUMA
bool UseAdaptiveSizeDecayMajorGCCost = true {product} {default} Adaptive size decays the major cost for long major intervals
bool UseAdaptiveSizePolicy = true {product} {default} Use adaptive generation sizing policies
bool UseAdaptiveSizePolicyFootprintGoal = true {product} {default} Use adaptive minimum footprint as a goal
bool UseAdaptiveSizePolicyWithSystemGC = false {product} {default} Include statistics from System.gc() for adaptive size policy
bool UseAddressNop = false {ARCH product} {default} Use '0F 1F [addr]' NOP instructions on x86 cpus
bool UseAdler32Intrinsics = false {diagnostic} {default} use intrinsics for java.util.zip.Adler32
bool UseBASE64Intrinsics = false {product} {default} Use intrinsics for java.util.Base64
bool UseBMI1Instructions = false {ARCH product} {default} Use BMI1 instructions
bool UseBMI2Instructions = false {ARCH product} {default} Use BMI2 instructions
bool UseBiasedLocking = true {product} {default} Enable biased locking in JVM
bool UseBimorphicInlining = true {C2 product} {default} Profiling based inlining for two receivers
int UseBootstrapCallInfo = 1 {diagnostic} {default} 0: when resolving InDy or ConDy, force all BSM arguments to be resolved before the bootstrap method is called; 1: when a BSM that may accept a BootstrapCallInfo is detected, use that API to pass BSM arguments, which allows the BSM to delay their resolution; 2+: stress test the BCI API by calling more BSMs via that API, instead of with the eagerly-resolved array.
bool UseBsdPosixThreadCPUClocks = true {product} {default} enable fast Bsd Posix clocks where available
bool UseC1Optimizations = true {C1 develop} {default} Turn on C1 optimizations
bool UseCHA = true {develop} {default} Enable CHA
bool UseCISCSpill = true {C2 pd develop} {default} Use ADLC supplied cisc instructions during allocation
bool UseCLMUL = false {ARCH product} {default} Control whether CLMUL instructions can be used on x86/x64
bool UseCMSBestFit = true {product} {default} Use CMS best fit allocation strategy
bool UseCMSInitiatingOccupancyOnly = false {product} {default} Only use occupancy as a criterion for starting a CMS collection
bool UseCMoveUnconditionally = false {C2 product} {default} Use CMove (scalar and vector) ignoring profitability test.
bool UseCRC32CIntrinsics = false {diagnostic} {default} use intrinsics for java.util.zip.CRC32C
bool UseCRC32Intrinsics = false {diagnostic} {default} use intrinsics for java.util.zip.CRC32
bool UseCharacterCompareIntrinsics = false {C2 diagnostic} {default} Enables intrinsification of java.lang.Character functions
bool UseCodeAging = true {product} {default} Insert counter to detect warm methods
bool UseCodeCacheFlushing = true {product} {default} Remove cold/old nmethods from the code cache
bool UseCompiler = true {product} {default} Use Just-In-Time compilation
bool UseCompressedClassPointers = false {lp64_product} {default} Use 32-bit class pointers in 64-bit VM. lp64_product means flag is always constant in 32 bit VM
bool UseCompressedOops = false {lp64_product} {default} Use 32-bit object references in 64-bit VM. lp64_product means flag is always constant in 32 bit VM
bool UseConcMarkSweepGC = false {product} {default} Use Concurrent Mark-Sweep GC in the old generation
bool UseCondCardMark = false {product} {default} Check for already marked card before updating card table
bool UseCountLeadingZerosInstruction = false {ARCH product} {default} Use count leading zeros instruction
bool UseCountTrailingZerosInstruction = false {ARCH product} {default} Use count trailing zeros instruction
bool UseCountedLoopSafepoints = false {C2 product} {default} Force counted loops to keep a safepoint
bool UseCounterDecay = true {product} {default} Adjust recompilation counters
bool UseDetachedThreads = true {develop} {default} Use detached threads that are recycled upon termination (for Solaris only)
bool UseDivMod = true {C2 product} {default} Use combined DivMod instruction if available
bool UseDynamicNumberOfCompilerThreads = true {product} {default} Dynamically choose the number of parallel compiler threads
bool UseDynamicNumberOfGCThreads = true {product} {default} Dynamically choose the number of threads up to a maximum of ParallelGCThreads parallel collectors will use for garbage collection work
bool UseExactTypes = true {C2 develop} {default} Use exact types to eliminate array store checks and v-calls
bool UseFMA = false {product} {default} Control whether FMA instructions are used when available
bool UseFPUForSpilling = false {C2 product} {default} Spill integer registers to FPU instead of stack when possible
bool UseFakeTimers = false {develop} {default} Tell whether the VM should use system time or a fake timer
bool UseFastJNIAccessors = true {product} {default} Use optimized versions of Get<Primitive>Field
bool UseFastLocking = true {C1 develop} {default} Use fast inlined locking code
bool UseFastNewInstance = true {C1 develop} {default} Use fast inlined instance allocation
bool UseFastNewObjectArray = true {C1 develop} {default} Use fast inlined object array allocation
bool UseFastNewTypeArray = true {C1 develop} {default} Use fast inlined type array allocation
bool UseFastSignatureHandlers = true {develop} {default} Use fast signature handlers for native calls
bool UseFastStosb = false {ARCH product} {default} Use fast-string operation for zeroing: rep stosb
bool UseG1GC = false {product} {default} Use the Garbage-First garbage collector
bool UseGCOverheadLimit = true {product} {default} Use policy to limit of proportion of time spent in GC before an OutOfMemory error is thrown
bool UseGCTaskAffinity = false {product} {default} Use worker affinity when asking for GCTasks
bool UseGHASHIntrinsics = false {diagnostic} {default} Use intrinsics for GHASH versions of crypto
bool UseGlobalValueNumbering = true {C1 develop} {default} Use Global Value Numbering (separate phase)
bool UseHeavyMonitors = false {product} {default} use heavyweight instead of lightweight Java monitors
bool UseImplicitStableValues = true {C2 diagnostic} {default} Mark well-known stable fields as such (e.g. String.value)
bool UseIncDec = true {ARCH diagnostic} {default} Use INC, DEC instructions on x86
bool UseInlineCaches = true {product} {default} Use Inline Caches for virtual calls
bool UseInlineDepthForSpeculativeTypes = true {C2 diagnostic} {default} Carry inline depth of profile point with speculative type and give priority to profiling from lower inline depth
bool UseInterpreter = true {product} {default} Use interpreter for non-compiled methods
bool UseJumpTables = true {C2 product} {default} Use JumpTables instead of a binary search tree for switches
bool UseLWPSynchronization = true {product} {default} Use LWP-based instead of libthread-based synchronization (SPARC only)
bool UseLargePages = false {pd product} {default} Use large page memory
bool UseLargePagesInMetaspace = false {product} {default} Use large page memory in metaspace. Only used if UseLargePages is enabled.
bool UseLargePagesIndividualAllocation = false {pd product} {default} Allocate large pages individually for better affinity
bool UseLibmIntrinsic = true {ARCH diagnostic} {default} Use Libm Intrinsics
bool UseLocalValueNumbering = true {C1 develop} {default} Use Local Value Numbering (embedded in GraphBuilder)
bool UseLoopCounter = true {product} {default} Increment invocation counter on backward branch
bool UseLoopInvariantCodeMotion = true {C1 product} {default} Simple loop invariant code motion for short loops during GVN
bool UseLoopPredicate = true {C2 product} {default} Generate a predicate to select fast/slow loop versions
bool UseLoopSafepoints = true {develop} {default} Generate Safepoint nodes in every loop
bool UseMallocOnly = false {develop} {default} Use only malloc/free for allocation (no resource area/arena)
bool UseMathExactIntrinsics = true {C2 diagnostic} {default} Enables intrinsification of various java.lang.Math functions
bool UseMaximumCompactionOnSystemGC = true {product} {default} Use maximum compaction in the Parallel Old garbage collector for a system GC
bool UseMontgomeryMultiplyIntrinsic = false {C2 diagnostic} {default} Enables intrinsification of BigInteger.montgomeryMultiply()
bool UseMontgomerySquareIntrinsic = false {C2 diagnostic} {default} Enables intrinsification of BigInteger.montgomerySquare()
bool UseMulAddIntrinsic = false {C2 diagnostic} {default} Enables intrinsification of BigInteger.mulAdd()
bool UseMultiplyToLenIntrinsic = false {C2 diagnostic} {default} Enables intrinsification of BigInteger.multiplyToLen()
bool UseNUMA = false {product} {default} Use NUMA if available
bool UseNUMAInterleaving = false {product} {default} Interleave memory across NUMA nodes if available
bool UseNewCode = false {diagnostic} {default} Testing Only: Use the new version while testing
bool UseNewCode2 = false {diagnostic} {default} Testing Only: Use the new version while testing
bool UseNewCode3 = false {diagnostic} {default} Testing Only: Use the new version while testing
bool UseNewLongLShift = false {ARCH product} {default} Use optimized bitwise shift left
bool UseOSErrorReporting = false {pd product} {default} Let VM fatal error propagate to the OS (ie. WER on Windows)
bool UseOWSTTaskTerminator = true {diagnostic} {default} Use Optimized Work Stealing Threads task termination protocol
bool UseOnStackReplacement = true {pd product} {default} Use on stack replacement, calls runtime if invoc. counter overflows in loop
bool UseOnlyInlinedBimorphic = true {C2 product} {default} Don\'t use BimorphicInlining if can\'t inline a second method
bool UseOprofile = false {product} {default} enable support for Oprofile profiler
bool UseOptoBiasInlining = true {C2 product} {default} Generate biased locking code in C2 ideal graph
bool UsePSAdaptiveSurvivorSizePolicy = true {product} {default} Use adaptive survivor sizing policies
bool UseParallelGC = false {product} {default} Use the Parallel Scavenge garbage collector
bool UseParallelOldGC = false {product} {default} Use the Parallel Old garbage collector
bool UsePerfData = true {product} {default} Flag to disable jvmstat instrumentation for performance testing and problem isolation purposes
bool UsePopCountInstruction = false {product} {default} Use population count instruction
bool UsePrivilegedStack = true {develop} {default} Enable the security JVM functions
bool UseProfiledLoopPredicate = true {C2 product} {default} move predicates out of loops based on profiling data
bool UsePthreads = false {develop} {default} Use pthread-based instead of libthread-based synchronization (SPARC only)
bool UseRDPCForConstantTableBase = false {C2 product} {default} Use Sparc RDPC instruction for the constant table base.
bool UseRTMDeopt = false {ARCH product} {default} Perform deopt and recompilation based on RTM abort ratio
bool UseRTMLocking = false {ARCH product} {default} Enable RTM lock eliding for inflated locks in compiled code
bool UseSHA = false {product} {default} Control whether SHA instructions are used when available
bool UseSHA1Intrinsics = false {diagnostic} {default} Use intrinsics for SHA-1 crypto hash function. Requires that UseSHA is enabled.
bool UseSHA256Intrinsics = false {diagnostic} {default} Use intrinsics for SHA-224 and SHA-256 crypto hash functions. Requires that UseSHA is enabled.
bool UseSHA512Intrinsics = false {diagnostic} {default} Use intrinsics for SHA-384 and SHA-512 crypto hash functions. Requires that UseSHA is enabled.
intx UseSSE = 99 {product} {default} Highest supported SSE instructions set on x86/x64
bool UseSSE42Intrinsics = false {ARCH product} {default} SSE4.2 versions of intrinsics
bool UseSemaphoreGCThreadsSynchronization = true {diagnostic} {default} Use semaphore synchronization for the GC Threads, instead of synchronization based on mutexes
bool UseSerialGC = false {product} {default} Use the Serial garbage collector
bool UseSharedSpaces = true {product} {default} Use shared spaces for metadata
bool UseSignalChaining = true {product} {default} Use signal-chaining to invoke signal handlers installed by the application (Solaris & Linux only)
bool UseSlowPath = false {C1 develop} {default} For debugging: test slow cases by always using them
bool UseSquareToLenIntrinsic = false {C2 diagnostic} {default} Enables intrinsification of BigInteger.squareToLen()
bool UseStackBanging = true {develop} {default} use stack banging for stack overflow checks (required for proper StackOverflow handling; disable only to measure cost of stackbanging)
bool UseStoreImmI16 = true {ARCH product} {default} Use store immediate 16-bits value instruction on x86
bool UseStrictFP = true {develop} {default} use strict fp if modifier strictfp is set
bool UseStringDeduplication = false {product} {default} Use string deduplication
bool UseSubwordForMaxVector = true {C2 product} {default} Use Subword Analysis to set maximum vector size
bool UseSuperWord = true {C2 product} {default} Transform scalar operations into superword operations
bool UseTLAB = true {pd product} {default} Use thread-local object allocation
bool UseTableRanges = true {C1 develop} {default} Faster versions of lookup table using ranges
bool UseThreadPriorities = true {pd product} {default} Use native thread priorities
bool UseTypeProfile = true {product} {default} Check interpreter profile for historically monomorphic calls
bool UseTypeSpeculation = true {C2 product} {default} Speculatively propagate types from profiles
bool UseUnalignedAccesses = false {diagnostic} {default} Use unaligned memory accesses in Unsafe
bool UseUnalignedLoadStores = false {ARCH product} {default} Use SSE2 MOVDQU instruction for Arraycopy
bool UseUniqueSubclasses = true {C2 develop} {default} Narrow an abstract reference to the unique concrete subclass
bool UseVectorCmov = false {C2 product} {default} Use Vectorized Cmov
bool UseVectorizedMismatchIntrinsic = false {diagnostic} {default} Enables intrinsification of ArraysSupport.vectorizedMismatch()
bool UseXMMForArrayCopy = false {product} {default} Use SSE2 MOVQ instruction for Arraycopy
bool UseXMMForObjInit = false {ARCH product} {default} Use XMM/YMM MOVDQU instruction for Object Initialization
bool UseXmmI2D = false {ARCH product} {default} Use SSE2 CVTDQ2PD instruction to convert Integer to Double
bool UseXmmI2F = false {ARCH product} {default} Use SSE2 CVTDQ2PS instruction to convert Integer to Float
bool UseXmmLoadAndClearUpper = true {ARCH product} {default} Load low part of XMM register and clear upper part
bool UseXmmRegToRegMoveAll = false {ARCH product} {default} Copy all XMM register bits when moving value between registers
intx VMThreadPriority = -1 {product} {default} The native priority at which the VM thread should run (-1 means no change)
intx VMThreadStackSize = 1024 {pd product} {default} Non-Java Thread Stack Size (in Kbytes)
intx ValueMapInitialSize = 11 {C1 product} {default} Initial size of a value map
intx ValueMapMaxLoopSize = 8 {C1 product} {default} maximum size of a loop optimized by global value numbering
intx ValueSearchLimit = 1000 {C2 product} {default} Recursion limit in PhaseMacroExpand::value_from_mem_phi
bool Verbose = false {develop} {default} Print additional debugging information from other modes
bool VerifyActivationFrameSize = false {develop} {default} Verify that activation frame didn\'t become smaller than its minimal size
bool VerifyAdapterCalls = true {diagnostic} {default} Verify that i2c/c2i adapters are called properly
bool VerifyAdapterSharing = false {develop} {default} Verify that the code for shared adapters is the equivalent
bool VerifyAfterGC = false {diagnostic} {default} Verify memory system after GC
bool VerifyAliases = false {C2 develop} {default} perform extra checks on the results of alias analysis
bool VerifyBeforeExit = true {diagnostic} {default} Verify system before exiting
bool VerifyBeforeGC = false {diagnostic} {default} Verify memory system before GC
bool VerifyBeforeIteration = false {diagnostic} {default} Verify memory system before JVMTI iteration
bool VerifyBlockOffsetArray = false {develop} {default} Do (expensive) block offset array verification
bool VerifyCodeCache = false {notproduct} {default} Verify code cache on memory allocation/deallocation
bool VerifyCompiledCode = false {develop} {default} Include miscellaneous runtime verifications in nmethod code; default off because it disturbs nmethod size heuristics
bool VerifyConnectionGraph = true {C2 notproduct} {default} Verify Connection Graph construction in Escape Analysis
bool VerifyDUIterators = true {C2 notproduct} {default} Verify the safety of all iterations of Bi-directional Edges
bool VerifyDataPointer = true {develop} {default} Verify the method data pointer during interpreter profiling
bool VerifyDependencies = true {develop} {default} Exercise and verify the compilation dependency mechanism
bool VerifyDuringGC = false {diagnostic} {default} Verify memory system during GC (between phases)
bool VerifyDuringStartup = false {diagnostic} {default} Verify memory system before executing any Java code during VM initialization
bool VerifyFPU = false {develop} {default} Verify FPU state (check for NaN\'s, etc.)
intx VerifyGCLevel = 0 {diagnostic} {default} Generation level at which to start +VerifyBefore/AfterGC
uintx VerifyGCStartAt = 0 {diagnostic} {default} GC invoke count where +VerifyBefore/AfterGC kicks in
ccstrlist VerifyGCType = {diagnostic} {default} GC type(s) to verify when Verify*GC is enabled.Available types are collector specific.
bool VerifyGraphEdges = false {C2 notproduct} {default} Verify Bi-directional Edges
bool VerifyHashTableKeys = true {C2 notproduct} {default} Verify the immutability of keys in the VN hash tables
bool VerifyIdealNodeCount = false {C2 notproduct} {default} Verify that tracked dead ideal node count is accurate
bool VerifyIterativeGVN = false {C2 develop} {default} Verify Def-Use modifications during sparse Iterative Global Value Numbering
bool VerifyJNIEnvThread = false {notproduct} {default} Verify JNIEnv.thread == Thread::current() when entering VM from JNI
bool VerifyJNIFields = true {develop} {default} Verify jfieldIDs for instance fields
bool VerifyLastFrame = false {notproduct} {default} Verify oops on last frame on entry to VM
bool VerifyLoopOptimizations = false {C2 notproduct} {default} verify major loop optimizations
bool VerifyMergedCPBytecodes = true {product} {default} Verify bytecodes after RedefineClasses constant pool merging
bool VerifyMetaspace = false {develop} {default} Verify metaspace on chunk movements.
bool VerifyMethodHandles = true {diagnostic} {default} perform extra checks when constructing method handles
bool VerifyObjectStartArray = true {diagnostic} {default} Verify GC object start array if verify before/after
bool VerifyOops = false {develop} {default} Do plausibility checks for oops
bool VerifyOpto = false {C2 notproduct} {default} Apply more time consuming verification during compilation
bool VerifyOptoOopOffsets = false {C2 notproduct} {default} Check types of base addresses in field references
bool VerifyRegisterAllocator = false {C2 notproduct} {default} Verify Register Allocator
bool VerifyRememberedSets = false {diagnostic} {default} Verify GC remembered sets
bool VerifySharedSpaces = false {product} {default} Verify shared spaces (false for default archive, true for archive specified by -XX:SharedArchiveFile)
bool VerifyStack = false {develop} {default} Verify stack of each thread when it is entering a runtime call
bool VerifyStackAtCalls = false {develop} {default} Verify that the stack pointer is unchanged after calls
bool VerifyStringTableAtExit = false {diagnostic} {default} verify StringTable contents at exit
ccstrlist VerifySubSet = {diagnostic} {default} 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
bool VerifyThread = false {develop} {default} Watch the thread register for corruption (SPARC only)
bool WalkStackALot = false {notproduct} {default} Trace stack (no print) at every exit from the runtime system
intx WarmCallMaxSize = 999999 {C2 develop} {default} size of the largest inlinable method
intx WarmCallMaxWork = 999999 {C2 develop} {default} execution time of the largest inlinable method
intx WarmCallMinCount = -1 {C2 develop} {default} number of calls (per method invocation) to enable inlining
intx WarmCallMinProfit = -1 {C2 develop} {default} number of calls (per method invocation) to enable inlining
uintx WarnOnStalledSpinLock = 0 {notproduct} {default} Print warnings for stalled SpinLocks
bool WhiteBoxAPI = false {diagnostic} {default} Enable internal testing APIs
bool WizardMode = false {develop} {default} Print much more debugging information
uintx YoungGenerationSizeIncrement = 20 {product} {default} Adaptive size percentage change in young generation
uintx YoungGenerationSizeSupplement = 80 {product} {default} Supplement to YoungedGenerationSizeIncrement used at startup
uintx YoungGenerationSizeSupplementDecay = 8 {product} {default} Decay factor to YoungedGenerationSizeSupplement
size_t YoungPLABSize = 4096 {product} {default} Size of young gen promotion LAB\'s (in HeapWords)
bool ZapFillerObjects = true {develop} {default} Zap filler objects with 0xDEAFBABE
bool ZapResourceArea = true {develop} {default} Zap freed resource/arena space with 0xABABABAB
bool ZapStackSegments = true {notproduct} {default} Zap allocated/freed stack segments with 0xFADFADED
bool ZapUnusedHeapArea = true {develop} {default} Zap unused heap space with 0xBAADBABE
bool ZapVMHandleArea = true {notproduct} {default} Zap freed VM handle space with 0xBCBCBCBC
bool ZeroTLAB = false {product} {default} Zero out the newly created TLAB
bool ZombieALot = false {notproduct} {default} Create zombies (non-entrant) at exit from the runtime system
intx ZombieALotInterval = 5 {notproduct} {default} Number of exits until ZombieALot kicks in