JPH07219909A - Method for converting program - Google Patents

Abstract

PURPOSE:To evade the generation of an error due to mismatch between the array areas of plural procedures which is generated when the contents of a sequentially processing program are arrayed in parallel in each procedure. CONSTITUTION:An array to be referred to in each procedure is analyzed (101), the division size of the array is determined (102) and the area size of an array element to be referred in a procedure concerned except an area specified by the division size is specified (103). Whether the range of an array area secured for the initial execution sentence of each procedure and a succeeding execution sentence to be a slave procedure accessing sentence coincides with the array element reference area of the procedure itself or not is decided, and when both the areas are mismatched, a library function accessing sentence for rescuing the areas of the array so that the secured array area matches with the array element reference range of its own procedure is added.

Description

Detailed Description of the Invention

[0001]

The present invention relates to a program written for a serial processing computer or a shared memory type parallel computer,
The present invention relates to a technique of a parallelizing compiler or a parallelizing translator that converts a program that can be executed on a distributed memory type parallel computer.

[0002]

2. Description of the Related Art Among parallel computers composed of a plurality of processors, one having a memory unique to each processor is called a distributed memory type parallel computer.

In such a distributed memory parallel computer, when processing a large-scale array that appears in scientific and technological calculations, each element of the array to be processed is usually divided into memory of each processor and allocated. In each processor, parallel processing of array elements is realized by executing processing of each allocated element in parallel.

As a method of dividing an array for parallel processing of array elements in such a distributed memory type parallel computer, a method as shown in FIG. 23 is conventionally known.

In FIG. 23, the small squares represent one array element, and the number attached above it represents the processor number to which the element is assigned. In addition, here
The array is a one-dimensional array, and the number of processors is four.

FIG. 23 (a) shows a method called cyclic division. According to this method, each element of the array is sequentially allocated to different processors one by one. Then, when the last processor is reached, allocation is performed again from the first processor.

Next, FIG. 23 (b) shows a method called cyclic block division. According to this method, several array elements are grouped into one block, and each block is cyclically divided into blocks. Assign to the processor. In the illustrated example, two array elements are grouped into one block.

Finally, FIG. 23 (c) shows a method called acyclic block division. According to this method,
The entire array is equally divided and assigned to each processor.

Although a one-dimensional array is shown here, when the array is multidimensional, a method of dividing each dimension by a combination of such methods is also conceivable.

Here, a language processor for converting a program written in a serial processing language into a program for a parallel computer by dividing an array or inserting interprocessor communication statements into a program is parallelized. I call it a compiler.

As described above, in the parallelizing compiler, it is necessary to divide the array and generate a parallel program in order to allow a plurality of processors to perform parallel processing of the array element.

A conventional technique for dividing such an array to generate a parallel program is, for example, Hiranandan.
i, Kennedy, and Tseng, "Evaluation of Compiler Opt
imizations for Fortran D on MIMD Distributed-Memor
y Machines ", Proc. of 1992Int'l Conf. on Supercomp
The technology described in uting, pp.1-14, July 1992 is known.

According to this technique, a user inserts an instruction statement designating an array division pattern into a program for sequential processing written in the Fortran language, the array is divided according to the instruction statement, and the parallel program is executed. To generate.

This technique will be described by taking a program described in the following Fortran language as an example.

◇ REAL A (100), B (100) ◇ DISTRIBUTE A (BLOCK), B (BLOCK) ◇ DO J = 2,99 ◇ A (J) = B (J-1) + ... + B (J + 1) ◇ ENDDO ◇ In this program, the real type arrays A and B with 100 elements are declared in the first line. Second line DISTRIBU
The TE sentence is the above-mentioned directive sentence, and indicates that the division pattern of the arrays A and B is a non-cyclic block division. In the 3rd to 5th lines, the value of J is changed from 2 to 9
Up to 9, increasing by 1 while A (J) = B (J-1) +. ． ． It is instructed that the calculation of + B (J + 1) should be performed.

By the way, such a program has the directives inserted therein, DISTRIBUTE A (BLOCK), B (BL
The parallel conversion according to OCK) is as follows. Note that the number of processors is four here.

◇ REAL A (25), B (0:26) ◇ {Transfer the boundary element of B to the adjacent processor. } ◇ DO J = LB, UB ◇ A (J) = B (J-1) + ... + B (J + 1) ◇ ENDDO ◇ This program is common to all processors. However,
For parts that require different processing for each processor,
An instruction statement is stored in the program so that different processing is performed depending on the processor number. For example, the variables LB and UB represent the lower limit and the upper limit of the loop execution range, which are assigned different values for each processor when the program is executed. In this case, since the loop execution range of the original program is from 2 to 99, the set of (LB, UB) is (2, 25) in processor 1, and processor 2, 3
Becomes (1,25), and processor 4 becomes (1,24).

It should be noted that the range of the elements of the array A is 1 to 25, while that of the array B is 0 to 2
It is up to 6. If an array with 100 elements is divided into four processors in a non-cyclic block, the number of elements of each processor is originally 25 as in array A.
However, the array B is B (J-1), B (J +
Since it is referred to in the form of 1), the element of B near the boundary of the processor is required by both adjacent processors. This state is shown in FIG.

As shown in the figure, for example, the element B (25) is originally assigned to the processor 1, but B is used to calculate the value of A (26) in the processor 2.
The value of (25) is required. Therefore, for such a boundary element, it is necessary to secure an area for an element that should be originally allocated to the adjacent processor and have the value transferred from the adjacent processor before the execution of the loop. For this reason, in the type declaration of the array B, the range of elements is expanded by the boundary area.

[0020]

By the way, a program generally includes a plurality of procedures such as a main program and a subroutine. Further, parallel conversion of a program is generally performed by parallelizing and converting each procedure and then combining them.

However, according to the above-mentioned technique of Hiranandani et al., The following problems occur when parallelizing and converting a program composed of such a plurality of procedures for each procedure.

That is, the size of the reserved boundary area differs between one procedure and another procedure. Therefore, if these procedures are combined, a wrong program will result due to area mismatch. The problem arises that

For example, when the array B in the above-mentioned example is referred to by another procedure, there is no reference such as B (J-1) or B (J + 1) in the procedure. In this case, the declaration of the array B after the procedure is parallelized becomes B (25) like the array A. This is B mentioned above
Since it does not match the declaration (0:26), a program that combines such procedures will not operate correctly.

Therefore, an object of the present invention is to provide a conversion of a program divided into a plurality of procedures into a parallel program which operates correctly for each procedure.

