JPH0728691A - Garbage collection efficiency increasing method - Google Patents

Abstract

PURPOSE:To improve the execution efficiency of a program by recovering many memory areas without making garbage collection trace reference which is not used afterward when garbage collection is started. CONSTITUTION:A control flow analytic procedure 1 statically analyzes the control flow of a program before execution and generates a control flow graph 11. A memory allocation analytic procedure 2 analyzes memory arrangement at every node, and generates a control flow graph 12 to which the memory allocation is added. A reference analytic procedure 3 finds reference which is alive at the entrances of respective nodes and not alive at the exits and generates a control flow graph 13 which has life/death kinds added to reference in the memory arrangement. A mark insertion procedure 4 gives marks in the program so that the garbage collection do not trace the reference back.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for improving the efficiency of garbage collection, and more particularly to executing a program created by a language processing system such as a symbol processing language or an object-oriented language which requires allocating memory on demand. The present invention relates to a garbage collection efficiency method for efficiently performing garbage collection sometimes performed.

[0002]

2. Description of the Related Art A conventional method for improving the efficiency of garbage collection checks whether a reference can be reached to each cell which is a unit of a memory area, and when the cell can be reached, the cell is used. It was decided that it could not be recovered because it was inside.

However, those references are not always used after that, and cells that are only pointed to by references that are not used will not be used thereafter. That is, in the conventional garbage collection efficiency method, it is theoretically impossible to judge a reference that will not be used after that, because it does not have the operation information of the program, and it is actually possible to collect the cells. Was hampered by such unused references.

Further, the conventional method for improving the efficiency of garbage collection is applied to a program created in a language in which a procedure can be passed as a parameter to another procedure and a memory area can be allocated at the time of execution to change the content. Did not have an effective way to perform the control flow analysis required for static analysis of programs.

[0005]

The conventional method for improving the efficiency of the garbage collection described above has a problem that when the garbage collection is started, the reference which is not actually used thereafter is traced. Since it takes an extra time to perform the garbage collection and the number of cells that can be collected is reduced, the garbage collection is activated more during the execution of the program, which reduces the execution efficiency of the entire program. have.

Further, in the conventional garbage collection efficiency improving method, since the cell recovery efficiency is low, the maximum value of the total memory required for executing the program becomes large, and especially in the execution mode having virtual memory. However, there is a drawback in that the execution efficiency of the program is greatly reduced because more virtual memory units are required and the possibility of exchanging between the main memory and the auxiliary memory increases.

[0007]

According to a first aspect of the present invention, there is provided a garbage collection efficiency improving method for efficiently performing garbage collection at the time of executing a target program. A control flow analysis procedure for statically analyzing the control flow and creating a tree-structured control flow graph with the processing unit as a node and the control flow as an arc, and (B) a memory for each node of the control flow graph. By performing the layout analysis, the memory layout analysis procedure for adding the memory layout of each node, and (C) each node of the control flow graph with the memory layout added is alive at the entrance but not alive at the exit. Reference analysis hand to find references that are not used later for And (D) a mark insertion procedure for marking the unused reference found in the reference analysis procedure so that the reference is not traced by garbage collection. When invoked, it includes avoiding following the reference in the program marked in the mark insertion procedure.

