Java JVM XX Options


虚拟机优化的时候需要知道怎么去设置参数,编译了一个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/ 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
    ccstr PrintAssemblyOptions                     =                                        {diagnostic} {default}       Print options string passed to
     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                   =                           {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
     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
     bool UseCRC32Intrinsics                       = false                                  {diagnostic} {default}       use intrinsics for
     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