[0025]

[Means for Solving the Problems] To achieve the above object,
The present invention is, for example, a parallel program executed by a plurality of processors of a distributed memory parallel computer for a conversion target program that performs processing by referring to an array, and secures an area of the array portion, A program conversion method for converting a parallel program for performing processing by referring to a portion of an array that secures an area, wherein at least for each of a plurality of procedures constituting a conversion target program, a parallel program obtained by converting the procedure In the parallel program that converts the procedure based on the analysis result of the size of the array and how to refer to the array with respect to the array shared with other procedures in the array referred to in 1. Determining the range of the portion of the array to be referenced, and executing the processor that executes the parallel program that is the conversion of the procedure An area is secured at the start of execution of the execution statement as an execution statement that is executed first after the target is switched from the parallel program that has converted the other procedure included in the conversion target program to the parallel program that has converted the procedure. If the range of the part of the sequence that has been performed and the range of the part of the sequence referred to by the parallel program that has converted the procedure match are determined from the range of the determined part of the sequence, and they do not match Reallocates the area of the array so that it matches the range of the array referenced by the parallel program that has converted the procedure, and executes the parallel program that has converted the procedure in the area that has been allocated again. And a step of writing an execution statement that specifies the execution of the process of fetching the part of the array referenced by the processor in the parallel program obtained by converting the procedure. It provides a program conversion method characterized by.

[0026]

According to the above-described program conversion method of the present invention, the target of execution of the processor that executes the parallel program with the converted procedure is more than the parallel program with converted other procedures included in the conversion target program. The procedure is converted by the execution statement added as the first execution statement after switching the procedure to the converted parallel program, and the range of the array part where the area is secured at the start of execution of the execution statement and the procedure. Whether or not the range of the sequence part referred to by the parallel program matches is determined based on the determined range of the sequence part. If they do not match, the region of the sequence part executes the procedure. The parallel program is re-allocated so that it matches the range of the array part that the converted parallel program refers to, and the parallel program that converted the procedure to the re-allocated area Sequence portion of a processor that executes a gram refers is captured.

Therefore, even if areas of different ranges are secured for the same array for each parallel program obtained by converting the procedure forming one program, in this case, prior to the process of referring to this array. , The area is reallocated, and the area of the array referenced by the processor executing the parallel program is fetched in the area, so that the program can operate correctly.

[0028]

EXAMPLES Examples of the present invention will be described below.

First, in the present embodiment, a distributed memory type parallel computer that executes a parallel program that has been parallelized and converted will be described in advance.

FIG. 1 shows the configuration of this distributed memory type parallel computer.

As shown in the figure, the distributed memory type parallel computer includes a plurality of processors 201 to 20n, an interconnection network 22 connecting them, local memories 211 to 21n attached to each processor, and an external storage device 22.
It is composed of 1 to 22n. The data on each local memory can be directly referenced by the processor to which it is attached, but cannot be directly referenced by other processors. In order to refer to the data on the local memory associated with a certain processor from another processor, the data must be transferred through the interconnection network 22.

It is assumed that each processor is assigned a processor number starting from 1. That is,
Processor 201 is number 1, processor 202 is number 2, ...
・ ・ ・ Shall be numbered. The parallel program is stored in, for example, the external storage device 22n, and is transferred from the processor 20n to each processor and executed as necessary.

In this embodiment, as an example, a parallel program executed by such a distributed memory parallel computer is
A case where the two serial processing programs shown in FIGS. 2 and 3 are converted into parallel programs will be described as an example.

The program 300 shown in FIG. 2 and the program 301 shown in FIG. 3 have a relationship between a high-order procedure and a low-order procedure, respectively.

That is, the upper procedure program 3 of FIG.
The statement in 00, ◇ CALL SUB (A, B) ◇, calls the lower procedure program 301 in FIG. The data A and B, which are the arguments of the procedure call, are a one-dimensional array having 100 elements according to the declaration statements in each of the programs 300 and 301, ◇ REAL A (100), B (100) ◇. It is declared to be data.

In this embodiment, it is assumed that the upper procedure program 300 and the lower procedure program 301 are stored in different files. Then, in the present embodiment, the parallelization conversion is separately performed for each procedure. That is, after converting each procedure independently, these are combined to create an execution module that is actually executed by a parallel computer. However, even if both programs 300 and 301 are stored in the same file, this embodiment
It is applicable as well.

The first embodiment of the program conversion method according to the present invention will be described below.

FIG. 4 shows the procedure of program parallel conversion according to the first embodiment.

As shown in the figure, in this procedure, first, in step 100, the program 300 before conversion (see FIG. 2).
Alternatively, 301 (see FIG. 3) is read. Then, in step 101, the reference pattern of the array data in the loop in the program is analyzed and registered in the reference pattern table.

In the reference pattern table, as shown in FIG.
The subscript pattern of the array element referenced in the program loop is registered. The reference pattern table is composed of a loop number field 4000, an array name field 4001, and a subscript expression field 4002.

FIG. 5A shows the upper procedure program 30.
0 is a reference pattern table 400, and FIG. 5B is a reference pattern table 40 for the lower procedure program 301.
1 is shown. According to step 101, in the reference pattern table 400 of FIG. 5A, the array elements A (I) and B (I) appearing in the loop 10 of the program 300 of FIG. 2 and the array element A appearing in the loop 20 of FIG. (I) and B (I) are registered, and array elements A (I) and B (I-1) appearing in the loop 30 of the program 301 of FIG. 3 are registered in the reference pattern table 401 of FIG. 5B. , B (I + 1) are registered.

Next, in step 102, the array division pattern is determined based on the reference pattern table 400 or 401.

Then, in step 103, the size of the boundary region of the array division is determined based on the reference pattern table 400 or 401. Then, the determined division pattern and boundary area size are registered in the array division table.

The array division table is, as shown in FIG. 6, an array name field 4100 and a divided block size field 4.
101 and boundary size field 4102. FIG. 6A shows an array division table 410 for the upper procedure program 300, and FIG. 6B shows an array division table 411 for the lower procedure program 301.

Here, in the case of a one-dimensional array, the division pattern can be expressed by the division block size. That is, the divided block size is 1 for cyclic division,
In the case of non-cyclic block division, it is a value obtained by rounding up (number of array elements) / (number of processors) to an integer, and in the case of cyclic block division, it is an intermediate value. In the case of a multidimensional array, information such as the dimension to be divided is further required. In this embodiment, for convenience of explanation, the arrays A and B appearing in the programs 300 and 301 are one-dimensional arrays, the division pattern is non-cyclic block division, and (the number of array elements) / (the number of processors) is rounded up to an integer. The block size is expressed by the value. Then, as the registration of the division pattern in the array division table, the division block size of the array referred to in the procedure is registered in the division block size field 4101.

