JP2011085985A - Memory management method, memory management program, and information processor - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To dynamically detect most of long-lived objects stored in an external heap region, and to suppress the occurrence of FullGC by storing these objects in the external heap region. <P>SOLUTION: First, an origin object is detected by analyzing a reference relation of a long-lived object released in an Old region by FullGC. Then, an object generation instruction is detected to generate a long-lived origin object by profiling a rate by which the origin object generated based on each object generation instruction is released in the Old region by the FullGC. When the object is long-lived, the object generation destination is changed to an external heap, and the origin object is generated in the external heap region. Furthermore, a member object referenced from the origin object is set to a movement object from a New region to the Old region by CopyGC, and when a rate at which the object is released together with the origin object is high, the object moves to the same external heap as that of the origin object. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a memory management method, a memory management program, and an information processing apparatus.

  A Java virtual machine (hereinafter referred to as “JavaVM”; “VM” is an abbreviation of “Virtual Machine”), which is a processing system of the Java (registered trademark) language, implements a garbage collector. The garbage collector manages the memory area (hereinafter referred to as “Java heap area”) that JavaVM reserves for storing objects, and dynamically creates objects (memory areas to which objects are allocated) during program execution. Among them, objects that are no longer needed (the memory area to which they are allocated) are dynamically released by garbage collection (hereinafter referred to as “GC”; “GC” is an abbreviation for “garbage collection”) (automatic release function) . For convenience of explanation, the release of the memory area may be described as the release of the object stored in the memory area.

  One of the GC methods is generational GC. In JavaVM that uses generational GC as the GC method, the Java heap area is divided into generations, such as the New area and Old area. Furthermore, the New area is divided into an Eden area and a Survivor area, and the Survivor area is divided into a From area and a To area.

  Objects created dynamically during program execution are initially stored in the Eden area. When the Eden area is depleted, the garbage collector executes CopyGC for the New area only, which requires only a short time to stop executing the application program. In this copy garbage collection, the objects stored in the Eden area and the objects stored in the From area among the objects that can be reached by sequentially tracing object references from the root set such as registers, runtime stacks, and global variables are copied to Copy to the area. Here, the copy destination area is an Old area when the object to be copied has undergone CopyGC more than a certain number of times, that is, a long-lived object. In addition, the To region is used for an object that has not passed CopyGC more than a certain number of times, that is, an object that is not yet long-lived. Then, an object that has not been copied is released as an unnecessary object. Note that after the end of CopyGC, the roles of the From area and To area are changed in preparation for the next CopyGC.

  On the other hand, when the Old area is depleted, the garbage collector executes FullGC for the entire area including both the New area and the Old area where the execution stop time of the application program is long. In this FullGC, objects that can be reached by sequentially tracing object references from the root set are marked as being necessary for program execution. Then, after all the reachable objects are traced from the root set, the objects not marked are released as unnecessary objects.

  In recent years, the Java-based system described above (hereinafter referred to as “Java system”) is a mission-critical field that must continue to function normally for 24 hours, 365 days, such as the financial and mission critical systems. But it is increasingly used. Java systems are also becoming larger and more complex, and the amount of data handled is also increasing. However, if the Java heap area is increased, the amount of data that the garbage collector must process increases, so the business program execution stop time tends to increase due to the occurrence of GC. Therefore, the occurrence of GC in the Java system, especially the occurrence of FullGC, is one of the major problems.

  As a method for solving this problem, a method disclosed in Patent Document 1 is known. In the method disclosed in Patent Document 1, JavaVM, in addition to a Java heap area that is a target for object release by GC, a heap area that is a target for object release not by GC (hereinafter referred to as “external heap area”). .) The external heap area is an area that can be managed by a program developer, and the creation and release of an object for the external heap area follows the program source code description by the program developer. That is, it is possible to perform explicit memory management (hereinafter referred to as “explicit memory management”) by program source code description for automatic memory management by the garbage collector.

  The program developer writes the program source code to generate an object in the external heap in the external heap area, so that the external heap is secured as needed during program execution, and the object is generated in the external heap. . Moreover, in order to release the object stored in the external heap, the external heap is released by writing the program source code so as to release the external heap. In releasing the external heap, it is checked whether or not an object necessary for subsequent program execution exists in the external heap to be released. If the required object does not exist as a result of the check, the external heap is released. If a necessary object exists, the object is moved to a heap area different from the external heap to be released, and then the external heap is released. Then, by releasing the external heap, the objects stored in the external heap are released regardless of the GC. By securing a long-lived object in the external heap and releasing it in the external heap, the usage amount of the Old area can be suppressed, and the occurrence of FullGC due to the exhaustion of the Old area can be suppressed.

JP 2009-37547 A

When using an external heap area to prevent the occurrence of FullGC due to the depletion of the Old area, the program developer estimates the lifetime of the object when the program is executed, and the long-lived object to be stored in the external heap area is the external heap. It is necessary to write program source code to be stored in the area. However, in order to estimate the life of an object, it is necessary to consider the life cycle of the object based on the reference relationship of the object at the time of program execution, and advanced knowledge and experience are required.
In addition, for various reasons such as the large scale and complexity of Java systems, program development by sharing of multiple people, and the existence of implicit object generation and object references not described in the program source code, the program developer It is extremely difficult to grasp in advance the reference relationship of objects that dynamically change during program execution. Therefore, even a long-lived object that should be stored in the external heap area may actually be an object that cannot be stored in the external heap area. Conversely, if such an object can be detected dynamically and stored in the external heap area, the occurrence of FullGC can be further suppressed.

  An object of the present invention is to make it possible to dynamically detect many long-lived objects to be stored in the external heap area and to store these objects in the external heap area.

In order to achieve the above object, the present invention, in a language processing execution system having a memory management mechanism such as a Java system, first analyzes the reference relationship of a long-lived object released in the Old area by FullGC. The object corresponding to the root of the reference relationship (hereinafter referred to as “starting object”) is dynamically detected. Next, for each object generation instruction, profiling the rate at which the starting object generated by the object generation instruction is released in the Old area by FullGC, thereby detecting the object generation instruction generating the long-lived starting object. Then, for an object generation instruction that generates a long-lived starting point object, the object generation destination is changed to the external heap, and the starting point object is generated in the external heap area. Furthermore, for an object referenced from the origin object (hereinafter referred to as “member object”), the origin object is released when the member object is moved from the New area to the Old area by CopyGC. Move the member objects that are released at a high rate to the same external heap as the origin object.
In this way, since a long-lived object to be stored in the external heap area can be stored in the external heap area, the occurrence of GC, in particular, the occurrence of FullGC can be suppressed.
Details will be described later.

  According to the present invention, many long-lived objects to be stored in the external heap area can be dynamically detected and actually stored in the external heap area.

It is a figure which shows the structure of the computer system 101 with which JavaVM of embodiment of this invention operate | moves, and input-output data. It is a figure which shows the example of the Java source file 104 described by the Java language. It is a figure which shows an example of the object analysis information 126 of embodiment of this invention. It is a figure which shows an example of the object generation information table 301 of embodiment of this invention. It is a figure which shows an example of the object profiling information table 302 of embodiment of this invention. It is a figure which shows an example of the member object information 303 of embodiment of this invention. It is a figure which shows an example of the data structure of the object for object profiling of embodiment of this invention. It is a figure which shows an example of the object classification bit of embodiment of this invention. It is a figure which shows an example of the data structure of the external heap 117 of embodiment of this invention. It is a figure which shows the state of the object stored in the Old area | region of the Java heap area | region 115 in the time of completion | finish of the process of step 1801 of the FullGC process 1703 of embodiment of this invention. It is a figure which shows the specific procedure which specifies an origin object by performing the process from step 1901 of step 1901 of the object profiling process 1803 of embodiment of this invention. It is a figure for demonstrating the procedure of the movement of the member object in the CopyGC process of embodiment of this invention. It is a flowchart which shows the procedure of the bytecode reading process of embodiment of this invention. It is a flowchart which shows the procedure of the object production | generation destination change process 1303 of embodiment of this invention. It is a flowchart which shows the procedure of the method execution process of embodiment of this invention. It is a flowchart which shows the procedure of the object production | generation process 1502 of embodiment of this invention. It is a flowchart which shows the procedure of GC process 1602 of embodiment of this invention. It is a flowchart which shows the procedure of the FullGC process 1703 of embodiment of this invention. It is a flowchart which shows the procedure of the object profiling process 1803 of embodiment of this invention. It is a flowchart which shows the procedure of the member object process 1904 of embodiment of this invention. It is a flowchart which shows the procedure of CopyGC process 1702 of embodiment of this invention. It is a flowchart which shows the procedure of the member object movement process of embodiment of this invention. It is a figure which shows the network structure of embodiment of this invention.

