java.1

.RS
.RS
.PP
\f[CB]\-XX:AllocatePrefetchInstr=0\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:AllocatePrefetchLines=\f[R]\f[I]lines\f[R]
Sets the number of cache lines to load after the last object allocation
by using the prefetch instructions generated in compiled code.
The default value is 1 if the last allocated object was an instance, and
3 if it was an array.
.RS
.PP
The following example shows how to set the number of loaded cache lines
to 5:
.RS
.PP
\f[CB]\-XX:AllocatePrefetchLines=5\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:AllocatePrefetchStepSize=\f[R]\f[I]size\f[R]
Sets the step size (in bytes) for sequential prefetch instructions.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, \f[CB]g\f[R] or \f[CB]G\f[R]
to indicate gigabytes.
By default, the step size is set to 16 bytes:
.RS
.RS
.PP
\f[CB]\-XX:AllocatePrefetchStepSize=16\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:AllocatePrefetchStyle=\f[R]\f[I]style\f[R]
Sets the generated code style for prefetch instructions.
The \f[I]style\f[R] argument is an integer from 0 to 3:
.RS
.TP
.B \f[CB]0\f[R]
Don\[aq]t generate prefetch instructions.
.RS
.RE
.TP
.B \f[CB]1\f[R]
Execute prefetch instructions after each allocation.
This is the default setting.
.RS
.RE
.TP
.B \f[CB]2\f[R]
Use the thread\-local allocation block (TLAB) watermark pointer to
determine when prefetch instructions are executed.
.RS
.RE
.TP
.B \f[CB]3\f[R]
Generate one prefetch instruction per cache line.
.RS
.RE
.RE
.TP
.B \f[CB]\-XX:+BackgroundCompilation\f[R]
Enables background compilation.
This option is enabled by default.
To disable background compilation, specify
\f[CB]\-XX:\-BackgroundCompilation\f[R] (this is equivalent to specifying
\f[CB]\-Xbatch\f[R]).
.RS
.RE
.TP
.B \f[CB]\-XX:CICompilerCount=\f[R]\f[I]threads\f[R]
Sets the number of compiler threads to use for compilation.
By default, the number of compiler threads is selected automatically
depending on the number of CPUs and memory available for compiled code.
The following example shows how to set the number of threads to 2:
.RS
.RS
.PP
\f[CB]\-XX:CICompilerCount=2\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:+UseDynamicNumberOfCompilerThreads\f[R]
Dynamically create compiler thread up to the limit specified by
\f[CB]\-XX:CICompilerCount\f[R].
This option is enabled by default.
.RS
.RE
.TP
.B \f[CB]\-XX:CompileCommand=\f[R]\f[I]command\f[R]\f[CB],\f[R]\f[I]method\f[R][\f[CB],\f[R]\f[I]option\f[R]]
Specifies a \f[I]command\f[R] to perform on a \f[I]method\f[R].
For example, to exclude the \f[CB]indexOf()\f[R] method of the
\f[CB]String\f[R] class from being compiled, use the following:
.RS
.RS
.PP
\f[CB]\-XX:CompileCommand=exclude,java/lang/String.indexOf\f[R]
.RE
.PP
Note that the full class name is specified, including all packages and
subpackages separated by a slash (\f[CB]/\f[R]).
For easier cut\-and\-paste operations, it\[aq]s also possible to use the
method name format produced by the \f[CB]\-XX:+PrintCompilation\f[R] and
\f[CB]\-XX:+LogCompilation\f[R] options:
.RS
.PP
\f[CB]\-XX:CompileCommand=exclude,java.lang.String::indexOf\f[R]
.RE
.PP
If the method is specified without the signature, then the command is
applied to all methods with the specified name.
However, you can also specify the signature of the method in the class
file format.
In this case, you should enclose the arguments in quotation marks,
because otherwise the shell treats the semicolon as a command end.
For example, if you want to exclude only the \f[CB]indexOf(String)\f[R]
method of the \f[CB]String\f[R] class from being compiled, use the
following:
.RS
.PP
\f[CB]\-XX:CompileCommand="exclude,java/lang/String.indexOf,(Ljava/lang/String;)I"\f[R]
.RE
.PP
You can also use the asterisk (*) as a wildcard for class and method
names.
For example, to exclude all \f[CB]indexOf()\f[R] methods in all classes
from being compiled, use the following:
.RS
.PP
\f[CB]\-XX:CompileCommand=exclude,*.indexOf\f[R]
.RE
.PP
The commas and periods are aliases for spaces, making it easier to pass
compiler commands through a shell.
You can pass arguments to \f[CB]\-XX:CompileCommand\f[R] using spaces as
separators by enclosing the argument in quotation marks:
.RS
.PP
\f[CB]\-XX:CompileCommand="exclude\ java/lang/String\ indexOf"\f[R]
.RE
.PP
Note that after parsing the commands passed on the command line using
the \f[CB]\-XX:CompileCommand\f[R] options, the JIT compiler then reads
commands from the \f[CB]\&.hotspot_compiler\f[R] file.
You can add commands to this file or specify a different file using the
\f[CB]\-XX:CompileCommandFile\f[R] option.
.PP
To add several commands, either specify the \f[CB]\-XX:CompileCommand\f[R]
option multiple times, or separate each argument with the new line
separator (\f[CB]\\n\f[R]).
The following commands are available:
.TP
.B \f[CB]break\f[R]
Sets a breakpoint when debugging the JVM to stop at the beginning of
compilation of the specified method.
.RS
.RE
.TP
.B \f[CB]compileonly\f[R]
Excludes all methods from compilation except for the specified method.
As an alternative, you can use the \f[CB]\-XX:CompileOnly\f[R] option,
which lets you specify several methods.
.RS
.RE
.TP
.B \f[CB]dontinline\f[R]
Prevents inlining of the specified method.
.RS
.RE
.TP
.B \f[CB]exclude\f[R]
Excludes the specified method from compilation.
.RS
.RE
.TP
.B \f[CB]help\f[R]
Prints a help message for the \f[CB]\-XX:CompileCommand\f[R] option.
.RS
.RE
.TP
.B \f[CB]inline\f[R]
Attempts to inline the specified method.
.RS
.RE
.TP
.B \f[CB]log\f[R]
Excludes compilation logging (with the \f[CB]\-XX:+LogCompilation\f[R]
option) for all methods except for the specified method.
By default, logging is performed for all compiled methods.
.RS
.RE
.TP
.B \f[CB]option\f[R]
Passes a JIT compilation option to the specified method in place of the
last argument (\f[CB]option\f[R]).
The compilation option is set at the end, after the method name.
For example, to enable the \f[CB]BlockLayoutByFrequency\f[R] option for
the \f[CB]append()\f[R] method of the \f[CB]StringBuffer\f[R] class, use the
following:
.RS
.RS
.PP
\f[CB]\-XX:CompileCommand=option,java/lang/StringBuffer.append,BlockLayoutByFrequency\f[R]
.RE
.PP
You can specify multiple compilation options, separated by commas or
spaces.
.RE
.TP
.B \f[CB]print\f[R]
Prints generated assembler code after compilation of the specified
method.
.RS
.RE
.TP
.B \f[CB]quiet\f[R]
Instructs not to print the compile commands.
By default, the commands that you specify with the
\f[CB]\-XX:CompileCommand\f[R] option are printed; for example, if you
exclude from compilation the \f[CB]indexOf()\f[R] method of the
\f[CB]String\f[R] class, then the following is printed to standard output:
.RS
.RS
.PP
\f[CB]CompilerOracle:\ exclude\ java/lang/String.indexOf\f[R]
.RE
.PP
You can suppress this by specifying the
\f[CB]\-XX:CompileCommand=quiet\f[R] option before other
\f[CB]\-XX:CompileCommand\f[R] options.
.RE
.RE
.TP
.B \f[CB]\-XX:CompileCommandFile=\f[R]\f[I]filename\f[R]
Sets the file from which JIT compiler commands are read.
By default, the \f[CB]\&.hotspot_compiler\f[R] file is used to store
commands performed by the JIT compiler.
.RS
.PP
Each line in the command file represents a command, a class name, and a
method name for which the command is used.
For example, this line prints assembly code for the \f[CB]toString()\f[R]
method of the \f[CB]String\f[R] class:
.RS
.PP
\f[CB]print\ java/lang/String\ toString\f[R]
.RE
.PP
If you\[aq]re using commands for the JIT compiler to perform on methods,
then see the \f[CB]\-XX:CompileCommand\f[R] option.
.RE
.TP
.B \f[CB]\-XX:CompilerDirectivesFile=\f[R]\f[I]file\f[R]
Adds directives from a file to the directives stack when a program
starts.
See \f[B]Compiler Control\f[R]
[https://docs.oracle.com/en/java/javase/12/vm/compiler\-control1.html#GUID\-94AD8194\-786A\-4F19\-BFFF\-278F8E237F3A].
.RS
.PP
The \f[CB]\-XX:CompilerDirectivesFile\f[R] option has to be used together
with the \f[CB]\-XX:UnlockDiagnosticVMOptions\f[R] option that unlocks
diagnostic JVM options.
.RE
.TP
.B \f[CB]\-XX:+CompilerDirectivesPrint\f[R]
Prints the directives stack when the program starts or when a new
directive is added.
.RS
.PP
The \f[CB]\-XX:+CompilerDirectivesPrint\f[R] option has to be used
together with the \f[CB]\-XX:UnlockDiagnosticVMOptions\f[R] option that
unlocks diagnostic JVM options.
.RE
.TP
.B \f[CB]\-XX:CompileOnly=\f[R]\f[I]methods\f[R]
Sets the list of methods (separated by commas) to which compilation
should be restricted.
Only the specified methods are compiled.
Specify each method with the full class name (including the packages and
subpackages).
For example, to compile only the \f[CB]length()\f[R] method of the
\f[CB]String\f[R] class and the \f[CB]size()\f[R] method of the
\f[CB]List\f[R] class, use the following:
.RS
.RS
.PP
\f[CB]\-XX:CompileOnly=java/lang/String.length,java/util/List.size\f[R]
.RE
.PP
Note that the full class name is specified, including all packages and
subpackages separated by a slash (\f[CB]/\f[R]).
For easier cut and paste operations, it\[aq]s also possible to use the
method name format produced by the \f[CB]\-XX:+PrintCompilation\f[R] and
\f[CB]\-XX:+LogCompilation\f[R] options:
.RS
.PP
\f[CB]\-XX:CompileOnly=java.lang.String::length,java.util.List::size\f[R]
.RE
.PP
Although wildcards aren\[aq]t supported, you can specify only the class
or package name to compile all methods in that class or package, as well
as specify just the method to compile methods with this name in any
class:
.IP
.nf
\f[CB]
\-XX:CompileOnly=java/lang/String
\-XX:CompileOnly=java/lang
\-XX:CompileOnly=.length
\f[R]
.fi
.RE
.TP
.B \f[CB]\-XX:CompileThresholdScaling=\f[R]\f[I]scale\f[R]
Provides unified control of first compilation.
This option controls when methods are first compiled for both the tiered
and the nontiered modes of operation.
The \f[CB]CompileThresholdScaling\f[R] option has a floating point value
between 0 and +Inf and scales the thresholds corresponding to the
current mode of operation (both tiered and nontiered).
Setting \f[CB]CompileThresholdScaling\f[R] to a value less than 1.0
results in earlier compilation while values greater than 1.0 delay
compilation.
Setting \f[CB]CompileThresholdScaling\f[R] to 0 is equivalent to disabling
compilation.
.RS
.RE
.TP
.B \f[CB]\-XX:+DoEscapeAnalysis\f[R]
Enables the use of escape analysis.
This option is enabled by default.
To disable the use of escape analysis, specify
\f[CB]\-XX:\-DoEscapeAnalysis\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:InitialCodeCacheSize=\f[R]\f[I]size\f[R]
Sets the initial code cache size (in bytes).
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
The default value depends on the platform.
The initial code cache size shouldn\[aq]t be less than the system\[aq]s
minimal memory page size.
The following example shows how to set the initial code cache size to 32
KB:
.RS
.RS
.PP
\f[CB]\-XX:InitialCodeCacheSize=32k\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:+Inline\f[R]
Enables method inlining.
This option is enabled by default to increase performance.
To disable method inlining, specify \f[CB]\-XX:\-Inline\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:InlineSmallCode=\f[R]\f[I]size\f[R]
Sets the maximum code size (in bytes) for already compiled methods that
may be inlined.
This flag only applies to the C2 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
The default value depends on the platform and on whether tiered
compilation is enabled.
In the following example it is set to 1000 bytes:
.RS
.RS
.PP
\f[CB]\-XX:InlineSmallCode=1000\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:+LogCompilation\f[R]
Enables logging of compilation activity to a file named
\f[CB]hotspot.log\f[R] in the current working directory.
You can specify a different log file path and name using the
\f[CB]\-XX:LogFile\f[R] option.
.RS
.PP
By default, this option is disabled and compilation activity isn\[aq]t
logged.
The \f[CB]\-XX:+LogCompilation\f[R] option has to be used together with
the \f[CB]\-XX:UnlockDiagnosticVMOptions\f[R] option that unlocks
diagnostic JVM options.
.PP
You can enable verbose diagnostic output with a message printed to the
console every time a method is compiled by using the
\f[CB]\-XX:+PrintCompilation\f[R] option.
.RE
.TP
.B \f[CB]\-XX:FreqInlineSize=\f[R]\f[I]size\f[R]
Sets the maximum bytecode size (in bytes) of a hot method to be inlined.
This flag only applies to the C2 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
The default value depends on the platform.
In the following example it is set to 325 bytes:
.RS
.RS
.PP
\f[CB]\-XX:FreqInlineSize=325\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:MaxInlineSize=\f[R]\f[I]size\f[R]
Sets the maximum bytecode size (in bytes) of a cold method to be
inlined.
This flag only applies to the C2 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
By default, the maximum bytecode size is set to 35 bytes:
.RS
.RS
.PP
\f[CB]\-XX:MaxInlineSize=35\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:C1MaxInlineSize=\f[R]\f[I]size\f[R]
Sets the maximum bytecode size (in bytes) of a cold method to be
inlined.
This flag only applies to the C1 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
By default, the maximum bytecode size is set to 35 bytes:
.RS
.RS
.PP
\f[CB]\-XX:MaxInlineSize=35\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:MaxTrivialSize=\f[R]\f[I]size\f[R]
Sets the maximum bytecode size (in bytes) of a trivial method to be
inlined.
This flag only applies to the C2 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
By default, the maximum bytecode size of a trivial method is set to 6
bytes:
.RS
.RS
.PP
\f[CB]\-XX:MaxTrivialSize=6\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:C1MaxTrivialSize=\f[R]\f[I]size\f[R]
Sets the maximum bytecode size (in bytes) of a trivial method to be
inlined.
This flag only applies to the C1 compiler.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
By default, the maximum bytecode size of a trivial method is set to 6
bytes:
.RS
.RS
.PP
\f[CB]\-XX:MaxTrivialSize=6\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:MaxNodeLimit=\f[R]\f[I]nodes\f[R]
Sets the maximum number of nodes to be used during single method
compilation.
By default the value depends on the features enabled.
In the following example the maximum number of nodes is set to 100,000:
.RS
.RS
.PP
\f[CB]\-XX:MaxNodeLimit=100000\f[R]
.RE
.RE
.TP
.B \f[CB]\-XX:NonNMethodCodeHeapSize=\f[R]\f[I]size\f[R]
Sets the size in bytes of the code segment containing nonmethod code.
.RS
.PP
A nonmethod code segment containing nonmethod code, such as compiler
buffers and the bytecode interpreter.
This code type stays in the code cache forever.
This flag is used only if \f[CB]\-XX:SegmentedCodeCache\f[R] is enabled.
.RE
.TP
.B \f[CB]\-XX:NonProfiledCodeHeapSize=\f[R]\f[I]size\f[R]
Sets the size in bytes of the code segment containing nonprofiled
methods.
This flag is used only if \f[CB]\-XX:SegmentedCodeCache\f[R] is enabled.
.RS
.RE
.TP
.B \f[CB]\-XX:+OptimizeStringConcat\f[R]
Enables the optimization of \f[CB]String\f[R] concatenation operations.
This option is enabled by default.
To disable the optimization of \f[CB]String\f[R] concatenation operations,
specify \f[CB]\-XX:\-OptimizeStringConcat\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+PrintAssembly\f[R]
Enables printing of assembly code for bytecoded and native methods by
using the external \f[CB]hsdis\-<arch>.so\f[R] or \f[CB]\&.dll\f[R] library.
For 64\-bit VM on Windows, it\[aq]s \f[CB]hsdis\-amd64.dll\f[R].
This lets you to see the generated code, which may help you to diagnose
performance issues.
.RS
.PP
By default, this option is disabled and assembly code isn\[aq]t printed.
The \f[CB]\-XX:+PrintAssembly\f[R] option has to be used together with the
\f[CB]\-XX:UnlockDiagnosticVMOptions\f[R] option that unlocks diagnostic
JVM options.
.RE
.TP
.B \f[CB]\-XX:ProfiledCodeHeapSize=\f[R]\f[I]size\f[R]
Sets the size in bytes of the code segment containing profiled methods.
This flag is used only if \f[CB]\-XX:SegmentedCodeCache\f[R] is enabled.
.RS
.RE
.TP
.B \f[CB]\-XX:+PrintCompilation\f[R]
Enables verbose diagnostic output from the JVM by printing a message to
the console every time a method is compiled.
This lets you to see which methods actually get compiled.
By default, this option is disabled and diagnostic output isn\[aq]t
printed.
.RS
.PP
You can also log compilation activity to a file by using the
\f[CB]\-XX:+LogCompilation\f[R] option.
.RE
.TP
.B \f[CB]\-XX:+PrintInlining\f[R]
Enables printing of inlining decisions.
This let\[aq]s you see which methods are getting inlined.
.RS
.PP
By default, this option is disabled and inlining information isn\[aq]t
printed.
The \f[CB]\-XX:+PrintInlining\f[R] option has to be used together with the
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R] option that unlocks diagnostic
JVM options.
.RE
.TP
.B \f[CB]\-XX:ReservedCodeCacheSize=\f[R]\f[I]size\f[R]
Sets the maximum code cache size (in bytes) for JIT\-compiled code.
Append the letter \f[CB]k\f[R] or \f[CB]K\f[R] to indicate kilobytes,
\f[CB]m\f[R] or \f[CB]M\f[R] to indicate megabytes, or \f[CB]g\f[R] or
\f[CB]G\f[R] to indicate gigabytes.
The default maximum code cache size is 240 MB; if you disable tiered
compilation with the option \f[CB]\-XX:\-TieredCompilation\f[R], then the
default size is 48 MB.
This option has a limit of 2 GB; otherwise, an error is generated.
The maximum code cache size shouldn\[aq]t be less than the initial code
cache size; see the option \f[CB]\-XX:InitialCodeCacheSize\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:RTMAbortRatio=\f[R]\f[I]abort_ratio\f[R]
Specifies the RTM abort ratio is specified as a percentage (%) of all
executed RTM transactions.
If a number of aborted transactions becomes greater than this ratio,
then the compiled code is deoptimized.
This ratio is used when the \f[CB]\-XX:+UseRTMDeopt\f[R] option is
enabled.
The default value of this option is 50.
This means that the compiled code is deoptimized if 50% of all
transactions are aborted.
.RS
.RE
.TP
.B \f[CB]\-XX:RTMRetryCount=\f[R]\f[I]number_of_retries\f[R]
Specifies the number of times that the RTM locking code is retried, when
it is aborted or busy, before falling back to the normal locking
mechanism.
The default value for this option is 5.
The \f[CB]\-XX:UseRTMLocking\f[R] option must be enabled.
.RS
.RE
.TP
.B \f[CB]\-XX:+SegmentedCodeCache\f[R]
Enables segmentation of the code cache.
Without the \f[CB]\-XX:+SegmentedCodeCache\f[R], the code cache consists
of one large segment.
With \f[CB]\-XX:+SegmentedCodeCache\f[R], we have separate segments for
nonmethod, profiled method, and nonprofiled method code.
These segments aren\[aq]t resized at runtime.
The feature is enabled by default if tiered compilation is enabled
(\f[CB]\-XX:+TieredCompilation\f[R] ) and
\f[CB]\-XX:ReservedCodeCacheSize\f[R] >= 240 MB.
The advantages are better control of the memory footprint, reduced code
fragmentation, and better iTLB/iCache behavior due to improved locality.
iTLB/iCache is a CPU\-specific term meaning Instruction Translation
Lookaside Buffer (ITLB).
ICache is an instruction cache in theCPU.
The implementation of the code cache can be found in the file:
\f[CB]/share/vm/code/codeCache.cpp\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:StartAggressiveSweepingAt=\f[R]\f[I]percent\f[R]
Forces stack scanning of active methods to aggressively remove unused
code when only the given percentage of the code cache is free.
The default value is 10%.
.RS
.RE
.TP
.B \f[CB]\-XX:\-TieredCompilation\f[R]
Disables the use of tiered compilation.
By default, this option is enabled.
.RS
.RE
.TP
.B \f[CB]\-XX:UseSSE=\f[R]\f[I]version\f[R]
Enables the use of SSE instruction set of a specified version.
Is set by default to the highest supported version available (x86 only).
.RS
.RE
.TP
.B \f[CB]\-XX:UseAVX=\f[R]\f[I]version\f[R]
Enables the use of AVX instruction set of a specified version.
Is set by default to the highest supported version available (x86 only).
.RS
.RE
.TP
.B \f[CB]\-XX:+UseAES\f[R]
Enables hardware\-based AES intrinsics for hardware that supports it.
This option is on by default on hardware that has the necessary
instructions.
The \f[CB]\-XX:+UseAES\f[R] is used in conjunction with UseAESIntrinsics.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseAESIntrinsics\f[R]
Enables AES intrinsics.
Specifying\f[CB]\-XX:+UseAESIntrinsics\f[R] is equivalent to also enabling
\f[CB]\-XX:+UseAES\f[R].
To disable hardware\-based AES intrinsics, specify
\f[CB]\-XX:\-UseAES\ \-XX:\-UseAESIntrinsics\f[R].
For example, to enable hardware AES, use the following flags:
.RS
.RS
.PP
\f[CB]\-XX:+UseAES\ \-XX:+UseAESIntrinsics\f[R]
.RE
.PP
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RE
.TP
.B \f[CB]\-XX:+UseAESCTRIntrinsics\f[R]
Analogous to \f[CB]\-XX:+UseAESIntrinsics\f[R] enables AES/CTR intrinsics.
.RS
.RE
.TP
.B \f[CB]\-XX:+UseGHASHIntrinsics\f[R]
Controls the use of GHASH intrinsics.
Enabled by default on platforms that support the corresponding
instructions.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseBASE64Intrinsics\f[R]
Controls the use of accelerated BASE64 encoding routines for
\f[CB]java.util.Base64\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseAdler32Intrinsics\f[R]
Controls the use of Adler32 checksum algorithm intrinsic for
\f[CB]java.util.zip.Adler32\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCRC32Intrinsics\f[R]
Controls the use of CRC32 intrinsics for \f[CB]java.util.zip.CRC32\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCRC32CIntrinsics\f[R]
Controls the use of CRC32C intrinsics for \f[CB]java.util.zip.CRC32C\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseSHA\f[R]
Enables hardware\-based intrinsics for SHA crypto hash functions for
some hardware.
The \f[CB]UseSHA\f[R] option is used in conjunction with the
\f[CB]UseSHA1Intrinsics\f[R], \f[CB]UseSHA256Intrinsics\f[R], and
\f[CB]UseSHA512Intrinsics\f[R] options.
.RS
.PP
The \f[CB]UseSHA\f[R] and \f[CB]UseSHA*Intrinsics\f[R] flags are enabled by
default on machines that support the corresponding instructions.
.PP
This feature is applicable only when using the
\f[CB]sun.security.provider.Sun\f[R] provider for SHA operations.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.PP
To disable all hardware\-based SHA intrinsics, specify the
\f[CB]\-XX:\-UseSHA\f[R].
To disable only a particular SHA intrinsic, use the appropriate
corresponding option.
For example: \f[CB]\-XX:\-UseSHA256Intrinsics\f[R].
.RE
.TP
.B \f[CB]\-XX:+UseSHA1Intrinsics\f[R]
Enables intrinsics for SHA\-1 crypto hash function.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseSHA256Intrinsics\f[R]
Enables intrinsics for SHA\-224 and SHA\-256 crypto hash functions.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseSHA512Intrinsics\f[R]
Enables intrinsics for SHA\-384 and SHA\-512 crypto hash functions.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseMathExactIntrinsics\f[R]
Enables intrinsification of various \f[CB]java.lang.Math.*Exact()\f[R]
functions.
Enabled by default.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseMultiplyToLenIntrinsic\f[R]
Enables intrinsification of \f[CB]BigInteger.multiplyToLen()\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \-XX:+UseSquareToLenIntrinsic
Enables intrinsification of \f[CB]BigInteger.squareToLen()\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \-XX:+UseMulAddIntrinsic
Enables intrinsification of \f[CB]BigInteger.mulAdd()\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \-XX:+UseMontgomeryMultiplyIntrinsic
Enables intrinsification of \f[CB]BigInteger.montgomeryMultiply()\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \-XX:+UseMontgomerySquareIntrinsic
Enables intrinsification of \f[CB]BigInteger.montgomerySquare()\f[R].
Enabled by default on platforms that support it.
Flags that control intrinsics now require the option
\f[CB]\-XX:+UnlockDiagnosticVMOptions\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCMoveUnconditionally\f[R]
Generates CMove (scalar and vector) instructions regardless of
profitability analysis.
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCodeCacheFlushing\f[R]
Enables flushing of the code cache before shutting down the compiler.
This option is enabled by default.
To disable flushing of the code cache before shutting down the compiler,
specify \f[CB]\-XX:\-UseCodeCacheFlushing\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCondCardMark\f[R]
Enables checking if the card is already marked before updating the card
table.
This option is disabled by default.
It should be used only on machines with multiple sockets, where it
increases the performance of Java applications that rely on concurrent
operations.
.RS
.RE
.TP
.B \f[CB]\-XX:+UseCountedLoopSafepoints\f[R]
Keeps safepoints in counted loops.
Its default value depends on whether the selected garbage collector
requires low latency safepoints.
.RS
.RE
.TP
.B \f[CB]\-XX:LoopStripMiningIter=\f[R]\f[I]number_of_iterations\f[R]
Controls the number of iterations in the inner strip mined loop.
Strip mining transforms counted loops into two level nested loops.
Safepoints are kept in the outer loop while the inner loop can execute
at full speed.
This option controls the maximum number of iterations in the inner loop.
The default value is 1,000.
.RS
.RE
.TP
.B \f[CB]\-XX:LoopStripMiningIterShortLoop\f[R]=\f[I]number_of_iterations\f[R]
Controls loop strip mining optimization.
Loops with the number of iterations less than specified will not have
safepoints in them.
Default value is 1/10th of \f[CB]\-XX:LoopStripMiningIter\f[R].
.RS
.RE
.TP
.B \f[CB]\-XX:+UseFMA\f[R]
Enables hardware\-based FMA intrinsics for hardware where FMA
instructions are available (such as, Intel and ARM64).
FMA intrinsics are generated for the
\f[CB]java.lang.Math.fma(\f[R]\f[I]a\f[R]\f[CB],\f[R] \f[I]b\f[R]\f[CB],\f[R]
\f[I]c\f[R]\f[CB])\f[R] methods that calculate the value of \f[CB](\f[R]
\f[I]a\f[R] \f[CB]*\f[R] \f[I]b\f[R] \f[CB]+\f[R] \f[I]c\f[R] \f[CB])\f[R]
expressions.
.RS
.RE
.TP
.B \f[CB]\-XX:+UseRTMDeopt\f[R]
Autotunes RTM locking depending on the abort ratio.
This ratio is specified by the \f[CB]\-XX:RTMAbortRatio\f[R] option.
If the number of aborted transactions exceeds the abort ratio, then the
method containing the lock is deoptimized and recompiled with all locks
as normal locks.
This option is disabled by default.
The \f[CB]\-XX:+UseRTMLocking\f[R] option must be enabled.
.RS
.RE
.TP
.B \f[CB]\-XX:+UseRTMLocking\f[R]
Generates Restricted Transactional Memory (RTM) locking code for all
inflated locks, with the normal locking mechanism as the fallback
handler.
This option is disabled by default.
Options related to RTM are available only on x86 CPUs that support
Transactional Synchronization Extensions (TSX).
.RS
.PP
RTM is part of Intel\[aq]s TSX, which is an x86 instruction set
extension and facilitates the creation of multithreaded applications.
RTM introduces the new instructions \f[CB]XBEGIN\f[R], \f[CB]XABORT\f[R],
\f[CB]XEND\f[R], and \f[CB]XTEST\f[R].
The \f[CB]XBEGIN\f[R] and \f[CB]XEND\f[R] instructions enclose a set of
instructions to run as a transaction.
If no conflict is found when running the transaction, then the memory
and register modifications are committed together at the \f[CB]XEND\f[R]
instruction.
The \f[CB]XABORT\f[R] instruction can be used to explicitly abort a
transaction and the \f[CB]XTEST\f[R] instruction checks if a set of
instructions is being run in a transaction.
.PP
A lock on a transaction is inflated when another thread tries to access
the same transaction, thereby blocking the thread that didn\[aq]t
originally request access to the transaction.
RTM requires that a fallback set of operations be specified in case a
transaction aborts or fails.
An RTM lock is a lock that has been delegated to the TSX\[aq]s system.
.PP
RTM improves performance for highly contended locks with low conflict in
a critical region (which is code that must not be accessed by more than
one thread concurrently).
RTM also improves the performance of coarse\-grain locking, which
typically doesn\[aq]t perform well in multithreaded applications.
(Coarse\-grain locking is the strategy of holding locks for long periods
to minimize the overhead of taking and releasing locks, while
fine\-grained locking is the strategy of trying to achieve maximum
parallelism by locking only when necessary and unlocking as soon as
possible.) Also, for lightly contended locks that are used by different
threads, RTM can reduce false cache line sharing, also known as cache
line ping\-pong.
This occurs when multiple threads from different processors are
accessing different resources, but the resources share the same cache
line.
As a result, the processors repeatedly invalidate the cache lines of
other processors, which forces them to read from main memory instead of
their cache.
.RE
.TP
.B \f[CB]\-XX:+UseSuperWord\f[R]
Enables the transformation of scalar operations into superword
operations.
Superword is a vectorization optimization.
This option is enabled by default.
To disable the transformation of scalar operations into superword
operations, specify \f[CB]\-XX:\-UseSuperWord\f[R].
.RS
.RE
.SH ADVANCED SERVICEABILITY OPTIONS FOR JAVA
.PP
These \f[CB]java\f[R] options provide the ability to gather system
information and perform extensive debugging.
.TP
.B \f[CB]\-XX:+DisableAttachMechanism\f[R]
Disables the mechanism that lets tools attach to the JVM.
By default, this option is disabled, meaning that the attach mechanism
is enabled and you can use diagnostics and troubleshooting tools such as
\f[CB]jcmd\f[R], \f[CB]jstack\f[R], \f[CB]jmap\f[R], and \f[CB]jinfo\f[R].
.RS
.RS
.PP
\f[B]Note:\f[R] The tools such as \f[B]jcmd\f[R], \f[B]jinfo\f[R],
\f[B]jmap\f[R], and \f[B]jstack\f[R] shipped with the JDK aren\[aq]t
supported when using the tools from one JDK version to troubleshoot a
different JDK version.
.RE
.RE
.TP
.B \f[CB]\-XX:+ExtendedDTraceProbes\f[R]
\f[B]Linux and macOS:\f[R] Enables additional \f[CB]dtrace\f[R] tool probes
that affect the performance.
By default, this option is disabled and \f[CB]dtrace\f[R] performs only
standard probes.
.RS
.RE
.TP
.B \f[CB]\-XX:+HeapDumpOnOutOfMemoryError\f[R]
Enables the dumping of the Java heap to a file in the current directory
by using the heap profiler (HPROF) when a
\f[CB]java.lang.OutOfMemoryError\f[R] exception is thrown.
You can explicitly set the heap dump file path and name using the
\f[CB]\-XX:HeapDumpPath\f[R] option.
By default, this option is disabled and the heap isn\[aq]t dumped when
an \f[CB]OutOfMemoryError\f[R] exception is thrown.
.RS
.RE
.TP
.B \f[CB]\-XX:HeapDumpPath=path\f[R]
Sets the path and file name for writing the heap dump provided by the
heap profiler (HPROF) when the \f[CB]\-XX:+HeapDumpOnOutOfMemoryError\f[R]
option is set.
By default, the file is created in the current working directory, and
it\[aq]s named \f[CB]java_pid<pid>.hprof\f[R] where \f[CB]<pid>\f[R] is the
identifier of the process that caused the error.
The following example shows how to set the default file explicitly
(\f[CB]%p\f[R] represents the current process identifier):
.RS
.RS
.PP
\f[CB]\-XX:HeapDumpPath=./java_pid%p.hprof\f[R]
.RE
.IP \[bu] 2
\f[B]Linux and macOS:\f[R] The following example shows how to set the
heap dump file to \f[CB]/var/log/java/java_heapdump.hprof\f[R]:
.RS 2
.RS
.PP
\f[CB]\-XX:HeapDumpPath=/var/log/java/java_heapdump.hprof\f[R]
.RE
.RE
.IP \[bu] 2
\f[B]Windows:\f[R] The following example shows how to set the heap dump
file to \f[CB]C:/log/java/java_heapdump.log\f[R]:
.RS 2
.RS