The garbage collection efficiency improving method of the second aspect of the invention is a garbage collection efficiency improving method for performing efficient garbage collection at the time of execution of a target program. Control flow analysis procedure for creating a tree-structured control flow graph having a control flow as an arc and a processing unit as a node, and (B) analysis of memory allocation for each node of the control flow graph. By doing so, the memory layout analysis procedure for adding the memory layout of each node and (C) each node of the control flow graph with the memory layout added are used later because they are alive at the entrance and not at the exit. A reference analysis procedure for finding unresolved references, (D A null pointer assignment procedure for assigning a null pointer indicating that nothing is pointing to the reference in the program so that the unused reference found in the reference analysis procedure is not traced by garbage collection. This includes not following the reference in the program that has been assigned a null pointer in the null pointer assignment procedure when garbage collection is activated.

Furthermore, the garbage collection efficiency improving method of the third invention is the garbage collection efficiency improving method of the first and second inventions, wherein the control flow analysis procedure of the first and second inventions is a static program of the target program. In order to perform a detailed analysis, the basic function of operating each memory area to be collected by garbage collection, the operation of newly allocating the memory area, the operation of reading the value of the memory area, and the value of the memory area It includes using the lambda expression, which is an extension of the modifying operation, as a parsing expression format.

[0010]

Embodiments of the present invention will now be described with reference to the drawings. FIG. 1 is a flow chart showing a first embodiment of the garbage collection efficiency improving method of the present invention. First
The method for improving the efficiency of garbage collection in the embodiment of FIG.
As shown in FIG. 1, first, in the control flow analysis procedure 1, a control flow of a pre-execution program is statically analyzed, and a control flow of a tree structure in which a processing unit is a node and the control flow is an arc. Graph 11 is created.

Then, in the memory layout analysis procedure 2, the memory layout is analyzed for each node of the control flow graph 11 to create the control flow graph 12 to which the memory layout is added. Therefore, the reference analysis procedure 3 finds a reference that is alive at the entrance and not alive at the exit for each node of the control flow graph 12 to which the memory allocation is added, and adds the type of life or death to the reference in the memory allocation. The created control flow graph 13 is created.

Further, the mark insertion procedure 4 marks in the target program according to the control flow graph 13 in which the reference in the memory allocation is added with the type of life or death so that the garbage collection does not follow these references. Are doing Of these, various implementation methods are conceivable particularly for the control flow analysis procedure 1 and the memory allocation analysis procedure 2. The implementation method for each of the above procedures will be described below.

First, the control flow graph 11 created in the control flow analysis procedure 1 is a directed graph, and when an arc exists from the node a as a processing unit to the node b, the processing of the node b is performed by the node a. This indicates that the candidate is a candidate that is performed after the processing. Further, the process of each node may be defined in any way as long as the condition that it does not jump out from the middle of the process or jump into the middle of the process is satisfied.

The control flow analysis is a simple operation for a program that does not pass a procedure as an actual argument of the procedure and does not have a pointer to the procedure. But,
It is not easy for a program to pass a procedure as an actual argument of a procedure, or for a program that has a pointer variable to the procedure. The reason is that when a procedure that is the value of such an argument or pointer variable is called, all the procedures that such argument or variable may have as a value in order to determine the processing to be performed by it. Because I have to ask.

For example, a program created in the LISP language, which is a typical language, has a garbage collection function and often includes a description of passing a procedure (called a function in the LISP language) as an argument.
In general, a complete analysis of all possible values of a variable is an uncomputable problem, so
We will seek a safe approximate solution. This safety means that the reference that is finally used is not erroneously determined not to be used. Conversely, it is acceptable to determine the value of an unused variable as likely to be used.

In the control flow analysis, this corresponds to a solution that takes a lot of processing that may be performed subsequently from a certain position. It should be noted that it is not safe if the actual processing is dropped. The approximate solution is
There are many possible implementations, depending on the ease of calculation and the accuracy of the approximation. The simplest approximation is to call all procedures from a procedure that is the value of a variable. If the procedure call that is the value of such a variable is limited in the program, this method can also be a valid approximation. As an improvement of this method, a method of narrowing down the procedures that may be called can be considered based on the number of parameters and the type information of the procedure call.

After obtaining the safe control flow graph 11, the memory layout analysis procedure 2 analyzes the memory layout for each node of the control flow graph 11. There are several possible methods for implementing this as a safe analysis. FIG. 2 is a diagram showing an example of a reference in a target program and a memory cell. As shown in FIG. 2, the reference 21 in the program points to a cell 24 of the memory, and the reference 22 in the program in the cell 24,
When 23 indicates the cells 25 and 26, the memory layout analysis procedure 2 of the present embodiment does not consider selecting the reference 21 and finding the references 22 and 23 as candidates for the reference to be marked.

The reason for limiting in this way is that processing is easy on the one hand, and marking is executed at the time of execution at a small amount, but it is an overhead. This is because the execution time of the entire program may be lengthened if this is done. By limiting in this way, it is conceivable that all the cells that can be traced from a certain variable are compressed by being represented by the cell that is the value of this variable, as the simplest method for implementing memory allocation analysis.

FIG. 3 is a diagram showing an example of a compression method of the memory configuration in the first embodiment. When the actual memory arrangement has cells 31, 32, and 33 as shown in FIG. 3A, as shown in FIG. 3B, a memory that can be traced from a variable by only one reference. Cells 31, 32
The cell 33 is represented by the cell 32 so that only the cell 33 is shown. As a reference for a more accurate analysis method of such a method, Horwitz, S., et al. Dependence A
nalysis for Pointer Variables. Proceedings of theS
There is IGPLAN '89 pp28-40,1989.

After performing the safe control analysis and the safe memory allocation in this way, the reference analysis procedure 3
As a live variable analysis, a well-known method for finding a fixed point of an equation is used. For references on this specific method, see Aho, and Ullman. Principl.
es of Compiler design. Addison-Wesley (1977) Japanese translation compiler I II, Harada translation science company.

Then, for each node, a reference that is alive at the entrance and not alive at the exit is found, and finally, the mark insertion procedure 4 changes from the state where the reference is alive to the state where the reference is not alive in the program. After that, we mark it with tags so that garbage collection does not follow those references. As an alternative to this marking, there is a method of substituting an empty pointer indicating that nothing is being pointed to. This method has the advantage that it can be implemented without any changes to the garbage collection behavior.

Next, a second embodiment using a method of obtaining a more accurate control flow approximation effective for a LISP language will be described. As a reference for control flow analysis methods for LISP languages that do not have substitutions for variables, see Shivers, O. The semantics o.
f scheme control-flow analysis.the first ACM SIG
PLAN and IFIP Symposium on Partial Evaluation andS
There is emantics-Based Program Manipulation, June 1991, but this second embodiment is an extension of this so as to handle substitution.

First, the call c which is a reference in the program
Is the internal representation of the control flow analysis.
One of the two forms. (F v ₁ v ₂ ... V _n ) (if v f ₁ f ₂ ) (set m v f) (val m f) (new v f) (rec x v c)

Here, m is a memory cell or a variable having a cell as a value, and v is basic data such as a lambda expression or a numerical value, a memory cell or a variable having these as values,
f is a lambda expression, an appropriate primitive function, or a variable whose value is these. Then, as an example of the primitive function, + that performs only addition is used here.

The lambda expression has the following form. _{λx 1 x 2 ...... x n.} c , where the call c is one of the six types of the above, cells of the memory is the pair with the label and its value. Here, a CPS (Continuation Passing Style) lambda format is used in order to reduce cases and improve efficiency. The CPS lambda format is a format in which calculation proceeds without returning all function calls, and may be used as an internal format of LISP languages.

As a reference for such a description, Kran
z, D. et al. ORBIT: An optimizing compiler for Schem
e. SIGPLAN Notices 21 (7), pp 219-223. Association
There is of Computing Machinery, July 1986. Note that this document also describes a method of converting a program of a LISP system language into a CPS lambda format.

The core of the control flow problem of converting to such an internal format is at the time when this call is executed when f is a variable in the call of (f v ₁ v ₂ ... V _n ). Reduce to finding the set of all possible primitive functions and lambda expressions as the value of f. Since finding such a set completely becomes a problem that cannot be calculated, a safe solution is sought. That is, the value that can actually be the value of f is always included in the set, but in reality, a value that is not a value may be included in the set.

Therefore, the control flow analysis is performed in the following procedure. The heart of this analysis is to find all the possibilities for all variables and memory cell values in the program. These values are either basic data such as numbers, primitive functions, lambda expressions or memory cells. If it is elementary data, for example, whether it is 1 or 2 does not affect the result, so both 1 and 2 values of all elementary data types have a single
Will be represented on behalf of.

FIG. 4 is a diagram showing an example of the control flow graph of the second embodiment. As shown in FIG.
The program converted into the internal format can be regarded as a tree structure. The nodes that are the nodes of the tree are calls c1 and c
2, c3 or lambda expressions r1, r2, r3. Therefore, all the news are called from this tree, and the label m of a different memory cell is assigned to the node (new v f). Note that the following description describes the case where different variables do not have the same name for simplicity.

First, a variable table 4 showing all variables
Create 1 and assign an empty set as the initial value for each value in it. Then, a cell table 42 showing labels for all memory cells is created, and an empty set is assigned as an initial value of each value in the cell table 42. FIG. 5 is a diagram showing a first example of content changes regarding the variable table 41 of the second embodiment. In addition, FIG. 6 is a diagram showing a first example of content changes regarding the cell table 42 of the second embodiment. On the other hand, FIG.
It is a figure which shows the example of. Further, FIG. 8 shows the variable table 4
It is a figure which shows the 2nd example of the content change regarding 1).