Hereinafter, as a mode for carrying out the present invention, a Java VM will be described as an example in detail with reference to the drawings as appropriate.
FIG. 1 is a diagram showing a configuration of a computer system 101 on which Java VM according to the embodiment of this invention operates, and input / output data.

  In the computer system (information processing apparatus) 101, the Java source file 104 described in the Java language is compiled by the Java compiler 109, so that the Java VM 110 is interpreted by interpreter execution and is described in byte code which is an executable format. A Java class file 103 is generated. Furthermore, a predetermined business process is executed by executing the Java class file 103 by the Java VM 110. Therefore, the Java class file 103 can be said to be a program for executing the predetermined business process.

  The computer system 101 includes hardware resources such as a processor (control unit) 129, a main storage (storage unit) 107, an auxiliary storage (storage unit) 102, an input device 130, and an output device 131. The processor 129, the main memory 107, the auxiliary memory 102, the input device 130, and the output device 131 are connected to each other via a bus 128.

The processor 129 executes various processes by executing various programs stored in the main memory 107.
The main memory 107 stores programs, information necessary for program execution, and program processing results. The main memory 107 may be a volatile memory or a non-volatile memory. The main memory 107 stores a Java compiler 109, a Java VM 110, a data area 108, and an operating system 127.

  The auxiliary storage 102 includes a Java class file 103 used for executing business processing, a Java source file 104 for generating the Java class file 103, an object analysis information file 105 used for storing object analysis information 126, and And a setting file 106 for recording a flag for controlling the operation of the Java VM 110 and a threshold value of the parameter.

The input device 130 is an interface for inputting necessary information to the computer system 101. The input device 130 is, for example, a keyboard or a mouse.
The output device 131 is a device that outputs information such as processing results to the outside. The output device 131 is, for example, a display.

  The data area 108 is an area for storing information necessary for program execution and the processing result of the program. The data area 108 includes byte code information 112 that is a byte code of a method, a Java heap area (first memory area) 115 that is an object storage area for GC, and an external heap area (first memory area that is an object storage area that is not GC target). 2 memory area) 116, and object analysis information 126 such as information related to object generation and object profiling. The external heap area 116 is further secured and released as needed in the external heap area 116, such as the external heap 1 (117), the external heap 2 (118), the external heap 3 (119), and so on. Includes possible areas.

  Here, the Java VM 110 stored in the main memory 107 will be described. The JavaVM 110 is a language processing execution system including a memory management mechanism that dynamically releases a memory area that is no longer needed.

  The Java VM 110 includes a bytecode reading unit 111, an object generation destination changing unit 113, a method executing unit 114, a memory managing unit 120, and an object analyzing unit 125. The bytecode reading unit 111, the object generation destination changing unit 113, the method execution unit 114, the memory management unit 120, and the object analysis unit 125 are programs executed by the processor 129.

  The bytecode reading unit 111 reads the bytecode of the method from the Java class file 103 received by the JavaVM 110 and generates bytecode information 112 related to the method in the data area 108. At that time, when the object generation destination of the object generation instruction existing in the bytecode information 112 is changed by executing the object generation destination changing unit 113, or when the object analysis information 126 related to the bytecode information 112 is generated and updated. There is. Details of the processing of the bytecode reading unit 111 will be described with reference to FIG.

  The object generation destination changing unit 113 refers to the object generation information table 301 (see FIG. 4) and appropriately changes the object generation destination related to the object generation instruction from the Java heap area 115 to the external heap area 116. Details of the processing of the object generation destination changing unit 113 will be described with reference to FIG.

  The method execution unit 114 executes the method according to each instruction of the bytecode information 112. When the next instruction to be executed is an object generation instruction, the object generation unit 121 is requested to perform object generation processing (object generation processing request). The method execution unit 114 first executes the method as an interpreter. On the other hand, for methods that are frequently executed in interpreter execution, the instruction sequence of the bytecode information 112 is dynamically compiled, and the method is compiled code execution. Note that the method execution unit 114 may interpret the method from the beginning to the end, or may execute the compiled code from the beginning. Also, when the method execution unit 114 is executing the compile code of the method and the bytecode information 112 is rewritten, the method execution unit 114 stops executing the compile code of the method and temporarily returns to interpreter execution. Processing may continue. Details of the process of the method execution unit 114 will be described with reference to FIG.

  The memory management unit 120 manages a memory area used by the Java VM 110. The memory management unit 120 includes an object generation unit 121 and a GC unit 122.

When the object generation unit 121 receives the object generation processing request from the method execution unit 114, the object generation unit 121 attempts to generate an object in the Java heap area 115 or the external heap area 116 in accordance with the content of the object generation processing request. Here, when the area for generating the object is empty and the object generation is successful, the generated object is returned to the caller.
On the other hand, when there is no free space in the Java heap area 115 and object generation to the Java heap area 115 fails, the GC unit 122 is requested to perform a GC process (GC process request), and the GC unit 122 executes the GC process. The memory area that is no longer necessary in the Java heap area 115 is released. Then, the object generation is attempted again, and if it further fails, an error of insufficient memory is generated.
If there is no free space in the external heap area 116 and the object generation in the external heap area 116 fails, the object generation in the Java heap area 115 is attempted. Furthermore, when the object generation to the Java heap area 115 also fails, the GC section 122 is requested to perform the GC process, and the GC section 122 executes the GC process to release the memory area that is no longer needed in the Java heap area 115. To do. Then, the object generation is attempted again, and if it further fails, an error of insufficient memory is generated.

  The object generation unit 121 records an object ID for identifying the generated object as an object generated by the object generation instruction in the generated object, and generates the object by the object generation instruction. This may be recorded in the object profiling information table 302 (see FIG. 5). Details of the processing of the object generation unit 121 will be described with reference to FIG.

  The GC unit 122 includes a CopyGC unit 124 and a FullGC unit 123. When the GC unit 122 receives the GC processing request from the object generation unit 121, the GC unit 122 actually sends the copy GC unit 124 when the New region is exhausted and the FullGC unit 123 when the Old region is exhausted. Request GC processing. Details of the processing of the GC unit 122 will be described with reference to FIG.

  When the copy GC unit 124 receives a GC processing request from the GC unit 122, the copy GC unit 124 executes a copy GC for only the New area in the Java heap area 115. At this time, the object that has been moved from the New area to the Old area of the Java heap area 115 by CopyGC is an external heap 117 (one of the external heaps secured in the external heap area 116 from the New area. ), When unnecessary external heap 117 is released, and by executing the object generation destination changing unit 113, the object generation instruction of the object generation instruction existing in the bytecode information 112 is generated. The destination may be changed. Details of the processing of the CopyGC unit 124 will be described with reference to FIG.

  When receiving the GC processing request from the GC unit 122, the Full GC unit 123 executes Full GC for all the GC target areas including the New area and the Old area in the Java heap area 115. At this time, the object analysis unit 125 may be executed to execute object profiling processing. Details of the processing of the FullGC unit 123 will be described with reference to FIG.

  The object analysis unit 125 dynamically detects the starting object corresponding to the root of the reference relationship by analyzing the reference relationship of the long-lived object released in the Old area by FullGC. Then, for each object generation instruction, the number of times the starting object generated by the object generation instruction is released in the Old area by FullGC is profiled. For the member object referenced from the starting point object, the number of times that the member object is released together with the starting point object being released is profiled. Details of the processing of the object analysis unit 125 will be described with reference to FIG.

  The Java VM 110 has a flag for controlling the operation (hereinafter referred to as “setting flag”) and a parameter threshold value (hereinafter referred to as “setting threshold value”). The default values of the setting flag and the setting threshold value can be changed by specifying them in the setting file 106 or the input device 130.

  The JavaVM 110 detects the objects to be stored in the external heap area 116 by analyzing the reference relationship of the long-lived objects released in the Old area by FullGC, and stores these objects in the external heap area 116. , FullGC will be suppressed. On the other hand, by using the object analysis information file 105 in which the analysis result of the reference relation of a long-lived object released in the Old area by FullGC is used, the object to be stored in the external heap area 116 is changed by the operation change of the Java VM 110 by the setting flag. The object profiling for detection may not be performed, and the execution may be performed in a state in which FullGC is suppressed from the time when the Java VM 110 is activated.

