5.11.3 Contents output when output level is normal

This subsection describes the contents output for each event when normal is specified in log output levels.

The normal is the log output level specified when there are normal operations.

Organization of this subsection

(1) GC occurrence (Output Explicit heap usage status)
(2) Explicit memory block explicit release process
(3) Java heap overflow in Explicit memory block explicit release process
(4) Automatic release processing of the explicit memory block
(5) Java heap overflow in the automatic release processing of the explicit memory block
(6) Error in opening the automatic allocation configuration file for Explicit Memory Management
(7) Error in parsing the automatic allocation configuration file for Explicit Memory Management
(8) Automatic allocation error in Explicit Memory Management
(9) Error in opening the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality
(10) Error in parsing the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality

(1) GC occurrence (Output Explicit heap usage status)

Output Explicit heap usage status when GC occurred.

Output this log when there is no object for migration from Java heap to Explicit heap. <EH_USED_BF> and <EH_USED_AF> would have same value when there is no object to migrate to Explicit heap.

(a) Output trigger

Output trigger is the termination of GC.

(b) Output format

[ENS]<ctime>[EH: <EH_USED_BF>-><EH_USED_AF>(<EH_TOTAL>/<EH_MAX>)][E/F/D: <AC_NUM>/<FL_NUM>/<DA_NUM>][cause:<CAUSE>][CF: <CF_CNT>]

(c) Output items

The following table describes each item indicated in (b) output format.

Table 5‒33: Output items (GC occurrence (Output Explicit heap usage status))
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates occurrence date and time of GC. Output in the format same as extended `verbosegc` information. Output in millisecond units when the `-XX:+HitachiOutputMilliTime` option is set.
`<EH_USED_BF>`	`<const>K`	Output used size of Explicit heap before execution of GC. The unit is kilo bytes.
`<EH_USED_AF>`	`<const>K`	Output used size of Explicit heap after execution of GC. The unit is kilo bytes.
`<EH_TOTAL>`	`<const>K`	Output secured memory size of Explicit heap after execution of GC. The unit is kilo bytes.
`<EH_MAX>`	`<const>K`	Output Explicit heap maximum size. The unit is kilo bytes.
`<AC_NUM>`	`<const>`	Output number of Explicit memory blocks whose sub status is Enable after GC execution.
`<FL_NUM>`	`<const>`	Normally 0 is output
`<DA_NUM>`	`<const>`	Output number of Explicit memory blocks whose sub status is Disable after GC execution.
`<CAUSE>`	`GC\|Full GC`	Output type of GC that is triggered. `GC` indicates copy GC and `Full GC` indicates Full GC.
`<CF_CNT>`	`<const>`	Output the failure count of initialization of Explicit memory blocks from the occurrence of previous GC up to occurrence of current GC.

(d) Example of output

Output example

[ENS]<Thu Oct 21 14:55:50 2007>[EH: 150528K->162816K(162816K/1048576K)][E/F/D: 200/0/0][cause:GC][CF: 0]

You can check the following contents in this output example:

Output trigger is copy GC occurred on October 21, 2007 (Friday) 14:55:50.
Migration to Explicit heap occurred in GC and used size of Explicit heap changed from 150,528K to 162,816K.
The secured size of Explicit heap after occurrence of GC is 162,816K. Maximum size of Explicit heap is 1,048,576K.
After the occurrence of GC, Explicit memory blocks whose sub status is Enable are 200 blocks.

To Page Top

(2) Explicit memory block explicit release process

Output usage status of the Explicit heap or Java heap after termination of the explicit release process of Explicit memory block.

(a) Output trigger

The Explicit release process of Explicit memory block.

The Explicit release of Explicit memory block occurs immediately after GC The following log is output after log described in (1) GC occurrence (Output Explicit heap usage status).

(b) Output format

[ENS]<ctime>[EH: <EH_USED_BF>-><EH_USED_AF>(<EH_TOTAL>/<EH_MAX>), <ELAPSED> secs][E/F/D: <AC_NUM>/<FL_NUM>/<DA_NUM>]\
[DefNew::Eden: <ED_USED_BF>-><ED_USED_AF>(<ED_TOTAL>)][DefNew::Survivor: <SV_USED_BF>-><SV_USED_AF>(<SV_TOTAL>)]\
[Tenured: <TN_USED_BF>-><TN_USED_AF>(<TN_TOTAL>)][User: <USERCPU> secs][Sys: <SYSCPU> secs][cause:<CAUSE>]