On the other hand, the boundary size is determined by performing the procedure shown in FIG. 7 for each of the arrays referred to in the program.

That is, first, in step 1030, the reference pattern table 400 or 401 is searched to extract a reference whose subscript expression is "I + constant" for the target array. Here, I represents the control variable of the loop.

Next, in step 1031, of such references, the one with the largest absolute value of "constant" is selected.
Then, in step 1032, the absolute value of the largest one is determined as the boundary size of the array, and the array partition table 40
Register 0 or 401 in the boundary size field 4102 for that array.

For example, in the reference pattern table 400 of the higher-level procedure of FIG. 5A, the array A has two references, but the subscript expressions are all "I". Since this can be regarded as "I + 0", the value of the constant is 0. Since the absolute value of 0 is 0, the boundary size of the array A in the upper procedure is determined to be 0, and the value is registered in the boundary size field 4102 of the array division table 410 of the upper procedure in FIG. 6A. Further, for example, in the reference pattern table 401 of the lower procedure in FIG. 6B, the reference subscript expression of the array B is "I-1".
And “I + 1”, and the above constant values are −1 and 1, respectively. Since both of these absolute values are 1, the boundary size of the array B in the lower procedure is determined to be 1, and this value is set to the array division table 41 of the lower procedure in FIG. 6B.
It is registered in the boundary size field 4102 of 1.

After the registration in the array partition table is completed in this way, next, in step 104 in FIG. 4, the program is scanned to detect the lower procedure call statement. Then, if a lower procedure call statement is detected, the procedure proceeds to step 105, and if there is no lower procedure call statement in the program, the procedure proceeds to step 109.

Upper procedure program 300 shown in FIG.
Then, since there is a lower procedure call statement, the procedure proceeds to step 105. Since there is no lower procedure call statement in the lower procedure program 301, the procedure proceeds to step 109.

Now, in step 105, it is determined whether or not there is array data in the actual argument of the detected lower procedure call. If so, the process proceeds to step 106, and if not, the process proceeds to step 109.

In step 106, a variable for storing the divided block size of the array and a variable for storing the boundary size are generated for the array data which is the actual argument of the lower procedure call, and the declaration statement of the variable is generated. Is inserted into the program. The block size variable name is _B in the array name
It is assumed that the character string LOCK is added, and the boundary size variable name is the array name to which the character string _MARGIN is added. The types of these variables are integer types. In addition, a keyword indicating that the area of the array is to be reallocated is inserted in the declaration statement of the original array.

For example, the upper procedure program 3 in FIG.
In 00, the arrays A and B are the actual arguments of the subprocedure call statement ◇ CALL SUB (A, B) ◇, so the process proceeds from step 105 to step 106, and variables A_BLOCK and A_MRG are used.
Generate IN, B_BLOCK, B_MARGIN and insert the declaration statements ◇ INTEGER A_BLOCK, A_MARGIN, B_BLOCK, B_MARGIN ◇ of these variables into the program. In addition, in the declaration statements of arrays A and B, the keyword'A indicating that the area is to be reallocated is displayed.
Insert LLOCATABLE :: '.

Here, FIG. 8 shows the parallelized parallelized higher-order procedure program 310 of the higher-order procedure program 300 shown in FIG. 2. The declaration statements of the arrays A and B are made by the procedure described so far. Is inserted with a keyword such as ◇ REAL, ALLOCATABLE :: A (25), B (25) ◇, and after that, the newly created variable declaration statement ◇ INTEGER A_BLOCK, A_MARGIN, B_BLOCK, B_MARGIN ◇ is inserted. It Note that the size of each array in the declaration can be determined in the same manner as the technique of Hiranandani et al. However, in the first embodiment, it can be directly determined from the array partition table.

Now, after step 106, next, in step 107, the generated block size variable and boundary size variable are added as actual arguments of the lower procedure call.
The position to add is immediately after the corresponding array argument.

In the upper procedure program 300 of FIG.
This process is performed on the above-mentioned lower procedure call statement ◇ CALL SUB (A, B) ◇, so that this lower procedure call statement is converted to the higher procedure program 3 in FIG.
As shown in 10, CALL SUB (A, A_BLOCK, A_MARGIN, B, B_BLOCK, B_MARGI
N) Converted to ◇.

Next, at step 108, a statement for checking the value of the boundary size variable and reallocating the array area with reference to the array partition table shown in FIG. 6 is inserted immediately after the lower procedure call. Specifically, the call of the library function CHECK_MARKIN is inserted. CHECK_
MARGIN takes five arguments, the first argument is the start address of the array, the second argument is the block size variable for that array, the third argument is an integer representing the block size in the higher-level procedure, and the fourth argument is the array. The boundary size variable for, the fifth argument is an integer that represents the boundary size within the higher order procedure.

For the high-order procedure program 300 of FIG. 2, as shown in the converted high-order procedure program 310 of FIG. 8, the above-mentioned low-order procedure call statement ◇ CALL SUB (A, A_BLOCK, A_ MARGIN, B, B_BLOCK , B_MARGIN) ◇ immediately after ◇ CALL CHECK_MARGIN (A, A_BLOCK, 25, A_MARGIN, 0) ◇ CALL CHECK_MARGIN (B, B_BLOCK, 25, B_MARGIN, 0) ◇ is inserted.

Library function CHECK_MARKIN
Although the details of the function of will be described later, the outline thereof will be described here. Converted upper-level procedure program 310 of FIG.
Then, since the call of CHECK_MARKIN is immediately after the call of the lower procedure, it is immediately after the execution of the lower procedure program. Therefore, the block size variable and the boundary size variable store the values of the block size and the boundary size in the lower procedure. CHECK_MARKIN
Compares those values with the block size and boundary size in the upper procedure given as the third and fifth arguments.

If they do not match, CHE
CK_MARGIN reallocates the array area and rearranges the array elements to match the block size and boundary size in the higher-level procedure. By doing this, no matter what the block size or boundary size is in the subprocedure,
Immediately after execution returns from the subprocedure, the value in the superprocedure can be matched to ensure correct operation of the program.

Next, in step 109, it is judged whether or not the own procedure is the main program, that is, the highest-level procedure. If it is the main program, the process proceeds to step 113, and if not, the process proceeds to step 110. If the higher-level procedure program 300 is the main program,
If it has been converted, the process proceeds to step 113. Further, since the lower procedure program 301 is not the main program, if it is being converted, the process proceeds to step 110.

