JP2002312179A - Method for determining number of register to be allocated - Google Patents

Abstract

PROBLEM TO BE SOLVED: To effectively use registers left over, when an end function in a function call is executed in an architecture having a register stack. SOLUTION: After conventional register allocation is executed, the calling relation for functions and the number of registers required are examined, and when there are unused registers, these registers are reallocated within a range which do not cause register shortage in the execution of the other functions.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a method of applying register allocation in an optimizing compiler, and more particularly to a method of determining the number of register allocations for improving the application of other optimizing processes in a compiler.

[0002]

2. Description of the Related Art Many modern computer architectures are equipped with a large number of registers. Some of the architectures have a register stack that uses a register as a stack. Intel processors have a register stack for some registers. The structure of this register stack is described in “Intel, IA-64 Application Dev.
eloper's Architecutre Guide, 1999, section 4.1, which is hereby incorporated by reference.

The compiler's register allocation technique has been developed mainly for architectures that do not have a register stack function. Register allocation techniques can be broadly classified into two types. One of them is a method (method A) aimed at allocating as few registers as possible to a certain fixed range of a program, for example, a procedure or a loop. Such a method is discussed in Section 12.5 of "Ikuo Nakada, Compiler Configuration and Optimization, Asakura Shoten, 1999". This part is incorporated herein by reference. In these methods, efficient allocation can be performed for the register allocation unit, but there is no guarantee that the optimization is performed in a larger unit such as the entire program. Further, since there is no transfer of register allocation information between register allocation target portions, it is difficult to maximize the use of registers that can be used in an architecture for executing a program.

On the other hand, "Vatsa Santhanam et al., Register
allocation across procedure andmodule boundarie
s., SIGPLAN90 ”, etc., proposes a method (method B) of performing inter-procedure analysis before register allocation and performing register allocation in large units beyond procedures based on the information. In this method, registers are allocated after collecting information on variables in the entire program.
Registers can be efficiently allocated to each procedure.

[0005] As one of the program analysis information used by the compiler, there is information on a call relationship between functions or procedures. One of the techniques for expressing this information is a call graph. The call graph is a graph structure in which each function is a node of the graph and edges are connected from the function caller to the callee. For the call graph, see "DFJerding et. Al, Visualizing inte
ractions in programexecutins., ICSE97 ". This part is incorporated herein by reference.

[0006]

In the conventional register allocating method A, physical registers may be left at the end of register allocation of the entire program. However, allocating more registers to the program may facilitate the application of other optimizations and improve program execution performance.

Further, if a method of allocating a register for optimization in addition to the required number of registers in advance is adopted,
When allocating registers for the rest of the program,
A register shortage occurs, and a save / restore code for the register contents is created, which may worsen the execution performance of the program.

In the conventional register allocation method B, prior to register allocation, it is necessary to perform live information of each variable of a program across procedures, which requires a considerable amount of time for analysis.

An object of the present invention is to solve the problem that the number of registers required for the entire program is smaller than the total number of registers.
An object of the present invention is to provide a method of effectively using registers while reallocating surplus registers to respective parts of a program while reducing the time required for analysis between procedures.

[0010]

The above object is achieved by performing a reassignment process of available registers after the application of the conventional register allocation process, when there are remaining available registers. (1) Allocate registers to the processing units of the program. (2) The following processing is performed only when unassigned registers remain. (3) Create a call graph representing the dependencies of the procedures in the program. (4) Reassign unassigned registers. (5) If necessary, repeat the process (4).

By this processing, the number of unallocated registers can be minimized, so that application of other optimization processing is promoted, and high-speed execution of the program becomes possible.

[0012]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below with reference to the drawings.

The following description does not limit the application of the present invention.

FIG. 1 is a schematic configuration diagram showing a computer system to which the present invention is applied. The method for determining the number of register allocations according to the present invention is implemented in an optimizing compiler, stored in the main storage 102 or the disk device 103, and
Executed in U101.

FIG. 2 shows a configuration of an optimizing compiler in which the present invention is implemented. The program 201 is input to the optimizing compiler 202 and converted into, for example, an object code 206 executed by the computer shown in FIG. The optimizing compiler 202 performs preprocessing such as syntax analysis 203 on the input program 201, and generates an intermediate language 204. After that, an optimization process 205 is performed on the intermediate language 204 to generate an object code 206.

FIG. 3 shows the configuration of the register allocator 301 in the optimization processor 205.

The register initial allocation unit 302 divides the input program 305 into program pieces in units of register allocation, and allocates registers to the program pieces. As a result, register allocation information 306 such as the minimum number of required registers for each function is obtained.