(c) Output items

The following table describes each item indicated in (b) output format.

Table 5‒34: Output items (Explicit memory block explicit release process)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence date and time of the Explicit memory block explicit release process. Output in the format same as extended `verbosegc` information. Output in milli-seconds unit when `-XX:+HitachiOutputMilliTime` option is set.
`<EH_USED_BF>`	`<const>K`	Output used size of the Explicit heap before the Explicit memory block explicit release process. The unit is kilo bytes.
`<EH_USED_AF>`	`<const>K`	Output used size of the Explicit heap after the Explicit memory block explicit release process. The unit is kilo bytes.
`<EH_TOTAL>`	`<const>K`	Output secured size of the Explicit heap after the Explicit memory block explicit release process. The unit is kilo bytes.
`<EH_MAX>`	`<const>K`	Output Explicit heap maximum size. The unit is kilo bytes.
`<ELAPSED>`	`<time>`	Output time required for the Explicit memory block explicit release process. The unit is seconds.
`<AC_NUM>`	`<const>`	Output number of Explicit memory blocks whose sub status is `Enable` after execution of the Explicit memory block explicit release process.
`<FL_NUM>`	`<const>`	Normally 0 is output
`<DA_NUM>`	`<const>`	Output number of Explicit memory blocks whose sub status is `Disable` after execution of the Explicit memory block explicit release process.
`<ED_USED_BF>`	`<const>K`	Output used size of the Eden area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<ED_USED_AF>`	`<const>K`	Output used size of the Eden area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<ED_TOTAL>`	`<const>K`	Output secured size of the Eden area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<SV_USED_BF>`	`<const>K`	Output used size of the Survivor area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<SV_USED_AF>`	`<const>K`	Output used size of the Survivor area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<SV_TOTAL>`	`<const>K`	Output secured size of the Survivor area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<TN_USED_BF>`	`<const>K`	Output used size of the Tenured area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<TN_USED_AF>`	`<const>K`	Output used size of the Tenured area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<TN_TOTAL>`	`<const>K`	Output secured size of the Tenured area after executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<USERCPU>`	`<time>`	Output the user CPU time taken by the explicit release processing of the Explicit memory block. The unit is seconds.
`<SYSCPU>`	`<time>`	Output the system CPU time taken by the explicit release processing of the Explicit memory block. The unit is seconds.
`<CAUSE>`	`Reclaim`	Output as `Reclaim`. `Reclaim` is the log output in the explicit release processing of the Explicit memory block.

(d) Example of output

Output example:

[ENS]<Tue Jul 24 01:23:51 2007>[EH: 150528K->149528K(162816K/1048576K), 0.1129602 secs][E/F/D: 523/0/0]\
[DefNew::Eden: 0K->0K(243600K)][DefNew::Survivor: 0K->0K(17400K)][Tenured: 103400K->103400K(556800K)]\
[User: 0.0900000 secs][Sys: 0.0200000 secs][cause:Reclaim]

You can check the following contents in this output example:

Output trigger is the Explicit memory block explicit release process occurred on July 24, 2007 (Tuesday) 1:23:51.
Explicit heap used size reduced from 150,528K to 149,528K by the explicit release process of the Explicit memory block.
Secured size of Explicit heap after Explicit memory block explicit release process is 162,816K. Maximum size of Explicit heap is 1,048,576K.
The time for the explicit release process of Explicit memory block is 0.1129602 seconds.
There are 523 Explicit memory blocks whose sub status is Enable after Explicit memory block explicit release process.
There are no changes in each area of Java heap by the Explicit memory block explicit release process. In other words, there is no object moved to Java heap.
The explicit release processing of the Explicit memory block took 0.0900000 seconds of the user CPU time, and 0.0200000 seconds of the system CPU time.

To Page Top

(3) Java heap overflow in Explicit memory block explicit release process

The object moves to Java heap in the explicit release process of Explicit memory block and the status is output when Java heap overflows. Output the usage status of Explicit heap and Java heap when Java heap overflows.

(a) Output trigger

The object moves from Explicit heap to Java heap in the explicit release process of the Explicit memory block and output is triggered when Java heap overflows.

(b) Output format

[ENS]<ctime>[EH: <EH_USED_BF>-><EH_USED_AF>(<EM_TOTAL>/<EH_MAX>), <ELAPSED> secs][E/F/D: <AC_NUM>/<FL_NUM>/<DA_NUM>]\
[DefNew::Eden: <ED_USED_BF>-><ED_USED_AF>(<ED_TOTAL>)][DefNew::Survivor: <SV_USED_BF>-><SV_USED_AF>(<SV_TOTAL>)]\
[Tenured: <TN_USED_BF>-><TN_USED_AF>(<TN_TOTAL>)][User: <USERCPU> secs][Sys: <SYSCPU> secs][cause:<CAUSE>]

(c) Output items

The following table describes each item indicated in (b) output trigger.

Table 5‒35: Output items (Java heap overflow in the explicit release process of the Explicit memory block)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence date and time of the Explicit memory block explicit release process. Output in the format same as extended `verbosegc` information. Output in milli-seconds unit when `-XX:+HitachiOutputMilliTime` option is set.
`<EH_USED_BF>`	`<const>K`	Output used size of the Explicit heap before the Explicit memory block explicit release process. The unit is kilo bytes.
`<EH_USED_AF>`	`<const>K`	Output used size of the Explicit heap after Java heap overflow. When Java heap overflows, the explicit release process of Explicit memory block is not executed and hence the value is always same as <`EH_USED_BF`>. The unit is kilo bytes.
`<EH_TOTAL>`	`<const>K`	Output secured size of the Explicit heap after Java heap overflow. The unit is kilo bytes.
`<EH_MAX>`	`<const>K`	Output Explicit heap maximum size. The unit is kilo bytes.
`<ELAPSED>`	`<time>`	Output time from start of the Explicit memory block explicit release process to Java heap overflow. The unit is seconds.
`<AC_NUM>`	`<const>`	Output number of the Explicit memory blocks whose sub status is `Enable` after Java heap overflow.
`<FL_NUM>`	`<const>`	Normally 0 is output
`<DA_NUM>`	`<const>`	Output number of the Explicit memory blocks whose sub status is `Disable` after Java heap overflow.
`<ED_USED_BF>`	`<const>K`	Output used size of the Eden area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<ED_USED_AF>`	`<const>K`	Output used size of the Eden area after Java heap overflow. The unit is kilo bytes.
`<ED_TOTAL>`	`<const>K`	Output secured size of the Eden area after Java heap overflow. The unit is kilo bytes.
`<SV_USED_BF>`	`<const>K`	Output used size of the Survivor area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<SV_USED_AF>`	`<const>K`	Output used size of the Survivor area after Java heap overflow. The unit is kilo bytes.
`<SV_TOTAL>`	`<const>K`	Output secured size of the Survivor area after Java heap overflow. The unit is kilo bytes.
`<TN_USED_BF>`	`<const>K`	Output used size of the Tenured area before executing the Explicit memory block explicit release process. The unit is kilo bytes.
`<TN_USED_AF>`	`<const>K`	Output used size of the Tenured area after Java heap overflow. The unit is kilo bytes.
`<TN_TOTAL>`	`<const>K`	Output secured size of the Tenured area after Java heap overflow. The unit is kilo bytes.
`<USERCPU>`	`<time>`	Output the user CPU time taken from the start of the explicit release processing of the Explicit memory block until Java heap overflows. The unit is seconds.
`<SYSCPU>`	`<time>`	Output the system CPU time taken from the start of the explicit release processing of the Explicit memory block until Java heap overflows. The unit is seconds.
`<CAUSE>`	`Reclaiming`	Output as "`Reclaiming`". Reclaiming is the log output by Java heap overflow in the release process of Explicit memory block.

(d) Example of output

Output example:

[ENS]<Tue Jul 24 01:23:51 2007>[EH: 706728K->706728K(706728K/1048576K), 0.1129602 secs][E/F/D: 523/0/0]\
[DefNew::Eden: 0K->243600K(243600K)][DefNew::Survivor: 0K->17400K(17400K)][Tenured: 278000K->556800K(556800K)]\
[User: 0.0900000 secs][Sys: 0.0200000 secs][cause:Reclaiming]
[ENS]<Tue Jul 24 01:23:51 2007>[EH: 706728K->706728K(706728K/1048576K)][E/F/D: 523/0/0][cause:Full GC][CF: 0]
[ENS]<Tue Jul 24 01:23:53 2007>[EH: 706728K->148528K(148528K/1048576K), 0.0123405 secs][E/F/D: 521/0/0]\
[DefNew::Eden: 0K->0K(243600K)][DefNew::Survivor: 0K->0K(17400K)][Tenured: 551800K->552800K(556800K)]\
[User: 0.0090000 secs][Sys: 0.0020000 secs][cause:Reclaim]

You can confirm the following contents in this output example:

Output trigger is the Java heap overflow in the Explicit memory block explicit release process occurred on July 24, 2007(Tuesday) 1:23:51.
The time from starting the explicit release process of Explicit memory block to Java heap overflow is 0.1129602 seconds.
There are 523 Explicit memory blocks whose sub status is Enable after Java heap overflow.
5,398,00K moved to Java heap in the explicit release process of Explicit memory block causing Java heap overflow.
The process from the start of the explicit release processing of the Explicit memory block until the overflowing of the Java heap took 0.0900000 seconds of the user CPU time, and 0.0200000 seconds of the system CPU time.

In the output contents of output example, third line ENS onwards is the log output by the explicit release process of Explicit memory block. Always output the log of Explicit memory block release process after log output by Java heap overflow. In this example, the following contents are output:

Restarted the explicit release process of Explicit memory block on July 24, 2007 1:23:53 and output this log.
The used size of Explicit heap reduced from 706,728K to 148,528K in the explicit release process of Explicit memory block that was restarted.
The secured size of Explicit heap after executing the explicit release process of restarted Explicit memory block is 148,528K. Maximum size of Explicit heap is 1,048,576K.
The time for the explicit release process of restarted Explicit memory block is 0.0123405 seconds.
There are 521 Explicit memory blocks whose sub status is Enable after the restarted Explicit memory block explicit release process.
The usage size of Tenured area of Java heap increased from 551,800K to 552,800K as a result of the explicit release process of restarted Explicit memory block.
The explicit release processing of the restarted Explicit memory block took 0.0090000 seconds of the user CPU time and 0.0020000 seconds of the system CPU time.

To Page Top

(4) Automatic release processing of the explicit memory block

The usage status of the explicit memory and explicit memory block is output from the automatic release - automatic reserve or automatic release - explicit reserve of the explicit memory block up to the automatic release processing of the explicit memory block.

(a) Output trigger

The log is output when the automatic release - automatic reserve or automatic release - explicit reserve of the explicit memory block and automatic release processing of the Explicit memory block occur.

(b) Output format

[ENS]<ctime>[EH: <EH_USED_BF>-><EH_USED_AF>(<EH_TOTAL>/<EH_MAX>), <ELAPSED> secs][E/F/D: <AC_NUM>/<FL_NUM>/<DA_NUM>]\
[DefNew::Eden: <ED_USED_BF>-><ED_USED_AF>(<ED_TOTAL>)]
[DefNew::Survivor: <SV_USED_BF>-><SV_USED_AF>(<SV_TOTAL>)]\
[Tenured: <TN_USED_BF>-><TN_USED_AF>(<TN_TOTAL>)][target:<EH_MIG_TRG>/<EH_MIG_DED>/<EH_MIG_LIV>]\
[User: <USERCPU> secs][Sys: <SYSCPU> secs][cause:<CAUSE>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒36: Output items (Automatic release processing of the explicit memory block)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence date and time of automatic release - automatic reserve of the explicit memory block. Output with the format same as the extended `verboseGC` functionality. Output in milliseconds, when the `HitachiOutputMilliTime` option is set up.
`<EH_USED_BF>`	`<const>K`	Outputs the used size of the explicit memory before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<EH_USED_AF>`	`<const>K`	Outputs the used size of the explicit memory after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<EH_TOTAL>`	`<const>K`	Outputs the secured size of the explicit memory after the automatic release processing of the Explicit memory block. The unit is kilobytes.
`<EH_MAX>`	`<const>K`	Outputs the maximum explicit memory size. The unit is kilobytes.
`<ELAPSED>`	`<time>`	Outputs the time from the start of the automatic release-automatic reserve process of the explicit memory block up to the end of the automatic release processing. The unit is seconds.
`<AC_NUM>`	`<const>`	Outputs the number of valid explicit memory blocks that have the `Enable` sub state, after the automatic release processing of the explicit memory block.
`<FL_NUM>`	`<const>`	Always outputs 0.
`<DA_NUM>`	`<const>`	Outputs the number of valid explicit memory blocks that have the `Disable` sub state, after the automatic release processing of the explicit memory block.
`<ED_USED_BF>`	`<const>K`	Outputs the used size of the Eden area before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<ED_USED_AF>`	`<const>K`	Outputs the used size of the Eden area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<ED_TOTAL>`	`<const>K`	Outputs the secured size of the Eden area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<SV_USED_BF>`	`<const>K`	Outputs the used size of the Survivor area before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<SV_USED_AF>`	`<const>K`	Outputs the used size of the Survivor area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<SV_TOTAL>`	`<const>K`	Outputs the secured size of the Survivor area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<TN_USED_BF>`	`<const>K`	Outputs the used size of the Tenured area before the automatic release processing of the Explicit memory block. The unit is kilobytes.
`<TN_USED_AF>`	`<const>K`	Outputs the used size of the Tenured area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<TN_TOTAL>`	`<const>K`	Outputs the secured size of the Tenured area after the automatic release processing of the explicit memory block. The unit is kilobytes.
`<EH_MIG_TRG>`	`<const>K`	Outputs the used size of the explicit memory for which the automatic release processing of the explicit memory block was executed. The unit is kilobytes.
`<EH_MIG_DED>`	`<const>K`	Outputs the used size of the explicit memory that decreased due to the execution of the automatic release processing of the explicit memory block. The unit is kilobytes.
`<EH_MIG_LIV>`	`<const>K`	Outputs the used size of the explicit memory that did not decrease in spite of the execution of the automatic release processing of the explicit memory block. The unit is kilobytes.
`<USERCPU>`	`<time>`	Outputs the user CPU time taken from the start of the automatic release - automatic reserve processing of the Explicit memory block until the end of the automatic release processing. The unit is seconds.
`<SYSCPU>`	`<time>`	Outputs the system CPU time from the start of the automatic release - automatic reserve processing of the Explicit memory block until the end of the automatic release processing. The unit is seconds.
`<CAUSE>`	`Migrate`	Outputs `Migrate`. Indicates that the log was output due to the automatic release processing of the explicit memory block.

