JPH11184710A - Device and method for optimizing real argument of partial arrangement - Google Patents

Abstract

PROBLEM TO BE SOLVED: To attain shortening in execution time by omitting the allocation of a memory area and the copy of a value as much as possible when linking the number of partial arrangement execution and temporary argument arrangement by generating an optimizing code, to which the area allocation is connected, based on area allocation omission enable conditions. SOLUTION: A source program is inputted to an optimizing device 1 of a compiler and concerning the area allocated to the arrangement of respective arguments, a translation time continuity discriminating means 2 discriminates continuity. Based on the discriminated result of the translation time continuity discriminating means 2, an individual output code generating means 31 generates an output code for allocating the area to each real argument of partial arrangement. A memory allocation connection code generating means 32 generates an optimizing code reducing the number of times of memory allocation by connecting the allocated areas out of the output of the individual output code generating means 31. In this case, when it is possible to generate the allocation of plural memories, a code is generated by simultaneously connecting them to one memory allocation.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to optimization of a Fortran compiler, and more particularly to an apparatus and a method for optimizing by allocating and omitting an area allocation when combining a partial array actual argument and a dummy argument array.

[0002]

2. Description of the Related Art Conventionally, when a partial array actual argument is combined with a dummy argument array, an area corresponding to the size of the partial array is newly allocated, a value is copied to the area, and then the called procedure is executed. The method of passing was used. Referring to FIG. 6, which shows a conventional compiled code, the entire array A (100,
100), B (100, 100), C (100, 10)
0) (line number 601), the partial array A (1:10
0,5), B (X, 8), C (5,1: 100), TMP1, TM
The area of P2 and TMP3 is taken (line numbers 602 to 60
8), each partial sequence is allocated as SUB2 (TMP1, TMP2, TMP3) (line number 609). However, in this method, since the areas are individually taken, each time a procedure having a partial array actual argument is called, an overhead of memory allocation and copying of a value occurs, and thus the execution performance of the program is reduced.

[0003]

The first problem is that every time a procedure having a partial array actual argument is called, an overhead for memory allocation and copying of a value occurs, thereby deteriorating the execution performance of the program. It is. The reason is that when combining a partial actual argument with a dummy argument array,
This is because an area of the size of the partial array is newly allocated, the value is copied there, and the start address of the newly allocated area is passed to the called procedure.

SUMMARY OF THE INVENTION In view of the above, it is an object of the present invention to optimize the execution of a partial array actual argument by associating a memory area and copying a value as much as possible when combining an actual argument with a dummy argument array. Is to shorten.

[0005]

SUMMARY OF THE INVENTION Therefore, according to the present invention,
By compiling the Fortran language and omitting and concatenating the area allocation when combining the subarray actual argument in the source program with the dummy argument array, the subarray actual argument optimization device that generates the optimized source code can be used. A translation continuity judging unit for judging an omission condition of the region allocation of the partial sequence; and a code generating unit for generating an optimized code in which the region allocation of the partial sequence is linked. Comprises: an individual output code generating means for allocating an area to the partial array; and a memory allocation concatenated code generating means for concatenating the area allocation based on the area allocation omission condition. I do.

[0006] The partial array actual argument optimizing device, when combining the partial array actual argument with the dummy argument array,
This is possible by judging whether or not they are arranged consecutively in the memory area of the parent array, outputting an execution code corresponding to the judgment result, and linking a plurality of memory allocations to combine them at once. As far as possible, allocation of a memory area and copying of a value to the memory area can be omitted.

[0007]

BEST MODE FOR CARRYING OUT THE INVENTION
This will be described with reference to the drawings. Referring to FIG. 1 showing the best mode of the present invention, a partial array actual argument optimizing device 1 includes a translation run determination unit 2 and an output code generation unit 3. The output code generation means 3 includes the translation continuity determination means 2
From the output of the individual output code generating means 31 for generating an output code for allocating an area to each partial array actual argument based on the determination result of
A memory allocation concatenated code generating means 32 for generating an optimized code in which the allocated areas are concatenated to reduce the number of memory allocations. The method performed in this embodiment will be described with reference to FIG. 2. Referring to FIG. 2, a step 200 of inputting a source program, and an optimization based on an omissible condition of area allocation when compiling and optimizing the source program A translation continuity determination step 201 for determining the possibility, a code generation step 202 for generating an individual output code according to the result of the determination, and a memory allocation connection code generation step 2 for connecting and optimizing the individual output codes
03, and outputting 204 the optimized code, wherein the subarray actual argument is stored in the memory area of its parent argument,
The omission condition for judging whether or not they are continuously arranged is determined, and the allocation area is omitted as much as possible, and optimization for reducing memory allocation and value copying is performed.