The call graph creation unit 303 includes a call graph 30 representing a function calling relationship with respect to the entire program.
Create 7.

The register reallocation unit 304 allocates unused registers to appropriate functions using the register allocation information 306 and the call graph 307. Processing 302, 303
All the processes performed in the above use the existing technology as it is.

In the following, a description will be given of the register reallocation unit 304, which is a characteristic process of the present invention.

FIG. 4 is a flowchart showing the operation of the register reassignment unit 304 in FIG. The inputs to the register reassignment unit are the register assignment information 306 and the call graph 307 in FIG.
In the following description, a node having no caller function node among the nodes of the call graph is called a root node, and a node having no callee function node is called a leaf node.

In the process 401, the sum of the last node set and the number of unused registers on the route is obtained. Note that the end node is a leaf node that has no circulation path from the root node to the leaf node.

In step 402, a set of functions to be reallocated, which is a set of functions that are candidates for allocating unused registers obtained in step 401, is obtained.

In the process 403, the unused registers obtained in the process 401 are reassigned to the candidate functions obtained in the process 402, and a new register allocation number is obtained.

In the process 404, the above process is repeated until the number of allocated registers no longer changes. However, this repetition can be terminated depending on factors such as the compile time.

FIG. 5 is a flowchart showing an example of the process 401.

By the process 501, the processes from the process 502 to the process 505 are applied to each leaf node.

In the process 502, if there is a circulation route on the route from the root node to the leaf node to be processed, the route is excluded from the process target. This is because, when a circulation path appears in the call graph, the number of required registers at the time of executing the function of the leaf node cannot be specified.

In step 503, the number of unused registers at the time of executing the leaf node is obtained. This can be obtained by subtracting the total number of required registers of the nodes (functions) on the path from the root node to the leaf node from the total number of registers. However, if it is 0 or less, it is set to 0.

In the process 504, when there is no unused register, the route is excluded from the target of the process.

In the process 505, if there is an unused register, the leaf node being processed is registered in the end node set in order to remember the route. In Steps 506 and 507, all nodes are marked in advance in Step 507 to determine whether the node is a target of register reassignment, and those that do not satisfy the conditions are excluded in Step 506. .

FIG. 6 is a flowchart showing an example of the processing of the processing 402. By the process 601, the processes 602 and 603 are applied to each function. In the process 602, it is checked whether or not all the nodes corresponding to the function to be processed have the mark added in the process 505. If there is at least one node without a mark, the function is removed from the re-allocation target, and in step 603, the marks on all nodes corresponding to the function are removed. Also, in the processes 604 and 605, if the node whose mark is to be removed is included in the last node set, the node is removed from the set. If all the corresponding nodes are marked, in process 606, they are registered in the reassignment target function set.

FIG. 7 is a flowchart showing an example of the process 403.

In the processes 701 and 702, an unused register corresponding to the route is allocated to the reassignment target node on the route from the root node to the last node. Note that, here, unused registers are evenly allocated to the reassignment target nodes.
When profile information and the like can be used and a priority can be assigned to a function by an execution frequency or the like, the number of allocations can be set according to the ratio of the priority.

In steps 703 and 704, new register allocation numbers are obtained for all the reallocation candidate functions.

If there are a plurality of nodes in the corresponding call graph, in this embodiment, the minimum value of the allocation value of each node is selected. This makes it possible to prevent the number of assignments from exceeding the total number of registers even for an assignment to a function having a plurality of call points. Further, in the present processing, when priority is given to a specific route of the call graph, it is possible to select a value of a node included in the route. Finally, the sum of the allocation value and the current number of allocated registers is set as a new register allocated number.

The above-described method for determining the number of registers to be assigned is applied to a simple example, and its functions and effects are confirmed.

A program having a function shown in FIG. 8 is taken as an example. Column 801 is the name of the function. Here, it is assumed that eight functions from A to H are defined. Column 802 is a set of functions called by the function. For example, function A is
Call B, D, F, G. It is assumed that as a result of register allocation for these programs by the process 302, the number of register allocations for each function becomes the number shown in the column 803. It is assumed that the computer on which this program is executed has 100 registers.

FIG. 9 shows a call graph for this program created by the process 303. In this call graph, the root node is 901, the leaf node is 903,
905, 908 and 912.

