VM Options Explorer - OpenJDK6 HotSpot

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

Weight for perm gen exponential resizing, between 0 and 100

Adaptive size scale down factor for shrinking

Time scale over which major costs decay

Policy for changing generation size for pause goals

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

Collecton interval for printing information; zero => never

Number of collections before the adaptive sizing is started

Weight given to exponential resizing, between 0 and 100

Policy for changeing generation size for throughput goals

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

call thr_setconcurrency at thread create time to avoid 
LWP starvation on MP systems (For Solaris Only)

Enable aggressive optimizations - see arguments.cpp

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

2 for class split, 3 for unique instances

aligns entry code to specified value (in bytes)

Number of lines to prefetch ahead of instance allocation pointer

Distance to prefetch ahead of allocation pointer

Prefetch 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 = prefetch instructions for each allocation, 

2 = use TLAB watermark to gate allocation prefetch, 

3 = use BIS instruction on Sparc for allocation prefetch

accept MethodHandle.invoke and MethodHandle.invokeGeneric 
as equivalent methods

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)

Always act like a server-class machine

when using recompilation, never interpret methods 
containing loops

(Unstable) Force inflation

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

It forces all freshly committed pages to be pre-touched.

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

Always tenure objects in eden. (ParallelGC only)

support sun.misc.Unsafe.defineAnonymousClass (deprecated)

Distance to prefetch destination array in arracopy

Distance to prefetch source array in arracopy

Assert/Guarantee on external suspend wait failure

number of times to evaluate expression in assert 
(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS

(Unsafe,Unstable) Diagnostic - Controls emission of atomics

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

Automatic GC selection pause threshhold in ms

How much tracing to do of bytecode escape analysis estimates

Interpreter Back edge threshold at which an OSR compilation is invoked

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 layour

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

Minimum size in bytes when block zeroing will be used

Use Sparc V9 branch-on-register opcodes

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

Execute breakpoint upon encountering VM warning

Enables the Java bytecode verifier for local classes

Enables 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 methodDataOops in Tier1-generated code

id of osr compilation to break at

id of compilation to break at

size limit for blocks heuristically cloned in ciTypeFlow

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

Wait for this many CI accesses to occur in all compiles before 
beginning to throw OutOfMemoryErrors in each compile

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

collect timing information for compilation

detailed per-bytecode tracing of ciTypeFlow analysis

Whether abort-on-overflow semantics is implemented

(Temporary, subject to experimentation)
Nominal minimum work per abortable preclean iteration

(Temporary, subject to experimentation)
 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

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

Compact when asked to collect CMS gen with clear_all_soft_refs

Size (in cards) of CMS concurrent MT marking task

Whether multi-threaded concurrent work enabled (if ParNewGC)

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

Use BinaryTreeDictionary as default in the CMS generation

Dump useful information about the state of the CMS old 
 generation upon a promotion failure.

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

CMS: cushion for block demand during sweep

Number of CMS full collection done before compaction if > 0

Lower bound on the duty cycle when CMSIncrementalPacing is 
enabled (a percentage, 0-100)

CMS incremental mode duty cycle (a percentage, 0-100). If
CMSIncrementalPacing is enabled, then this is just the initial
value

Whether CMS GC should operate in 'incremental' mode

Percentage (0-100) by which the CMS incremental mode duty cycle
 is shifted to the right within the period between young GCs

Whether the CMS incremental mode duty cycle should be 
automatically adjusted

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

Percentage CMS perm generation occupancy to start a 
CMScollection cycle. A negative value means that 
CMSTriggerPermRatio is used

An absolute ceiling above which CMS will always consider the 
perm gen ripe for collection

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

Whether we should simulate frequent marking stack / work queue
 overflow

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

(Temporary, subject to experimentation)
Maximum number of abortable preclean iterations, if > 0

(Temporary, subject to experimentation)
Maximum time in abortable preclean in ms

Max size of CMS gen promotion lab caches per worker per blksize

Min size of CMS gen promotion lab caches per worker per blksize

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

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

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

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

Whether preserved marks should be restored early

Whether to always record survivor space PLAB bdries
 (effective only if CMSParallelSurvivorRemarkEnabled)

Number of blocks to attempt to claim when refilling CMS LAB for 
parallel GC.

Whether parallel remark enabled (only if ParNewGC)

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

Whether concurrent precleaning enabled in perm gen
 (effective only when CMSPrecleaningEnabled is true)

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

Don't re-iterate if #dirty cards less than this

Whether concurrent precleaning enabled

In a dump enabled by CMSDumpAtPromotionFailure, include 
 more detailed information about the free chunks.

In a dump enabled by CMSDumpAtPromotionFailure, 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

Size of CMS KlassKlass revisit stack

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

Attempt scavenge before the CMS remark step

The Eden occupancy % at which to try and schedule remark pause

If Eden used is below this value, don't try to schedule remark

Start sampling Eden top at least before yg 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

Trace CMS incremental mode

Trace CMS incremental mode pacing computation

Trace some actions of the CMS sweeper

Trace the CMS thread state (enable the trace_state() method)

Percentage of MinHeapFreeRatio in the CMS perm generation that 
is allocated before a CMS collection cycle commences, that 
also collects the perm generation

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 concurrent mark & sweep

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

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 decating 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 threhold 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, experimental code

Canonicalize graph nodes

temporary - see javaClasses.cpp

generate checks in encoding/decoding code in debug VM

Verify all arguments to JNI calls

Checks memory initialization

Warn if value contains oop ( requires ZapDeadLocals)

Check for unhandled oops in VM code

Check zapping of unused heap space

Do unloading of classes

Whether to clean the chunk pool asynchronously

(Unsafe,Unstable)

Always clear local variables of interpreter activations upon 
entry

clip inlining if aggregate method exceeds DesiredMethodLimit

Code cache expansion size (in bytes)

When less than X space left, start code cache cleaning

Minimum number of segments in a code cache block.

When less than X space left, we stop compiling.

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

Code entry alignment for generated code (in bytes)

Collect youngest generation before each full GC

Collect information about IndexSets

Show extra info in PrintNMethods output

Allocate nonstatic fields in gaps between previous fields

which compilation policy (0/1)

Number of times to recompile method before returning result

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)