In this method, when a partial array is referred to as an actual argument, first, a source program is input to the optimizing device 1 of the compiler (step 200). The translation continuity determining means 2 of the apparatus 1 determines continuity of the area assigned to each argument array (step 2).
01). The judgment is as follows: (1) The memory area of the partial array is statically continuous.

(2) The memory area of the partial array is statically discontinuous.

(3) It is not possible to statically judge whether the memory area of the partial array is continuous or discontinuous.

There are three cases.

In the above determination, when the number of dimensions dmy_rnk partial array A ′ is an actual argument, the number of dimensions of the parent array A is act_rnk, and the lower and upper limits of the declaration of the i-th dimension of array A are respectively act_lb (i), act_
When ub (i) is set, continuity is determined by whether or not the sequence A and its partial sequence A ′ satisfy all of the following conditions.

The ith dimension of the subarray actual argument A ′ of the array A is as follows: (a) If 1 ≦ i <dmy_rnk, the subscript selected by the subscript specification of the subarray is act_lb (i)
To act_ub (i) by one.

If there is a subsequence range reference, the length of the subsequence is equal to the size of each element.

(B) If i = dmy_rnk, the subscript to be selected is incremented by one according to the subscript designation of the partial array.

If there is a subsequence range reference, the length of the subsequence is equal to the size of each element, unless the dimension of the i-th dimension is 1.

(C) If i> dmy_rnk, a single subscript is specified. The obtained classification of the partial array argument is input to the output code generation means 3.

In the output code generation means 3, the individual output code generation means 31 generates an individual code based on the determination result of the translation continuity determination means 2 (step 20).
2).

According to the above classification, (1) When the memory area of the partial array is statically continuous,
Output code that calculates the address of the first element in the array element order of the subarray, starts from that address, and combines the memory area with the size equal to the size of the subarray as the actual argument with the corresponding dummy argument Generate

(2) When the memory area of the partial array is statically discontinuous, memory allocation and value copying are performed as before, and the size of the partial array starts from the start address of the newly allocated area. Generates an output code to combine a memory area equal to the size of the actual argument with the corresponding dummy argument.

(3) If it is not possible to statically determine whether the memory area of the partial array is continuous or discontinuous, it is determined at execution time whether the memory area of the partial array is continuous. If it is continuous, calculate the address of the first element in the array element order of the subarray, start from that address, and combine the memory area whose size is equal to the size of the subarray as the actual argument with the corresponding dummy argument Generate output code to be generated. If it is discontinuous, after allocating memory and copying the value as before, a memory area whose size is equal to the size of the partial array, starting from the start address of the newly allocated area, Generate output code to be combined. The output code of the individual output code generation means 31 is input to the memory allocation concatenated code generation means 32. If there is a possibility that a plurality of memory allocations may occur in the output code of the individual output code generation unit 31, the memory allocation connection code generation unit 32 generates a code in which the allocations are collectively connected to one memory allocation (step 203). ).