Next, while following the tree of FIG. 4 from top to bottom, the following operation is performed and repeated until all Def and Val are unchanged. (1) When the node is called (f v ₁ v ₂ ...... v _n ), as shown in FIG. 5, the lambda expression (λx ₁ x ₂ ...... x _n. C) included in Def (f) is used _. On the other hand, Def (v ₁ ) is added to the set of values of x ₁ of the variable table 41, Def (v ₂ ) is added to the set of values of x ₂ , and Def is added to the set of values of x _n. (V _n ) is added. When v is other than a variable, Def (v) represents {v}.

(2) When the node is called (new v f), as shown in FIG. 6, Def is set to Val (m) for the memory cell m assigned to this new.
Add (v). Here, the label of Val (m) is m
Represents a set of values of memory cells. Also, Def
A memory cell m is added to the set of values of x in the variable table 41 for all lambda expressions (λx.c) included in (f). (3) When the node is called (set m v f), as shown in FIG. 7, for all memory cells n included in Def (m), Def is set to the set of values of n in the cell table 42. Add (v).

(4) When the node is called (val m f), as shown in FIG. 8, the set Def (f)
Val (m) is added to the set of values of x in the variable table 41 for all lambda expressions (λx.c) included in. (5) When the call has the node (rec x v c), Def (x) is added to Def (x) and any of the above operations is performed depending on the form of the call c.

