JPH04104330A - Procedure calling system at parallel processing time - Google Patents

Abstract

PURPOSE:To reduce the overhead of calling a procedure at the time of a parallel processing by generating a procedure quotation instruction string storing an address in an argument list at the time of calling the procedure as against an argument which the address decides at the time of executing a program. CONSTITUTION:When a source program 1 is given, a procedure quotation detection part 211 in a syntax analysis part 21 detects the procedure quotation 'CALLSUB(X(1), Y, Z(1), 1.0)' in a compiler 2. An argument list analysis part 212 judges that the addresses of array elements X(I) and Z(I) among arguments X(1), Y, Z(1) and 1.0 are decided at the time of execution and the addresses of a variable Y and a constant 1.0 are statically decided before the start of execution, and outputs them as an argument list information 25. A procedure quotation text generation part 213 calculates the addresses of the array elements X(1) and Z(1) among the arguments and generates an intermediate text 24. A paralleling part 22 converts the intermediate text 24 so that the calculation of addresses are executed in parallel on plural processors.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a compiler having a parallelization function, and particularly to a compiler that improves the runtime performance of a program including procedure references.

[Conventional technology]

In recent years, technology has advanced in which multiple processors operate in parallel to improve computer performance, but in programs that have a structure that allows parallel processing, it is necessary to execute the processes in the program in parallel. The processing time of the program is shortened by dividing the program into units (hereinafter referred to as tasks) and processing the tasks in parallel on multiple processors.

In a program with such a structure, the procedures in the program are shared and used by each processor, so if the procedure calls another procedure, endruntness of the procedure cannot be guaranteed. In order to An instruction sequence (hereinafter referred to as a procedure-quoting instruction sequence) that calls a procedure by setting it was generated.

For example, when a source program as shown in FIG.
I), Y, Z (1), 1.0) Number of arguments as shown in Figure 3 for J, address of X (1), address of Y, address of Z (1) and 1.0 In order to create an argument list consisting of the addresses of , as shown in Figure 4, an instruction sequence sets the address of A procedure quoting instruction sequence was generated that consisted of five instruction sequences: an instruction sequence that placed 1.0 in the argument list, an instruction sequence that placed an address of 1.0 in the argument list, and an instruction sequence that called a procedure (SUB).

As shown in Figure 2, rGLOBAL X (100)Y
, Z (100)J declares that arrays X and Z having 100 elements and variable Y are to be placed in a static data area shared between tasks to be processed in parallel. Therefore, the procedure citation rCALL SUB
(X N), Y, Z (1) 1.0) In the argument list for J, the addresses of variable Y and constant 1.0 are determined statically, so originally the addresses do not need to be set when executing the argument list. However, in the procedure citation instruction sequence shown in FIG. 4, all argument addresses were set unconditionally.

[Problem to be solved by the invention]

In the conventional procedure calling method for parallel processing described above, it was necessary to insert the argument address into the argument list for each procedure call. Even for data shared between tasks, procedure arguments, etc., it is necessary to execute a procedure reference instruction sequence that stores the address in the argument list when executing a procedure call, and the overhead of a procedure call is large. There are drawbacks.

In view of the above-mentioned points, an object of the present invention is to place an argument list to be passed when a procedure is called in a local area for each task executed in parallel, and for arguments whose addresses are determined before program execution, is set as an initial value in the argument list at the start of a program or each task, and only for arguments whose addresses are determined during program execution, the address is stored in the argument list when the procedure is called. The purpose of this invention is to provide a procedure calling method during parallel processing that generates .

[Means to solve the problem]