number of interpreted method invocations before (re-)compiling

// Design center runs on 1.3.1

If +ZapDeadCompiledLocals, 
skip this many before compiling in zap calls

If +ZapDeadCompiledLocals, 
compile this many after skipping (incl. skip count, -1 = all)

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

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 # of ms.

Limit of ops to make speculative when using CMOVE

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

Convert float2int clipping idiom to integer clipping

Converts sleep(0) to thread yield 
(may be off for SOLARIS to improve GUI)

// do not convert sleep(0) to yield. Helps GUI

Converts yield to a sleep of MinSleepInterval to simulate Win32 
behavior (SOLARIS only)

Count number of bytecodes executed

counts method invocations

// not implemented in the interpreter

counts jni method invocations

counts jvm method invocations

collect statistic counters during LinearScan

count exceptions that could be replaced by branches due to 
inlining

counts VM runtime calls

Min. ms. between invocation of CounterDecay

half-life time of invocation counters (in secs)

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

Create minidump on VM fatal error

check for critical JNI entry points

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 info for non-safepoints in nmethods

add debugging code to vtable dispatch

set when executing debug methods in debug.ccp 
(to prevent triggering assertions)

Maximum fraction (1/n) of real memory used for maximum heap 
size; deprecated: to be renamed to MaxRAMFraction

The native priority at which threads run if not elsewhere 
specified (-1 means no change)

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

desired max. method size (in bytecodes) after inlining

Die upon failure to reach safepoint (see SafepointTimeout)

Disable mechanism that allows tools to attach to this VM

Tells whether calling System.gc() does a full 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

Iterations limit in Node::dominates

don't compile methods > HugeMethodLimit

Interval between which yields will be dropped (milliseconds)

Throw away obvious excess yield calls (for SOLARIS only)

// yield no more than 100 times per second

// Determined in the design center

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

Private flag to 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

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

support JSR 292 (method handles, invokedynamic, 
anonymous classes

support method handles (deprecated)

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.

Override built-in error report server address

Analyze bytecodes to estimate escape state of arguments

maximum nof events in event log

Enable execution of internal VM tests.

If non-zero, exit after this GC.

Exit the VM if we fill the code cache.

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

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

Enable performance-impacting dtrace probes

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: Aggression level for coalescing, increasing from 0 to 4

CMS: the smaller the percentage the greater the coalition force

Verify that all refs 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

(Unsafe,Unstable) Experimental

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)

