7.13.1 -XX:HitachiJITCompileMaxMemorySize

Description

-XX:HitachiJITCompileMaxMemorySize specifies the maximum memory size of the C heap to be allocated during JIT compilation. If the size of the C heap memory allocated by JIT compilation exceeds the specified value, a log entry is output to the Java VM log file, and subsequent processing for JIT compilation is suppressed. After the specified value is exceeded, Java methods that were the targets of JIT compilation will be executed by the interpreter only. Even when JIT compilation is suppressed, Java VM is not forcibly terminated and continues processing.

If 0 is specified, there is no upper limit on the size of the memory to be allocated during JIT compilation.

Note that Java VM internal threads (JIT compiler threads) are used for JIT compilation. Because there are two JIT compiler threads, the upper limit for one JIT compiler thread is half of the value specified in this option.

Even when an upper limit is set by using this option, if the size of the C heap that is actually available is less than the upper limit, a C heap shortage might occur before the upper limit is reached. In such cases, Java VM is forcibly terminated.

Prerequisite option

• -server

Format of output

[id][Thread:  thread_id]<date>["thread_name" exceeded max memory size.]
[current_sizeK->new_sizeK/limit_size_per_threadK/limit_sizeK]
[compile_target][byte_code_size]

The following provides details about the output.

Output item	Output content
id	JMS (Java VM log file identifier)
thread_id	Thread ID of the JIT compiler thread for which JIT compilation was suppressed
date	Date and time JIT compilation was suppressed If the -XX:+HitachiOutputMilliTime option is specified, this item is output in milliseconds.
thread_name	Thread name of the JIT compiler thread for which JIT compilation was suppressed
current_size	Size (in kilobytes) of the memory currently allocated to the JIT compiler thread for which JIT compilation was suppressed
new_size	Sum of the sizes (in kilobytes) of the memory currently allocated to the JIT compiler thread for which JIT compilation was suppressed and of the additional memory that was to be allocated
limit_size_per_thread	Upper limit (in kilobytes) per JIT compiler thread
limit_size	Upper limit (in kilobytes) of all JIT compiler threads
compile_target	Java method that is subject to JIT compilation
byte_code_size	Byte code size (in bytes) of the Java method that is subject to JIT compilation

Syntax

-XX:HitachiJITCompileMaxMemorySize=integer_value

Specifiable values

integer_value

Type: Integer

Specify the maximum size of the memory to be allocated during JIT compilation. Specify the size in units of bytes. You can also specify k for kilo, m for mega, and g for giga. The specifiable values are described below. If you specify a value outside of these ranges, 0 is set.

For 32-bit Java VM:

0 to 2³²-1 (4,294,967,295)

For 64-bit Java VM:

0 to 2⁶⁴-1 (18,446,744,073,709,551,615)

If you specify 0, the will be no upper limit on the size of the memory to be allocated during JIT compilation. If a C heap shortage occurs during JIT compilation, Java VM is forcibly terminated.

Default value

If the definition item is omitted:

-XX:HitachiJITCompileMaxMemorySize=0

[JMS][Thread:  0x03bf1150]<Wed Feb 24 14:33:58 2010>
["CompilerThread0" exceeded  max memory size.][262143K->262145K/262144K/524288K]
[test1.func][213]

Notes

• If the size of the memory allocated during JIT compilation exceeds the upper limit specified for this option and JIT compilation is suppressed, application throughput will decrease.

• If a value other than a natural number is specified, the operation is the same as that when an undefined option is specified.