Next, at step 110, it is judged whether or not there is array data in the dummy argument of the self procedure. If so, go to step 111, otherwise go to step 113
Proceed to. In step 111, for the array data that is the dummy argument of the procedure itself, similarly to step 106, a variable that stores the divided block size of the array and a variable that stores the boundary size are generated, and the variable is declared. Insert a statement into your program. In addition, a keyword indicating that the area of the array is to be reallocated is inserted in the declaration statement of the original array.

For example, the lower procedure program 3 of FIG.
In 01, since there are arrays A and B in the dummy argument, the process proceeds from step 110 to step 111.

Here, FIG. 9 shows a parallelized high-order procedure program 311 obtained by performing parallel conversion of the low-order procedure program 301 shown in FIG. As shown in the figure, keywords such as ◇ REAL, ALLOCATABLE :: A (25), B (0:26) ◇ are inserted in the declaration statements of the arrays A and B in step 111. After that, the newly created variable declaration statements ◇ INTEGER A_BLOCK, A_MARGIN, B_BLOCK, B_MARGIN ◇ are inserted. Note that, as described above, the size of each array in the declaration statement can be determined in the same manner as the technology of Hiranandani et al. Described above, or in the case of the first embodiment, it can be directly determined from the array partition table. .

Next, after step 111, step 11
In step 2, the generated block size variable and boundary size variable are added as dummy arguments of the self procedure call. The position to add is immediately after the corresponding array argument.

For the lower procedure program 301 of FIG. 3, ◇ SUBROUTINE SUB (A, B) ◇, ◇ SUBROUTINE SUB (A, A_BLOCK, as shown in the converted lower procedure program 311 of FIG. A_MARGIN, B, B_BLOCK, B
_MARGIN) ◇ will be converted.

Next, in step 113, a statement for checking the value of the boundary size variable and reallocating the array area is inserted at the beginning of the procedure itself. Specifically, the above-mentioned CHECK_MA
Insert a call to a library function called RGIN.

By this step 113, for the upper procedure program 300 of FIG. 2, as shown in the post-conversion upper procedure program 310 of FIG. 8, ◇ CALL CHECK_MARGIN (A, A_BLOCK, 25, A_MARGIN , 0) ◇ CALL CHECK_MARGIN (B, B_BLOCK, 25, B_MARGIN, 0) ◇ is inserted. As will be described later, CHE
CK_MARGIN also has a function of reserving the array area if it is not already reserved.
As a result, the initial area of the array is secured in the upper procedure.

On the other hand, in step 113, for the lower procedure program 301 of FIG. 3, as shown in the post-conversion lower procedure program 311 of FIG. 9, ◇ CALL CHECK_MARGIN (A, A_BLOCK, 25, A_MARGIN, 0) ◇ CALL CHECK_MARGIN (B, B_BLOCK, 25, B_MARGIN, 1) ◇ is inserted. Since the boundary size of the array B is 1 in the subordinate procedure, the 5th value of CHECK_MARKIN is set.
The argument is 1.

As a result, the above-mentioned CHECK_MA
The RGIN function ensures that the correct operation of the program is guaranteed, regardless of the block size or boundary size in the higher-level procedure, immediately after the lower-level procedure program is called, it can be adjusted to the value in the lower-level procedure. It

Next, at step 114, other conversion processing for program parallelization is executed. This includes insertion of a call statement ◇ CALL EXCHANGE_MARGIN (B, B_BLOCK, B_MARGIN) ◇ of a library function for exchanging array element values in the boundary area between processors, and change of loop index range. Details of the library function EXCHANGE_MARKING that exchanges the values of array elements in the boundary area between processors will be described later.

Finally, in step 115, the converted program 310 or 311 is output to the external storage, and the process is terminated.

Now, the above-mentioned library function CHECK
The details of the functions of _MARKIN and EXCHANGE_MARKIN will be described.

When the parallel program created as described above is actually executed on the parallel computer, these functions are
When called from the program, the following processing is performed.

First, the library function CHECK_MAR
The GIN will be described.

FIG. 10 shows the library function CHECK_M.
The procedure of the process performed by ARGIN is shown.

As shown, the library function CHEC
When K_MARGIN is called, step 700
Then, the argument passed to itself is checked to obtain the current start address of the array, the current divided block size, and the current boundary size. Further, in step 701, the argument similarly passed to itself is checked to obtain the new divided block size and boundary size of the array, that is, the block size and boundary size required in the procedure that called CHECK_MARKIN. Then, in step 702, it is checked whether or not the area of the array is already secured. This is done by determining whether the current block size or border size of the array is zero. The non-allocation of the array area means that the array is not yet used at the early stage of program execution, and therefore the area is not reserved at all. If not secured, the process proceeds to step 703 to secure the array area according to the array declaration statement, and then proceeds to step 708. In step 702, if the array area is already reserved, the process proceeds to step 704.

In step 704, it is determined whether the current block size and the new block size of the array are the same and the current boundary size and the new boundary size are the same. If they are equal to each other, the processing is finished as it is. If either of them is not equal, the process proceeds to step 705 to secure an area having a size that matches the boundary size with the new block size. Then, in step 706, the array in the original area is copied to an appropriate position in the newly secured area.
Next, in step 707, the previous area is released, and in step 708, the three variables passed as arguments, the start address of the array, the current divided block size, the current boundary size (*, * _BLOCK, * _MARGIN). ) Are each updated to a new value.

Note that in step 704, not only the current boundary size and the new boundary size but also the current block size and the new block size of the array are compared for each procedure depending on the processing performed by the procedure. This is because it takes into consideration that an array division method (see FIG. 23) may be adopted. Regarding all procedures, 2 shown in the first embodiment
When the array division method is guaranteed, as in one procedure (FIGS. 2 and 3), only the current boundary size and the new boundary size may be compared.

Now, in this way, the library function CHEC
K_MARGIN constitutes an array area reallocating device 80 as shown in FIG. 11 on the processor for executing it and the local memory associated with it.

The array area unsecured determination section 800 in the array area reallocation device 8 executes the processing of step 702 in FIG. The size comparison unit 801 uses step 70 in FIG.
Process 4 is executed. The array area securing / releasing unit 802
The processing of steps 703, 705, and 707 of FIG. 10 is executed. The variable updating unit 803 performs step 7 in FIG.
The processing of 08 is executed. The sequence copy unit 804 is shown in FIG.
The processing of step 706 is executed. With such a configuration, the array area reallocating device 80 uses the current start address variable 820, the current block size variable 821, the current boundary size variable 822, the new block size variable 823, and the new boundary size variable 824 which are given from the outside. To reallocate the array area. These variables are stored in the storage area associated with the array area reallocating device 80.