FIG. 2 is a diagram illustrating an example of the Java source file 104 described in the Java language.
Lines 1 to 17 show the contents of the Sample class.
The third to ninth lines and the eleventh to fifteenth lines indicate the contents of the processing of the methodA () method and the methodB () method, respectively.
Lines 5 and 13 use the new operator to instruct the Java heap area 115 to generate an object whose class type is ClassA. The 6th line instructs the new operator to generate an object whose class type is ClassZ in the Java heap area 115. Thus, for example, when methodA () is executed five times, five objects whose class type is ClassA and five objects whose class type is ClassZ are generated. If methodB () is executed 10 more times, another 10 objects whose class type is ClassA are generated.

  Here, by executing methodA () and methodB (), an object having the same class type, ClassA, is generated, but the object instructed for generation in the fifth line of methodA () and 13 of methodB () For an object that is instructed to generate on the line, even if the class type is the same ClassA, the lifetime of the same object is not necessarily the same. On the other hand, the five objects that are instructed to be generated in the fifth line of methodA () by the execution of methodA () are objects generated by the same process of methodA (), and therefore, the lifetime of similar objects. It can be said that there is a high possibility of becoming.

  In object profiling, even if the class type is the same, it is possible to profile objects in more detail by distinguishing objects that differ in the location where the generation of the object is directed.

FIG. 3 is a diagram illustrating an example of the object analysis information 126 according to the embodiment of this invention.
The object analysis information 126 stores object analysis information related to the bytecode information 112, and includes an object generation information table 301, an object profiling information table 302, and member object information 303. Details of the member object generation information table 301, the object profiling information table 302, and the member object information 303 will be described with reference to FIGS. 4, 5, and 6, respectively.

FIG. 4 is a diagram illustrating an example of the object generation information table 301 according to the embodiment of this invention.
Each row of the object generation information table 301 stores information related to an object generation command, and includes an object generation command address 401, an object ID (Identifier) 402, a class name 403, and an object generation destination 404.

  The object generation instruction address 401 stores the position of the object generation instruction. The position of the object generation instruction is, for example, an address where the object generation instruction exists in the bytecode information 112 corresponding to the object generation instruction such as the new operator in the example of the Java source file 104 shown in FIG. Note that, for example, when the object analysis information 126 is stored in the object analysis information file 105, the position of the object generation instruction may be indicated by an offset from the beginning of the bytecode information 112 to the position where the object generation instruction exists.

  The object ID 402 stores a unique value assigned for each object generation instruction. The object ID field 702 (see FIG. 7) of the object that is the object of the object profiling process stores the object ID 402 related to the object generation command that generated the object. Thereby, it can be determined by which object generation instruction the object is generated. For example, in the example of the Java source file 104 shown in FIG. 2, an object whose generation type is ClassA in line 5 and an object whose generation type is classA in line 13 are class A. The object IDs stored in the object header 701 are different such as # 0 and # 4. On the other hand, even if there are multiple objects whose class type is ClassA in the fifth line, the same object ID is # 0 for objects with the same position where the object is generated become.

  The class name 403 stores the name of the class type of the object generated by the object generation command.

  The object generation destination 404 stores the generation destination of the object generated by the object generation instruction. The object generation destination is “Java heap area” in the initial state, but is changed to “external heap 1” by the object generation destination changing unit 113 according to the result of the object profiling process. In addition, the object generation destination is set to “Java heap fixed” so that the object generation destination changing unit 113 does not change it, or “designated external heap” is set, so that the explicit memory management API (explicit memory management) API is an abbreviation for “application programming interface”.) It can also be an external heap specified by An object generated in the external heap designated by the explicit memory management API is released by the explicit memory management API, and is not automatically released for each unnecessary external heap 117. Details of the object profiling process will be described with reference to FIG.

FIG. 5 is a diagram illustrating an example of the object profiling information table 302 according to the embodiment of this invention.
The object profiling information table 302 stores the result of the object profiling process for the object associated with the object ID 402, and includes an object ID 501, an object generation count 502, an object profiling count 503, and a member object information address 504.

  The object ID 501 stores an object ID for linking the row data of the object generation information table 301 and the row data of the object profiling information table 302. By searching using this object ID as a key, the row data of the object generation information table 301 and the row data of the object profiling information table 302 for the object identified by this object ID can be referred to. Here, for example, when the row data of the object profiling information table 302 is prepared in advance for the row data of the object generation information table 301, the row data of the object generation information table 301 and the row data of the object profiling information table 302 are in a one-to-one relationship. In order to cope with this, the object generation information table 301 and the object profiling information table 302 may be combined into one table. Further, when the object identified by the object ID 402 is generated for the first time in order to save the memory area reserved for the object profiling information table 302, the row of the object profiling information table 302 with respect to the row data of the object generation information table 301 is stored. Data may be registered. In the example of the embodiment of the present invention, the row data of the object profiling information table 302 is prepared in advance for the row data of the object generation information table 301. For convenience, the object generation information table 301 and the object profiling information table 302 are separately provided. It is shown as a table.

  The object generation number 502 stores the number of times the object identified by the object ID 501 is actually generated by the object generation command related to the object ID 501.

  The object profiling count 503 stores the number of times the object stored in the Old area identified by the object ID 501 has been released by FullGC, that is, the number of times the object profiling processing has been performed on the object identified by the object ID 501. To do. Details of the object profiling process will be described with reference to FIG.

  The member object information address 504 stores the address of the member object information 303 related to the object identified by the object ID 501. Details of the member object information 303 will be described with reference to FIG.

FIG. 6 is a diagram showing an example of member object information 303 according to the embodiment of this invention.
The member object information 303 stores information about the state of reference relations of objects profiled by the object profiling process, and a data structure for storing information about the starting object (hereinafter referred to as “starting object data structure”). And a data structure for storing information about member objects (hereinafter referred to as “member object data structure”). The starting object is an object stored in the Old area that is the starting point of the object profiling process, and is no longer referenced from the root set or the required object after the end of the previous FullGC and before the start of the current FullGC. An object or an object that is highly likely not to be referenced from a root set or a necessary object. In addition, among the objects that can be reached by sequentially following the object reference from the starting object, member objects are objects that are released together when the starting object is released by FullGC, or may be released together. It is a high object. Details of the object profiling process will be described with reference to FIG.

  In an example of the embodiment of the present invention, the member object information 303 is shown as a tree structure in which the starting object data structure 601 and the member object data structures 602 to 607 are connected by pointers. In FIG. 6, the starting object data structure is indicated by a double-line rectangle, and the member object data structure is indicated by a single-line rectangle.

  The origin object data structure 601 stores a pointer to the member object data structure corresponding to the member object for each object reference field in order to record the status of the reference relationship from the origin object to the reference member object. For example, an example of the embodiment of the present invention indicates that the starting object data structure 601 connects the member object data structure 602 and the member object data structure 603 by pointers.

  The member object data structures 602 to 607 store, for each object reference field, a pointer to the member object data structure corresponding to the reference destination member object in order to record the status of the reference relationship from the member object to the reference destination member object. For example, an example of the embodiment of the present invention indicates that the member object data structure 603 connects the member object data structure 605 and the member object data structure 606 with a pointer. The pointer 608 indicates that an object whose class type is ClassF has an object reference field, but an object referred to by the object reference field is not recorded (NULL).

