JPH06214800A - Optimum processing system of object program - Google Patents

Abstract

PURPOSE:To improve the performance of the compiler of a computer with a vector arithmetic function. CONSTITUTION:A system is the optimum processing system of an object program for executing optimization by in-line expansion at the time of compiling so as to generate the object program for the computer with the vector arithmetic function and it is constituted by providing a procedure call analyzing part 9 detecting that calling out of procedure appeared in the unit of translation at the time of in-line expansion is the call of character operation procedure which the system offers and an object selecting part 10 selecting one of a scholor instruction for minimizing execution time of character operation procedure or the vector instruction as an object which detected by the procedure calling-out analyzing part 9 offers and used for the in-line expansion of character operation procedure.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compilation technique for translating a source program written in a high-level programming language such as FORTRAN or C into a target program in a machine-oriented language such as a machine language, and more particularly to a supercomputer. An ultra-high-speed computer for scientific and technological calculations called
The present invention relates to a target program optimization processing system suitable for generating a target program in which a character string operation procedure is efficiently optimized in a computer that performs vector calculation.

[0002]

2. Description of the Related Art Conventionally, a compiler has been "optimized" in order to translate a source program into an efficient target program. This optimization includes optimization that shortens the program execution time and optimization that reduces the required storage capacity. In particular, optimization for shortening the execution time is an important technique for increasing the processing speed of the computer. As a conventional technique for reducing the execution time, for example, Ikuo Nakata, "Compiler" (1985)
In some cases, inline expansion as described on page 220 of Sangyo Tosho Co., Ltd. is used. This is to reduce the number of calculations by expanding the main body of the procedure in the place where the procedure is called in the intermediate language, omitting many processes required to execute the procedure call.
The execution of procedure calls can be sped up.

However, this technique does not consider a system having a vector processor, and only a scalar instruction is used in a computer for vector calculation such as a super-high-speed computer for scientific and technological calculation called a super computer. In this case, there is a problem that the execution time of the inline expansion object for the character string reading procedure may be longer than that when the vector instruction is used.

C language source program (3) shown below
The compiling operation according to the conventional technique will be described with reference to the example of FIG.

In the case of compiling the C language source program (3), the function "memcpy" is inline expanded using only scalar instructions. This function “memcpy” changes the storage area specified by the second argument (source) from the storage area specified by the first argument (dest) to the third storage area.
The number of bytes specified by the argument (1000) is copied. If this function "memcpy" is expanded inline using only scalar instructions, the scalar machine instruction that transfers bytes between storage areas has a limit on the number of bytes that can be transferred at one time. It must either be repeated with, or it must be an object that enumerates the relevant machine instructions. Therefore, the optimization for speeding up the execution of the target program was not sufficient.

[0006]

The problem to be solved by the prior art is that the prior art does not consider the use of vector instructions in the inline expansion at the time of compiling a source program. In addition, it is not possible to efficiently optimize a program in a system having a vector processor. An object of the present invention is to solve these problems of the prior art and to provide an optimization processing system for a target program which makes it possible to speed up a target program used in a computer having a vector operation function and improve the performance of a compiler. That is.

[0007]

In order to achieve the above object, an optimization processing system for an object program according to the present invention comprises:
When compiling a source program into a target program for a computer having a vector operation function, the intermediate language generated from the source program is optimized by inline expansion. Used for inline expansion of a procedure call analysis unit that detects that a procedure call that appears in a unit is a call of a system-provided character manipulation procedure, and the system-provided character manipulation procedure that is detected by this procedure call analysis unit. As an object, an object selection unit for selecting either a scalar instruction or a vector instruction that minimizes the execution time of the character operation procedure is provided.

[0008]

In the present invention, when the character operation procedure is expanded inline, the number of characters to be operated by the corresponding procedure is taken into consideration, and the execution time is increased when only the scalar instruction is used or when the vector instruction is used. Choose to create short objects. For example, a character manipulation function that handles a large number of characters is expanded inline using vector instructions.
In this way, by inline expanding the character operation procedure using the vector instruction, it is possible to speed up the execution of the object program of the computer having the vector operation function.

[0009]

Embodiments of the present invention will now be described in detail with reference to the drawings. FIG. 1 is a block diagram showing an embodiment of a configuration relating to the present invention of an optimization processing system for an object program of the present invention. In the figure, 1 is a C language source program to be compiled, 2 is a compiler for compiling the C language source program 1, and 3 is a target program of the C language source program 1 compiled by the compiler 2. The compiler 2 includes a source analysis unit 4 that generates an intermediate language from the C language source program 1,
An intermediate language optimizing unit 5 that performs optimization according to the present invention of the intermediate language generated by the source analyzing unit 4 and various data appearing in the intermediate language optimized by the intermediate language optimizing unit 5 On the other hand, a storage area allocating section 6 for allocating addresses in the storage area, a register allocating section 7 for allocating actual resources to data appearing in the optimized intermediate language, and a target program 3 generated from the optimized intermediate language. It is configured by the target program output unit 8.