Next, the library function EXCHANGE_M
The processing performed by ARGIN will be described.

FIG. 12 shows the library function EXCHANGE.
The procedure of the process performed by _MARKIN is shown.

For convenience of explanation, as shown in FIG. 24, the processors constituting the parallel computer are arranged in the order of the processor numbers from left to right, and now the library function EXCHA is used.
It is assumed that the argument of NE_MARGIN specifies the array B, and the elements of the array B are arranged in the order of element numbers from left to right.

First, the library function EXCHANGE_M
The processor that executes ARGIN starts with step 7
At 21, it determines if it is the leftmost processor,
If so, proceed to step 723.

On the other hand, if not, step 722.
Then, B_MARKIN data is transferred to the left adjacent processor from the position where the third argument B_MARKIN is advanced from the beginning of the array B, and the process proceeds to step 723. Here, the beginning of the array B is designated by the first argument.

In step 723, it is determined whether or not the processor itself is the rightmost processor, and if so, the process proceeds to step 726. On the other hand, if not, in step 724, the data transferred from the processor on the right is transferred from the beginning of the area of the array B to the third argument B_MARKIN and the second argument B_B.
Store from the position advanced by LOCK data. Then, in step 725, the second argument B_
B_MARKI from the position advanced by BLOCK data
Transfer N data to the processor on the right, step 7
Proceed to 26.

In step 726, it is again judged whether or not it is the leftmost processor, and if so, the processing is terminated, and if not so, the processing proceeds to step 727, in which the data transferred from the processor on the left is transferred. , Array B is stored from the beginning of the area.

The program conversion procedure described above can be executed in a parallel program generation system as shown in FIG.

As shown in the figure, the parallel program generation system 9 includes a parallelizing compiler 5 and a linkage editor 9.
1 and a parallel processing library 92.
The parallel processing library 92 includes a function (CHECK_MARKING) 920 for reallocating an array area and a function EXC.
Includes HANGE. The pre-conversion program 30 created by the user is converted by the parallelizing compiler 5 and output as the post-conversion program 31. The linkage editor 91 combines the plurality of converted programs 31 and the parallel processing library 92 to generate the executable program 35. The executable program 35 is a parallel program that can be executed by the processors 201 to 20n of the parallel computer.

Then, the parallelizing compiler 5 is configured as shown in FIG.
4, the syntax analysis unit 50, the reference pattern analysis unit 51, the division pattern / boundary size determination unit 52, and the conversion unit 5
3, a code generation unit 54, a reference pattern table 40, and an array division table 41.

The conversion unit 53 includes a procedure call detection unit 5
30, division pattern / boundary size variable generation unit 53
1. An array area re-secured sentence insertion unit 533 is included. The syntax analysis unit 50 performs the process of step 100 of FIG. That is, the pre-conversion program 30 is read and the intermediate language 60 is read.
To generate. The intermediate language 60 is an expression of a program inside the compiler, and its format can be the same as that of a conventional compiler. Reference pattern analysis unit 51
Performs the process of step 101 in FIG. That is, the array reference pattern is analyzed and registered in the reference pattern table 40. The division pattern / boundary size determination unit 52 performs the processes of step 102 and step 103 of FIG. That is, the divided block size and the boundary size of the array are determined based on the reference pattern table and registered in the array divided table 41.

The procedure call detector 530 performs the processing of steps 104, 105, 109 and 110 in FIG. That is, it detects a sub-procedure call, determines whether or not the procedure itself is the main program, and checks whether or not there is array data in the argument. The division pattern / boundary size variable generation unit 531 performs the processes of steps 107, 108, 111 and 112 of FIG.
That is, a variable for divided block size and a variable for boundary size are generated, the declaration sentence of the variable is inserted into the intermediate word 60, and the variable is added to the intermediate word 60 as an argument. The array area reassurance sentence insertion unit 532 performs the processing of steps 108 and 113 of FIG. That is, a sentence for reallocating the array area is inserted into the intermediate word 60. The process of step 114 in FIG. 4 is performed by the other part of the conversion unit 53. The code generator 54 reads the intermediate word 60 and generates the converted program 31.

Actually, such a parallel program generation system and a parallelizing compiler are realized on a computer by a corresponding program.

The first embodiment of the present invention has been described above.

The second embodiment of the present invention will be described below.

In the second embodiment, the minimum value of the boundary size in the first embodiment is predetermined.

Now, the second embodiment will be described by taking the case where the minimum boundary size is 1 as an example.

In the second embodiment, the boundary size is determined by the procedure shown in FIG. 15 instead of the procedure described above.

Note that this procedure is performed for each of the sequences referenced in the program.

In the second embodiment, first, in step 1030 and step 1031, as in the first embodiment, the reference pattern table 400 or 401 (see FIG. 5) is searched and the target array is searched. For a reference whose subscript form is "I + constant",
Among such references, the one with the largest absolute value of "constant" is selected.

Then, in step 1035, the maximum absolute value is compared with the minimum value 1 of the predetermined boundary size. If the absolute value is 1 or more, the process proceeds to step 1036, and if the absolute value is less than 1, that is, 0, the process proceeds to step 1037.

At step 1036, the maximum absolute value is determined as the boundary size of the array and registered in the boundary size field 4102 for the array in the array partition table.

On the other hand, in step 1037, the predetermined minimum value 1 is set as the boundary size and registered in the boundary size field 4102 for the array.

For example, in the reference pattern table 400 of the higher order procedure shown in FIG.
However, since this is less than 1, the boundary size is set to 1 instead of 0.

Similarly, the array B in the upper procedure program and the array A in the lower procedure program have a boundary size of one.

Thereafter, when the program is converted using the boundary size thus obtained in the same manner as in the first embodiment, the converted high-order procedure and low-order procedure programs are shown in FIGS. 16 and 17, respectively. As shown in, the size of the array after division is (0:26), and the fifth argument (boundary size) of the library function CHECK_MARGIN is 1.

Therefore, the post-conversion upper procedure program 312 of FIG. 16 and the post-conversion lower procedure program 3 of FIG.
When 13 is combined, since the boundary area of size 1 is secured for the arrays A and B in any of the procedures, the reallocation of the area does not actually occur in the library function CHECK_MARKIN. Further, even when it is necessary to secure a boundary area having a different size for a certain array in a different procedure, the area is re-allocated as in the first embodiment, and thus the operation is not disturbed. Absent.