(d) Example of output

The following is an output example:

[ENS]<Tue Jul 14 02:31:22 2009>[EH: 256512K->256128K(256256K/1048576K), 0.1124626 secs][E/F/D: 423/0/0]\
[DefNew::Eden: 0K->0K(243600K)][DefNew::Survivor: 0K->0K(17400K)][Tenured: 103400K->103400K(556800K)][target:584K/384K/200K]\
[User: 0.0900000 secs][Sys: 0.0200000 secs][cause:Migrate]

You can check the following details in this output example:

The output trigger is the automatic release processing of the explicit memory block in the GC that occurred on July 14, 2009 (Tuesday) at 2:31:22.
The used size of explicit memory changed from 256,512K to 256,128K due to the automatic release processing.
The secured size of explicit memory after the automatic release processing is 256,256K and the maximum size is 1,048,576K.
The time taken for the automatic release processing was 0.1124626 seconds.
There are 423 explicit memory blocks whose sub-state is Enable after the automatic release processing.
Among the used size of explicit memory, 584K were automatically released using the automatic release processing. The size that decreased was 384K and the size that did not decrease was 200K.
There are no changes in the Java heap areas due to the automatic release processing for the explicit memory block.
The automatic release processing took 0.0900000 seconds of the user CPU time, and 0.0200000 seconds of the system CPU time.

