5.11.5 Contents Output when Output Level is Debug

This subsection describes the contents output for each event when you specify debug in log output level.

Supplement: Use debug, for detail information besides the contents output to verbose, while implementing by debugging. In the logs output within debug, there are some logs with high overheads than that of the logs that require execution of Full GC for output.

Organization of this subsection

(1) Migration of object to Java heap by the explicit release of Explicit memory block
(2) Initialization of Explicit memory block (Output detail information)
(3) Details of automatic release processing of the Explicit memory block (Output detailed information)

(1) Migration of object to Java heap by the explicit release of Explicit memory block

If you want to refer an object in Explicit memory block from the Explicit memory block that is not the target for explicit release, move that object to Java heap for explicitly releasing the Explicit memory block. This log does output of information of object moved to Java heap and object of the reference source.

(a) Output trigger

Output is triggered when an object is moved to Java heap in the explicit release process of Explicit memory block.

(b) Output format

[EDO][eid=<EID>: Reference to <REFED_NAME>(<REFED_PTR>), total <R_SIZE>]
[EDO] <REF_NAME>(<REF_PTR>)<REF_GEN>

Note:: Output for each object referred by Explicit memory block that is not the target for explicit release.

(c) Output items

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

Table 5‒51: Output items (Migration of objects to Java heap as a result of the explicit release of Explicit memory block)
Output items	Output contents	Meaning
`<EID>`	`<const>`	Output ID of the Explicit memory block that has objects referred from other Explicit heap and that are not target for explicit release in the Explicit memory block explicit release process.
`<REFED_NAME>`	`<letters>`	Output all class names of objects (Objects shown in<`REF_NAME`>(<`REF_PTR`>) ) referred from objects other than Explicit heap that are not target for explicit release in Explicit memory block explicit release process.
`<REFED_PTR>`	`<ptr>`	Output memory address before migration of objects indicating <`REFED_NAME`> to Java heap.
`<R_SIZE>`	`<const>K`	Output total size of objects to be moved to Java heap by referring from <`REF_NAME`>(<`REF_PTR`>). Total size is the value including the objects in the Explicit memory block that are to be released explicitly and objects that are indirectly referred from <`REF_NAME`>(<`REF_PTR`>)^#. The unit is kilo bytes.
`<REF_NAME>`	`<letters>\|JVM`	Output all class names of objects referring <`REFED_NAME`>(<`REFED_PTR`>). Output as "JVM" when reference source is stack or internal JavaVM.
`<REF_PTR>`	`<ptr>`	Output object indicating <`REF_NAME`>, stack or memory address in JavaVM.
`<REF_GEN>`	`(eid=<EID>)\|(DefNew)\|(Tenured)\|(JVM)`	Output area belonging to <`REF_NAME`>(<`REF_PTR`>) or generation name. Output ID of Explicit memory block for Explicit memory block. Output "JVM" when referred from stack or JavaVM.

#: Also refer to the following supplement:

Supplement

This supplement gives an overview when there are many reference routes to an object moving to Java heap.

The description is provided with following figure as an example.

Figure 5‒9: Example where there are multiple reference routes to object moving to Java heap

Output when object to be moved to Java heap is referred from multiple objects

There are cases when the objects to be moved to Java heap are referred from multiple objects. In the figure, there are two types; A->B and E->B of reference routes for object B.

In such cases, the information related to reference of A->B, E->B is output separately in logs.

<R_SIZE> calculation when there is indirect referring from multiple objects

Output value that includes objects in the Explicit memory block that are to be released explicitly and objects that are referred indirectly from <REF_NAME>(<REF_PTR>) in <R_SIZE>. However, the calculation method differs when object to be moved to Java heap is indirectly referred from multiple objects.

In the figure, object D is indirectly referred by the following three types of routes:

A->B->D
E->B->D
E->F->D

When referred by multiple routes, the size of object is added to <R_SIZE> reference relation calculated initially. For example, when the reference relation is output in the following A->B, E->B, E->F sequence, the size of object D is added in <R_SIZE> of A->B. In such cases, the output of <R_SIZE> of each reference relation would be as follows:

A->B

Total of size of object B and object D is 4K.
E->B

2k that is the size of object B.
E->F

1K that is the size of object F.

(d) Example of output

Output example.

[EDO][eid=5: Reference to java.lang.HashMap$Entry(0x1234568), total 125K]
[EDO] java.util.HashMap$KeyIterator(0x1134428)(eid=1)
[EDO][eid=5: Reference to ClassA(0x1234580), total 19250K]
[EDO] ClassV(0x1234468)(Tenured)
[EDO][eid=5: Reference to ClassZ(0x1234680), total 12K]
[EDO] ClassU(0x1233468)(DefNew)
[EDO][eid=9: Reference to JP.co.Hitachi.soft.jvm.BBB(0x1034428), total 1250K]
[EDO] JVM(0x23456780)(JVM)

You can check the following contents in this output example:

Object of java.lang.HashMap$Entry that is in the Explicit memory block of eid=5 is referred from object of java.util.HashMap$KeyIterator that is in the Explicit memory block of eid=1 which is not the explicit release target. As a result, object of 125Kbyte is moved to Java heap.
Object of ClassA that is in Explicit memory block of eid=5 is referred from object of ClassV in Tenured area. As a result, an object of 19,250 Kbyte is moved to Java heap.
Object of ClassZ in Explicit memory block of eid=5 is referred from object of ClassU in New area. As a result, object of 12Kbyte is moved to Java heap.
Object of JP.co.Hitachi.soft.jvm.BBB that is in Explicit memory block of eid=9 is referred from stack or internal JavaVM. As a result, an object of 1,250 kilobyte is moved to Java heap.