As described above, according to the second embodiment, the boundary area is provided in advance irrespective of the array reference pattern, thereby reducing the probability that the array area is re-secured during program execution. be able to. This is because in practical programs, the required boundary size is often a small integer such as 1 or 2. Therefore, this second book
According to the embodiment, it is possible to reduce the overhead of re-securing the array and improve the processing performance by appropriately setting the minimum value of the boundary size.

The third embodiment of the present invention will be described below.

In the third embodiment, the specification of the directive is expanded so that the boundary size can also be specified, and the user specifies the boundary size in the conversion source program in advance.

FIG. 18 and FIG. 19 show examples of the pre-conversion high-order procedure program 304 and the low-order procedure program 305, respectively, in which the instruction text by the user is inserted.

Directives in the high-order procedure program 304 and the low-order procedure program 305 DISTRIBUTE A (BLOCK: MARGIN (0)), B (BLOCK: MARGIN (1))
◇ has been inserted by the user. MARG in the directive
The specification of IN (m) (m is an integer) sets the boundary size to m.
And instruct you to. Therefore, this directive indicates that the division pattern of the array A is a non-cyclic block division and the boundary size is 0, and the division pattern of the array B is a non-cyclic block division and the boundary size is 1. Of course, it is the responsibility of the user to ensure that these instructions are consistent between procedures.

In the third embodiment, such a program is parallelized and converted according to the procedure shown in FIG.

That is, first, in step 120, the program 304 or 305 before conversion is read. next,
In steps 121 and 122, the directives in the program are analyzed, and the divided block size and boundary size of the array are determined according to the instructions and registered in the array partition table shown in the first embodiment.

Then, in step 123, other conversion processing for program parallelization is executed. Step 1
The processing of 23 is the same as the processing of step 114 of FIG. 4, and changes the size of the array, inserts a statement for exchanging the values of array elements in the boundary area between processors, and changes the loop index range.

Finally, in step 124, the converted program is output to the external storage, and the processing ends.

As described above, in the third embodiment, since the user is responsible for matching the boundary size between procedures, the steps of generating the boundary size variable and inserting the array area reallocating statement are not performed. unnecessary.

FIG. 21 shows the procedure of FIG.
8 shows a post-conversion high-order procedure program 314 obtained by converting the high-order procedure program 304 of FIG. In addition, FIG.
9 shows a converted lower procedure program 315 obtained by converting the lower procedure program 305 of FIG. In both procedures, the declaration statements of arrays A and B are ◇ REAL A (25), B (0:26) ◇. Further, unlike the post-conversion programs 310 and 311 (see FIGS. 8 and 9) according to the first and second embodiments, the declaration of the boundary size variable and the array area reallocating statement do not appear. This is because the array declarations after division match between procedures, so there is no need to reallocate array areas.

The respective embodiments according to the present invention have been described above.

In the above embodiment, FORTRAN is used.
The program described in the above was taken as an example, but other languages such as the so-called C language and PASCA are also available.
The same can be applied to a program written in a language such as L. Although the converted program is shown in the source program format, it may be directly output in the object program format as the converted program. Further, in the above embodiments, the serial processing program is used as an example of the pre-conversion program, but the same can be applied even when the pre-conversion program is a shared memory type parallel computer program. Further, in the above embodiment, 1
Although the description has been given by taking the dimensional array as an example, the same can be applied to an array having two or more dimensions. Further, the case where the array is shared between the procedures in the form of the argument of the procedure call has been described, but the same can be applied to the case where the array is shared in other forms such as an external variable. Further, in the above embodiments, the case where the array is divided by the non-cyclic block division method has been shown, but in addition to this, the same can be applied to the case where the array is divided by the cyclic block division or the cyclic block.

As described above, according to each embodiment of the present invention, when a program for a serial processing computer divided into a plurality of files is converted into a program executable on a distributed memory type parallel computer, The boundary size of array division can be automatically determined, and each file can be converted separately. Further, by setting the minimum value of the boundary size in advance, the probability of occurrence of reallocation of the array area is reduced, and a program with good execution efficiency can be generated.

[0124]

As described above, according to the present invention, a program for serial processing divided into a plurality of procedures can be converted into a parallel program that operates correctly even if it is parallelized for each procedure. .

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of a distributed memory type parallel computer that executes a parallel program.

FIG. 2 is an explanatory diagram showing an example of a sequential processing program.

FIG. 3 is an explanatory diagram showing an example of a sequential processing program.

FIG. 4 is a flowchart showing a program conversion procedure according to the first embodiment of the present invention.

FIG. 5 is a table showing a reference pattern table used in the first embodiment of the present invention.

FIG. 6 is a diagram showing an array partition table used in the first embodiment of the present invention.

FIG. 7 is a flowchart showing a procedure for determining a boundary size according to the first embodiment of the present invention.

FIG. 8 is a diagram showing an example of a parallel program converted in the first embodiment of the present invention.

FIG. 9 is a diagram showing an example of a parallel program converted in the first embodiment of the present invention.

FIG. 10 is a flowchart showing the operation of the array area reserving function used in the first embodiment of the present invention.

FIG. 11 is a block diagram showing a configuration of an array area reallocating device realized by an array area reallocating function used in the first embodiment of the present invention.

FIG. 12 is a flow chart showing the operation of a function for exchanging boundary data used in the first embodiment of the present invention.

FIG. 13 is a block diagram showing the configuration of a parallel program generation system according to the first example of the present invention.

FIG. 14 is a block diagram showing a configuration of a parallelizing compiler according to the first exemplary embodiment of the present invention.

FIG. 15 is a flowchart showing a procedure for determining a boundary size according to the second embodiment of the present invention.

FIG. 16 is a diagram showing an example of a parallel program converted in the second embodiment of the present invention.

FIG. 17 is a diagram showing an example of a parallel program converted in the second embodiment of the present invention.

FIG. 18 is an explanatory diagram showing an example of a sequential processing program converted in the third embodiment of the present invention.

FIG. 19 is an explanatory diagram showing an example of a sequential processing program converted in the third embodiment of the present invention.

FIG. 20 is a flowchart showing the procedure of program conversion according to the third embodiment of the present invention.

FIG. 21 is a diagram showing an example of a parallel program converted in the third embodiment of the present invention.

FIG. 22 is a diagram showing an example of a parallel program converted in the third embodiment of the present invention.