The procedure calling method during parallel processing of the present invention includes a syntax analysis unit that reads a source program written in a high-level language, performs syntax analysis, and generates intermediate text, and extracts parallel processable parts of the source program from the intermediate text. a parallelization unit that detects and converts the intermediate text into an intermediate text having a structure that is processed in parallel by a plurality of processors, and a code that generates and outputs an object program from the intermediate text converted by the parallelization unit. A procedure citation detection unit that detects procedure citations in a source program in a compiler equipped with a generation unit, and a procedure citation detection unit that analyzes arguments at the time of procedure citation detected by the procedure citation detection unit and determines an address when the program is executed. An argument list analysis unit that determines whether the address is an argument or an argument whose address is determined before program execution and generates argument list information including the determination result, and an argument list analysis unit that determines whether the address is an argument whose address is determined before program execution and generates argument list information including the determination result. The syntax analysis unit includes a procedure citation text generation unit that generates intermediate text that is calculated and stored in the argument list, and the argument list at the time of procedure citation is generated on a plurality of processors based on the argument list information. An object program that is allocated to a storage area as task local data that is allocated to each task, which is a unit of parallel execution, and that has the address of an argument whose address is determined before program execution as the initial value of the argument list. The code generation section includes a task local data generation section that generates task local data, and a procedure citation instruction string generation section that generates a procedure citation instruction string from an intermediate text of the procedure citation.

[Effect]

In the procedure calling method during parallel processing of the present invention, the procedure citation detection section of the syntax analysis section detects procedure citations in the source program, and the argument list analysis section extracts the arguments at the time of procedure citation detected by the procedure citation detection section. It analyzes and determines whether the address is determined during program execution or the address is determined before program execution, generates argument list information including the determination result, and the procedure quotation text generation unit determines whether the address is determined when the program is executed. For the argument to be determined, the argument address is calculated and intermediate text is generated to be stored in the argument list.The task local data generation part of the code generation part generates the argument list when citing the procedure based on the argument list information. is allocated to the storage area as task local data for each task, which is a unit that is executed in parallel on multiple processors, and for arguments whose addresses are determined before program execution, the addresses are used as the initial values of the argument list. An object program having the following is generated, and a procedure citation instruction string generation unit generates a procedure citation instruction string for the procedure citation intermediate text.