To Page Top

(5) Java heap overflow in the automatic release processing of the explicit memory block

During the automatic release processing of the explicit memory block, objects were moved to the Java heap. In this case, the usage status of the explicit memory and the Java heap is output when the Java heap overflows.

The overflow of Java heap indicates that while moving the objects to the Java heap, there was no free space in the Java heap. For details, see 7. Suppression of Full GC by Using the Explicit Memory Management Functionality in the uCosminexus Application Server Expansion Guide.

(a) Output trigger

If there is a shortage of free space in the explicit memory area during the automatic release processing of the explicit memory block, the objects are moved to the Java heap. A log is output, when the Java heap overflows.

(b) Output format

[ENS]<ctime>[EH: <EH_USED_BF>-><EH_USED_AF>(<EH_TOTAL>/<EH_MAX>), <ELAPSED> secs][E/F/D: <AC_NUM>/<FL_NUM>/<DA_NUM>]\
[DefNew::Eden: <ED_USED_BF>-><ED_USED_AF>(<ED_TOTAL>)]
[DefNew::Survivor: <SV_USED_BF>-><SV_USED_AF>(<SV_TOTAL>)]\
[Tenured: <TN_USED_BF>-><TN_USED_AF>(<TN_TOTAL>)][target:<EH_MIG_TRG>/<EH_MIG_DED>/<EH_MIG_LIV>]\
[User: <USERCPU> secs][Sys: <SYSCPU> secs][cause:<CAUSE>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒37: Output items (Java heap overflow in the automatic release processing for the explicit memory block)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence date and time of the automatic release processing of the explicit memory block. Output in the format same as would output for the extended `verboseGC` functionality. Output in milliseconds when the `HitachiOutputMilliTime` option is set up.
`<EH_USED_BF>`	`<const>K`	Outputs the used size of the explicit memory before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<EH_USED_AF>`	`<const>K`	Outputs the used size of the explicit memory after the Java heap overflows. The unit is kilobytes.
`<EH_TOTAL>`	`<const>K`	Outputs the secured size of explicit memory after the Java heap overflows. The unit is kilobytes.
`<EH_MAX>`	`<const>K`	Outputs the maximum explicit memory size. The unit is kilobytes.
`<ELAPSED>`	`<time>`	Outputs the time from the start of the automatic release processing of the explicit memory block to the overflow of the Java heap. The unit is seconds.
`<AC_NUM>`	`<const>`	Outputs the number of explicit memory blocks that have the `Enable` sub state after the automatic release processing of the explicit memory block.
`<FL_NUM>`	`<const>`	Always outputs 0.
`<DA_NUM>`	`<const>`	Outputs the number of explicit memory blocks that have the `Disable` sub state after the Java heap overflows.
`<ED_USED_BF>`	`<const>K`	Outputs the used size of the Eden area before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<ED_USED_AF>`	`<const>K`	Outputs the used size of the Eden area after the Java heap overflows. The unit is kilobytes.
`<ED_TOTAL>`	`<const>K`	Outputs the secured size of the Eden area after the Java heap overflows. The unit is kilobytes.
`<SV_USED_BF>`	`<const>K`	Outputs the used size of the Survivor area before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<SV_USED_AF>`	`<const>K`	Outputs the used size of the Survivor area after the Java heap overflows. The unit is kilobytes.
`<SV_TOTAL>`	`<const>K`	Outputs the secured size of the Survivor area after the Java heap overflows. The unit is kilobytes.
`<TN_USED_BF>`	`<const>K`	Outputs the used size of the Tenured area before the automatic release processing of the explicit memory block. The unit is kilobytes.
`<TN_USED_AF>`	`<const>K`	Outputs the used size of the Tenured area after the Java heap overflows. The unit is kilobytes.
`<TN_TOTAL>`	`<const>K`	Outputs the secured size of the Tenured area after the Java heap overflows. The unit is kilobytes.
`<EH_MIG_TRG>`	`<const>K`	Outputs the used size of the explicit memory for which the automatic release processing of the explicit memory block was executed. The unit is kilobytes.
`<EH_MIG_DED>`	`<const>K`	Outputs the used size of explicit memory that has decreased due to the execution of the automatic release processing of the explicit memory block, until the Java heap overflowed. The unit is kilobytes. Always outputs OK.
`<EH_MIG_LIV>`	`<const>K`	Outputs the used size of the explicit memory that did not decrease due to the execution of the automatic release processing of the explicit memory block, until the Java heap overflowed. The unit is kilobytes. Does not include the size of the objects that caused the Java heap overflow.
`<USERCPU>`	`<time>`	Outputs the user CPU time taken from the start of the automatic release processing of the Explicit memory block until the overflowing of the Java heap. The unit is seconds.
`<SYSCPU>`	`<time>`	Outputs the system CPU time taken from the start of the automatic release processing of the Explicit memory block until the overflowing of the Java heap. The unit is seconds.
`<CAUSE>`	`Migrating`	Outputs `Migrating`. Indicates that the log was output due to the Java heap overflow in the automatic release processing of the explicit memory block.

(d) Example of output

An output example is as follows:

[ENS]<Tue Jul 14 02:31:22 2009>[EH: 706728K->706728K(706728K/706728K), 0.1129602 secs][E/F/D: 522/0/1]\
[DefNew::Eden: 0K->243600K(243600K)][DefNew::Survivor: 0K->17400K(17400K)][Tenured: 278000K->556800K(556800K)]\
[target:372000K/0K/339800K] [User: 0.0900000 secs][Sys: 0.0200000 secs][cause:Migrating]

You can check the following details in this output example:

The output trigger is the Java heap overflow in the automatic release processing for the explicit memory block in the GC that occurred on July 14, 2009 (Tuesday) at 2:31:22.
The used size of explicit memory changed from 706,728K due to the automatic release processing.
The secured size of explicit memory after the automatic release processing is 706,728K and the maximum size is 706,728K.
The time taken for the automatic release processing was 0.1129602 seconds.
There are 522 explicit memory blocks that have Enable sub state after the automatic release processing. There is one explicit memory block that has Disable sub state.
Among the used size of explicit memory, 372,000K were automatically released using the automatic release processing. The size that did not decrease until Java heap overflow was 339,800K.
Due to Java heap overflow during the automatic release processing, the used size of Java heap reached the upper limit for each area.
The process from the start of the automatic release processing of the Explicit memory block until the overflowing of the Java heap took 0.0900000 seconds of the user CPU time, and 0.0200000 seconds of the system CPU time.

To Page Top

(6) Error in opening the automatic allocation configuration file for Explicit Memory Management

An error message is output, when an attempt to open or read the automatic allocation configuration file for Explicit Memory Management fails.

(a) Output trigger

The error message is output when an attempt to open or read the automatic allocation configuration file for Explicit Memory Management fails. For example, when the file does not exist, the user does not have the permission to read the file, or an unexpected IO error occurs while reading the file.

(b) Output format

[ENA]<ctime> failed to open file. [file=<FILENAME>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒38: Output items (Error in opening the automatic allocation configuration file for Explicit Memory Management)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence time, when an attempt to open the automatic allocation configuration file using Explicit Memory Management has failed. Output with the format same as would output for the extended `verboseGC` functionality. Output in milliseconds, when the `HitachiOutputMilliTime` option is set up.
`<FILENAME>`	`<letters>`	Outputs the name of the automatic allocation configuration file that has failed to open (does not include the directory name).

(d) Example of output

An output example is as follows:

[ENA]<Tue Jul 24 01:23:51 2007> failed to open file. [file=usrexmem.cfg]

You can check the following details in this output example:

An attempt to open the automatic allocation configuration file for Explicit Memory Management failed on July 24, 2007 (Tuesday) at 1:23:51.

To Page Top

(7) Error in parsing the automatic allocation configuration file for Explicit Memory Management

An error message is output, when a line that failed in the parsing of the automatic allocation configuration file for Explicit Memory Management exists.

(a) Output trigger

The error message is output when a line that failed in the parsing of the automatic allocation configuration file for Explicit Memory Management exists. If there are coding format errors in multiple lines of the file, the log is output several times.

(b) Output format

[ENA]<ctime> parsed error line. [file=<FILENAME> line=<LINENO>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒39: Output items (Error in parsing the automatic allocation configuration file for Explicit Memory Management)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the time when an attempt to parse the automatic allocation configuration file using the Explicit Memory Management functionality has failed. Output with the format same as would output for the extended `verboseGC` functionality. Output in milliseconds, when the `HitachiOutputMilliTime` option is set up.
`<FILENAME>`	`<letters>`	Outputs the name of the automatic allocation configuration file for which file parsing failed (does not include the directory name).
`<LINENO>`	`<const>`	Outputs the line number where the parsing failed.

(d) Example of output

An output example is as follows:

[ENA]<Tue Jul 24 01:23:51 2007> parsed error line. [file=usrexmem.cfg line=25]

You can check the following details in this example of output:

The parsing of the automatic allocation configuration file for the Explicit Memory Management functionality failed in the 25^th line on July 24, 2007 (Tuesday) at 1:23:51.

To Page Top

(8) Automatic allocation error in Explicit Memory Management

An error message is output, when a class specified by the Explicit Memory Management functionality fails to allocate automatically to Explicit Memory Management.

(a) Output trigger

The error message is output, when a class specified by the Explicit Memory Management functionality fails to allocate automatically to Explicit Memory Management.

(b) Output format

[ENA]<ctime> creation <CLASS_LIST> class's object in explicit memory is failed. [target=<CLASS_METHOD> \
detail=<MESSAGE>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒40: Output items (Automatic allocation error in Explicit Memory Management)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Indicates the occurrence time when an attempt of the automatic allocation using Explicit Memory Management has failed. Output with the format same as would output for the extended `verboseGC` function. Output in milliseconds, when the `HitachiOutputMilliTime` option is set.
`<CLASS_LIST>`	`<letters>`	Outputs the list of fully qualified class names of the objects for which an attempt of the automatic allocation using Explicit Memory Management has failed. The list might be blank.
`<CLASS_METHOD>`	`<letters>`	Outputs the fully qualified names of the classes for which an attempt of the automatic allocation using Explicit Memory Management has failed. The method names indicating more detailed failure locations might also be output.
`<MESSAGE>`	`<letters>`	Outputs a detailed message indicating the cause of the failure during the automatic allocation using Explicit Memory Management.

(d) Example of output

An output example is as follows:

[ENA]<Tue Jul 24 01:23:51 2007> creation java.util.HashMap, java.util.LinkedList \
class's object in explicit memory is failed. [target=com.sample.MainClass.main \
detail=Invalid class file format. (max_stack = 65536, max = 65535, min = 0)]

You can check the following details in this output example:

With the Explicit Memory Management functionality, an attempt to automatically allocate the class jp.co.sample.Main on the explicit memory management using has failed on July 24, 2007 (Tuesday) at 1:23:51.

To Page Top

(9) Error in opening the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality

When an attempt to open and read the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality fails, an error message is output.

(a) Output trigger

The error message is output when an attempt to open and read the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality fails. For example, this includes cases such as when the file does not exist, the user does not have the permission to read the file, and an unexpected IO error occurs while the file is being read.

(b) Output format

[ENO]<ctime> failed to open file. [<TYPE>] [file=<FILENAME>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒41: Output items (Error in opening the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Specifies the time at which the configuration file failed to open. The time is output in the same format as the time output by the extended VerboseGC functionality. If the `HitachiOutputMilliTime` option is set up, the time is output in milliseconds.
`<TYPE>`	`SYS\|USR\|DEF`	Outputs the type of the configuration file that could not be opened and read. `SYS` indicates the configuration file provided with the system, `USR` indicates the configuration file with the file path specified in the JavaVM invocation option, and `DEF` indicates the configuration file existing in the default file path of the JavaVM invocation option.
`<FILENAME>`	`<letters>`	Outputs the name of the configuration file that could not be opened (does not include the directory name).

(d) Example of output

An example of output is as follows:

[ENO]<Fri Aug 10 17:41:51 2012> failed to open file. [USR] [file=javamove.cfg]

You can check the following details in this example of output:

The configuration file with the file path specified in the JavaVM invocation option failed to open on August 10, 2012 (Friday) at 17:41:51.

To Page Top

(10) Error in parsing the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality

If there is a line in which the parsing of the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality has failed, an error message is output.

(a) Output trigger

The error message is output if there is a line in which the parsing of the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality has failed. If a coding format error exists in multiple lines of a file, the log is output multiple times.

(b) Output format

[ENO]<ctime> parsed error line. [TYPE] [file=<FILENAME> line=<LINENO>]

(c) Output items

The following table describes the items specified in (b) Output format.

Table 5‒42: Output items (Parsing error in the automatic allocation configuration file for Explicit Memory Management)
Output items	Output contents	Meaning
`<ctime>`	`<letters>`	Specifies the time at which the parsing of the configuration file of the functionality for specifying the classes to be excluded from the Explicit Memory Management functionality failed. The time is output in the same format as the time output by the extended `verboseGC` functionality. If the `HitachiOutputMilliTime` option is set up, the time is output in milliseconds.
`<TYPE>`	`SYS\|USR\|DEF`	Outputs the type of configuration file for which the file parsing failed. `SYS` indicates the configuration file provided with the system, `USR` indicates the configuration file with the file path specified in the JavaVM invocation option, and `DEF` indicates the configuration file existing in the default file path of the JavaVM invocation option.
`<FILENAME>`	`<letters>`	Outputs the name of the configuration file for which the file parsing failed (does not include the directory name).
`<LINENO>`	`<const>`	Outputs the line number for which the parsing has failed.

(d) Example of output

An example of output is as follows:

[ENO]<Fri Aug 10 17:41:51 2012> parsed error line. [USR] [file=javamove.cfg line=25]

You can check the following details in this example of output:

The parsing of the configuration file with the file path specified in the JavaVM invocation option failed in the 25^th line on August 10, 2012 (Friday) at 17:41:51.

To Page Top