Further, the intermediate language optimizing section 5 checks the procedure appearing in the translation unit to be a call of a character operation procedure provided in advance by the system, and a procedure call analyzing section 9 according to the present invention. An object selecting unit 10 according to the present invention for selecting a scalar instruction or a vector instruction to be output as an object so as to minimize the execution time of the character operation procedure, and an optimization processing unit 11 for performing various optimizations. It is composed by.

In the object program optimizing system of this embodiment having such a configuration, the compiler 2 reads the C language source program 1 from the storage device and generates a predetermined object program 3 on the storage device. At this time, each unit shown in FIG. 1 performs the following processing. That is,
The source analysis unit 4 analyzes a sentence of the read C language source program 1 and develops it into an intermediate language. Then, the intermediate language optimization unit 5 performs various optimizations on the intermediate language and changes the intermediate language in order to generate the efficient target program 3. Further, the storage area allocating unit 6 allocates addresses in the storage area to various data appearing in the intermediate language. The register allocating unit 7 allocates a register to the data appearing in the intermediate language. The target program output unit 8 generates a machine instruction, optimizes it at the instruction word level, and then outputs it to the storage device.

In hardware equipped with a vector processor, improving the utilization rate of the vector processor is the key to improving the program execution speed. For example,
In a procedural language such as the C language as in this embodiment, the system often provides a character operation procedure as a library. However, by performing inline expansion using vector instructions, the execution speed is further increased. It is possible to improve.

That is, in the object program optimization processing system of the present embodiment, when a character operation procedure is called in a translation unit, the call is provided by a system different from the user-defined procedure. A function for recognizing a procedure is provided as the procedure call analysis unit 9. In addition, the compiler 2 is equipped as the object selection unit 10 with a function of determining whether the execution time is shorter with the scalar instruction or the vector instruction, based on the number of operated characters. As a result, the object program optimization processing system according to the present embodiment executes the object program execution by using vector instructions for inline expansion of the character manipulation procedure rather than using only scalar instructions. If the time gets shorter,
Inline expansion of character manipulation procedures using this vector instruction.

In this embodiment, the procedure call analysis unit 9 determines that the corresponding procedure is not defined in the translation unit.
The procedure call is performed by comparing the type and number of arguments of the corresponding procedure call, the type of return value, and the type and number of arguments of the character operation procedure provided by the system, and the type of return value, respectively. Is classified as a call to a character manipulation procedure provided by the system. As a result, even in the case of the same procedure name, it is possible to classify only the call of the user-defined procedure or the call of the procedure provided by the system. Further, when selecting either the scalar instruction or the vector instruction as the one having the shorter execution time of the inline expansion, the object selecting unit 10 performs it based on the number of characters to be operated. This makes it possible to avoid erroneously selecting the one with a longer execution time. Hereinafter, the procedure call analysis unit 9 and the object selection unit 10 will be described.
This will be performed using FIGS. 2 and 3 below.

FIG. 2 is an explanatory diagram showing an embodiment of the inline expansion operation according to the present invention of the optimization processing system for the object program in FIG. This embodiment shows an inline expansion processing operation of a procedure call according to the present invention, which is one of various kinds of optimization processing performed by the intermediate language optimization unit 5 in FIG.
Each of the reference numerals 23 is an intermediate file used to carry over the data to the next process. The intermediate file 21 consists of an intermediate language converted from the C language source program 1 by the source analysis unit 4 of FIG.
Uses the intermediate file 21 to check the argument and return value of the procedure being called and create the intermediate file 22.

The object selecting unit 10 then outputs the intermediate file 2 that has been checked by the procedure call analyzing unit 9.
2 is used to select whether the inline expansion is performed by a scalar instruction or a vector instruction, and the intermediate file 23 is created. At this point, the optimization of the inline expansion according to the present invention for the procedure call is completed. Using the intermediate file 23 created in this way, the optimization processing unit 11 in FIG. 1 further performs various optimizations. The processing operation of the intermediate language optimizing unit 5 in FIG. 1 shown in FIG. 2 according to the present invention will be described with reference to FIG.

