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

Call fatal if the exception pointed by AbortVMOnException has this message

Weight for perm gen exponential resizing, between 0 and 100

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

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

Call thr_setconcurrency at thread creation time to avoid LWP starvation on MP systems (for Solaris Only)

Enable aggressive optimizations - see arguments.cpp

Control optimizations for aggressive boxing elimination

0 for no aliasing, 1 for oop/field/static/array split, 2 for class split, 3 for unique instances

Number of lines to prefetch ahead of instance 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

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)

When using recompilation, never interpret methods containing loops

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)

support sun.misc.Unsafe.defineAnonymousClass (deprecated)

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

SOLARIS_ONLY(64*K) NOT_SOLARIS(max_uintx)

SOLARIS_ONLY(64*K) NOT_SOLARIS(max_uintx)

Distance to prefetch destination array in arracopy

cpu/sparc/vm/globals_sparc.hpp

cpu/sparc/vm/globals_sparc.hpp

Assert/Guarantee on external suspend wait failure

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

Instruct the VM to assume multiple processors are available

(Unsafe,Unstable) Diagnostic - Controls emission of atomics

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

Automatic GC selection pause threshold in milliseconds

Automatically shutdown native memory tracking under stress situations. When set to false, native memory tracking tries to stay alive at the expense of JVM performance

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 for methods with exception handlers

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

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

cpu/sparc/vm/globals_sparc.hpp

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

cpu/sparc/vm/globals_sparc.hpp

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

Patch invokedynamic appendix not known at compile time

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

trueInTiered

trueInTiered

trueInTiered

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

CI_COMPILER_COUNT

CI_COMPILER_COUNT

CI_COMPILER_COUNT

use a separate counter when assigning ids to osr compilations

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

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

Wait for this many CI accesses to occur in all compiles before beginning to throw OutOfMemoryErrors 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

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

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

display timing information after each successful 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

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

Whether class unloading enabled when using CMS GC

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

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

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 (effective only 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

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

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

Number of CMS full collection done before compaction if > 0

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

Minimum percentage (0-100) of the CMS incremental duty cycle used when CMSIncrementalPacing is enabled

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 unloading of classes when class unloading is enabled

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

double

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

double

Simulate frequent marking stack / work queue overflow

An "interval" counter that determines how frequently to 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 milliseconds)

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

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

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

The 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

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

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

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

Number of blocks to attempt to claim when refilling CMS LAB's 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 abortable preclean phase

Preclean survivors during abortable preclean phase

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

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

Print the eden and the survivor chunks used for the parallel initial mark or remark of the eden/survivor spaces

In a dump enabled by CMSDumpAtPromotionFailure, include more detailed information about the allocated objects

Choose variant (1,2) of verification following remark

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

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

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

Start sampling eden top at least before young gen occupancy reaches 1/<ratio> 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

double

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

double

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

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

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

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

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

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

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

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

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

Create separate nodes for length in array accesses

Generate checks in encoding/decoding code in debug VM

Warn if value contains oop (requires ZapDeadLocals)

falseInEmbedded

falseInEmbedded

falseInEmbedded

Always clear local variables of interpreter activations upon entry

Clip inlining if aggregate method exceeds DesiredMethodLimit

When less than X space left, start code cache cleaning

Minimum number of segments in a code cache block

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

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

Code entry alignment for generated code (in bytes)

trueInDebug

trueInDebug

trueInDebug

Allocate nonstatic fields in gaps between previous fields

Number of times to recompile method before returning result

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

ccstrlist

Read compiler commands from this file [.hotspot_compiler]

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

ccstrlist

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

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

number of interpreted method invocations before (re-)compiling

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)

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)

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

Limit of ops to make speculative when using CMOVE

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

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

Convert float2int clipping idiom to integer clipping

Convert sleep(0) to thread yield (may be off for Solaris to improve GUI)

Convert yield to a sleep of MinSleepInterval to simulate Win32 behavior (Solaris only)

Count exceptions that could be replaced by branches due to inlining

The minimum interval (in milliseconds) between invocation of CounterDecay

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

Enable dtrace probes for method-entry and method-exit

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

trueInDebug

trueInDebug

trueInDebug

