JP2000132406A - Optimization method for object memory - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce the load of a garbage collection and to enhance the execution performance of an application by carrying out the data flow analysis of a program, checking the section where an object is referred to and inserting an object opening instruction into the end of a reference section of the object. SOLUTION: An intermediate code 201 which finished the analysis of data undergoes an object reference analysis 202. Then the code 201 undergoes an object existence section analysis 203 after the analysis 202 is over. An object existence section means a program section where an object holds the effective data. When the analysis 203 is over, an object opening instruction is inserted (204) into the end of a reference section of the object. In such a constitution, the load of a garbage collection is reduced and the execution performance of an application is improved.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for managing a memory in use of a computer.

[0002]

2. Description of the Related Art In a computer system, memory management is an important factor that affects system performance and reliability. There are two main types of memory management methods.

One is a method in which an application explicitly releases a memory. A typical example of this method is the C language. See "Programming Language C by BW Kernighan, DM Richie" for details. According to the C language specification, the application program itself must manage the memory, except for areas allocated as local or static variables. A typical approach is to use the library function malloc ()
The necessary memory is acquired from the system by using, and when it has been used, it is returned to the system using the library function free (). The handling of the reserved memory is entirely up to the application program.

[0004] The other is a system in which garbage collection is performed and the system silently collects unnecessary memory. A representative of this method is the Java language. See Laura Limey and Charles Parkinson for details.
An introduction to the Java language ". According to the Java language specification, an application obtains an object's memory from the system using a new instruction. However, unlike C, there is no instruction to return memory to the system. Ja
In the va language execution environment, a process called the garbage collector is always running. The garbage collector monitors application memory usage and automatically reclaims unused object memory. Applications do not need to explicitly free memory.

[0005]

The method of explicitly managing a memory by an application is efficient, but has a problem that memory management becomes complicated. The timing at which the memory is required and the timing at which the memory is not required are closely related to the control structure of the application and are generally extremely complicated. If the used memory is released by mistake, incorrect operation will occur. Conversely, not properly releasing used memory can cause other problems. This is called a memory leak. Unnecessary memory occupies the memory area and eventually runs out of system memory.

A method for performing garbage collection is as follows.
An advantage is that complicated memory management is not required on the application side. There is a problem that the execution performance of the application is reduced. The garbage collector process always runs in parallel with the execution of the application. Since the garbage collector is a process for examining memory reference relationships in a wide range, the load on the system is not light. The execution performance of the application will surely decrease accordingly.

[0007]

A data flow analysis of a program is performed to check a section in which an object is referred to. An object release instruction is inserted at the end of the object reference section. As a result, the load of garbage collection can be reduced and the execution performance of the application can be improved.

[0008]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 shows the overall configuration. Processing system
101 receives as input a virtual code 102 or a source code 103. If it is a virtual code, perform code conversion 104,
It is converted into an intermediate code suitable for the subsequent data flow processing 106. In the case of a source code, a syntax analysis 105 is performed to convert it into an intermediate code. The generated intermediate code is subjected to data flow analysis 106. The data flow analysis is a process of analyzing an intermediate code and clarifying a reference relationship between various data. This data flow analysis is exactly the same classical one as the data flow analysis performed by an ordinary optimizing compiler. For details on intermediate code and data flow analysis, see “AV
Compilers-Principles, Techniques and Tools "by Ayho, R. Sessy and JD Ullman. When the analysis is completed, the process proceeds to the object memory optimizing process 107. This is to check the reference relationship of objects and release memory without going through the garbage collector. Details will be described later with reference to FIG. The intermediate code for which the object memory optimization has been completed is sent to a code generation process. There are two types of code generation depending on the target execution environment. In the case of a normal native execution environment, a machine code generation process 108 is performed to generate an optimized machine code 110. In the case of a virtual machine environment, an optimized virtual code 111 is generated by performing a virtual code regeneration process 109.