FIG. 3 is a flow chart showing an embodiment of the inline expansion operation according to the present invention of the intermediate language optimizing unit in FIG. This embodiment will be described with reference to the following C language source programs (1) and (2). Incidentally, C
In the language, a procedure is called a function, so in the following description, a function is used with the same meaning as a procedure. C language source program (1): extern char source [1000]; extern char dest [1000]; extern int memcpy (int n) {int i; for (i = 0; i <n; i ++) {* (dest + i) = * (source + i);} return (0);} / * or more, translation unit (1) * / / * or less, translation unit (2) * / char source [1000] = "This is a C program "; char dest [1000]; main (void) {memcpy (10); / * call (1) * / memcpy (900); / * call (2) * /} This C language source program (1 ) Is "return
(0);} "is the translation unit (1), and the subsequent units are the translation units (2), which are translated in separate units. C language source program (2): include <string.h> char source [1000] = "This is a C program"; char dest [1000]; main (void) {memcpy (dest, source, 10); / * Call (3) * / memcpy (dest + 10, source + 10,900); / * Call (4) * /} This C language source program (2) is translated as the same translation unit.

First, the procedure call analysis unit 9 in FIG. 1 checks the arguments of the procedure (step 30).
1). For example, the function “memcpy” that is called in the translation unit of the C language source program (1) is a function defined by the user in another translation unit of the translation unit (1) and the translation unit (2). In this case, in order to determine whether the function call in the translation unit can be expanded inline, the argument of the function call to be processed is compared with the argument of the system-provided function that can be expanded inline (step 302). Here, in the C language source program (1), since "call (1)" and "call (2)" are different from the system-provided function "memcpy", it is determined that inline expansion is not possible, and these functions An object for a normal function call is generated from the call (step 307).

The function "memcpy" called in the translation unit of the C language source program (2) is a system-provided function. When inlining the function "memcpy" provided by such a system, depending on the amount of data to be copied, it is better to inline with a scalar instruction or to inline with a vector instruction. come. The boundary value can be determined by the individual system. The boundary value and the amount of data to be handled are compared by the object selection unit 10 in FIG. 1 (steps 303 and 304).

For example, in the C language source program (2), since "call (4)" has a large number of bytes of data to be copied, inline expansion using a vector instruction is executed more than inline expansion using only a scalar instruction. Since the speed is high, inline expansion is performed using vector instructions (step 305). On the other hand, "call (3)"
Since the number of bytes of data to be copied is small, inline expansion using only scalar instructions will result in faster execution speed than inline expansion using vector instructions.
Inline expansion is performed with a scalar instruction (step 306).
In this way, when a function (procedure) is called, not only the scalar instruction but also the vector instruction is used to perform the inline expansion, so that it is possible to generate a target program having a higher execution speed than the inline expansion using only the scalar instruction.

As described above with reference to FIGS. 1 to 3, in the object program optimizing system of this embodiment, when the character operation procedure is inline expanded in the hardware equipped with the vector processor, Considering the number of characters to be operated in the procedure, select the generation of an object with a short execution time when using only scalar instructions or when using vector instructions. For example, a character manipulation function that handles a large number of characters is expanded inline using vector instructions. As a result, it is possible to generate a high-speed target program using vector instructions in the inline expansion of a character manipulation procedure in a system having a vector operation function.

The present invention is not limited to the embodiments described with reference to FIGS. 1 to 3, and various modifications can be made without departing from the scope of the invention. For example, although the present embodiment has been described using a C language source program, the present invention can be applied to a source program using another high-level language such as FORTRAN or COBOL.

[0023]

According to the present invention, at the time of compiling to generate an object program for a computer having a vector operation function, inline expansion of a character operation procedure is performed by using a vector instruction, thereby achieving a high speed object. A program can be generated and the performance of the compiler can be improved.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of a configuration relating to the present invention of an optimization processing system for an object program of the present invention.

FIG. 2 is an explanatory diagram showing an example of an inline expansion operation according to the present invention of the optimization processing system for the object program in FIG.

3 is a flowchart showing an embodiment of an inline expansion operation according to the present invention of the intermediate language optimizing unit in FIG.

[Explanation of symbols]

 1 C language source program 2 compiler 3 target program 4 source analysis unit 5 intermediate language optimization unit 6 storage allocation unit 7 register allocation unit 8 target program output unit 9 procedure call analysis unit 10 object selection unit 11 optimization processing unit 21 to 21 23 Intermediate file

Claims (1)

[Claims] 1. An optimization processing system for a target program, which optimizes an intermediate language generated from the source program by inline expansion when compiling the source program into a target program for a computer having a vector operation function. Provided by the procedure call analysis means for detecting that the procedure call appearing in the translation unit at the time of the inline expansion is the call of the character operation procedure provided by the system, and the system detected by the procedure call analysis means. As an object used for inline expansion of a character manipulation procedure, an object selection means for selecting either a scalar instruction or a vector instruction that minimizes the execution time of the character manipulation procedure is provided, and the object program is optimized. Processing system.