VM Options Explorer - OpenJDK9 HotSpot

AOT library

Call fatal if the exception pointed by AbortVMOnException 
has this message

Call fatal if this exception is thrown. Example: 
java -XX:AbortVMOnException=java.lang.NullPointerException Foo

Adaptive size scale down factor for shrinking

Time scale over which major costs decay

If collection costs are within margin, reduce both by full 
delta

Number of consecutive collections before gc time limit fires

Number of steps where heuristics is used before data is used

Collection interval for printing information; zero means never

Number of collections before the adaptive sizing is started

Weight given to exponential resizing, between 0 and 100

Policy for changing generation size for throughput goals

Weight given to time in adaptive policy, between 0 and 100

Enable aggressive optimizations - see arguments.cpp

Control optimizations for aggressive boxing elimination

0 for no aliasing, 1 for oop/field/static/array split, 

2 for class split, 3 for unique instances

Perform vector store/load alignment in loop

Number of lines to prefetch ahead of instance allocation 
pointer

Distance to prefetch ahead of allocation pointer. 
-1: use system-specific value (automatically determined

Select instruction to prefetch ahead of allocation pointer

Number of lines to prefetch ahead of array allocation pointer

Step size in bytes of sequential prefetch instructions

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

Allow VM to run with EXTSHM=ON.

Allow JNIEnv proxies for jdbx

Obey the ACC_SUPER flag and allow invokenonvirtual calls

Allow parallel defineClass requests for class loaders 
registering as parallel capable

Do not complain if the application installs signal handlers 
(Solaris & Linux only)

Globally supress vectorization set in VectorizeMethod

Always act like a server-class machine

Accesses to all variables should always be atomic

When using recompilation, never interpret methods 
containing loops

do all inlining incrementally

Require the VM to acquire the class loader lock before calling 
loadClass() even for class loaders registering 
as parallel capable

Force all freshly committed pages to be pre-touched

Restore the FPU control word after every JNI call (expensive)

Force safe construction, as if all fields are final.

Always tenure objects in eden (ParallelGC only)

Allocation less than this value will be allocated 
using malloc. Larger allocations will use mmap.

Maximum number of arraycopy elements inlined as a sequence of
loads/stores

Distance to prefetch destination array in arraycopy

Distance to prefetch source array in arraycopy

Assert/Guarantee on external suspend wait failure

Assert Range Check Elimination

Instruct the VM to assume multiple processors are available

Timeout in ms the attach listener waits for a request

Sets max value cached by the java.lang.Integer autobox cache

Automatic GC selection pause threshold in milliseconds

Avoid generating unaligned memory accesses

How much tracing to do of bytecode escape analysis estimates 
(0-3)

A thread requesting compilation is not blocked during 
compilation

bailout of compilation after building of HIR

bailout of compilation after building of LIR

bailout of compilation for methods with exception handlers

Compiled methods which throws/catches exceptions will be 
deopt and intp.

Estimate of footprint other than Java Heap

Number of return bci's to record in ret profile

Threshold of number of revocations per type to try to 
rebias all objects in the heap of that type

Threshold of number of revocations per type to permanently 
revoke biases of all objects in the heap of that type

Decay time (in milliseconds) to re-enable bulk rebiasing of a 
type after previous bulk rebias

Number of milliseconds to wait before enabling biased locking

Minimal number of lookupswitch entries for rewriting to binary 
switch

Bind CMS Thread to CPU if possible

Bind GCTaskThreads to CPUs if possible

Minimum size in bytes when block copy will be used

Use edge frequencies to drive block ordering

Miniumum %% of a successor (predecessor) for which block 
layout a will allow a fork (join) in a single chain

Allow back branches to be fall throughs in the block layout

Maintain _unallocated_block in BlockOffsetArray 
(currently applicable only to CMS collector)

Minimum size in bytes when block zeroing will be used

Minimum size in bytes when block zeroing will be used

Bootstrap JVMCI before running Java main method

Use Sparc V9 branch-on-register opcodes

Break at construction of this Node (either _idx or _debug_idx)

Execute breakpoint upon encountering VM warning

Enable the Java bytecode verifier for local classes

Enable the Java bytecode verifier for remote classes

Sets a breakpoint at entry of each compiled method

Use CHA and exact type results at call sites when updating MDOs

Profile branches when generating code for updating MDOs

Profile calls when generating code for updating MDOs

Profile checkcasts when generating code for updating MDOs

Profile inlined calls when generating code for updating MDOs

Profile virtual calls when generating code for updating MDOs

Update MethodData*s in Tier1-generated code

The id of osr compilation to break at

The id of compilation to break at

compile native methods if supported by the compiler

compile on stack replacement methods if supported by the 
compiler

1 compiler thread for log(N CPUs)

Number of compiler threads to run

use a separate counter when assigning ids to osr compilations

id of compilation to trigger assert in compiler thread for 
the purpose of testing, e.g. generation of replay data

Fire OutOfMemoryErrors throughout CI for testing the compiler 
(non-negative value throws OOM after this many CI accesses 
in each compile)

enable potentially expensive verification in ciObjectFactory

display the contents of the compile queue whenever a 
compilation is enqueued

when CIPrint is active, print the name of the active compiler

print method bytecodes of the compiled code

display every request for compilation

print the results of ciTypeFlow analysis

The id of the first osr compilation to permit 
(CICountOSR must be on)

The id of the first compilation to permit

The id of the last osr compilation to permit 
(CICountOSR must be on)

The id of the last compilation to permit

display timing information after each successful compilation

be more verbose in compilation timings

collect timing information for compilation

detailed per-bytecode tracing of ciTypeFlow analysis

Whether abort-on-overflow semantics is implemented

Nominal minimum work per abortable preclean iteration

Time that we sleep between iterations when not given 
enough work per iteration

Bitmap operations should process at most this many bits 
between yields

Percentage CMS generation occupancy at which to 
initiate CMS collection for bootstrapping collection stats

Interval in milliseconds that CMS thread checks if it 
should start a collection cycle

Whether class unloading enabled when using CMS GC

When CMS class unloading is enabled, the maximum CMS cycle 
count for which classes may not be unloaded

Clean-on-enter optimization for reducing number of dirty cards

Size (in cards) of CMS concurrent MT marking task

Whether multi-threaded concurrent work enabled 
(effective only if ParNewGC)

Number of times the coordinator GC thread will sleep while 
yielding before giving up and resuming GC

Always record eden chunks used for the parallel initial mark 
or remark of eden

Percentage (0-100) used to weight the current sample when 
computing exponential averages for CMS statistics

CMS: cushion for block demand during sweep

Percentage (0-100) used to add conservatism when computing the 
duty cycle

Replenish an indexed free list with this number of chunks

Percentage CMS generation occupancy to start a CMS collection 
cycle. A negative value means that CMSTriggerRatio is used

An absolute ceiling above which CMS will always consider the 
unloading of classes when class unloading is enabled

CMS: the factor by which to inflate estimated demand of large 
block sizes to prevent coalescing with an adjoining block

CMS: the factor by which to inflate estimated demand of large 
block sizes to prevent splitting to supply demand for smaller 
blocks

Warn in case of excessive CMS looping

Simulate frequent marking stack / work queue overflow

An 'interval' counter that determines how frequently 
to simulate overflow; a smaller number increases frequency

Maximum number of abortable preclean iterations, if > 0

Maximum time in abortable preclean (in milliseconds)

Maximum size of CMS gen promotion LAB caches per worker 
per block size

Minimum size of CMS gen promotion LAB caches per worker 
per block size

Nominal number of refills of CMS gen promotion LAB cache 
per worker per block size

The gain in the feedback loop for on-the-fly PLAB resizing 
during a scavenge

React on-the-fly during a scavenge to a sudden 
change in block demand rate

The tolerance of the phase-change detector for on-the-fly 
PLAB resizing during a scavenge

Always record survivor space PLAB boundaries (effective only 
if CMSParallelSurvivorRemarkEnabled)

Use the parallel initial mark.

Whether parallel remark enabled (only if ParNewGC)

Whether parallel remark of survivor space 
enabled (effective only if CMSParallelRemarkEnabled)

CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence 
ratio

Maximum number of precleaning iteration passes

CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence 
ratio

Preclean ref lists during (initial) preclean phase

Preclean ref lists during abortable preclean phase

Preclean survivors during (initial) preclean phase

Preclean survivors during abortable preclean phase

Do not iterate again if number of dirty cards is less than this

Whether concurrent precleaning enabled

If logging for the 'gc' and 'promotion' tags is enabled on
trace level include more detailed information about the
free chunks

If logging for the 'gc' and 'promotion' tags is enabled on
trace level include more detailed information about the
allocated objects

Choose variant (1,2) of verification following remark

Replenish all intermediate free-list caches

Size (in cards) of CMS parallel rescan task

The minimum distance between eden samples for CMS (see above)

Attempt scavenge before the CMS remark step

The Eden occupancy percentage (0-100) at which 
to try and schedule remark pause

If Eden size is below this, do not try to schedule remark

Start sampling eden top at least before young gen 
occupancy reaches 1/ of the size at which 
we plan to schedule remark

CMS: the factor by which to inflate estimated demand of small 
block sizes to prevent coalescing with an adjoining block

CMS: the factor by which to inflate estimated demand of small 
block sizes to prevent splitting to supply demand for smaller 
blocks

When satisfying batched demand, split blocks from the 
IndexedFreeList whose size is a multiple of requested size

Check if the coalesced range is already in the 
free lists as claimed

Commence a CMS collection cycle (at least) every so many 
milliseconds (0 permanently, -1 disabled)

Percentage of MinHeapFreeRatio in CMS generation that is 
allocated before a CMS collection cycle commences

Check that all the garbage collected was returned to the 
free lists

Time in milliseconds that CMS thread waits for young GC

Don't drain below this size per parallel worker/thief

Number of times a GC thread (minus the coordinator) 
will sleep while yielding before giving up and resuming GC

Yield between steps of CMS

// default max size of CMS young gen, per GC worker thread

// default max size of CMS young gen, per GC worker thread

The maximum size of young gen chosen by default per GC worker 
thread available

// Default max size of CMS young gen, per GC worker thread.

// Default max size of CMS young gen, per GC worker thread.

// default max size of CMS young gen, per GC worker thread

// default max size of CMS young gen, per GC worker thread

// default max size of CMS young gen, per GC worker thread

The multiple of deviation from mean to use for buffering 
against volatility in free list demand

Percentage (0-100) used to weight the current sample when 
computing exponentially decaying averages for CMS FLS 
statistics

The multiple of deviation from mean to use for buffering 
against volatility in inter-sweep duration

Skip block flux-rate sampling for an epoch unless inter-sweep 
duration exceeds this threshold in milliseconds

Percentage (0-100) used to weight the current sample when 
computing exponentially decaying average for inter-sweep 
duration

When BindCMSThreadToCPU is true, the CPU to bind CMS thread to

Create separate nodes for length in array accesses

Canonicalize graph nodes

Temporary - see javaClasses.cpp

Generate checks in encoding/decoding code in debug VM

Verify the endorsed and extension directories are not used

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.

Verify all arguments to JNI calls

Check memory initialization

Check for unhandled oops in VM code

Check zapping of unused heap space

Do unloading of classes with a concurrent marking cycle

Do unloading of classes

Clean the chunk pool asynchronously

(Unsafe, Unstable)

Clip inlining if aggregate method exceeds DesiredMethodLimit

Code cache expansion size (in bytes)

Minimum number of segments in a code cache block

Minimum code cache size (in bytes) required to start VM.

// Tiered compilation has large code-entry alignment.

// Tiered compilation has large code-entry alignment.

Code cache segment size (in bytes) - smallest unit of 
allocation

// Tiered compilation has large code-entry alignment.

// Tiered compilation has large code-entry alignment.

// Tiered compilation has large code-entry alignment.

Code entry alignment for generated code (in bytes)

Collect information about IndexSets

Show extra info in PrintNMethods output

Allocate nonstatic fields in gaps between previous fields

Enable Strings to use single byte chars in backing store

which compilation policy (0-3)

Read compiler commands from this file [.hotspot_compiler]

Prepend to .hotspot_compiler; e.g. log,java/lang/String.

List of methods (pkg/class.name) to restrict compilation to

Preload all classes used by a class before start loading

Force a safepoint every n compiles so sweeper can keep up

First class to consider when using +CompileTheWorld

Last class to consider when using +CompileTheWorld

Compile all methods in all classes in bootstrap class path 
(stress test)

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.

number of interpreted method invocations before (re-)compiling

// Design center runs on 1.3.1

Read compiler directives from this file

Disable backwards compatibility for compile commands.

Limit on number of compiler directives.

Print compiler directives on installation.

(Solaris only) Give compiler threads an extra quanta

The native priority at which compiler threads should run 
(-1 means no change)

Compiler Thread Stack Size (in Kbytes)

Maximum size of class area in Metaspace when compressed 
class pointers are used

Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)