FIG. 2 shows an object memory optimizing process 107.
The detailed procedure is shown. The intermediate code 201 for which the data flow analysis 106 has been completed is, first, an object reference analysis 202
To Details of the analysis are described in FIG.

When the object reference analysis is completed, the process enters the object life cycle analysis 203 next. An object life cycle is a program section in which an object holds valid data. Objects outside the life cycle are dead. An object is dead
This means that objects are no longer referenced. Dead objects can free up memory and use the memory previously occupied by the object for other purposes. The details of the concept of the life cycle can be found in the above-mentioned "Compiler-Principles, Techniques and Tools" by AV Eiho, R. Cessy and JD Ullman.

After the object life cycle analysis is completed,
An object release instruction insertion 204 is performed. By inserting a release command at the point where the object died, the object can be released without going through the garbage collector.

Reference numeral 301 in FIG. 3 is an example of a program for explaining a processing procedure of object memory optimization. The example program accepts objects x and y as input and serves to exchange the contents. Two objects are created in the function. These are used as objects to temporarily save data. They are no longer needed after the function has finished and are usually collected by the garbage collector.

Reference numeral 401 in FIG. 4 shows a state in which object reference analysis has been performed on the example program. On the first line
The contents of x.member1 are copied to tmp1. This causes tmp
1 means that valid data has been stored. Such an operation is referred to herein as the definition of tmp1. In the second line, the contents of x.member2 are also copied to tmp2.

In the fourth line, the contents of tmp1 are copied to y.member1. This means that valid data has been moved from tmp1 to y.member1. Such an operation here is tmp1
Call it a reference. Since tmp1 will not be referenced after this point, there is no problem if you release the memory. Line 6 also copies the contents of tmp2 to y.member2.

Reference numeral 501 in FIG. 5 shows a state where the object live range analysis is performed on the example program. As mentioned above, tmp1 is defined on the first line and is referenced on the fifth line. That is, valid data is stored in the section from the first row to the fifth row. Such a state in which the object holds valid data is called that the object is alive. tmp1 will not be referenced in the fifth and subsequent lines. Even if the contents of tmp1 are destroyed after the fifth line, the application will work properly. Such a state is called a dead object. Dead objects are collected by garbage collection. When the object is actually collected depends on the garbage collection implementation. Many implementations do not collect dead objects immediately, but collect them collectively at a certain level.

FIG. 6 shows a state 601 in which an object release instruction is inserted into the example program. Based on the analysis result, a release command is inserted immediately after the object dies. Since the object tmp1 dies on the fifth line, an object release instruction free () is inserted immediately after that. The object tmp2 dies on line 6, so release it immediately afterwards. As soon as the object release instruction is executed, the object is deleted and the memory used by the object is returned to the system memory pool. Since the memory can be collected without going through the garbage collector, the system load is extremely small.

The processing for inserting the object release instruction is as follows.
Since it is performed at the time of compilation, the execution performance of the application is not reduced. Garbage collection is performed simultaneously with the application. If the garbage collection is executed frequently, the execution performance of the application is surely reduced.

[0018]

As described above, according to the present invention, the load of garbage collection is reduced, and the execution performance of an application is improved.

[Brief description of the drawings]

FIG. 1 is an overall configuration diagram of an object memory according to an embodiment of the present invention.

FIG. 2 is a flowchart illustrating a procedure of an object memory optimization process.

FIG. 3 is a diagram showing an example program for explaining an optimization procedure.

FIG. 4 is a diagram showing an example of object reference analysis.

FIG. 5 is a diagram showing an example of object life cycle analysis.

FIG. 6 is a diagram showing an example of inserting an object release instruction.

[Explanation of symbols]

101: processing system, 102: virtual code, 103:
Source code, 104: code conversion, 105: syntax analysis.

Claims (1)

[Claims] In a computer system, by analyzing an application program in advance and inserting a memory release instruction, a load of garbage collection at the time of execution is reduced, and the execution performance of the application is improved. Program optimization method.