FIG. 23 is a diagram showing an array division method.

FIG. 24 is a diagram showing allocation of division boundary elements of an array.

[Explanation of symbols]

 5 ... Parallelizing compiler 9 ... Parallel program generation system 30 ... Pre-conversion program 31 ... Post-conversion program 40 ... Reference pattern table 41 ... Array division table 201-20n ... Processors 211-21n ... Local memory

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Yasuhiko Saito 1099 Ozenji, Aso-ku, Kawasaki, Kanagawa Stock Company Hitachi Systems Development Laboratory (72) Masahiro Kainaga 1099 Ozenji, Aso-ku, Kawasaki-shi, Kanagawa Stock Company Hitachi Systems Development Laboratory

Claims (11)

[Claims] 1. A parallel program executed by a plurality of processors of a distributed memory parallel computer to execute a conversion target program for processing by referring to an array, and a partial array area which is a part of the array is secured. And a program conversion method for converting a parallel program that performs processing by referring to a partial array that secures an area, and for each of a plurality of procedures that make up the conversion target program, at least a parallel program that converts the procedure. A step of analyzing the size of the array and a method of referring to the array, which is shared with other procedures in the array referred to in the parallel program in which the procedure is converted based on the analysis result. And the step of determining the range of the array part referred to in An area at the start of execution of the execution statement as an execution statement that is executed first after the target of the line is changed from the parallel program obtained by converting the other procedure included in the conversion target program to the parallel program obtained by conversion of the procedure. Is determined on the basis of the determined range of the sequence part, whether the range of the sequence part secured is equal to the range of the sequence part referred to by the parallel program that has converted the procedure. If not, reallocate the area of the array so that it matches the range of the array referenced by the parallel program that converted the procedure, and convert the procedure to the reacquired area. A step of writing an executable statement that specifies the execution of the process of fetching the part of the array referenced by the processor that executes the program, in the parallel program obtained by converting the procedure. A program conversion method comprising: 2. The program conversion method according to claim 1, wherein the step of determining the range of the part of the array is performed by dividing the array into processors that execute a parallel program in parallel according to a predetermined rule. A step of determining a boundary size, which is a size of an array portion referred to by each processor that executes a parallel program in parallel, beyond the portion of the array allocated by the pattern to be allocated, and executing the execution statement. To determine whether the range of the array part whose area is secured at the start and the range of the array part referenced in the self procedure match, at least the area is secured at the start of execution of the executable statement. If the boundary size corresponding to the range of the array portion and the boundary size of the array determined in the previous step do not match, it is determined that they do not match. Program conversion method characterized in that there. 3. The program conversion method according to claim 1, wherein the step of determining the range of the portion of the array divides the array into processors that execute a parallel program in parallel according to a specified rule. And a boundary that is the size of the array portion referred to by each processor executing the parallel program in parallel, beyond the array portion allocated according to the pattern. In the step of determining the size, it is determined whether the range of the array portion in which the area is secured at the start of execution of the execution statement and the range of the array portion referred to in the self procedure match. , The divided arrangement pattern and boundary size corresponding to the range of the portion of the array where the area is secured at the start of execution of the executable statement, and the array determined in the previous step Split arrangement pattern - emissions and program conversion method, wherein the boundary size is determined to determine whether they match or not. 4. A parallel program, which is a parallel program executed by a plurality of processors of a distributed memory type parallel computer, for a conversion target program which performs processing by referring to an array, and secures an area of a portion of the array, Is a program conversion method for converting into a parallel program that performs processing by referring to the secured array part, and for each of a plurality of procedures that make up the conversion target program, at least in the parallel program that converts the procedure. Regarding the array that is shared with other procedures in the referenced array, the size of the array referenced in the procedure and the way of referring to the array are analyzed, and the procedure is converted for each array included in the procedure. Pattern that divides and allocates the array to each processor that executes the executed parallel program in parallel.
The boundary size, which is the size of the array portion referred to by each processor that executes the parallel program in parallel, is determined beyond the divided arrangement pattern that identifies the pattern and the portion of the array that is assigned according to the pattern. And a declarative statement that creates a variable that stores the partition allocation pattern of the array shared with other procedures and the boundary size, and the step of writing in the parallel program that converted the procedure, and the parallel method that converted the procedure. The execution target of the processor that executes the program is the execution statement that is first executed after switching from the parallel program obtained by converting the other procedure included in the conversion target program to the parallel program obtained by converting the procedure. Compare the value of the variable at the start of execution of the statement, the divided arrangement pattern of the array determined for the array and the boundary size, If not, reallocate and reallocate the area of the array referenced in the parallel program converted from the procedure based on the divided layout pattern and boundary size of the array determined in the previous step for the array. Take in the part of the array referenced by the processor that executes the parallel program that converted the procedure into the area,
A step of writing an execution statement in a parallel program that specifies execution of a process of changing the value of the variable to a value indicating the divided arrangement pattern and boundary size of the array determined in the previous step. How to convert the program. 5. A parallel program for executing a conversion target program for processing by referring to an array by a plurality of processors of a distributed memory parallel computer, wherein an area of the array is secured and Is a program conversion method for converting into a parallel program that performs processing by referring to the secured array part, and for each of a plurality of procedures that make up the conversion target program, at least in the parallel program that converts the procedure. Regarding the array that is shared with other procedures in the referenced array, the size of the array referenced in the procedure and the way of referring to the array are analyzed, and the procedure is converted for each array included in the procedure. Pattern that divides and allocates the array to each processor that executes the executed parallel program in parallel.
The boundary size, which is the size of the array portion referred to by each processor that executes the parallel program in parallel, is determined beyond the divided arrangement pattern that identifies the pattern and the portion of the array that is assigned according to the pattern. And a step of writing a declarative statement that generates a variable that stores the partition arrangement pattern of the array that is the actual argument of the execution statement that calls another procedure and the boundary size in the parallel program that has converted the procedure. , A step of writing an execution statement for calling the other procedure in which a variable storing the divided arrangement pattern and the boundary size is added as an actual argument in a parallel program converted from the procedure, and an execution for calling the other procedure As the execution statement to be executed next to the statement, the value of the variable that stores the divided arrangement pattern and the boundary size of the array that is the actual argument, and The divided arrangement pattern of the sequence determined for the sequence and the boundary size are compared, and if they do not match, the region of the sequence referred to in the parallel program converted from the procedure is determined for the sequence in the previous step. Reallocate based on the divided allocation pattern and boundary size of the array, take in the part of the array referenced by the processor that executes the parallel program that has converted the procedure in the reallocated area, and set the value of the variable to A step to describe an execution statement that specifies the execution of processing to change to a value that indicates the size and boundary size of the array determined in step in the parallel program, and the allocation pattern of the array that is the dummy argument of the program statement And a demarcation statement that creates a variable that stores the boundary size in the parallel program converted from the procedure. A step of writing a program statement in which a variable for storing the divided arrangement pattern of the array that is the dummy argument of the program statement and the boundary size is added as a dummy argument in the parallel program converted from the procedure, and the dummy argument of the program statement If there is an array that is, as the first executable statement of the parallel program that has converted the procedure, the value of the variable that stores the divided arrangement pattern and the boundary size of the array that is the dummy argument, Compare the divided layout pattern of the array determined in the previous step with the boundary size for the array, and if they do not match,
Reallocate the area of the array to be referenced in the parallel program converted from the procedure based on the divided layout pattern and boundary size of the array determined for the array, and execute the parallel program that converted the procedure to the reserved area The process of changing the value of the variable of the array that is the dummy argument into a value indicating the divided arrangement pattern and boundary size of the array determined in the previous step And a step of describing an executable statement designating the above in a parallel program. 6. The program conversion method according to claim 2, 3, 4, or 5, wherein a part of an array referred to by a processor executing the parallel program, which has converted the procedure, is fetched into the reallocated area. Is a sequence in which a portion of the corresponding array of the original area is copied to the reallocated area and another processor of the portion of the array to be copied to the reallocated area is allocated according to the pattern. Is transferred to the other processor, and the portion of the array corresponding to the boundary size is referred to by the own processor beyond the portion of the array allocated according to the pattern. Is received from another processor and stored in the reallocated area, and the program conversion method is performed. 7. The program conversion method according to claim 2, wherein the step of determining the boundary size exceeds the portion of the array allocated according to the pattern, and the parallel program is executed. When the size of the portion of the array referred to by each processor executing in parallel is smaller than a predetermined value set in advance, the predetermined value is used as a boundary size instead of the size, and the program conversion method is characterized. . 8. A parallel program for executing a conversion target program, which executes processing by referring to an array, by a plurality of processors of a distributed memory parallel computer, and secures an area of a part of the array, Is a program conversion method for converting into a parallel program that performs processing by referring to the secured array part, and for each of a plurality of procedures that make up the conversion target program, at least in the parallel program that converts the procedure. For arrays that are shared with other procedures in the referenced array, the size of the array referenced in the procedure is analyzed, and for each array included in the procedure, the parallel program that converted the procedure is parallelized. The divided arrangement pattern that specifies the pattern to be divided and assigned to each processor to be executed according to a predetermined rule is determined. The divided placement pattern is used as a declarative statement to generate an array consisting of the step, the determined divided placement pattern, and the boundary size of the array described in the conversion target program. -A declaration statement that creates an array of a size that matches the size of the part of the array allocated according to the command and the size of the part of the array referenced by each processor that executes the parallel program in parallel beyond the part And a step of describing in a parallel program. 9. A method for reallocating an array area, wherein each process executed on a processor executing a plurality of programs reallocates an array area shared with another process, wherein: The range of the shared array in which the area is secured at that time and the range of the array referenced by the process immediately after the execution target of the processor that executes If and do not match, it is determined by the variable that represents the range of the array where the area is secured and the range of the array referenced by the process described in the program that describes the process. Is to secure the area of the array so that it matches the range of the portion of the array referenced by the process, and the portion of the array referenced by the process in the reallocated area. Is copied from the original area, and the variable is updated to a value representing the range of the array referenced by the process described in the program. 10. A parallel program executed by a plurality of processors of a distributed memory type parallel computer to execute a conversion target program which performs processing by referring to an array, and secures an area of a portion of the array, Is a parallelizing compiler system for converting into a parallel program for processing by referring to the secured array part, and for each of a plurality of procedures constituting the conversion target program, at least in the parallel program in which the procedure is converted. Regarding the sequence that is shared with other procedures among the sequences referred to in, analyze the size of the sequence and how to refer to the sequence,
Based on the analysis result, the analysis means for determining the range of the array portion referred to in the parallel program converted from the procedure, and the execution target of the processor executing the parallel program converted to the procedure are the conversion targets. From the parallel program in which other procedures included in the program are converted, as an executable statement that is executed first after switching to the parallel program in which the relevant procedure is converted, the area of which the area is secured at the start of execution of the executable statement Whether the range of the part and the range of the part of the array referred to by the parallel program that has converted the procedure match is determined from the range of the part of the determined sequence. Reallocate the area of the part so that it matches the range of the part of the array referenced by the parallel program that converted the procedure, and place the area And a conversion unit that describes an execution statement that specifies execution of a process of copying a portion of an array referred to by a processor that executes a parallel program that has been converted from the original area in the parallel program that has converted the procedure. Characterizing parallelizing compiler system. 11. A parallel program which is executed in parallel by a plurality of processors of a distributed memory parallel computer from a conversion target program which performs processing by referring to an array,
What is claimed is: 1. A parallel program generation system, which secures an area of a portion of an array, and generates a parallel program for performing processing by referring to a portion of an array that has secured the area, comprising a library, a linkage unit, and a parallelizing compiler. The parallelizing compiler has, for each of a plurality of procedures constituting the conversion target program, at least with respect to an array shared with another procedure of the arrays referred to in the parallel program that has converted the procedure. , Analyze the size of the array and how to refer to the array,
Based on the analysis result, the analysis means for determining the range of the array portion referred to in the parallel program converted from the procedure, and the execution target of the processor executing the parallel program converted to the procedure are the conversion targets. From the parallel program in which other procedures included in the program are converted, as an executable statement that is executed first after switching to the parallel program in which the relevant procedure is converted, the area of which the area is secured at the start of execution of the executable statement Whether the range of the part and the range of the part of the array referred to by the parallel program that has converted the procedure match is determined from the range of the part of the determined sequence. Reallocate the area of the part so that it matches the range of the part of the array referenced by the parallel program that converted the procedure, and place the area A conversion unit that describes an execution statement that specifies a call of a library function that executes a process of copying a portion of an array referenced by a processor that executes a parallel program that has been converted from the original area, in the parallel program that has converted the procedure. And the library stores a program for executing the library function, the linkage editor includes a plurality of parallel programs obtained by the parallelizing compiler converting a plurality of procedures constituting a conversion target program, A parallel program generation system comprising means for linking a program in the library corresponding to a library function called in a plurality of parallel programs.