Number of threads concurrent gc will use

If non-zero, assert that GC threads yield within this 
number of milliseconds

Limit of ops to make speculative when using CMOVE

How many bytes to pad the fields/classes marked @Contended with

Convert cmpD to cmpF when one input is constant in float range

Convert float2int clipping idiom to integer clipping

Convert sleep(0) to thread yield

Convert yield to a sleep of MinSleepInterval to simulate Win32 
behavior

Count number of bytecodes executed

Count method invocations

Count jni method invocations

Count jvm method invocations

collect statistic counters during LinearScan

Count exceptions that could be replaced by branches due to 
inlining

Count VM runtime calls

The minimum interval (in milliseconds) between invocation of 
CounterDecay

Half-life time of invocation counters (in seconds)

Manually make GC thread crash then dump java stack trace; 
Test only

JVM aborts, producing an error log and core/mini dump, on the 
first occurrence of an out-of-memory error

Create core/mini dump on VM fatal error

Check for critical JNI entry points

Power8 or later: DPFD (default prefetch depth) value of the 
Data Stream Control Register.
 0: hardware default, 1: none, 2-7: min-max, 8: don't touch

Power8 or later: Specify encoded value for Data Stream Control 
Register

Power8 or later: URG (depth attainment urgency) value of the 
Data Stream Control Register.
 0: hardware default, 1: none, 2-7: min-max, 8: don't touch