(Example〕 Next, the present invention will be explained in detail with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of a compiler 2 to which a procedure calling method during parallel processing according to an embodiment of the present invention is applied. This compiler 2 inputs a source program 1 written in a high-level language such as FORTRAN and generates and outputs an object program 3. In the process, a syntax analysis unit 2 generates intermediate text 24.
1, and a parallelization unit 22 that detects parallel processable portions in the source program 1 from the intermediate text 24 and converts the intermediate text 24 into an intermediate text 24 having a structure that can be processed in parallel by a plurality of processors. The main part thereof consists of a code generation section 23 that generates and outputs the object program 3 from the generated intermediate text 24.

The syntax analysis unit 21 includes a procedure citation detection unit 211 that detects procedure citations in the source program 1, and a procedure citation detection unit 211 that analyzes arguments at the time of procedure citation and whose addresses are determined when the program is executed. An argument list analysis unit 212 that determines whether the argument is an argument and generates argument list information 25 including the determination result, and an argument list analysis unit 212 that determines whether the argument is an argument and generates argument list information 25 including the determination result, and for arguments whose addresses are determined during program execution, calculates the argument address and stores it in the argument list. The procedure citation text generation unit 213 generates an intermediate text 24.

The code generation unit 23 generates an argument list 311 at the time of procedure citation based on the argument list information 25 as data (hereinafter referred to as task local data) 31 allocated to each task executed in parallel on a plurality of processors in a storage area. In addition, for arguments whose addresses are determined before program execution, the addresses are assigned to the argument list 31.
Object program 3 that has as the initial value of 1
, and a procedure citation instruction string generation section 232 that generates a procedure citation instruction string for the intermediate text 24 of the procedure citation.

Next, the operation of the procedure call method during parallel processing in this embodiment configured as described above will be explained.

In the compiler 2, when the source program 1 as shown in FIG.
LL SUB (X (1)y, z (1), 1.0
) Detect J.

Next, the argument list analysis unit 212 calculates the arguments X(1), Y
, Z (T) and array element X(1
) and Z (+) are determined during execution, and that the addresses of variable Y and constant 1.0 are statically determined before the start of execution, and are output as argument list information 25.

Next, the procedure citation text generation unit 213 calculates the addresses of array elements X (1) and Z (1) among the arguments, stores them in the argument list, and generates an intermediate text that performs procedure citation. 24.

Next, the parallelization unit 22 converts the intermediate text 24 so that, for example, each repetition of the DO small loop is executed in parallel on a plurality of processors as one task.

Next, the task local data generation section 231 in the code generation section 23 generates arguments as shown in FIG. 6 based on the argument list information 25 output from the syntax analysis section 21, as shown in FIG. An argument list l with an initial image in which the number of objects, the address of Y, and the address of 1.0 are already set.
-311 is cited as the procedure (SUB), and each task (
An object program 3 is generated that statically allocates task local data 31 to a local area for each i, (i→-1), . . . ). Therefore, the task local data 31 is initialized only once in the image shown in FIG. 6 at the start of a program or each task.

In other words, the address of the variable Y, the constant 1.0, and the number of arguments 4, which are statically determined before the start of execution of the program or each task, will not be set again during the execution of the program or each task. do not have.

Finally, the procedure citation instruction sequence generation unit 232 inputs the intermediate text 24 generated by the procedure citation text generation unit 213 in the syntax analysis unit 21, and writes an X ( Generate a procedure reference instruction sequence consisting of three instruction sequences: an instruction sequence that places the address of 1) in the argument list, an instruction sequence that sets the address of Z(1) in the argument list, and an instruction sequence that calls the procedure (SUB). .

The object programs output from the compiler 2 are combined by a linker (not shown) that outputs an executable program that can be processed in parallel, and the executable progera 1 output from the linker can be processed in parallel by multiple processors. It is executed by a computer system equipped with a parallel execution control means. Therefore, the arguments X (1) and Z (1) whose addresses are determined when the program is executed
Only when the procedure is called, the address of G is stored in the argument list.

〔Effect of the invention〕

As explained above, the present invention places the argument list to be passed when calling a procedure in a local area for each task executed in parallel, and sets the address to the initial value for arguments whose addresses are determined before program execution. is set in the argument list at the start of the program or each task, and generates a procedure reference instruction sequence that stores the address in the argument list when calling the procedure only for arguments whose addresses are determined when the program is executed. This has the effect of reducing the overhead of procedure calls during parallel processing.

[Brief explanation of drawings]

Figure 1 is a block diagram showing the configuration of a compiler to which a procedure calling method during parallel processing according to an embodiment of the present invention is applied, and Figure 2 shows an example of a source program that is parallelized and includes procedure references. Figure 3 shows an example of an argument list when citing a procedure using the conventional procedure calling method during parallel processing. Figure 5 is a diagram illustrating assignment of task local data; Figure 6 is a diagram illustrating an example of an initial image of an argument list using the procedure call method during parallel processing in this embodiment; FIG. 3 is a diagram illustrating an example of a procedure citation instruction sequence generated by the procedure call method during parallel processing according to the present embodiment. In the figure, 1... source program, 2... compiler, 3... object program, 21... syntax analysis section, 22... parallelization section, 23... code generation section, 24... intermediate text, 25. Argument list information, 31. Task local data, 211. Procedure citation detection unit, 212. Argument list analysis unit, 213. Procedure citation text generation unit, 23. Task local data generation unit, 232. Procedure citation instruction string. Generation part, 311-Argument list.

Claims (1)

[Scope of Claims] A syntax analysis unit that reads a source program written in a high-level language and performs syntax analysis to generate an intermediate text; a parallelization unit that converts the text into an intermediate text having a structure to be processed in parallel by a plurality of processors, and a code generation unit that generates and outputs an object program from the intermediate text converted by the parallelization unit. In the compiler, there is a procedure quotation detection unit that detects procedure quotations in a source program, and an argument at the time of procedure quotation detected by this procedure quotation detection unit is analyzed. An argument list analysis unit that determines whether an address is a determined argument and generates argument list information including the determination result, and for arguments whose addresses are determined during program execution, calculates the argument address and stores it in the argument list. and a procedure citation text generation unit that generates an intermediate text such as the following: a syntax analysis unit that generates an intermediate text such as A task local data generation unit that generates an object program that is allocated to a storage area as task local data that is allocated for each task, and that has the address as the initial value of the argument list for arguments whose addresses are determined before program execution. and a procedure citation instruction string generation section that generates a procedure citation instruction sequence from an intermediate text of the procedure citation.