Prevent spurious or premature wakeups from object.wait 
(Solaris only)

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 with forcing use of 64bit literal fixups

Scaling factor for branch frequencies (deprecated)

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)

On re-interpret unc-trap compile next at CompLevel_fast_compile

The number of times we'll force an overflow during 
concurrent 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. Zero will disable 
concurrent processing.

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

If non-0 is the number of parallel rem set update threads, 
otherwise the value is determined ergonomically.

Each time the rset update queue increases by this amount 
activate the next refinement thread if available. 
Will be selected ergonomically by default.

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

Enables verboseness during concurrent region freeing

Confidence level for MMU/pause predictions

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

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

If true, use deferred RS updates

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.

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.

If the young survival rate is S, and there's room left in 
to-space, we will allow regions whose survival rate is up to 
S + (1 - S)*X, where X is this parameter (as a fraction.)

When set, G1 will fail when it encounters an FP 'error', 
so as to allow debugging

Forces flushing of log buffers before verification.

When true, use sparse table to save space.

Size of the G1 regions.

Expected Survival Rate for newly allocated bytes

Size of the region stack for concurrent marking.

Overhead of concurrent marking

Level (0-4) of verboseness of the marking code

The maximum desired number of mixed GCs after a marking cycle.

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

Threshold for regions to be added to the collection set. 
Regions with more live bytes that this will not be collected.

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

Threshold for the remaining old reclaimable bytes, expressed 
as a percentage of the heap size. If the old reclaimable bytes 
are under this we will not collect them with more mixed GCs.

If set G1 will print information on which regions are being 
allocated and which are reclaimed.

When true, print applications of closures to external locs.

When true, print extra stats about parallel cleanup.

Reachable object dump at the initial mark pause

The base file name for the reachable object dumps

Prints the liveness information for all regions in the heap 
at the end of a marking cycle.

If true, generate null-pointer filtering code in RS barrier

If true, generate region filtering code in RS barrier

If true, print a histogram of RS occupancies after each pause

If true, verify that no dirty cards remain after RS log 
processing.

When true, do RS scrubbing with verbose output.

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.

When true, record recent calls to rem set operations.

When true, record recent calls to rem set operations.

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.

If true, print generated stubs for the SATB barrier

Number of completed buffers that triggers log processing.

When true, do RS scrubbing after cleanup.

The number of regions we will add to the secondary free list 
at every append operation

Artificial delay during concurrent region freeing

It stresses the concurrent region freeing operation

Summarize concurrent mark info

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 -XX:+G1SummarizeRSetStats

Summarize remembered set processing info

Trace G1 concurrent refinement

If true, extra debugging code for CM restart for ovflw.

Size of an update buffer

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

If true, enable reference discovery during concurrent 
marking and reference processing at the end of remark.

Enables the parallelization of remembered set scanning 
during evacuation pauses

Enables the parallelization of remembered set updating 
during evacuation pauses

Verify card table cleanup.

If conc mark verification fails, dump reachable objects

the number of regions for which we'll print a surv rate 
summary.

print out the survival rate of young regions according to age.

Enforce ScavengeALot/GCALot at all potential safepoints

how many entries we'll try to leave on the stack during 
parallel GC

Delay in ms between expansion and allocation

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)

The exit of a JNI CS necessitating a scavenge also
 kicks off a bkgrd concurrent collection

GC log file size, Default: 0 bytes, no rotation 
Only valid with UseGCLogFileRotation

Reporting period for conc GC overhead reporting, in ms

Enables the GC overhead reporting facility

Enable parallel memory system verification

Time slice for MMU specification

Number of time stamp entries per gc worker thread

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

Adaptive size policy application time to GC time ratio

Generates code for array store checks

Generate explicit null checks for loads/stores/calls

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)

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

Specify alternate path to HPI library

Threshold for HandleMark allocation when +TraceHandleAllocation 
is used

OS specific low limit for heap base address

Dump heap to file after any major stop-world GC

Dump heap to file before any major stop-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)

Approximate segment size when generating a segmented heap dump

The collection count for the first maximum compaction

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

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