Enable dtrace probes for object allocation

Enable dtrace probes for method-entry and method-exit

Enable dtrace probes for monitor events

Tracing various information while debugging deoptimization

If false, restricts profiled locations to the root method only

Generate extra debugging information for non-safepoints in 
nmethods

add debugging code to vtable dispatch

Set when executing debug methods in debug.cpp 
(to prevent triggering assertions)

When +ReduceInitialCardMarks, explicitly defer any that 
may arise from new_pre_store_barrier

(Unsafe,Unstable) Number of iterations in safepoint loop 
before changing safepoint polling page to RO

(Unstable) Number of times to iterate in safepoint loop 
before blocking VM threads

Delay invoking the compiler until main application class is 
loaded

Use deoptimization in C1

Number of exits until DeoptimizeALot kicks in

Deoptimize at every exit from the runtime system

A comma separated list of bcis to deoptimize at

Deoptimize random frames on random exit from the runtime system

The desired maximum method size (in bytecodes) after inlining

Die upon failure to reach safepoint (see SafepointTimeout)

Disable mechanism that allows tools to attach to this VM

tell sim not to invoke bccheck callback

Ignore calls to System.gc()

do not expand intrinsics whose (internal) names appear here

Disable starting of additional Java threads 
(for debugging only)

If DisplayVMOutput is true, display all VM output to stderr