The member object data structures 602 to 607 also include the name of the class type of the member object and the number of times the member object is released together with the start object being released by FullGC, that is, object profiling for the start object. When the process is executed, the number of times the object profiling process is executed for the member object (hereinafter referred to as “member object profiling count”) is stored. For example, according to an example of the embodiment of the present invention, the number of times that the member object of ClassE indicated by the member object data structure 605 is also released together with the release of the origin object indicated by the origin object data structure 601 by FullGC. Indicates twice.
Here, the number attached to the pointer indicates the member object relevance ratio for convenience. The member object conformance rate is a rate at which the member object is released together with the origin object being released by FullGC. For example, the membership rate of the ClassF member object indicated by the member object data structure 606 is 0.75 because the starting object of ClassA indicated by the member object data structure 601 is released four times and the member object of ClassF is released three times. become. Also, the ClassG member object relevance ratio indicated by the member object data structure 607 is 0.25 because the ClassG member object is released once out of the ClassA starting object indicated by the member object data structure 601 being released four times. become.
Further, a broken line indicates a convenient boundary where the member object matching rate is 0.6, and an inner side surrounded by the broken line indicates that the member object matching rate is 0.6 or more.

  The member object information address 504 stores the address of the starting object data structure as the address of the member object information 303. For example, in the embodiment of the present invention, 0x81b2e23c which is the address of the starting object data structure 601 is stored in the member object information address 504 for the object whose object ID is # 4 stored in the object ID 501. It shows that. In the embodiment of the present invention, as an example, the starting object data structure 601 includes an object ID (subscript number “4”), an object class type name (Class A), and the number of profiling executions (number in parentheses). "4") is stored for convenience.

  FIG. 7 is a diagram illustrating an example of the data structure of the object profiling object according to the embodiment of this invention. The object profiling object includes an object header 701, an object ID field 702, and object data 703. The object profiling object is an object to be subjected to object profiling processing.

The object header 701 is object management information.
The object ID field 702 stores an object ID for identifying the object. This object ID is the object ID 402 related to the object generation command that generated the object. Note that the data structure of a normal object that is not the object of object profiling processing includes an object header 701 and object data 703. Even if the object is to be subjected to object profiling processing, if the object ID can be identified by storing the object ID in an empty area of the object header 701, the object data 703, and an area other than the data structure of the object, the object ID field There is no need to secure a separate area.
The object data 703 is the data body of the object.

  Note that the lower-order bits of the pointer to the object can be set to 0 according to the size of the object header 701, and can be used as a bit flag. For example, when the size of the object header 701 is 8 bytes, the lower 3 bits of the pointer to the object are 0. In the embodiment of the present invention, the lower-order bits of the pointer to the object may be used as a bit flag.

FIG. 8 is a diagram illustrating an example of the object type bit according to the embodiment of this invention.
The value of the object type bit 802 corresponds to the object type 801. In the embodiment of the present invention, 2 bits included in the object header 701 are used as object type bits.

Specifically, when the object type bit 802 is “00”, it indicates that the object is an “unanalyzed” object that is an unanalyzed object in the GC process or the object profiling process.
Further, when the object type bit 802 is “01”, it indicates that the object is a “necessary” object that has been determined to be an object necessary for program execution in the FullGC process.
Similarly, when the object type bit 802 is “10”, the object is a starting point of the object profiling process, and an object that is not referred to by a necessary object between the previous FullGC and the current FullGC, or This indicates that the object is a “starting point” object that is highly likely not to be referenced from the necessary object.
Further, when the object type bit 802 is “11”, among objects that can be reached by sequentially following the object reference from the starting object, objects that are released together when the starting object is released by FullGC, or , Indicating that the object is a “member” object that is likely to be released together.

FIG. 9 is a diagram illustrating an example of a data structure of the external heap 117 according to the embodiment of this invention. The external heap 117 includes an external heap header 901 and an object storage area 902.
The external heap header 901 is object management information, and stores the address of the member object information 303 stored in the member object reference information address 504 relating to the object generation instruction that generated the starting object stored in the external heap 117.
The object storage area 902 is an area for storing an object.

  FIG. 13 is a flowchart showing a procedure of byte code reading processing according to the embodiment of the present invention. This process is executed when the processor 129 processes the byte code reading unit 111. 10 to 12 will be described later.

  When the processor 129 executes the bytecode reading unit 111, the bytecode reading unit 111 first reads the bytecode of the method from the Java class file 103 received by the JavaVM 110, and stores the bytecode information 112 related to the method in the data area 108. Generate (step 1301).

  After the processing of step 1301, the JavaVM 110 setting flag is referenced to determine whether or not to change the object generation destination of the object generation instruction existing in the bytecode information 112 related to the method at the time of bytecode reading processing. (Step 1302).

  When the object generation destination is changed (the result of step 1302 is “YES”), the execution result of the object analysis information related to the method stored in the object analysis information file 105 accepted by the Java VM 110 is stored in the object analysis information 126. The object generation destination changing unit 113 is executed on the object indicated by the row data that is read and registered in the object profiling information table 302 related to the method, and the object generation destination changing process is executed (step 1303).

  When the object generation destination is not changed (the result of step 1302 is “NO”), or when the processing of step 1303 ends, it is determined whether or not object profiling is performed with reference to the setting flag of JavaVM 110 ( Step 1304).

  When performing object profiling (the result of step 1304 is “YES”), the object analysis information 126 related to the bytecode information 112 generated in the processing of step 1301 is generated, and all objects existing in the bytecode information 112 are generated. For the instruction, the object generation instruction address, the unique object ID assigned to the object generation instruction, and the class name of the object generated by the object generation instruction are respectively an object generation instruction address 401, an object ID 402, and a class name. Registered in 403 (including update). Further, the object generation destination 404 is registered in the “Java heap area” (step 1305). However, in the processing of step 1303, for an object generation instruction that reflects the execution result of the object analysis information related to the method stored in the object analysis information file 105 received by the JavaVM 110 in the object analysis information 126, step 1305 Do not perform the process.

  When object profiling is not performed (the result of step 1304 is “NO”), or after the process of step 1305 is completed, the present process is terminated.

  FIG. 14 is a flowchart illustrating a procedure of object generation destination change processing 1303 according to the embodiment of this invention. This processing is executed when the processor 129 processes the object generation destination changing unit 113.

  When the processor 129 executes the object generation destination changing unit 113, the object generation destination changing unit 113 first determines whether or not an unprocessed object ID exists in the object ID 501 in the object profiling table 302 to be processed ( Step 1401).

  When there is an unprocessed object ID in the object ID 501 (the result of step 1401 is “YES”), the object generation count 502 of the object identified by the object ID is the set threshold value (first threshold value) of the Java VM 110. It is determined whether or not this is the case (step 1402). In this step 1402, it is determined whether or not object generation has been performed a sufficient number of times to determine whether or not to change the object generation destination. For example, if the setting threshold for the number of object generations is 1000, an object generation command whose object ID 501 is # 0 has an object generation number 502 of 5872 (see FIG. 5). It can be determined that the object generation has been performed a sufficient number of times to determine whether or not. On the other hand, since the object generation command with the object ID 501 of # 104 has the object generation count 502 of 950 (see FIG. 5), the number of objects sufficient to determine whether or not to change the object generation destination It can be determined that the generation has not been performed.

  If the object generation count 502 is greater than or equal to the set threshold (the result of step 1402 is “YES”), the object profiling count 503 for the object generation count 502 associated with the object ID is the JavaVM 110 set threshold (second threshold). It is determined whether or not this is the case (step 1403). In this step 1403, the height of the rate at which the object generated by the object generation command related to the object ID is released by FullGC, that is, the object generated by the object generation command should be stored in the external heap area. It is determined whether or not the object generation destination of the object generation instruction should be changed to the external heap area based on the high ratio of becoming a long-lived object. For example, when the setting threshold value (ratio) of the object profiling count with respect to the object generation count is 0.50, there are 5872 objects generated by the object generation command whose object ID 501 is # 0 (see FIG. 5), of which 5830 Is released by FullGC, the ratio released by FullGC is 0.99, which is larger than the set threshold value. Therefore, it can be determined that the object generation destination of the object generation instruction should be changed to the external heap area. On the other hand, there are 10281 objects generated by the object generation command with the object ID 501 of # 103, of which 237 were released by FullGC, so the percentage released by FullGC is 0.02, from the setting threshold of 0.50 Since it is small, it can be determined that the object generation destination of the object generation instruction should not be changed to the external heap area.

  If the object profiling count 503 with respect to the object generation count 502 is greater than or equal to the set threshold (the result of step 1403 is “YES”), the object generation destination 404 associated with the object ID is set to “ For example, it is changed to “external heap area 1” other than “Java heap area” (step 1404).

  If the object generation count 502 is not greater than or equal to the set threshold (the result of step 1402 is “NO”), the object profiling count 503 for the object generation count 502 is not greater than or equal to the set threshold (the result of step 1403 is “NO”), or After the processing of 1404 is completed, the processing returns to step 1401. Then, the execution of this process is continued for the unprocessed object ID.

  If there is no unprocessed object ID in the object ID 501 (the result of step 1401 is “NO”), this process is terminated. In the determinations in step 1402 and step 1403, the comparison target value may be weighted according to the class size of the object related to the object ID.