The following is an example of processing performed by the register reallocation processing unit 305. First, the process 401 is applied. Therefore, the processes 502 to 505 are applied to each leaf node. In the processing of leaf node 903, root node 9
Since there is no circulation path on the path to 01 and the number of registers required when executing the function of the node 903 is 85 (50 + 30 + 5), there are 15 unused registers. Therefore, node 903
Is registered in the tail node set. In the processing of the leaf node (911, since the path of the call of the node 909 (function G) is on the path, the marks of the functions to be reassigned are removed from all the nodes on the path. Is shown in Fig. 10. Note that the asterisk (*) at the right shoulder of the node in the figure indicates the mark of the function to be reassigned, and the number in parentheses indicates the path to the leaf node. The number of unused registers is shown, and nodes 1003, 1005, and 1008 are registered in the last node set at this time.

Next, the processing shown in FIG. 6 is applied to the result shown in FIG. The node for the function D has two nodes 1004 and 1011, and since the node 911 has no mark, the mark of 1004 is also removed. In the function C, since the corresponding nodes 1003 and 1008 are both marked, they are added to the reassignment target function set. Similarly, when processing for another function is performed, the result of FIG. 11 is obtained. Also,
Functions B, C, F
Is registered.

Next, the processing shown in FIG. 7 is applied to the result shown in FIG. By the processing shown in FIG. 5, the nodes 1103 and 1108 are obtained as the end node set. In the processing of the node 1103, there are 15 unused registers, and the relocation marks on the route are the nodes 1102 and 1103, so that seven nodes 1102 and eight nodes 1103
Is allocated. Similarly, in the processing of the node 1108, the node 1108
3 is allocated to 1106, 3 is allocated to the node 1107, and 4 is allocated to the node 1108. Next, in steps 703 and 704, a final reassignment value of the reassignment candidate function is obtained. From the process 704, the final allocation value of the function B is the minimum value of 3, and the new allocation number is 33. In addition, the number assigned to function C is 9,
The number assigned to f is 8.

Thus, the process 401 to the process 403 are completed.
When this process is repeated in process 404, no change occurs in the number of assignments for the second time, and thus the process ends.

FIG. 12 shows the final result for this example. A column 1203 indicates the number of allocated registers obtained by applying this processing. This result guarantees the path where the number of registers used is less than the total number of registers before application, and also guarantees the minimum required value before processing for the path where the number of registers used is larger than the total number of registers. ing.

[0045]

According to the present invention, in the conventional register allocation process, unused registers can be allocated to appropriate functions, thereby promoting the application of other optimizations and increasing the number of functions. Optimization can be applied. Thus, the execution time of the computer program can be reduced.

[Brief description of the drawings]

FIG. 1 is a schematic configuration diagram of a computer system in which an optimization application method according to the present invention is executed.

FIG. 2 is a schematic configuration diagram of an optimizing compiler on which the optimizing application method according to the present invention is implemented.

FIG. 3 is a schematic configuration diagram giving an overview of a register allocation number determination method according to the present invention.

FIG. 4 is a flowchart illustrating an operation of a register reallocation processing unit.

FIG. 5 is a flowchart for obtaining a tail node set.

FIG. 6 is a flowchart for obtaining a reassignment candidate function set.

FIG. 7 is a flowchart of a reassignment number determination process.

FIG. 8 is a schematic diagram of a program taken as a specific example.

FIG. 9 is a diagram showing a call graph for the program taken up in FIG. 8;

FIG. 10 is a diagram showing a call graph obtained by applying the processing of FIG. 5 to the call graph of FIG. 9;

11 is a diagram showing a call graph obtained by applying the processing of FIG. 6 to the call graph of FIG.

12 is a diagram showing the number of assignments obtained as a result of applying the processing of FIG. 7 to the call graph of FIG. 11;

[Explanation of symbols]

101 CPU, 102 main memory, 103 disk device, 201
Source program, 202 ... optimizing compiler, 206 ... object.

Claims (5)

[Claims] 1. A processing method for determining the number of registers to be allocated in an optimizing compiler, comprising the steps of: a) allocating registers to each partial program so as to minimize the required number of registers; and b) creating a call graph. And c) reallocating unused registers when there is an unused register on a certain path in the call graph;
Method for determining the number of allocated registers. 2. The method for determining the number of allocated registers according to claim 1, wherein:
A method for determining the number of allocated registers using a set of registers. 3. A processing method for deciding the number of register allocations in an optimizing compiler for an architecture having a function capable of restricting registers available for a part of a program, the register allocation comprising each step of claim 1 A method of determining a number, wherein the number of registers is determined by using the number of registers available to a program part for managing the number of registers. 4. A compiler that performs processing using the method for determining the number of registers to be allocated according to claim 1. 5. A medium storing the implementation of the method for determining the number of registers allocated according to claim 1.