If DisplayVMOutput is true, display all VM output to stdout

Display all VM output on the tty, independently of LogVMOutput

Do Conditional Expression Elimination to simplify CFG

Perform escape analysis

Create reserve copy of graph in SuperWord.

Iterations limit in Node::dominates

Do not compile methods > HugeMethodLimit

Interval between which yields will be dropped (milliseconds)

Throw away obvious excess yield calls

// yield no more than 100 times per second

// Determined in the design center

Dump the names all loaded classes, that could be stored into 
the CDS archive, in the specified file

Record replay data for crashing compiler threads

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

Eagerly initialize classes if possible

Eagerly initialize -Xrun libraries; allows startup profiling, 
but not all -Xrun libraries may support the state of the VM 
at this time

Array size (number of elements) limit for scalar replacement

Use escape analysis to eliminate allocations

Control optimizations for autobox elimination

Eliminate unneccessary basic blocks

Optimize field loads and stores

Coarsen locks when possible

Eliminate nested locks of the same object when possible

Eliminate nested locks of the same object when possible

Eliminate unneccessary null checks

(Unsafe, Unstable) 
Control emission of inline sync fast-path code

Enable @Contended annotation support

Allow tools to load agents with the attach mechanism

Enable JVMCI

Enable event-based tracing

Maximum ergonomically set heap size (in bytes); zero means use 
MaxRAM / MaxRAMFraction