FIG. 15 is a flowchart illustrating a procedure of method execution processing according to the embodiment of this invention. This process is executed when the processor 129 processes the method execution unit 114.
The bytecode information 112 related to the execution target method generated by the bytecode reading unit 111 includes one or more instructions, and an instruction type is assigned to each instruction.

  When the processor 129 executes the method execution unit 114, the method execution unit 114 first determines whether or not the instruction type of the method to be executed is an object generation instruction (step 1501).

If the instruction type is not an object generation instruction (the result of step 1501 is “NO”), the instruction is executed (step 1504).
If the instruction type is an object generation instruction (the result of step 1501 is “YES”), the object generation unit 121 is executed to execute object generation processing (step 1502).

After the processing in step 1502 is completed, it is determined whether or not the object has been successfully generated (step 1503).
If the object generation has failed (the result of step 1503 is “NO”), the execution of the method is interrupted and a memory shortage error is generated (step 1505).

If the object has been successfully generated (the result of step 1503 is “YES”), or after the processing of step 1504 is completed, it is determined whether there is an instruction to be executed next (step 1506).
If there is an instruction to be executed next (the result of step 1506 is “YES”), the process of step 1501 is executed and the method execution process is continued.

  If there is no instruction to be executed next, that is, if all the instructions have been processed (the result of step 1506 is “NO”), or after the process of step 1505 is completed, this process ends.

  FIG. 16 is a flowchart showing a procedure of object generation processing 1502 according to the embodiment of this invention. This processing is executed when the processor 129 processes the object generation unit 121.

  When the processor 129 executes the object generation unit 121, the object generation unit 121 first obtains an amount of memory necessary for generating the object requested to be generated from the object generation destination 404 related to the object generation instruction (see FIG. 4). It is determined whether or not the object generation destination stored in (1) can be secured. If the object generation destination is the external heap area 116 and the amount of memory necessary for generating the object requested to be generated cannot be secured in the external heap area 116, the object requested to be generated is further generated. It is determined whether or not a sufficient amount of memory can be secured in the Java heap area 115. (Step 1601).

  When an amount of memory necessary for generating the object requested to be generated cannot be secured in the object generation destination (the result of step 1601 is “NO”), an unnecessary memory area in the Java heap area 115 is released. Then, the GC unit 122 is executed to execute the GC process (step 1602).

  After the execution of the processing in step 1602, it is determined again whether or not the memory required for generating the object requested to be generated can be secured in the Java heap area 115 (step 1603).

  If the amount of memory required to generate the object requested to be generated cannot be secured in the Java heap area 115 (the result of step 1603 is “NO”), the object generation has failed in the object generation process execution source. This is notified (step 1611).

  When the amount of memory necessary for generating the object requested to be generated can be secured in the object generation destination (the result of Step 1601 or Step 1603 is “YES”), where is the current object generation destination? It is determined whether or not there is (step 1604).

  If the current object generation destination is the Java heap area 115 (the result of step 1604 is “Java heap area”), the setting flag of the Java VM 110 is referenced to determine whether or not to perform object profiling (step 1606). .

  When object profiling is performed (the result of step 1606 is “YES”), an object profiling object is generated in the Java heap area 115, and the object for identifying the object generated by the object generation instruction The object ID 402 related to the generation command is recorded in the object ID field 702 of the object (step 1607).

  After the process of step 1607 is completed, in order to record that the object has been generated by the object generation instruction, 1 is added to the value of the object generation count 502 related to the object generation instruction, and the object profiling information table 302 is stored. Update (step 1609).

  If the current object generation destination is the external heap area 116 (the result of step 1604 is “external heap area”), the external heap 117 that is the object generation destination is generated. Then, the member object information address 504 related to the generation instruction is recorded in the external heap header 901 of the external heap 117 (step 1605). The initial size when the external heap is generated is the sum of the class size of the starting object related to the generation instruction and the class size of the member object whose member object conformance rate is equal to or greater than the set threshold according to the generation instruction. Set based on.

  When object profiling is not performed (the result of step 1606 is “NO”), or after the processing of step 1605 ends, a normal object that does not include the object ID field 702 is generated at the object generation destination (step 1608).

After the process of step 1608 is completed or after the process of step 1609 is completed, the generated object is notified to the execution source of the object generation process (step 1610).
After the process of step 1610 is finished or after the process of step 1611 is finished, this process is finished.

  It should be noted that a dedicated object generation instruction according to whether the object generation destination or object profiling is performed and an object generation process corresponding thereto are prepared, and a predetermined object generation is performed by appropriately rewriting the object generation instruction of the bytecode information 112 Processing may be executed. In that case, for example, the determination in step 1604 and step 1607 may be unnecessary.

FIG. 17 is a flowchart showing a procedure of the GC processing 1602 according to the embodiment of this invention. This process is executed when the processor 129 processes the GC unit 122.
When the processor 129 executes the GC unit 122, the GC unit 122 first determines whether the area depleted in the object generation processing 1502 is the New area or the Old area of the Java heap area 115 (step 1701).

  If the area depleted in the object generation process 1502 is the New area of the Java heap area 115 (the result of Step 1701 is “New area”), the CopyGC unit 124 is executed and the CopyGC process is executed (Step 1702). ).