An embodiment of the method for optimizing a partial array actual argument will be described with reference to the drawings. This optimization method is based on the source code 30 shown in FIG.
L A (100, 100), B (100, 100), C
For (100, 100) (line number 301), SUB2
(A (1: 100,5), B (X, 8), C (5: 1:
100) (line number 302) is used in a procedure call having a partial array actual argument. The method will be described with reference to FIG. 2 showing the processing flow of this method, with reference to FIGS. 3, 4, and 5. This method assumes that the source code 30 is partially compiled. Therefore, the value of each element of the integer type array X is
Statically unknown. The translation-time continuity determination unit 2 determines whether the subroutine SUB2 (A (1: 100,5), B (X,
8), C (5, 1: 100)) (line number 302), the following classification is performed on each subarray actual argument (step 201). (1) The partial array actual argument A (1: 100, 5) has a continuous memory area. (2) Regarding the partial array actual argument B (X, 8), it is statically unknown whether or not the memory area is continuous. (3) The partial array actual argument C (5, 1: 100) has a discontinuous memory area. According to the above classification, the individual output code generation unit 31 determines the execution result of the argument (B (X, 8) in this embodiment) for which the continuity of the memory area cannot be statically determined (the determination criterion is: (Same as at the time of translation), and outputs a code in which a memory is allocated for the case of a discontinuous partial array and a copy of the value of the actual argument is inserted (step 202). FIG. 4 shows an example in which the code is described in the Fortran language. At the time of execution, it is determined whether or not each element of the argument B (X, 8) in the individual output code 40 is arranged in a continuous memory area. If the element is discontinuous (line number 401), B (X, 8) ) And C (5: 1: 100)
Corresponding to the temporary regions TMP1, TMP2
(Line numbers 402 and 404) and B to that area
The values of (X, 8) and C (5,1: 100) are copied, and TMP1 and TMP2 are copied to B (X, 8) and C (
It is combined with the formal argument corresponding to (5, 1: 100) (line numbers 408, 409). If it is continuous (line number 411),
Temporary area TMP corresponding to only C (5: 1: 100)
1 (line number 412) and C (5,
1: 100) and copy TMP1 to C
It is combined with the dummy argument corresponding to (5, 1: 100) (line number 416).

Further, using the individual output code as an input,
The memory allocation concatenated code generation unit 32 outputs a code in which the number of memory allocations is reduced by combining a plurality of memory allocations into one (step 203). With this individual output code as an input, the memory allocation concatenated code generation means 32 outputs a code optimized by reducing the number of memory allocations by combining a plurality of memory allocations into one (step 203). FIG. 5 shows the optimized code described in the Fortran language. In this optimized code 50, the second argument B (X,
8) The two memory allocations corresponding to B (X, 8) and C (5,1: 100), respectively, which occur when each element is arranged discontinuously in the memory area, are linked. (Line numbers 402 and 404) Optimized for one memory allocation (Line number 502).

[0024]

The first effect is that the execution time of the program is reduced. The reason for this is that when combining a partial array actual argument with a dummy argument array, allocation of a memory area and occurrence of value copying are reduced as much as possible.

[Brief description of the drawings]

FIG. 1 is a diagram showing an embodiment of the present invention.

FIG. 2 is a flowchart showing execution of a method according to the embodiment.

FIG. 3 is a source code used to explain optimization in this embodiment.

FIG. 4 is an example of a code output by an individual output code generation unit of FIG. 1;

FIG. 5 is an example of an optimized linked code output by the memory-allocated linked code generation unit of FIG. 1;

FIG. 6 is an example of a conventional output code.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Subarray actual argument optimization device 2 Translation continuity judgment means 3 Output code generation means 31 Individual output code generation means 32 Memory allocation concatenated code generation means

Claims (3)

[Claims] 1. Compiling a Fortran language and omitting and concatenating an area allocation when combining a subarray actual argument in a source program with a dummy argument array,
In a partial array actual argument optimizing apparatus for generating optimized source code, an optimizing unit that connects a translation continuity determining unit that determines an area allocation omission condition of the partial array and an area allocation of the partial array Code generating means for generating a code, wherein the code generating means links the individual output code generating means for allocating an area to the partial array, and the area allocation based on the area allocation omitting condition. And a memory allocation concatenated code generating means. 2. Compiling a Fortran language and omitting and concatenating an area allocation when combining a partial array actual argument in a source program with a dummy argument array,
In the method of optimizing a partial array actual argument for generating an optimized source code, a step of inputting a source program and, when compiling the source program, omitting an area allocation due to continuity of an area allocation of the partial array actual argument A translation continuity determination step of determining a possible condition; a code generation step of allocating an area to each of the partial array actual arguments; and a memory allocation connection code generation step of connecting the allocation areas of the partial array based on the determination. And outputting an optimization code in which the allocation regions of the subarray actual arguments are connected. A method for optimizing a subarray actual argument. 3. A storage medium for recording a computer-readable program for executing each step of the optimization method.