Set when executing debug methods in debug.cpp (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

Deoptimize at every exit from the runtime system

ccstrlist

Deoptimize random frames on random exit from the runtime system

The desired maximum method size (in bytecodes) after inlining

Die upon failure to reach safepoint (see SafepointTimeout)

Disable mechanism that allows tools to attach to this VM

do not expand intrinsics whose (internal) names appear here

ccstrlist

Disable starting of additional Java threads (for debugging only)

Display all VM output on the tty, independently of LogVMOutput

If DisplayVMOutput is true, display all VM output to stderr

If DisplayVMOutput is true, display all VM output to stdout

Do Conditional Expression Elimination to simplify CFG

Throw away obvious excess yield calls (for Solaris only)

Interval between which yields will be dropped (milliseconds)

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

Eliminate nested locks of the same object when possible

share/vm/opto/c2_globals.hpp|share/vm/shark/shark_globals.hpp

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

support JSR 292 (method handles, invokedynamic, anonymous classes

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.

Analyze bytecodes to estimate escape state of arguments

Exit or throw assert in EA when it reaches time limit

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

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

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

Number of float LRG's that constitute high register pressure

CMS: larger free blocks are always available for coalescing

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

CMS: the smaller the percentage the greater the coalescing force

double

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

Do lots of (expensive) FLS index table verification

Inline allocations larger than this in doublewords must go slow

0 - type based with oops first, 1 - with oops last, 2 - oops in super and sub classes are together

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

Private flag to control optimizations for stable variables

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

trueInDebug

trueInDebug

trueInDebug

Force NUMA optimizations on single-node/UMA systems

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

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

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

Interval between which full gc will occur with +FullGCALot

On re-interpret unc-trap compile next at CompLevel_fast_compile

Expand the card count cache if the number of collisions for a particular entry exceeds this value.

share/vm/gc_implementation/g1/g1_globals.hpp

The number of times we'll force an overflow during concurrent marking

share/vm/gc_implementation/g1/g1_globals.hpp

Target duration of individual concurrent marking steps in milliseconds.

double

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

Enables verboseness during concurrent region freeing

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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.

share/vm/gc_implementation/g1/g1_globals.hpp

Force use of evacuation failure handling during certain evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

Number of successful evacuations between evacuation failures occurring at object copying

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

Force use of evacuation failure handling during initial mark evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

Force use of evacuation failure handling during mixed evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

Force use of evacuation failure handling during young evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

Total collections between forced triggering of evacuation failures

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

When expanding, % of uncommitted space to claim.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

Forces flushing of log buffers before verification.

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

1024 * 1024

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

The maximum size of the hot card count cache as a percentage of the number of cards for the maximum heap.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

The target number of mixed GCs after a marking cycle.

share/vm/gc_implementation/g1/g1_globals.hpp

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.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

When true, print applications of closures to external locs.

share/vm/gc_implementation/g1/g1_globals.hpp

When true, print extra stats about parallel cleanup.

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

The base file name for the reachable object dumps

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

If true, generate region filtering code in RS barrier

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

A target percentage of time that is allowed to be spend on process RS update buffers during the collection pause.

share/vm/gc_implementation/g1/g1_globals.hpp

When true, record recent calls to rem set operations.

share/vm/gc_implementation/g1/g1_globals.hpp

When true, record recent calls to rem set operations.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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.

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

Number of completed buffers that triggers log processing.

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

It stresses the concurrent region freeing operation

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

Enables heap region remembered set debug logs

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

Trace information string and symbol table scrubbing.

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

Enables the parallelization of remembered set scanning during evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

Enables the parallelization of remembered set updating during evacuation pauses

share/vm/gc_implementation/g1/g1_globals.hpp

share/vm/gc_implementation/g1/g1_globals.hpp

If conc mark verification fails, dump reachable objects

share/vm/gc_implementation/g1/g1_globals.hpp

Verify the code root lists attached to each heap region.

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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

share/vm/gc_implementation/g1/g1_globals.hpp

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)

The exit of a JNI critical section necessitating a scavenge, also kicks off a background concurrent collection

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

GC log file size (default: 0 bytes, no rotation). It requires UseGCLogFileRotation

Reporting period for conc GC overhead reporting, in ms

Number of time stamp entries per gc worker thread

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

Generate explicit null checks for loads/stores/calls

generate locking/unlocking code for synchronized methods and monitors

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

Threshold for HandleMark allocation when +TraceHandleAllocation is used

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

ScaleForWordSize(64*M)

ScaleForWordSize(64*M)

ScaleForWordSize(64*M)

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

Don't compile methods larger than this if +DontCompileHugeMethods

Number of integer LRG's that constitute high register pressure

Check performance difference allowing FP associativity and commutativity...

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

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

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

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

Initial size of the boot class loader data metaspace

NOT_LP64(2200*K) LP64_ONLY(4*M)

Initial compile at CompLevel_really_fast_compile (no profile)

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

Fraction (1/n) of real memory used for initial heap size

Initial ratio of young generation/survivor space size

Initialize various error and exception classes - turn off for individual method debugging

Initialize java.lang.String - turn off for individual method debugging

Initialize java.lang.System - turn off for individual method debugging

Percentage of the (entire) heap occupancy to start a concurrent GC cycle. It is used by GCs that trigger a concurrent GC cycle based on the occupancy of the entire heap, not just one of the generations (e.g., G1). A value of 0 denotes 'do constant GC cycles'.

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

Count of call site execution necessary to trigger frequent inlining

Ratio of call site execution to caller method invocation

Inline methods containing exception handlers (NOTE: does not work with current backend)

Inline natives that are known to be part of base library DLL

inline Object.clone and Arrays.copyOf[Range] intrinsics