When the area depleted in the object generation process 1502 is the Old area of the Java heap area 115 (the result of Step 1701 is “Old area”), the FullGC unit 123 is executed and the FullGC process is executed (Step 1703). ).
After the process of step 1702 is completed or after the process of step 1703 is completed, this process is terminated.

  FIG. 18 is a flowchart showing a procedure of the full GC processing 1703 according to the embodiment of this invention. This processing is executed when the processor 129 processes the FullGC unit 123.

  When the processor 129 executes the FullGC unit 123, the FullGC unit 123 first sets the object type “unanalyzed” in the object header 701 for all the objects to be subjected to FullGC. In addition, in order to indicate that the object is necessary for the execution of the subsequent program, an object that can be reached by sequentially tracing the object reference from the root set such as a register, a stack at the time of execution, and a global variable is displayed in the object header 701. Set the object type “Necessary”. Then, after tracing all the objects that can be reached from the root set, an object whose object type is “necessary” in the object header 701 is an object necessary for execution of the subsequent program, and the object type of the object header 701 is “unanalyzed”. Is determined as an object unnecessary for the subsequent program execution (step 1801).

  FIG. 10 is a diagram illustrating a state of an object stored in the Old area of the Java heap area 115 at the end of the process of Step 1801 of the FullGC process 1703 according to the embodiment of this invention.

  Each node represents an object. An object indicated by a double circle is an object in which the object type “necessary” is set in the object header 701 by the processing of Step 1801 of the FullGC processing 1703. The symbol in the node indicates the class name, and the number on the lower right of the class name indicates the object ID stored in the object ID field 702.

  An arrow connecting the objects indicates the reference relationship of the objects. A solid line arrow is an object reference traced by the process of step 1801 of the FullGC process 1703, and a broken line arrow is an object that has an object reference but has not been traced by the process of step 1801 of the FullGC process 1703 Indicates a reference.

  The route set 1001 is a register, a runtime stack, a global variable, and the like. When the processing of Step 1801 of the FullGC processing 1703 is executed starting from the object reference held in the route set 1001, all objects reachable by sequentially tracing the object reference from the route set 1001 are determined as necessary objects. Therefore, as shown in FIG. 10, objects indicated by double circles such as an object 1002, an object 1003, an object 1004, and an object 1005 are necessary objects. On the other hand, all objects that could not be reached by sequentially tracing object references from the root set 1001 are determined as unanalyzed objects (unnecessary objects). Therefore, as shown in FIG. 10, objects indicated by single circles such as an object 1006, an object 1007, and an object 1008 are unanalyzed objects. These unanalyzed objects are objects that are actually released by the FullGC process 1703, but are stored in the external heap area 116 in order to suppress the usage of the Old area of the Java heap 115 and to suppress the occurrence of the FullGC process 1703. However, it is desirable to release it regardless of GC.

  In addition, starting objects such as the object 1006, the object 1007, and the object 1008 corresponding to the root of the reference relation in the reference relation of the unanalyzed object are not referred to from the root set 1001 or the necessary object, so that the object is changed from the starting object. Objects that can only be reached by tracing sequentially are also released. Therefore, if the reachable objects are stored in the external heap area 116 by sequentially tracing the objects from the starting object including the starting object, the Old usage of the Java heap 115 can be further suppressed. For this purpose, it is necessary to identify starting objects and generate these starting objects in the external heap area 116. A method of specifying the starting object object will be described with reference to FIG.

Here, the description returns to the flowchart of the FullGC processing 1703 in FIG.
After the processing in step 1801 is completed, it is determined whether or not object profiling is performed with reference to the setting flag of JavaVM 110 (step 1802).

  When performing object profiling (the result of step 1802 is “YES”), the object analysis unit 125 is executed to execute object profiling processing (step 1803).

When object profiling is not performed (the result of step 1802 is “NO”), or after the processing of step 1803 ends, an object whose object type is not “necessary” in the object header 701 is released as an unnecessary object (step 1804). ).
After the process of step 1804 is completed, this process is terminated.

FIG. 19 is a flowchart showing a procedure of object profiling processing 1803 according to the embodiment of this invention. This processing is executed when the processor 129 processes the object analysis unit 125.
By executing the processing from step 1901 to step 1904 of this processing, the starting object can be specified.

  When this process is executed, first, it is determined whether or not there is an unprocessed unnecessary object for all the objects determined to be unnecessary in step 1801 (step 1901).

  If an unprocessed unnecessary object exists (the result of step 1901 is “YES”), the object type of the object header 701 of the object is referred to and it is determined whether the object type is “unanalyzed”. (Step 1902).

  If the object type is “unanalyzed” (the result of step 1902 is “YES”), the object type of the object header 701 of the object is set to “starting point” (step 1903).

  After the process of step 1903 is completed, the member object process is called for the starting object of step 1903, and the member object process is executed (step 1904).

  If the object type is not “unanalyzed” (the result of step 1902 is “NO”), or after the process of step 1904 is completed, the process returns to step 1901. Then, the execution of this process is continued for the unprocessed unnecessary object.

If there is no unprocessed unnecessary object (the result of step 1901 is “NO”), the object ID field 702 of the starting object is referred to for the starting object whose object type is “starting” in the object header 701, and Get the object ID of the origin object. Then, 1 is added to the value of the object profiling count 503 related to the object ID, and the object profiling information table 302 is updated. Further, the member object information 303 related to the origin object is referred to by the pointer stored in the member object information address 504 related to the object ID. If member object information 303 relating to the starting object does not exist, member object information 303 relating to the starting object is generated. Then, according to the reference relationship between the starting object and the member object that can be reached by sequentially tracing the object reference from the starting object, the member object data structure is appropriately added to the member object information 303, and the corresponding member object data structure The member object information 303 is updated by adding 1 to the member object profiling count stored in (step 1905).
After the process of step 1905 ends, this process ends.

  FIG. 20 is a flowchart showing a procedure of member object processing 1904 according to the embodiment of this invention. This process is executed by being called from the object profiling process 1803 or recursively called from the member object process 1904.

When this processing is executed, it is first determined whether or not there is an unprocessed reference destination object for the object that is the processing target of this processing (step 2001).
If there is an unprocessed reference destination object (the result of step 2001 is “YES”), the object type is determined by referring to the object type of the object header 701 of the reference destination object (step 2002).

When the object type is “starting point” (the result of step 2002 is “starting point”), it is determined whether or not the reference destination object is the same as the calling source starting object of the member object processing 1803 (step 2003). .
If the reference destination object is not the same as the calling source object of the member object processing 1803 (the result of step 2003 is “NO”), the object type of the object header 701 of the reference destination object is set to “member” (step) 2005).

When the object type is “unanalyzed” (the result of step 2002 is “unanalyzed”), the object type of the object header 701 of the reference destination object is set to “member” (step 2004).
After the processing of step 2004 is completed, member object processing 1904 is executed for the referenced object (step 1904).

When the object type is “member” (the result of step 2002 is “member”), when the reference destination object is the same as the calling source object of the member object processing 1803 (the result of step 2003 is “YES”). After the process of step 2005 is completed or after the process of step 1904 executed after step 2004 is completed, the process returns to step 2001. Then, the execution of this process is continued for an unprocessed reference destination object (the result of step 2001 is “YES”).
If there is no unprocessed reference destination object (the result of step 2001 is “NO”), this process ends.

  FIG. 11 is a diagram showing a specific procedure for identifying the starting object by executing the processing from step 1901 to step 1904 of the object profiling processing 1803 according to the embodiment of this invention.

  Each node represents an object. An object indicated by a single circle of a thin line is an unnecessary object in which the object type “unanalyzed” is still set in the object header 701 by the processing of step 1801 of the full GC processing 1703. The symbol in the node indicates the class name, and the number on the lower right of the class name indicates the object ID stored in the object ID field 702.

  An arrow connecting the objects indicates the reference relationship of the objects. A solid line arrow is an object reference traced by executing the processing from step 1901 to step 1904 of the object profiling process 1803, and a broken line arrow is a step 1901 of the object profiling process 1803 although an object reference exists. The object reference which has not been traced yet by executing the processing from step 1904 to step 1904 is shown.

  FIG. 11A shows the state at the end of the processing of step 1801 of the full GC processing 1703. It is assumed that the objects are processed in the order of the object 1009, the object 1011, the object 1008, the object 1010, and the object 1012 from a state in which the object reference relationship is not known.

  FIG. 11B processes the object 1009 and sets the object type of the object header 701 of the object 1009 to “starting point” because the object type is “unanalyzed” in the determination in step 1902 of the object profiling process 1803. Indicates the state. As a result, the starting object 1009 is indicated by a single circle with a bold line.