(6) When the node is a call (if v f ₁ f ₂ ), (f ₁ ○) is placed at the position of this node.
It is assumed that there are two calls, and (f ₂ ○), and both of these operations are performed. (7) If the node is a lambda expression, do nothing. Due to the above, Def and Val monotonically increase, and the number of elements included in the set is either ◯, the lambda expression existing in the program, or the first given memory cell, so the number is finite. Be sure to finish the above repetition.

The results of the control flow analysis are as follows. (1) From (f v ₁ v ₂ ... V _n ), Def
Any one of (f) is executed. (2) From (if v f ₁ f ₂ ), Def (f
Either ₁ ) or Def (f ₂ ) is executed. (3) From (set m v f), one of Def (f) is executed.

(4) From (val m f), Def
Any of (f) is executed. (5) One of Def (f) is executed from (new v f). (6) From (+ vvf), one of Def (f) is executed. (7) From (rec x v c), c is executed. (8) from _{(λx 1 x 2 ...... x n} . C) is, c is executed.

[0037]

As described above, the method for improving the efficiency of garbage collection of the present invention points out references that are no longer traced, so that the load at the time of executing garbage collection is slightly increased, but it can be used any longer. Since it is possible to reduce the tracing of non-relevant references, it is possible to collect more memory area by executing garbage collection once. Therefore, the garbage collection efficiency improving method of the present invention has the effect of reducing the number of times garbage collection is started at the time of execution and shortening the execution time of the entire program.