To Page Top

(2) Initialization of Explicit memory block (Output detail information)

Output detail information when you initialize a new Explicit memory block. Besides the output contents in 5.11.4(1) Initialization of Explicit memory block, output the stack trace of Java program executing initialization process. This log is output asynchronously with the execution of Java program on multiple lines. Hence, there are cases where some other log is output within the lines of this log. However, other logs are not output within one line.

(a) Output trigger

Initialization of Explicit memory block.

(b) Output format

<Information(verbose) of initialization of Explicit memory block>#[Thread: <TH_PTR>]
[EDO][Thread: <TH_PTR>] at <FRAME><SOURCE>
...

#: For output items, see 5.11.4(1) Initialization of Explicit memory block.

(c) Output items

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

Table 5‒52: Output items (Initialization of Explicit memory block(Output detail information))
Output items	Output contents	Meaning
Information(`vervose`) when initialization of Explicit memory block		See 5.11.4(1) Initialization of Explicit memory block.
`<TH_PTR>`	`<ptr>`	Output thread ID of thread to initialize Explicit memory block. Thread ID is same as tid output to thread dump.
`<FRAME>`	`<letters>.<letters>`	Output one frame in stack trace when initializing Explicit memory block. Output all class names and method names by delimiting them by a ".".
`<SOURCE>`	`(<letters>:<const>)\|(Native Method)\|(Unknown Source)`	Output the source file names where methods output to <`FRAME`> are described and line numbers match the stack trace. Output file names and line numbers by delimiting them by a ":". Output as "(Native Method)" when native method. Output as "(Unknown Source)" when you cannot acquire the source file name.

(d) Example of output

Output example.

[EVO]<Tue Jul 24 01:23:51 2007>[Created]["BasicExplicitMemory-2" eid=2(0x1234568)/B][Thread: 0x00035a60]
[EDO][Thread: 0x00035a60] at ExplicitMemory.registerExplicitMemory(Native Method)
[EDO][Thread: 0x00035a60] at BasicExplicitMemory.<init>(Unknown Source)
[EDO][Thread: 0x00035a60] at AllocTest.test(AllocTest.java:64)
[EDO][Thread: 0x00035a60] at java.lang.Thread.run(Thread.java:2312)

You can check the following contents in this output example:

Output trigger is initialization of memory block executed on July 24, 2007 1:23:51. Name of Explicit memory block is "BasicExplicitMemory-2". ID of Explicit memory block is eid=2.
Try initializing Explicit memory block by executing constructor of BasicExplicitMemory class on 64^th line of AllocTest.java.

To Page Top

(3) Details of automatic release processing of the Explicit memory block (Output detailed information)

Output the detailed information when the automatic release processing of the Explicit memory block occurs. Besides the output contents described in the subsection 5.11.3(4) Automatic release processing of the explicit memory block, output the EID information of the Explicit memory block executing the automatic release processing. The automatic release processing of the Explicit memory block might include the automatic release processing without the movement of objects, many-to-one automatic release processing, and one-to-one automatic release processing. Therefore, the information about EID without object movement, many-to-one EID, and one-to-one EID is output.

(a) Output trigger

The log is output when the automatic release processing for the explicit memory block occurs.

(b) Output format

[EDO][migrate:(<EID_DEL>{,<EID_DEL>}*|)/(<EID_MBF>{,<EID_MBF>}*-><EID_MAF>|)/(<EID_MIG>{,<EID_MIG>}*|)]

(c) Output items

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

Table 5‒53: Output items (Details of automatic release processing of the Explicit memory block (output detailed information))
Output items	Output contents	Meaning
`<EID_DEL>`	`<const>`	Outputs EID of the Explicit memory blocks without moving the objects, among the Explicit memory blocks released by the automatic release processing of the Explicit memory block.
`<EID_MBF>`	`<const>`	Outputs EID used before reserving the automatic release of the Explicit memory block where many-to-one automatic release processing occurred, among the Explicit memory blocks released by the automatic release processing of the Explicit memory block.
`<EID_MAF>`	`<const>`	Outputs EID of the Explicit memory blocks generated by the many-to-one automatic release processing, among the Explicit memory blocks generated by the automatic release processing of the Explicit memory block.
`<EID_MIG>`	`<const>`	Outputs EID of the Explicit memory blocks where the one-to-one automatic release processing occurred, among the Explicit memory blocks released by the automatic release processing of the Explicit memory block.

(d) Example of output

An output example is as follows:

[EVS]<Tue Jul 14 02:31:22 2009>[EH: 256512K->256128K(256256K/1048576K), 0.1124626 secs][E/F/D: 423/0/0][target:584K/384K/200K]\
[cause:Migrate]
[EDO][migrate:()/(2,4,6,9->10)/(1,8)]

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.
The automatic release processing was executed for the Explicit memory used size 584K.
The Explicit memory blocks with IDs (2, 4, 6, 9) are moved to the Explicit memory block with ID (10).
The Explicit memory blocks with IDs (1, 8) are moved to the same IDs (1, 8).

To Page Top