FIG. 11C processes the object 1011 that is the reference destination of the object 1009, and the object type is “unanalyzed” in step 2002 of the member object processing 1904. Therefore, the object type of the object header 701 of the object 1011 Indicates that “Member” is set. As a result, the object 1011 which is a member object is indicated by a single circle with a cross. Since the reference destination object of the object 1011 does not exist, the processing of the object 1009 ends here.
Further, since the object 1011 is processed and the object type is not “unanalyzed” in the determination in step 1902 of the object profiling process 1803, the process of the object 1011 is ended here.

  FIG. 11D processes the object 1008 and sets the object type of the object header 701 of the object 1008 to “starting point” because the object type is “unanalyzed” in the determination in step 1902 of the object profiling process 1803. Indicates the state.

FIG. 11 (e) processes the object 1009 that is the reference destination of the object 1008, the object type is “starting point” in the determination in step 2002 of the member object processing 1904, and in the determination in step 2003 of the member object processing 1904, Since the reference destination object 1009 and the call source object 1008 are not the same, the object type of the object header 701 of the reference destination object 1009 is set to “member”.
In addition, since the object 1010 that is the reference destination of the object 1008 is processed and the object type is “unanalyzed” in the determination of step 2002 of the member object processing 1904, the object type of the object header 701 of the object 1010 that is the reference destination is changed. The state set to “Member” is shown. Further, the object 1012 that is the reference destination of the object 1010 is processed, and the object type is “unanalyzed” in the determination in step 2002 of the member object processing 1904. Therefore, the object type “in the object header 701 of the object 1012 that is the reference destination” This shows a state in which “Member” is set. Note that the object 1008 that is the reference destination of the object 1012 has the object type “starting point” in the determination in step 2002 of the member object processing 1904, and is the same as the calling object 1008 in the determination in step 2003 of the member object processing 1904. Therefore, the processing of the object 1008 ends here.
Furthermore, since the object 1010 is processed and the object type is not “unanalyzed” in the determination in step 1902 of the object profiling processing 1803, the processing of the object 1010 ends here. The same applies to the object 1012.

  FIG. 11 (f) shows a state in which all the processing of the object 1009, the object 1011, the object 1008, the object 1010, and the object 1012 has been completed, and it is determined that the object 1008 is the starting object by analyzing the reference relationship of this object. Can be identified. Further, the object 1009, the object 1011, the object 1010, and the object 1012 are member objects, and the object reference 1013 from the member object to the starting object is processed as not existing.

  FIG. 21 is a flowchart showing a procedure of the copy garbage collection process 1702 according to the embodiment of this invention. This process is executed when the processor 129 processes the CopyGC unit 124.

  When the processor 129 executes the CopyGC unit 124, the CopyGC unit 124 first moves the objects necessary for the subsequent program execution stored in the New area to another area in the New area and moves them. The object that did not exist is released as an unnecessary object (step 2101). In the process of step 2101, for an object that can be reached by sequentially tracing object references from the starting object stored in the external heap area 116, the member object moving process is called for the starting object to move the member object. By executing the process, it is moved to an appropriate destination. Details of the member object movement processing will be described with reference to FIG.

After the processing of step 2101 is completed, for example, an object reference to the external heap 117 is inspected, and it is determined whether or not there is an unnecessary external heap 117 that is not referenced from anywhere (step 2102).
If there is an unnecessary external heap 117 (the result of step 2102 is “YES”), by releasing the unnecessary external heap area 116, for example, the external heap 1 or the external heap 3, the external heap 1 or the external heap The unnecessary object stored in 3 is released (step 2103).

If there is no unnecessary external heap 117 (the result of step 2102 is “NO”), or after the processing of step 2103 is completed, the setting flag of JavaVM 110 is referred to, and the object generation destination of the object generation instruction is specified during CopyGC processing. It is determined whether or not to change (step 2104).
When changing the object generation destination (the result of step 2104 is “YES”), the object generation destination changing unit 113 is executed on the object generation information table 301 to execute the object generation destination changing process (step 1303). ).
When the object generation destination is not changed (the result of step 2104 is “NO”), or after the processing of step 1303 is ended, this processing is ended.

  In the embodiment of the present invention, unnecessary external heap release and change of the object generation destination of the object generation instruction are performed at the time of CopyGC processing, but these processing are performed at a predetermined timing other than at the time of CopyGC processing. May be.

  FIG. 22 is a flowchart illustrating a procedure of member object movement processing according to the embodiment of this invention. This process is executed in the process of Step 2101 of the CopyGC process 1702.

When this processing is executed, it is first determined whether or not there is an unprocessed reference destination object for the object that is the processing target of this processing (step 2201).
If there is an unprocessed reference destination object (the result of step 2201 is “YES”), whether or not the reference destination object is a target to be moved from the New area to the Old area by the process of step 2101 of the CopyGC process 1702. Is determined (step 2202). Note that a reference object is a target to be moved from the New area to the Old area by CopyGC processing is a long-lived object that has undergone at least a number of CopyGCs to move the reference object to the Old area. Means.

  When the reference destination object is a movement target from the New area to the Old area (the result of Step 2202 is “YES”), the member object relevance ratio of the reference destination object is equal to or greater than the setting threshold (third threshold) of the JavaVM 110 It is determined whether or not (step 2203). In this determination, the member object relevance ratio may be weighted according to the class size of the member object.

  If the member object conformance rate of the reference destination object is equal to or greater than the set threshold value (the result of step 2203 is “YES”), the reference destination object is moved to the same external heap as the origin object (step 2204).

FIG. 12 shows the New and Old areas of the external heap 1, the external heap 2 and the Java heap 115 at the start and (b) end of the member object move processing according to the embodiment of the present invention. It is a figure which shows the state of the stored object.
Each node represents an object. Note that symbols in the nodes indicate class names. For example, the class name of the object 1201 whose symbol in the node is “A” is “ClassA”. An arrow connecting the objects indicates the reference relationship of the objects.

  Here, the object 1201 is a starting object stored in the external heap 1. An object 1208 is a starting point object stored in the external heap 2. A pointer to member object information 303 related to the object 1201 is stored in the external heap header 901 of the external heap 1 in which the object 1201 is stored, and the member object information 303 related to the object 1201 is referred to by this pointer. Similarly, a pointer to the member object information 303 related to the object 1208 is stored in the external heap header 901 of the external heap 2 in which the object 1208 is stored, and the member object information 303 related to the object 1208 is referred to by this pointer. . Here, it is assumed that the member object information 303 related to the object 1201 is the member object information 303 shown in FIG. Referring to the starting object data structure 601 of this member object information 303, it can be seen that the starting object of Class A has been released four times in the Old area by FullGC. Further, referring to the member object data structure 606 of the member object information 303, the ClassA member object is released three times in the Old area by releasing the starting object of ClassA by FullGC, the members of the member object information 303 With reference to the object data structure 605, it can be seen that the class A member object was released twice in the Old area by releasing the starting object of Class A by FullGC.

  Here, the member object matching rates of ClassB, ClassC, ClassD, ClassE, ClassF, and ClassG are 1.00, 1.00, 1.00, 0.50, 0.75, and 0.25, respectively. A member object with a high member object conformance rate is likely to be unnecessary at the same time as the starting object becomes unnecessary, so by storing a member object with a high member object conformance rate in the same external heap as the starting object, At the same time as the starting object becomes unnecessary, releasing the external heap also increases the possibility of releasing a member object having a high member object matching rate. For this reason, in the member object moving process, a member object having a high member object matching rate is moved to the same external heap as the starting object object. For example, when the setting threshold value of the member object conformance rate is 0.60, the object 1202, the object 1203, the object 1204, and the object 1206 having the member object conformance rate of 0.60 or more are subject to the same external heap as the object 1201 by the member object moving process. Move to 1. On the other hand, the object 1205 whose member object relevance rate is not 0.60 or more moves to the same external heap 2 as the object 1208 which is another starting object whose result of step 2203 is “YES” by the member object moving process. The object 1207 is an object that can be reached by sequentially tracing the object reference from the starting object stored in the external heap area 116. However, since the member object relevance rate is not 0.60 or more, the Old area of the Java heap area 115 Move to.

