VM Options Explorer - Corretto JDK19

Minimum array size in bytes to use AVX512 intrinsics
for copy, inflate and fill. When this value is set as zero
compare operations can also use AVX512 intrinsics.

Abort VM when method had failed to compile.

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

Abort upon failure to reach safepoint (see SafepointTimeout)

Delay in milliseconds for option AbortVMOnVMOperationTimeout

Abort upon failure to complete VM operation promptly

Specify the CPU count the VM should use and report as active

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 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

Increase the thread stack size to include space for glibc 
static thread-local storage (TLS) if true

Optimize heap options for long-running memory intensive apps

Control optimizations for aggressive boxing elimination

(Deprecated) 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

Path to the directory where a temporary file will be created 
to use as the backing store for Java Heap.

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 Java agent to be run with CDS dumping

Allow VM to run with EXTSHM=ON.

Allow parallel defineClass requests for class loaders 
registering as parallel capable

(Deprecated) Allow redefinition to add and delete private 
static or final methods for compatibility with old releases

Application will install primary signal handlers for the JVM 
(Unix only)

Globally suppress 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

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)

The path and name of the dynamic archive file

(0) first map at preferred address, and if 
unsuccessful, map at alternative address (default); 
(1) always map at alternative address; 
(2) always map at preferred address, and if unsuccessful, 
do not map the archive

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

Partial inline size used for small array operations
(e.g. copy,cmp) acceleration.

Assert Range Check Elimination

Async deflate idle monitors every so many milliseconds when 
MonitorUsedDeflationThreshold is exceeded (0 is off).

Memory budget (in bytes) for the buffer of Asynchronous 
Logging (-Xlog:async).

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

Create shared archive at exit if cds mapping failed

Used to estimate a variable ceiling based on number of threads 
for use with MonitorUsedDeflationThreshold (0 is off).

Avoid generating unaligned memory accesses

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

Minimal number of lookupswitch entries for rewriting to binary 
switch

Use edge frequencies to drive block ordering

Minimum %% 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

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. This 
initializes the compile queue with a small set of methods 
and processes the queue until it is empty. Combining this with 
-XX:-TieredCompilation makes JVMCI compile more of itself.

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

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

inlining only allowed for methods which don't exceed this 
number of expression stack and local slots

The maximum number of nested calls that are inlined by C1

The maximum bytecode size of a method to be inlined by C1

maximum number of nested recursive calls that are inlined by C1

The maximum bytecode size of a trivial method to be inlined by 
C1

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 native 
compilations

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

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

Create separate nodes for length in array accesses

Canonicalize graph nodes

Generate checks in encoding/decoding code in debug VM

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 
@IntrinsicCandidate annotation, that 
(2) there is an intrinsic registered for all loaded methods 
that are annotated with the @IntrinsicCandidate 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

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

Enable Strings to use single byte chars in backing store

Compilation modes: 
default: normal tiered compilation; 
quick-only: C1-only mode; 
high-only: C2/JVMCI-only mode; 
high-only-quick-internal: C2/JVMCI-only mode, 
with JVMCI compiler compiled with C1.

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

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

Read compiler directives from this file

Disable backwards compatibility for compile commands.

Limit on number of compiler directives.

Print compiler directives on installation.

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

Compiler Thread Stack Size (in Kbytes)