Furthermore, the method for improving the efficiency of garbage collection according to the present invention reduces the maximum value of the required memory, which is particularly advantageous for shortening the execution time in the execution environment of the virtual memory system, and is good for garbage collection. Regardless of the mark-and-sweep method or the copy method used, the smaller the number of memory areas that follow the reference, the shorter the execution time of garbage collection, which is also advantageous in this respect.

[Brief description of drawings]

FIG. 1 is a flow chart showing a first embodiment of a method for improving the efficiency of garbage collection of the present invention.

FIG. 2 is a diagram showing an example of a reference in a target program and a memory cell.

FIG. 3 is a diagram showing an example of a compression method of a memory configuration in the first embodiment.

FIG. 4 is a diagram showing an example of a control flow graph of the second embodiment.

FIG. 5 is a diagram showing a first example of a change in contents of a variable table 41 of the second embodiment.

FIG. 6 is a diagram showing a first example of changes in contents of the cell table 42 of the second embodiment.

FIG. 7 is a diagram showing a second example of content changes regarding the cell table 42.

FIG. 8 is a diagram showing a second example of content changes regarding the variable table 41.

[Explanation of symbols]

1 Control Flow Analysis Procedure 2 Memory Allocation Analysis Procedure 3 Reference Analysis Procedure 4 Mark Insertion Procedure 11 Control Flow Graph 12 Control Flow Graph with Memory Allocation 13 Control Flow Graph with Reference to Life in Memory Allocation 21 22, 23 Reference 24, 25, 26, 31, 32, 33 Cell 41 Variable table 42 Cell table c1, c2, c3 Call r1, r2, r3 Lambda expression

Claims (3)

[Claims] 1. A garbage collection efficiency method for performing efficient garbage collection when a target program is executed, comprising: (A) statically analyzing a control flow of a program before execution, and setting a processing unit as a node. A control flow analysis procedure for creating a control flow graph having a tree structure with a control flow as an arc, and (B) analysis of memory allocation for each node of the control flow graph to add the memory allocation of each node. A memory allocation analysis procedure, and (C) a reference analysis procedure for finding a reference that is not used later because it is alive at the entrance and not at the exit for each node of the control flow graph with the memory allocation added, ) Garbage unused references found in the reference analysis procedure above By including a mark insertion procedure for marking the reference in the program so that it is not traced in the collection, and when garbage collection is activated, in the program marked by the mark insertion procedure. The method for improving the efficiency of garbage collection, characterized in that the reference is not traced. 2. In a garbage collection efficiency method for performing efficient garbage collection at the time of execution of a target program, (A) statically analyzing a control flow for a program before execution, and processing units as nodes, A control flow analysis procedure for creating a control flow graph having a tree structure with a control flow as an arc, and (B) analysis of memory allocation for each node of the control flow graph to add the memory allocation of each node. A memory allocation analysis procedure, and (C) a reference analysis procedure for finding a reference that is not used later because it is alive at the entrance and not at the exit for each node of the control flow graph with the memory allocation added, ) Garbage unused references found in the reference analysis procedure above A null pointer assignment procedure that assigns an empty pointer indicating that the reference in the program is pointing to nothing so that it is not followed by a collection. A method for improving the efficiency of garbage collection, characterized in that the reference in the program assigned an empty pointer in the pointer assignment procedure is not followed. 3. The control flow analysis procedure according to claim 1, wherein the memory is a basic function of operating each memory area collected by garbage collection in order to perform static analysis of a target program. An operation of newly allocating an area, an operation of reading the value of the memory area,
3. The method of improving garbage collection efficiency according to claim 1, wherein a lambda expression that is an extension of the operation of changing the value of the memory area is used as an expression format for analysis.