If an error occurs, save the error data to this file 
[default: ./hs_err_pid%p.log] (%p replaced with pid)

If > 0, provokes an error after VM initialization; the value 
determines which error to provoke. See test_error_handler() 
in debug.cpp.

Timeout, in seconds, to limit the time spent on writing an 
error log in case of a crash.

Override built-in error report server address

Abort EA when it reaches time limit (in sec)

Analyze bytecodes to estimate escape state of arguments

Enable execution of internal VM tests

Whether the JVM is running unit tests or not

Exit or throw assert in EA when it reaches time limit

Exit the VM if we fill the code cache

JVM exits on the first occurrence of an out-of-memory error

standard exit from VM if bytecode verify error 
(only in debug mode)

Expand the assembler 
instruction required to load the base from DecodeN_NN nodes 
during matching.

Expand the assembler 
instruction required to load the base from DecodeN nodes during 
matching.

Expand the assembler 
instruction required to load the base from EncodeP_NN nodes 
during matching.

Expand the assembler 
instruction required to load the base from EncodeP nodes during 
matching.

A System.gc() request invokes a concurrent collection and 
also unloads classes during such a concurrent gc cycle 
(effective only when UseConcMarkSweepGC)

A System.gc() request invokes a concurrent collection; 
(effective only when using concurrent collectors)

Enable performance-impacting dtrace probes

Extra classlist for building the CDS archive file

Number of float LRG's that constitute high register pressure

// C2 on V9 gets to use all the float/double registers

CMS: larger free blocks are always available for coalescing

CMS: aggressiveness level for coalescing, increasing 
from 0 to 4

CMS: the smaller the percentage the greater the coalescing 
force

Verify that all references across the FLS boundary 
are to valid objects

Do lots of (expensive) FLS dictionary verification

Do lots of (expensive) FLS index table verification

Do lots of (expensive) FreeListSpace verification

Fail over to old verifier when split verifier fails

/* Note: This value is zero mod 1<<13 for a cheap sparc set. */Inline allocations larger than this in doublewords must go slow

Depth of hardwired instanceof accelerator array

Use fast TLAB refill code

0 - type based with oops first, 

1 - with oops last, 

2 - oops in super and sub classes are together

Fill delay slots (on SPARC only)

When true prevents OS-level spurious, or premature, wakeups 
from Object.wait (Ignored for Windows)

Optimize loads from stable fields (marked w/ @Stable)

Force dynamic selection of the number of 
parallel threads parallel gc will use to aid debugging

Force exceptions on FP stack under/overflow

Force NUMA optimizations on single-node/UMA systems

Using high time resolution (for Win32 only)

Make all non code cache addresses to be unreachable by 
forcing use of 64bit literal fixups

Scaling factor for branch frequencies (deprecated)

The maximum bytecode size of a frequent method to be inlined

Dummy object allocated with +FullGCALot, forcing all objects 
to move

Interval between which full gc will occur with +FullGCALot

For which invocation to start FullGCAlot

Force full gc at every Nth exit from the runtime system 
(N=FullGCALotInterval)

How many completed time periods from initial mark to first 
mixed gc are required to use the input values for prediction 
of the optimal occupancy to start marking.

Target duration of individual concurrent marking steps 
in milliseconds.

The threshold that defines (>=) a hot card.

Log base 2 of the length of conc RS hot-card cache.

The number of update buffers that are left in the queue by the 
concurrent processing threads. Will be selected ergonomically 
by default.

Maximum number of enqueued update buffers before mutator 
threads start processing new ones instead of enqueueing them. 
Will be selected ergonomically by default.

The last concurrent refinement thread wakes up every 
specified number of milliseconds to do miscellaneous work.

The number of parallel rem set update threads. 
Will be set ergonomically by 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.

Number of enqueued update buffers that will 
trigger concurrent processing. Will be selected ergonomically 
by default.

Confidence level for MMU/pause predictions

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.

Try to reclaim dead large objects that have a few stale 
references at every young GC.

Try to reclaim dead large objects at every young GC.