Force the class space to be allocated at this address or 
fails VM initialization (requires -Xshare=off.

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

Control intrinsics using a list of +/- (internal) names, 
separated by commas

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

Convert float2int clipping idiom to integer clipping

Count number of bytecodes executed

Count method invocations

collect statistic counters during LinearScan

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 thrown from JVM

Create core/mini dump on VM fatal error

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 tool probes for object allocation

Enable dtrace tool probes for method-entry and method-exit

Enable dtrace tool 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

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

Use deoptimization in C1

Number of exits until DeoptimizeALot kicks in

Deoptimize at every exit from the runtime system

Make nmethod barriers deoptimise a lot.

Interval for DeoptimizeObjectsALot.

The number of threads that revert optimizations based on 
escape analysis for all threads if DeoptimizeObjectsALot 
is enabled.

The number of threads that revert optimizations based on 
escape analysis for a single thread if DeoptimizeObjectsALot 
is enabled. The target thread is selected round robin.

For testing purposes concurrent threads revert optimizations 
based on escape analysis at intervals given with 
DeoptimizeObjectsALotInterval=n. The thread count is given 
with DeoptimizeObjectsALotThreadCountSingle and 
DeoptimizeObjectsALotThreadCountAll.

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

Detect and take action upon identifying synchronization on 
value based classes. Modes: 

0: off; 

1: exit with fatal error; 

2: log message to stdout. Output file can be specified with 
 -Xlog:valuebasedclasses. If JFR is running it will 
 also generate JFR events.

Disable mechanism that allows tools to attach to this VM

Ignore calls to System.gc()

do not expand intrinsics whose (internal) names appear here

Disable the use of stack guard pages if the JVM is loaded 
on the primordial process thread

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

Do JVMTI virtual thread mount/unmount transitions 
(disabling this flag implies no JVMTI events are posted)

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

Dummy flag for testing string handling in WriteableFlags

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

Write map file for Linux perf tool at exit

If true, sets bit 2 of /proc/PID/coredump_filter, thus 
resulting in file-backed private mappings of the process to 
be dumped into the corefile.

Record replay data for crashing compiler threads

If true, sets bit 3 of /proc/PID/coredump_filter, thus 
resulting in file-backed shared mappings of the process to 
be dumped into the corefile.

Transform loop with a merge point into 2 loops if inner loop is
expected to optimize better

Dynamically resize system dictionaries as needed

Force eager JVMCI initialization

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

Number of fields in instance limit for scalar replacement

Use escape analysis to eliminate allocations

Control optimizations for autobox elimination

Eliminate unnecessary basic blocks

Optimize field loads and stores

Coarsen locks when possible

Eliminate nested locks of the same object when possible

Eliminate unnecessary null checks

Enable @Contended annotation support

Allow tools to load agents with the attach mechanism

Allow JVMCI to be used in product mode. This alters a subset of 
JVMCI flags to be non-experimental, defaults UseJVMCICompiler 
and EnableJVMCI to true and defaults UseJVMCINativeLibrary 
to true if a JVMCI native library is available.

Enable JVMCI

Enable JVMTI asserts related to stack depth checks

Enable Thread SMR extra validity checks

Enable Thread SMR Statistics

Enables aggressive reboxing of vectors

Enables reboxing of vectors

Enables VectorSupport intrinsics

Use timed decays to shrink TLAB sizes. This conserves memory 
for the threads that allocate in bursts of different sizes, 
for example the small/rare allocations coming after the initial 
large burst.

Use elastic policy to manage TLAB sizes. This conserves memory 
for non-actively allocating threads, even when they request 
large TLABs for themselves. Active threads would experience 
smaller TLABs until policy catches up.

Max TLAB size to use with Epsilon GC. Larger value improves 
performance at the expense of per-thread memory waste. This 
asks TLAB machinery to cap TLAB sizes at this value.

Min expansion step for heap. Larger value improves performance 
at the potential expense of memory waste.

Print heap occupancy stats with this number of steps. 

0 turns the printing off.

TLAB sizing policy decays to initial size after thread had not 
allocated for this long. Time is in milliseconds. Lower value 
improves memory footprint, but penalizes actively allocating 
threads.

Multiplier to use when deciding on next TLAB size. Larger value 
improves performance at the expense of per-thread memory waste. 
Lower value improves memory footprint, but penalizes actively 
allocating threads.

Update heap occupancy counters after allocating this much 
memory. Higher values would make allocations faster at 
the expense of lower resolution in heap counters.

Maximum ergonomically set heap size (in bytes); zero means use 
MaxRAM * MaxRAMPercentage / 100

If true, error data is printed to stderr instead of a file

If true, error data is printed to stdout instead of a file

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 controlled_crash() 
in vmError.cpp.

max number of compiled code units to print in error log

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

Abort EA when it reaches time limit (in sec)

Analyze bytecodes to estimate escape state of arguments

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 
thrown from JVM

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.

Do not use subtype check macro node

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

(Deprecated) Enable performance-impacting dtrace probes. 
Use the combination of -XX:+DTraceMethodProbes, 
-XX:+DTraceAllocProbes and -XX:+DTraceMonitorProbes instead.

Error reports are more extensive.

Size of the cache for scoped values

Extra classlist for building the CDS archive file

Number of float LRG's that constitute high register pressure.
-1: means the threshold is determined by number of available 
float register for allocation

Do lots of (expensive) FLS dictionary verification

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

Flight Recorder options

(Deprecated) Enable Flight Recorder

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

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 concurrent start 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 G1 service thread wakes up every specified number of 
milliseconds to do miscellaneous work.

The number of parallel remembered set update threads. 
Will be set ergonomically by default.

Each time the remembered set 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.

Maximum number of remembered set entries a humongous region 
otherwise eligible for eager reclaim may have to be a candidate 
for eager reclaim. Will be selected ergonomically by default.

The percentage of regions in the collection set starting 
from the beginning where the forced evacuation failure 
injection will be applied.

Number of successful evacuations between evacuation failures 
occurring at object copying per thread

Force use of evacuation failure handling during evacuation 
pauses when marking is in progress

Force use of evacuation failure handling during concurrent 
start evacuation pauses

Force use of evacuation failure handling during mixed 
evacuation pauses

Force use of evacuation failure handling during young 
evacuation pauses

Total collections between forced triggering of evacuation 
failures

Force use of evacuation failure handling during certain 
evacuation pauses

Raise a fatal VM exit out of memory failure in the event 
 that heap expansion fails due to running out of swap.

When expanding, % of uncommitted space to claim.

Size of the G1 regions.

Amount of space, expressed as a percentage of the heap size, 
that G1 is willing not to collect to avoid expensive GCs.

The expected average occupancy of the last PLAB in 
percent.

Percentage (0-100) of the heap size to use as default 
 maximum young gen size.

The maximum number of verification failures to print. 
-1 means print all.

The target number of mixed GCs after a marking cycle.

Threshold for regions to be considered for inclusion in the 
collection set of mixed GCs. 
Regions with live bytes exceeding this will not be collected.

Percentage (0-100) of the heap size to use as default 
minimum young gen size.

An upper bound for the number of old CSet regions expressed 
as a percentage of the heap size.

Number of milliseconds after a previous GC to wait before 
triggering a periodic gc. A value of zero disables periodically 
enforced gc cycles.

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.

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.

A target percentage of time that is allowed to be spend on 
processing remembered set update buffers during the collection 
pause.

Chunk size used for rebuilding the remembered set.

The number of discovered reference objects to process before 
draining concurrent marking work queues.

Maximum number of entries per region in the Array of Cards 
card set container per MB of a heap region.

Maximum number of entries per Array of Cards card set 
container. Will be set ergonomically by default.

Percentage at which to coarsen a Howl bitmap to Howl full card 
set container.

Percentage at which to coarsen a Howl card set to Full card 
set container.

The percentage of free card set memory that G1 should keep as 
percentage of the currently used memory.

Time after which the card set free memory task reschedules 
itself if there is work remaining.

The amount of time that the free memory task should spend 
before a pause of G1RemSetFreeMemoryRescheduleDelayMillis 
length.

Maximum number of buckets per Howl card set container. The 
default gives at worst bitmaps of size 8k. This showed to be a 
good tradeoff between bitmap size (waste) and cacheability of 
the bucket array. Must be a power of two.

Number of buckets per Howl card set container. Must be a power 
of two. Will be set ergonomically by default.

It determines the minimum reserve we should have in the heap 
to minimize the probability of promotion failure.

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.

Number of entries in an SATB log buffer.

Number of completed buffers that triggers log processing.

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 trace
level for gc+remset

Size of an update buffer

Select green, yellow and red zones adaptively to meet the 
the pause requirements.

Adaptively adjust the initiating heap occupancy from the 
initial value of InitiatingHeapOccupancyPercent. The policy 
attempts to start marking in time based on application 
behavior.

Allows collections to be triggered proactively based on thenumber of free regions and the expected survival rates in eachsection of the heap.

Concurrently preclean java.lang.ref.references instances 
before the Remark pause.

Verifies the consistency of the marking bitmaps

Verify card table cleanup.

Verify the code root lists attached to each heap region.

If true, perform verification of each heap region's 
remembered set when verifying the heap during a full GC.

Enforce ScavengeALot/GCALot at all potential safepoints

Card table entry size (in bytes) for card based collectors

Number of entries we will try to leave on the stack 
during parallel gc

Delay between expansion and allocation (in milliseconds)

Minimum percentage of free space after a full GC before an 
OutOfMemoryError is thrown (used with GCTimeLimit)

How much the GC can expand the eden by while the GC locker 
is active (as a percentage)

Number of times to retry allocations when 
blocked by the GC locker

Number of consecutive collections before gc time limit fires

Time slice for MMU specification

Limit of the proportion of time spent in GC before 
an OutOfMemoryError is thrown (used with GCHeapFreeLimit)

Adaptive size policy application time to GC time ratio

Generates code for array store checks

Generate range checks for array accesses

generate locking/unlocking code for synchronized methods and 
monitors

Guarantee a safepoint (at least) every so many milliseconds 
(0 means none)

Generate a lot of handshakes. This works with 
GuaranteedSafepointInterval

If nonzero set a timeout in milliseconds for handshakes

OS specific low limit for heap base address

Dump heap to file after any major stop-the-world GC

Dump heap to file before any major stop-the-world GC

When HeapDumpOnOutOfMemoryError is on, the gzip compression 
level of the dump file. 0 (the default) disables gzip 
compression. Otherwise the level must be between 1 and 9.

Dump heap to file when java.lang.OutOfMemoryError is thrown 
from JVM

When HeapDumpOnOutOfMemoryError is on, the path (filename or 
directory) of the dump file (defaults to java_pid.hprof 
in the working directory)

The collection count for the first maximum compaction

How often should we maximally compact the heap (not allowing 
any dead space)

Heap allocation steps through preferred address regions to find
 where it can allocate the heap. Number of steps to take per 
region.

Size of heap (bytes) per GC thread used in calculating the 
number of GC threads

Number of compiled code invocations after which 
the method is considered as hot by the flusher

Don't compile methods larger than this if 
+DontCompileHugeMethods

Produce histogram of IC misses

Enables IEEE precision (for INTEL only)

Number of integer LRG's that constitute high register pressure.
-1: means the threshold is determined by number of available 
integer register for allocation

Replace ClearArrayNode by subgraph of basic operations.

Ignore empty path elements in -classpath

Ignore unrecognized VM options

Use implicit division by zero checks

Don't do implicit null checks if NPE's in a method exceeds 
limit

// Generate code for implicit null checks

// Generate code for implicit null checks

Generate code for implicit null checks

// Generate code for implicit null checks.

// Generate code for implicit null checks

// Generate code for implicit null checks.

// Generate code for implicit null checks

Increase the compile threshold for C1 compilation if the code 
cache is filled by the specified percentage

do cleanup after every iteration of incremental inlining

do post parse inlining of method handle calls

do post parse inlining of virtual calls

do post parse inlining

Trace all operations on this IndexSet (-1 means all, 0 none)

Threshold small size (in bytes) for clearing arrays. 
Anything this size or smaller may get converted to discrete 
scalar stores.

Initial code cache size (in bytes)

// Integral multiple of CodeCacheExpansionSize

// Integral multiple of CodeCacheExpansionSize

Initial heap size (in bytes); zero means use ergonomics

Fraction (1/n) of real memory used for initial heap size. 
Deprecated, use InitialRAMPercentage instead

Percentage of real memory used for initial heap size

Initial ratio of young generation/survivor space size

Initial value for tenuring threshold

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)

Inject thread creation failures for 
UseDynamicNumberOfCompilerThreads

Inject thread creation failures for 
UseDynamicNumberOfGCThreads

inline accessor methods (get/set)

Inline arraycopy native that is known to be part of 
base library DLL

Inline Class.isInstance, etc

File containing inlining replay information
[default: ./inline_pid%p.log] (%p replaced with pid)

Ratio of call site execution to caller method invocation

Inline intrinsics that can be statically resolved