VM Options Explorer - OpenJDK14 HotSpot

AOT library

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

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

Path to the directoy where a temporary file will be 
created to use as the backing store for old generation.
File of size Xmx is pre-allocated for performance reason, so
we need that much space available

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

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)

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

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

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

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

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

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.

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

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

Calculate class fingerprint

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

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

(Deprecated) Allocate nonstatic fields in gaps 
between previous fields

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

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

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

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

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

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

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

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.

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

Dynamic archive

Dynamically resize system dictionaries as needed

Eagerly initialize classes if possible

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

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 unneccessary 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 Thread SMR extra validity checks

Enable Thread SMR Statistics

Use timed decays to shrik 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 test_error_handler() 
in vmError.cpp.

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

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; 
(effective only when using concurrent collectors)

Enable performance-impacting dtrace probes

Error reports are more extensive.

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

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

(Deprecated) 0 - type based with oops first, 

1 - with oops last, 

2 - oops in super and sub classes are together

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

Flight Recorder options

(Deprecated) Enable Flight Recorder

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.

Number of successful evacuations between evacuation failures 
occurring at object copying

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

Force use of evacuation failure handling during initial mark 
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.

Max number of regions in a fine-grain table per MB.

Max number of regions for which we keep bitmaps.
Will be set ergonomically by default

Size of a work unit of cards claimed by a worker thread
during RSet scanning.

Max number of entries per region in a sparse table 
per MB.

Max number of entries per region in a sparse table.
Will be set ergonomically by default.

A target percentage of time that is allowed to be spend on 
process RS 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.

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.

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.

When heterogenous heap is enabled by AllocateOldGenAt 
option, after every GC, young gen is re-sized which 
involves system calls to commit/uncommit memory. To 
reduce these calls, we keep a buffer of extra regions to 
absorb small changes in young gen length. This flag takes 
the buffer size as an percentage of young gen length

Enforce ScavengeALot/GCALot at all potential safepoints

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

Enable parallel memory system verification

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

Delay in scheduling GC workers (in milliseconds)

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

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

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

large numbers of calls (per method invocation) force hotness

highly profitable inlining opportunities force hotness

trivial methods (no larger than this) force calls to be hot

trivial execution time (no larger than this) forces hotness

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

// Medium size register set, 6 special purpose regs, 3 SOE regs.

// large register set

Replace ClearArrayNode by subgraph of basic operations.

Check performance difference allowing FP 
associativity and commutativity...

Ignore empty path elements in -classpath

Suppress rewrites of bytecodes in the oopmap generator. 
This is unsafe!

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 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 size of the boot class loader data metaspace

Initial code cache size (in bytes)

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