Now, the description returns to the flowchart of the member object movement process of FIG.
After the process of step 2204 is completed, the member object movement process is called for the reference destination object, and the member object movement process is executed (step 2205).

When the reference destination object is not the object to be moved from the New area to the Old area (the result of step 2202 is “NO”), when the member object precision of the reference destination object is not equal to or greater than the set threshold (the result of step 2203 is “NO”) ), And after the process of step 2205 ends, the process returns to step 2201. Then, the execution of this process is continued for the unprocessed reference destination object.
If there is no unprocessed reference destination object (the result of step 2201 is “NO”), this process ends.

  In this member object movement process, the process of step 2202 may be omitted. That is, whether or not to move the reference object (member object) to the same external heap as the external heap in which the origin object exists may be determined only by the determination in step 2203. In other words, in some cases, it is more convenient to suppress the occurrence of GC by processing the referenced object to move to the same external heap as the starting object, even if the referenced object is not long enough to move to the Old area. . However, although it cannot be generally stated, it is effective to provide a determination in step 2202 and move a longer-lived reference destination object to the same external heap as the origin object, as in the processing of FIG.

  In the embodiment of the present invention, for example, as shown in the network configuration of FIG. 23, a plurality of computer systems 101 and a web server 201 are communicably connected via a network 203. The computer system 101 has a Java application 132 that functions in accordance with the description content of the Java source file 104, and the Java VM 110 executes the Java application 132 to realize a predetermined service.

  On the other hand, the web server 201 is a computer having hardware resources such as an input device, an output device, a processor, and a storage device. The web server 201 has a Java servlet 202, for example. The web server 201 dynamically creates a web page by causing the Java servlet 202 to function, and transmits the web page to the computer system 101 that requested the web page.

The computer system 101 may have a Java applet instead of the Java application 132. In this case, a predetermined service is realized by executing a Java applet using a web browser that browses a web page provided by the web server 201.
Further, the Java VM 110 included in the computer system 101 may be previously installed at the time of shipment, or may be acquired from the web server 201.

≪Others≫
Each of the above-described embodiments is suitable for carrying out the present invention, but the form of implementation is not limited to these, and various modifications can be made without departing from the scope of the present invention. It is.

  For example, the GC handled in this embodiment is a generational GC, but the GC to which the present invention is applicable is not limited to this. For example, it can be applied to a parallel GC.

  In addition, the object profiling count 503 registered in the object profiling information table 302 may be the number of copy GCs or the number of other GCs instead of the number of full GCs.

  In addition, specific configurations of hardware, software, flowcharts, and the like can be appropriately changed without departing from the spirit of the present invention.

101 Computer system (information processing equipment)
102 Auxiliary storage (storage unit)
103 Java class file 104 Java source file 105 Object analysis information file 106 Setting file 107 Main memory (storage unit)
108 Data Area 109 Java Compiler 110 JavaVM
111 Byte code reading unit 112 Byte code information 113 Object generation destination changing unit 114 Method executing unit 115 Java heap area (first memory area)
116 External heap area (second memory area)
117 External heap 1
118 External heap 2
119 External heap 3
DESCRIPTION OF SYMBOLS 120 Memory management part 121 Object generation part 122 GC part 123 FullGC part 124 CopyGC part 125 Object analysis part 126 Object analysis information 127 Operating system 128 Bus 129 Processor (control part)
DESCRIPTION OF SYMBOLS 130 Input device 131 Output device 132 Java application 201 Web server 202 Java servlet 203 Network 301 Object generation information table 302 Object profiling information table 303 Member object information

Claims (7)

A memory management method in an information processing apparatus that operates a virtual machine having an automatic release function that automatically releases a memory area that is no longer necessary in a memory area reserved for executing a program,
The storage unit of the information processing apparatus
As the memory area, a first memory area targeted for the automatic release function;
A second memory area that is not subject to the automatic release function, as the memory area;
For each object generated when the program is executed, an object generation instruction related to the object, an object generation count indicating the number of times the object is generated in the first memory area by the object generation instruction, and the automatic release Object analysis information including the object profiling count indicating the number of times the first memory area has been released by the function,
The control unit of the information processing apparatus
Referring to the object analysis information, determining whether the number of object generations of the object is equal to or greater than a first threshold stored in the storage unit;
Determining whether a ratio of the object profiling frequency to the object generation frequency is equal to or greater than a second threshold value stored in the storage unit when the object generation frequency is equal to or greater than the first threshold value; When,
When the ratio is equal to or greater than the second threshold, the step of changing the generation destination of the object by the object generation instruction to the second memory area is executed. The control unit of the information processing apparatus
Identifying objects other than objects that can be directly referred to by the virtual machine and objects that are directly or indirectly referenced by the directly referenceable objects among the objects generated in the first memory area;
With reference to the object analysis information, when the object generation count of the identified object is equal to or greater than the first threshold, and a ratio of the object profiling count to the object generation count is equal to or greater than the second threshold, The memory management method according to claim 1, further comprising: changing a generation destination of an object by an object generation instruction to the second memory area. The control unit of the information processing apparatus
In the specified object, a starting object that is an object that is not directly referenced from the virtual machine and that is not referred to by any object, and a member object that is an object that the starting object directly or indirectly references are set. Steps,
Determining whether the ratio of the object profiling count of the member object to the object profiling count of the starting object is equal to or greater than a third threshold stored in the storage unit;
The memory management method according to claim 2, wherein when the ratio is equal to or greater than the third threshold, the member object is also moved to the second memory area. The automatic release function is an automatic release function by generational garbage collection,
The first memory area includes a New area in which an object that is not long-lived is stored, and an Old area in which an object that is long-lived is stored. The memory management method according to one item. The memory management method according to claim 4, wherein the release of the first memory area indicated by the number of times of object profiling is a release for an area including both the New area and the Old area. A memory management program that functions as an information processing apparatus that operates a virtual machine having an automatic release function that automatically releases a memory area that is no longer necessary in a memory area reserved for executing a program,
The storage unit of the information processing apparatus
As the memory area, a first memory area targeted for the automatic release function;
A second memory area that is not subject to the automatic release function, as the memory area;
For each object generated when the program is executed, an object generation instruction related to the object, an object generation count indicating the number of times the object is generated in the first memory area by the object generation instruction, and the automatic release Object analysis information including the object profiling count indicating the number of times the first memory area has been released by the function,
The memory management program is stored in the control unit of the information processing apparatus.
With reference to the object analysis information, a process of determining whether or not the number of object generations of the object is equal to or greater than a first threshold stored in the storage unit;
A process of determining whether a ratio of the object profiling frequency to the object generation frequency is equal to or greater than a second threshold value stored in the storage unit when the object generation frequency is equal to or greater than the first threshold value. When,
When the ratio is equal to or greater than the second threshold value, a process of changing an object generation destination by the object generation instruction to the second memory area is executed. An information processing apparatus that operates a virtual machine having an automatic release function that automatically releases a memory area that is no longer necessary in a memory area reserved for executing a program,
As the memory area, a first memory area targeted for the automatic release function;
A second memory area that is not subject to the automatic release function, as the memory area;
For each object generated when the program is executed, an object generation instruction related to the object, an object generation count indicating the number of times the object is generated in the first memory area by the object generation instruction, and the automatic release A storage unit storing object analysis information including an object profiling count indicating the number of times the first memory area is released by a function;
Control for referring to the object analysis information to determine whether the number of times the object has been generated is equal to or greater than a first threshold stored in the storage unit;
Control for determining whether a ratio of the object profiling frequency to the object generation frequency is equal to or greater than a second threshold value stored in the storage unit when the object generation frequency is equal to or greater than the first threshold value. When,
A control unit that executes control to change a generation destination of the object by the object generation instruction to the second memory area when the ratio is equal to or greater than the second threshold. apparatus.

Images