JPH07244647A - Method and device for parallelization for indirect reference loop, and method and device for parallel execution - Google Patents

Abstract

PURPOSE:To enables the parallel execution and parallelization of general indirect reference loops and to enable parallel execution and parallelization, specially, when indirect reference is present on a left side by inserting a statement for deciding whether an array element referred to a loop including the indirect reference in present on its own processor or another processor in an indirect reference loop. CONSTITUTION:An initialization statement for a final iteration array last is interposed 121 right before an indirect loop. A statement for deciding whether the indirect reference is local reference or remote reference is interposed 122 before a substituted statement in a loop of a program. Then a statement for recording an iteration index in the final iteration array is inserted 123 into the part which is executed at the time of the local reference. Further, a statement for registering substitution information on the remote reference in a substitution list is inserted 124 into the part which is executed at the time of the remote reference. Statements for the postprocessing of the remote reference are added 125 and 126 after the loop.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program parallelizing method and apparatus for converting a program including an indirect reference loop written for a serial processing computer into a program executable on a distributed memory type parallel computer. The present invention relates to a parallel execution method and apparatus for an indirect reference loop.

[0002]

2. Description of the Related Art In a parallel computer system composed of a plurality of processors, one having a memory unique to each processor is called a distributed memory type parallel computer. When executing the processing of a large-scale array that appears in scientific and technical computing with a distributed memory parallel computer, divide each element of the array into the memory of each processor and allocate it, and execute the processing for each element in parallel with each processor. This method is usually used. One way to create a program that implements such a scheme is to use a parallelizing compiler.

A parallelizing compiler is a language processor that converts a program written in a serial processing language into a parallel computer program. A parallelizing compiler for a distributed memory parallel computer divides array elements and loop iterations (hereinafter, the loop iteration unit is called iteration. For example, i = 2 iteration) into each processor. Allocate, insert data transfer statements and synchronization statements if necessary, and generate a program for each processor. When an array element referred to by a certain iteration is assigned to its own processor, the array element reference is called "local reference", and when it is assigned to another processor, it is called "remote reference". For remote reference, it is necessary to transfer the array element value by interprocessor communication. Therefore, it must be taken into consideration that in a distributed memory parallel computer, it takes a very long time to start interprocessor communication. Normally, a start-up time of several hundred steps or more of CPU calculation is required. Therefore, if communication is performed for each individual remote reference, the performance will be greatly reduced due to the startup overhead. Therefore, in a distributed memory parallel computer, it is very important to devise a method of transferring a plurality of array elements collectively and reducing the number of communications.

If the array element reference has a simple linear subscript such as a [i + 1], the range of the array element referred to by remote can be determined at compile time, and the statement for transferring the array elements collectively can be relatively easily performed. Can be generated. However, if the subscript is more complicated, the transfer sentence generation becomes more difficult. A particular problem is the case of indirect reference described below. An indirect reference is an array element reference whose subscript is an array element, such as a [p [i]]. A loop including an indirect reference is called an indirect reference loop. The indirect reference loop frequently appears in actual problems such as the calculation of a coarse matrix generated by the finite element method and the Gaussian elimination method with pivot exchange. The feature of the indirect reference loop is that it is impossible to generate a data transfer statement by compiling the elements referred to by remote at the time of compilation because the value of the subscript is unknown until the time of execution. Therefore, the indirect reference loop is more difficult to parallelize than the loop having a linear subscript.
The prior art relating to the parallelization method of the indirect reference loop includes Koelbel and Mehtra, "C.
ompinging Global Name-Spac
e Parallel Loops for Dist
ribbedExecution ”, IEEE T
rans. on Parallel Land Dist
ribbed Systems, Vol. 2, N
o. 4, pp. 440-451, 1991. There, the indirect reference loop was parallelized into a loop based on the following parallel execution method. The parallel execution method is to execute an "inspector loop" that creates a list including position information of array elements referred to by remote at the beginning of the program. If the value of the subscript array is invariant throughout the program, insp
The actor loop only needs to be executed once throughout the entire program. After that, the elements referred to by remote can be collectively transferred based on the list in each indirect reference loop. As another conventional technique, Kubota, Miyoshi, Ohno, Mori, Nakajima, Tomita, "Automatic parallelizing compiler for distributed memory parallel computer-Inspect
or / Executor algorithm speedup- ",
Parallel Processing Symposium JSPP'93, pp. 47-
There is 54. There, based on the above-mentioned conventional technology,
Ins in special cases such as subscript array substitution
A method for speeding up the vector loop has been proposed.

[0005]

In the conventional method, the indirect reference loop to be parallelized has a special condition. In other words, there are restrictions such as the value of the subscript array being invariable throughout the program and the value of the subscript array being replaced. Further, in the above-mentioned conventional technology, the form of the parallelized indirect reference loop was shown, but the parallelization procedure for converting the indirect reference loop into such a form is
It was not stated clearly. Furthermore, the conventional method does not address the problem that occurs when the indirect reference is on the left side of the assignment statement. That is, a loop such as for (i = 0; i <N; i ++) a [p [i]] = b [i]; (where the above sentence is in C language, and i ++ sequentially i In addition, the right side of the equation is a known value, the left side is a so-called unknown value, which is determined by the known value of the right side.) For different i, p [i] is When it takes the same value, different iterations rewrite the same element of array a.
Among them, only the value written by the last iteration remains as the value after the loop ends. For example, a [p
[2]] = b [2], p [2] = 12, and a [p
If [6]] = b [6] and p [6] = 12, b [6] remains as the value of a [12]. When this loop is executed in parallel, each array element after the end of the loop must have the same value as in serial execution that is not parallel execution, but the conventional method did not address that problem. . An object of the present invention is to enable parallel execution and parallelization of a general indirect reference loop.
In particular, it is to enable parallel execution and parallelization when an indirect reference is on the left side.

[0006]

In a program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, a loop including an indirect reference in which an array subscript is an array For inserting a statement that determines whether the referenced array element is in its own processor or another processor into the indirect reference loop, and if the referenced array element is in another processor Inserting a statement for registering information about the array element in a list in the indirect reference loop, and inserting a list exchange statement for exchanging the list between processors after the indirect reference loop. Using the exchanged list, a statement for substituting the array element value of another processor into the array element of the local processor is added to the list exchange statement. So that and inserting after the sentence. Further, in a method of executing an indirect reference loop whose array subscript is an array in parallel in a distributed memory type parallel computer, it is determined whether the referenced array element is in its own processor or another processor in the indirect reference loop. , A step of assigning to the array element when it is in its own processor, a step of registering information about the array element in a list in the indirect reference loop when it is in another processor, After the indirect reference loop ends, the steps of exchanging the list between the processors and the step of substituting the value of the array element of the other processor into the array element of the own processor by using the exchanged list are included. Further, in a program parallelizing device for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, a loop including an indirect reference in which an array subscript is an array is referred to. A means for inserting into the indirect reference loop a statement for determining whether the existing array element is in its own processor or in another processor, and information about the array element when the referenced array element is in another processor. Using a means for inserting a statement for registering a list in a list in the indirect reference loop, a means for inserting a list exchange statement for exchanging the list between processors after the indirect reference loop, and the exchanged list. And a statement for substituting the value of the array element of another processor into the array element of its own processor after the list exchange statement. It has to. Further, in a device that executes in parallel an indirect reference loop whose array subscript is an array in a distributed memory parallel computer, means for determining whether the referenced array element is in its own processor or another processor, Means for assigning to the array element when it is in its own processor, means for registering information about the array element in a list when it is in another processor, and means for exchanging the list between processors
Means for substituting the array element value of the other processor into the array element of the own processor using the exchanged list. Also, in the program parallelization method, it is determined whether the referenced array element is in its own processor or another processor for the loop in which the indirect reference whose array subscript is an array appears on the right side of the assignment statement. Inserting a statement in the indirect reference loop,
The step of inserting a statement for registering the position information about the array element in the position list in another processor into the indirect reference loop, and the position list exchange statement for exchanging the position list between the processors Using the step of inserting after the reference loop and the exchanged position list,
The step of inserting a statement that creates a value list containing the values of array elements referenced by another processor after the position list exchange statement, and the value list exchange statement that exchanges the value list between the processors A step of inserting after the value list exchange statement, a step of inserting after the value list exchange statement, and a step of substituting the value of the array element of another processor into the array element of the own processor using the exchanged value list. I am trying to include it. In the parallel execution method, a step of determining in the indirect reference loop whether the referenced array element is in its own processor or another processor, and assigning to the array element if it is in its own processor A step of registering position information about the array element in a position list in the indirect reference loop when the processor is in another processor, and a step of exchanging the position list between the processors after the end of the indirect reference loop. Creating a value list containing the values of array elements referenced by other processors using the exchanged position list; and exchanging the value list between processors.
The step of substituting the array element value of another processor into the array element of the own processor by using the exchanged value list. Also, in the program parallelization method, for the loop where an indirect reference in which the array subscript is an array appears on the left side of the assignment statement, record the iteration index at which the element of the indirectly referenced array was last rewritten. Inserting the declaration statement of the final iteration array into the program, inserting the initialization statement of the final iteration array before the indirect reference loop, and the array element being referenced is in the local processor. A statement for determining whether or not it is in another processor in the indirect reference loop; a statement for recording an iteration index in the final iteration array in the indirect reference loop; In the indirect reference loop, a statement to register the assignment information about the array element in the assignment list when A step of inserting an assignment list exchange statement for exchanging the assignment list between processors after the indirect reference loop, and a value of an array element of another processor using the exchanged assignment list. Statement to assign to the array element of
And a step of inserting after the substitution list exchange statement. Also, in the program parallelization method,
For a loop in which an indirect reference in which the array subscript is an array appears on the left side of the addition and assignment statement, a statement that determines whether the referenced array element is in the local processor or another processor is the indirect reference. Inserting inside the loop,
The step of inserting a statement for registering the assignment information about the array element in the assignment list into the indirect reference loop when the processor is in another processor and the assignment list exchange statement for exchanging the assignment list between the processors are And a step of inserting after the assignment list exchange statement, a step of inserting after the reference loop, and a statement for adding and assigning the value of the array element of another processor to the array element of the own processor using the exchanged assignment list. I am trying to include it. In the parallel execution method, a step of determining in the indirect reference loop whether the referenced array element is in its own processor or another processor, and addition to the array element if it is in its own processor A step of assigning, a step of registering assignment information about the array element in the assignment list in the indirect reference loop when it is in another processor, and a step of exchanging the assignment list between processors after completion of the indirect reference loop And a step of adding and substituting the array element value of the other processor to the array element of the own processor by using the exchanged substitution list.

[0007]

According to the parallel execution method of the present invention, since a list of information regarding remote references is created during execution of an indirect reference loop, parallel execution is possible even when the subscript array changes in the program. Even if there is an indirect reference on the left side, since the index of the iteration that rewrites the array element is recorded, only the value rewritten by the last iteration can be left after the loop ends. Further, according to the parallelization method of the present invention, a program that realizes the above parallel execution method can be generated.

[0008]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a flow chart showing the procedure of a program parallelization method according to an embodiment of the present invention. Before describing program parallelization with reference to FIG. 1, a configuration of a parallel computer on which a program parallelized by the present invention operates and a parallel execution method of an indirect reference loop by the present invention on the parallel computer will be described. explain. FIG. 2 shows an example of the configuration of a distributed memory type parallel computer to which the present invention is applied. This parallel computer executes a program parallelized by the program parallelization method of the present invention. The parallel computer is composed of a plurality of processors 201 to 20n, local memories 211 to 21n associated with each processor, and an interconnection network 22 connecting them. 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 for data associated with one processor to be referenced by another processor, the data must be transferred through the interconnection network 22.

FIG. 3 shows an example of an indirect reference loop. The first line is a declaration statement of the arrays a and b of 10,000 elements of real number type, and the second line is the declaration statement of the array p of 10,000 elements of integer type. The third to fifth lines are indirect reference loops. The subscript of the array b on the right side of the assignment statement on the 4th line is the array p. When this loop is executed on a distributed memory parallel computer, the loop iterations and array elements are divided and assigned to each processor. For example, processor 1: iteration 0 to 99, array a
[0] to a [99], b [0] to b [99], p
[0] to p [99] Processor 2: Iterations 100 to 199, arrays a [100] to a [199], b [100] to b
[199], p [100] to p [199], and so on. Here, the iteration number is represented by the value of the variable i. With this allocation, when performing a certain iteration i, the array element reference a
[I] and p [i] are always assigned to the own processor. That is, a local reference. However, the array element reference b [p [i]] is not always assigned to the own processor. That is, there is a possibility of referring to remote. Whether b [p [i]] is a local reference or a remote reference is determined by the value of p [i] and is not fixed until the program is executed. Considering this situation, the parallel execution method of this indirect reference loop will be described. In the following, a processor to which an array element is assigned is called an "owner", and a processor to which an iteration that refers to the element is assigned is called a "referencer" (for example, b [p [ 2]] = b [12
0], the processor assigned the iteration of i = 2 referring to the element b [120] is the processor 1, and the processor 1 in this case is the referencer. ). Also, the index of the indirectly referenced array element, that is, the value of p [i] (for example, p
The value 120) of [2] is the "owner index",
The iteration index i (eg i in the previous example)
= 2) is called a "referencer index".

FIG. 5 is a flow chart showing the procedure of the parallel execution method according to the present invention of the indirect reference loop of FIG. 3 on the parallel computer of FIG. This procedure is executed by each of the processors 201 to 20n of the parallel computer. First, each processor performs steps 400 to 40 for each iteration assigned to itself.
Process 3 is performed. After the processing for all iterations is completed, the processing from step 404 to step 407 is executed. The details of the processing of each step will be described below. Step 400 is a determination as to whether or not there are still unprocessed iterations assigned to itself. Step 401 if there are unprocessed iterations
Then, the process for the iteration is performed. The indirect reference b [p [i]] is loc in step 401.
It is determined whether it is an al reference or a remote reference. This determination is possible because the value of the subscript array p [i] is fixed when the loop is executed. If it is a local reference, proceed to step 402, and if it is a remote reference, step 403.
Proceed to. In step 402, the substitution for the local reference is executed. Since the array element that is locally referenced is on its own processor, interprocessor communication is not necessary for this assignment. In step 403, the position information regarding the remote reference is registered in the position list. Here, the position information means that if the processor number of the owner of the element b [p [i]] (for example, b [p [2]] = b [120], the processor number of the owner is 2. ), The value of the owner index p [i] (for example, if p [2] = 120, the value is 120), and the referencer index i.
Value (for example, if b [p [2]], this value is 2). The structure of the position list will be described later with reference to FIG. If there is no unprocessed iteration in step 400, the process proceeds to step 404, and after that, post-processing of remote reference is performed based on the position list. Step 404
At the time of proceeding to, the position list of each processor has registered therein the position information regarding the remote reference such that the processor itself is the referrer. This is called a "referencer side position list". In step 404, location lists are exchanged between all processors so that location information for remote references passes from the referrer to the owner. At this time, referrer information is also passed. As an exchange method, for example, Johnsson
and Ho, "Optimum Broadca
sting and Personalized Co
mmunication in Hypercube
s ", IEEE Trans. on Comput
ers, Vol. 38, No. 9, pp. 124
A method such as all-to-all communication described in 9-1268, 1989 may be used. This exchange causes each processor to have a location list for remote references that it owns. This is called the "owner side position list". In step 405, based on the owner side position list, a value list including the value of the remote reference owned by itself (this is called an "owner side value list") is created. The structure of the value list will be described later with reference to FIG. In step 406, remote
Exchange lists of values among all processors so that the values of a reference pass from owner to referencer. This exchange causes each processor to have a list of values for remote references that it is a referrer to. This is called a "referencer side value list". In step 407, the value of b [p [i]] is set to the array element a [i] on the left side of the remote reference which is the referrer based on the referrer side value list.
To. Through the above processing, parallel execution of the indirect reference loop in FIG. 3 is completed.

Next, the structure of the position list and the value list used in this parallel execution method will be described. FIG. 6 shows the structure of the referrer side position list. It is composed of a header 500 having an entry for each owner and a list body 501 connected from each entry with a pointer. One entry in the list body 501 corresponds to each remote reference. The list body 501 has two fields 504 and 50 representing an owner index and a referrer index.
It consists of 5. The header 500 includes a field 502 indicating the processor number of the owner and a field 503 indicating the number of pairs (registration number) registered in the list body. For example, the first item (hatched portion) of the position list in FIG. 6 indicates that the value of the array element b [66] of the processor No. 4 should be assigned to the array element a [5] of this processor. It represents. The structure of the owner-side position list is almost the same as the structure of the referrer-side position list, except that the owner field 502 in the header 500 is replaced with a field representing the referencer.

FIG. 7 shows the structure of the owner-side value list.
Similar to the position list, the header 510 and the list body 511
Composed of. The entry of the header 510 is provided for each referrer. The contents of the list body 511 are values of array elements to be transferred. The order of the values should match the order of the indexes in the position list. For example, in FIG.
The shaded portion of the value list of indicates that the value 13.2 is referred to by the processor 5. Which array element on the referrer side is assigned the value of 13.2 can be known by the order correspondence with the position list on the referrer side when the value list is sent to the referrer side. The structure of the referrer side value list is almost the same as the structure of the owner side value list, except that the referrer field 512 in the header 510 is replaced with a field representing the owner. This is the end of the description of the parallel execution method of the indirect reference loop according to the present invention.

Next, a parallel execution device for the parallel execution method of the indirect reference loop according to the present invention will be described. Figure 8
Represents an example of such a parallel execution device. In each processor 20, a calculation unit 230 and a remote reference determination unit 2
31, position information registration unit 232, network control unit 23
3, value list creation unit 234, remote reference assignment unit 2
35, reference side position list 240, owner side position list 241, owner side value list 242, reference side value list 2
Including 43. Each list 240 to 243 can be placed in the local memory 21. The remote reference determination unit 231 performs the process of step 401 in FIG. That is, the owner index p of the indirect reference from the calculation unit 230
[I] is received and it is a local reference or remote
e Determine whether it is a reference. The position information registration unit 232 performs the process of step 403 of FIG. That is, remote
The location information about the reference is registered in the referrer side location list 240. The network control unit 233 performs the processing of step 404 and step 406 of FIG. That is,
Through the interconnection network 22, the location list 240
And 241 and the value lists 242 and 243 are exchanged between the processors. The value list creation unit 234 performs the process of step 405 of FIG. That is, the owner-side value list 242 is created based on the owner-side position list 241. The arithmetic unit 230 performs normal arithmetic processing. This includes
Including substitution execution of local reference in step 402 of FIG. The remote reference assigning unit 235 performs the process of step 407 in FIG. That is, using the referrer side value list 243, substitution is performed for the remote reference, which is the referrer.

Returning to FIG. 1, details of one embodiment of the program parallelizing method of the present invention will be described. The parallelization method of this embodiment targets an indirect reference loop of the form shown in FIG. That is, the loop that satisfies the following conditions is targeted. (1) The content of the loop is one assignment statement. (2) Each side of the assignment statement is one array element reference. The arrangement on both sides is different. (3) The subscript of the array on the left side is the loop iteration index i. (4) The subscript of the array on the right side is another array. That is, the right side is an indirect reference. By this parallelization method, the indirect reference loop of FIG. 3 is converted into the parallel execution program 301 as shown in FIG. The program shown in FIG. 4 realizes the parallel execution method 40 shown in FIG.

Below, referring to the program of FIG.
Details of the parallelization method of FIG. 1 will be described. Step 100
Then, before the assignment statement in the loop, a statement that determines whether the indirect reference is a local reference or a remote reference is inserted. This corresponds to the fourth line in FIG. Where owner (p [i]) is
This is a library function for obtaining the owner processor number from the index value p [i]. Further, _self is a variable indicating the own processor number. The else in line 6 is also inserted in this step. In step 101, remote
A statement to register the location information about the reference in the location list,
It is inserted after the else, that is, in the part executed in the case of a remote reference. Put_l on line 7 of FIG.
The call of the library procedure called ocinfo () (corresponding to the processing of step 403 in FIG. 5) is the registration statement. The procedure argument is the information to be registered, that is,
The owner processor number owner (p [i]), the owner index p [i], and the referencer index i.
In step 102 to step 105, after the loop, r
Insert a statement to perform post-processing for referring to emote. Post-processing takes the form of library procedure calls. Step 1
In 02, a statement for exchanging the position list, that is, a call of the library procedure exchange_loclist () (corresponding to the processing of step 404 in FIG. 5) is inserted. In step 103, the statement that creates the list of values,
That is, the library procedure make_vallist
(B) Insert a call (corresponding to the processing of step 405 in FIG. 5). An array b that is indirectly referenced is given as an argument. In step 104, the statement for exchanging the value list, that is, the library procedure exchang
Insert a call to e_vallist () (corresponding to the processing of step 406 in FIG. 5). Step 10
In 5, the statement in which the assigner executes the substitution for the remote reference, that is, the library procedure remote_
The call of assign (a) (corresponding to the processing of step 407 in FIG. 5) is inserted. The array a to be assigned is given as an argument. These library procedure calls are inserted from the 9th line to the 12th line in the post-parallelization program of FIG. In addition, ep1, e in the third line of FIG.
p2 is a variable representing the range of iterations assigned to each processor, and a different value is set for each processor. Further, the range of the array assigned to each processor is actually from ep1 to ep2, but in FIG. 4, the size of the array in the declaration statement on the first and second lines is left as 10,000 for simplification.

This concludes the description of the method for parallelizing an indirect reference loop according to the present invention. In the present embodiment and the following embodiments, the post-parallelization program is shown in the form of the source program, but the present invention can be similarly applied even when the post-parallelization program is in the object program form.
Further, in the present embodiment and the subsequent embodiments, the serial processing program as shown in FIG. 3 is used as an example of the pre-parallelization program, but even when the pre-parallelization program is a shared memory type parallel computer program, the present invention Are applicable as well. Further, in the present embodiment and the following embodiments, the case of the one-dimensional array and the single loop has been described as an example, but the multi-dimensional array and the multiple loop can be similarly parallelized.

Next, as another embodiment of the present invention, a parallel execution method and a parallelization method of a loop having an indirect reference on the left side of an assignment statement will be described. FIG. 9 shows an example of a loop having an indirect reference on the left side. Array a on the left side of the assignment statement in the loop
Has a subscript of array p. In this loop, when p [i] takes the same value for different i, different iterations rewrite the same element of array a. Among them, only the value written by the last iteration remains as the value after the loop ends. For example, a [p
[2]] = b [2], p [2] = 12, and a [p
If [6]] = b [6] and p [6] = 12, b [6] remains as the value of a [12]. When executing this loop in parallel, each array element after the end of the loop must have the same value as in serial execution. In the parallel execution method of the present invention, in order to solve the above problem, an integer array having the same size as the left side array a is newly provided. This array is called the "final iteration array".
Each element of the final iteration array is assigned to each processor similarly to the left side array a. Each element holds the index of the iteration in which the corresponding element of the array a was last rewritten (6 in the above example).

FIG. 11 is a float chart showing the procedure of the parallel execution method of the present invention for the indirect reference loop of FIG. At step 420, an initial value is set for each element of the final iteration array. The initial value is one less than the minimum value of the iteration index. In the case of the loop of FIG. 9, -1 is set as the initial value. Step 421
Is a judgment as to whether or not there are still unprocessed iterations assigned to itself. If there is an unprocessed iteration, the process proceeds to step 422, and the process for that iteration is performed. Step 422
And indirect reference a [p [i]] is a local reference or remo
It is determined whether it is a te reference. If it is a local reference, proceed to step 423, and if it is a remote reference, step 4
Go to 25. In step 423, the substitution for the local reference is executed. For the iteration for which substitution has been performed, the index i is recorded in the final iteration array in step 424. In step 425, re
The substitution information about the mote reference is registered in the "substitution list". The substitution information registered here is the element a [p
[I]] is the processor number of the owner, the value of the owner index p [i], the value of the referencer index i, and the value of the right side array element b [i].

Here, the structure of the substitution list will be described. Figure 1
2 shows the structure of the substitution list. Similar to the position list, the header 520 has an entry for each owner, and a list body 521 connected from each entry with a pointer. The list body 521 includes three fields 524, 525, and 526, and each field represents the value of the array element b [i] on the right side, the owner index p [i], and the referencer index i. For example, the first item (hatched part) of the substitution list in FIG. 12 is that the value of 26.5 should be substituted by the iteration number 3 for the array element a [35] of the processor number 4. Is represented.

Returning to FIG. 11, if there are no unprocessed iterations in step 421, the process proceeds to step 426, and thereafter, post-processing of remote reference is performed based on the substitution list. In step 426, the substitution lists are exchanged among all the processors. This exchange causes each processor to have an assignment list for remote references that it owns. The processing from step 427 to step 430 is performed for each entry in the list body 521 of the substitution list. Step 427 is a determination as to whether or not there is an unprocessed entry in the list body 521. If there is no unprocessed entry, the parallel execution ends. If there is an unprocessed entry, the process proceeds to step 428, and the process for that entry is performed. At step 428, referrer index 526 in the entry.
And the element value of the final iteration array corresponding to the owner index 525 in the entry. For example, if the referrer index in the entry is i = 2,
The owner index is p [2] = 12, and last [12] = 6 in the final iteration array last.
Then, 2 and 6 are compared. If the former is less than or equal to the latter, the entry in the substitution list represents substitution by an iteration before the iteration recorded in the final iteration array. Therefore, this substitution should not be executed, and the process returns to step 427 to process the next entry. For example, the reference index in the entry is i = 2, the owner index is p [2] = 12, and the final iteration array las
When last [12] = 6 at t,
Since 2 (the former) <6 (the latter), the substitution is not executed. If the former is larger than the latter, proceed to step 429.
In step 429, substitution by remote reference is executed. For example, if the referrer index in the entry is i =
6, the owner index is p [6] = 12, and last is in the last iteration array last.
If [12] = 2, then 6 (the former)> 2 (the latter), so the substitution is executed. That is, the content of the value field 524 of the assignment list entry is assigned to the element of the left side array a corresponding to the owner index 525. In step 430, the referencer index 526 is assigned to the element of the final iteration array corresponding to the owner index 525.

Next, referring to FIG. 13, details of an embodiment of the program parallelizing method of the present invention for a loop having an indirect reference on the left side will be described. The parallelization method of this embodiment is
The indirect reference loop of the form shown in FIG. 9 is targeted. That is, the loop that satisfies the following conditions is targeted. (1) The content of the loop is one assignment statement. (2) Each side of the assignment statement is one array element reference. The arrangement on both sides is different. (3) The subscript of the array on the right side is the loop iteration index i. (4) The subscript of the array on the left side is another array. That is, the left side is an indirect reference. With this parallelization method, the indirect reference loop of FIG.
Is converted into a parallel execution program 311 as shown in FIG.
The program of FIG. 10 realizes the parallel execution method shown in the figure. Hereinafter, the details of the parallelization method in FIG. 13 will be described with reference to the program 311 in FIG. In step 120, the declaration statement of the final iteration array last is inserted. In FIG. 10, the third line is the declaration statement.
In step 121, the initialization statement of the final iteration array last is inserted immediately before the indirect reference loop. In FIG. 10, the library procedure initialize on the fourth line
The call of e () (corresponding to the processing of step 420 in FIG. 11) is the initialization statement. The arguments of the procedure are the array last to be initialized and the initial value -1. In step 122, a statement that determines whether the indirect reference is a local reference or a remote reference is inserted before the assignment statement in the loop of the program. In FIG. 10, it corresponds to the sixth line. E on the 9th line
lse is also inserted in this step. In step 123, the statement that records the iteration index in the final iteration array is inserted before the else, that is, in the portion executed in the case of the local reference. The 8th line of the figure is the sentence. In step 124, a statement for registering the substitution information about the remote reference in the substitution list is inserted after the else, that is, in the portion executed in the case of the remote reference. Put_asgn in line 10 of FIG.
The call of the library procedure called info () (corresponding to the processing of step 425 in FIG. 11) is the registration statement. The procedure argument is the information to be registered, that is, the owner processor number owner (p [i]), the owner index p [i], the referencer index i, and the right side array element b [i]. In steps 125 to 126, a statement for post-processing the remote reference is inserted after the loop. In step 125, a statement for exchanging the substitution list, that is, the library procedure exchan
ge_asgnlist () (step 426 of FIG. 11)
(Corresponding to the processing of)) is inserted. In FIG. 10, it is inserted in the 12th line. In step 126, the owner side executes a statement to execute the remote reference assignment, that is, the library procedure remote_assign_1.
Insert the call of (a). The array a to be assigned is given as an argument. In FIG. 10, it is inserted in the 13th line. This library executes the processing from step 427 to step 430 in FIG. That is, for each entry in the substitution list, the reference index and the element value of the final iteration array are compared, and substitution is executed only when the former is larger than the latter. When the substitution is executed, the index is recorded in the final iteration array. This is the end of the description of the method of parallelizing the left indirect reference loop according to the present invention.

Next, as another embodiment of the present invention, a parallel execution method and a parallelization method in the case where there is an indirect reference on the left side of an addition assignment statement (the meaning of which will be described later) will be described. The loop targeted by this embodiment satisfies the following conditions. (1) The content of the loop is one addition assignment statement. (2) Each side of the assignment statement is one array element reference. The arrangement on both sides is different. (3) The subscript of the array on the right side is the loop iteration index i. (4) The subscript of the array on the left side is another array. That is, the left side is an indirect reference. FIG. 14 shows an example of a loop targeted by this embodiment. Four
The line is an addition assignment statement. The addition assignment operator '+ =' included in it indicates that the element on the right side is added to the element on the left side, that is, a [p [i]] = a [p.
It is equivalent to [i] + b [i]. The process of adding values to array elements one after another like this loop frequently appears in a numerical calculation program. Therefore parallel execution of this loop is very important in reality.

When this type of loop is executed in parallel, the exchange coupling law of addition can be used, so the order of execution of each iteration may be arbitrary. Therefore, unlike the previous embodiment, no final iteration sequence is needed. Also, the referrer index of the body of the substitution list is not necessary. The same holds true when the operation included in the assignment operator is multiplication or the like. The parallel execution method of this loop is basically the same as that shown in FIG. 11, but for the above reason,
Many steps can be omitted. What can be omitted is initialization of the final iteration array in step 420, recording of indexes in the final iteration array in steps 424 and 430, and determination of the size of the index in step 428. The method for parallelizing the loop is basically the same as that shown in FIG. 13, but some steps can be omitted. Step 120 can be omitted.
Insert final iteration array declaration statement, step 1
The initialization statement of the final iteration array 21 is inserted, and the index recording statement of step 123 is inserted.

FIG. 15 shows the result of the parallelization method of FIG.
It is a parallel execution program in which the indirect reference loop of is parallelized. Compared to the program of FIG. 10 of the previous embodiment, the sentence regarding the final iteration array is eliminated. Also,
Registration library put_asg to the substitution list on the 7th line
The referencer index i is not included in the argument of ninfo_2 (corresponding to the processing of step 425 in FIG. 11). Exchange_asnglist_2 on line 9
Is a library procedure (corresponding to the processing of step 426 in FIG. 11) for exchanging an assignment list not including a referrer index between processors. 10th line remo
te_assign_2 is a library procedure for executing remote substitution on the owner side (step 42 in FIG. 11).
(Corresponding to the processing of 7,429), but re in FIG.
Unlike the mote_assign_1, the index comparison in step 428 and the index recording in step 430 in FIG. 11 are not included.

Next, as another embodiment of the present invention, a method for parallelizing a loop including a plurality of statements and a plurality of indirect references will be described. In this parallelization method, such a loop is converted into a combination of loops including one indirect reference described above, and then parallelized. The parallelization method of the present embodiment targets a loop that satisfies the following conditions. (1) Only an assignment statement or addition assignment statement is included in the loop.
There may be multiple sentences. (2) There is at least one indirect reference in the loop. (3) No control jumps out of the loop or jumps in the loop. (4) The right side of each assignment statement is an expression composed of array elements or scalar variables. (5) An indirect reference subscript array is not defined in the loop. (6) The indirect reference array appearing on the left side of the assignment statement is not referenced anywhere else in the loop. Hereinafter, a loop satisfying this condition will be referred to as a "general indirect reference loop". Further, the loop targeted in the above embodiments is called a "basic indirect reference loop". In the present embodiment, the loop index starts from 0 and increases by 1 for simplification, but the same method can be applied to other cases. FIG. 16 shows an example of a loop which is the target of this parallelization method.

FIG. 18 shows the procedure of the parallelization method of this embodiment. As a result of the steps 140 to 145 of FIG. 18, the general indirect reference loop 330 of FIG.
Is decomposed into a combination 331 of basic indirect reference loops.

Hereinafter, the program 330 of FIGS.
The details of the parallelization method in FIG. 18 will be described with reference to FIG. Step 14 for each indirect reference in the loop
The processing from 0 to step 145 is performed. Step 140
Is a determination of whether there is an indirect reference in the original loop. If there is no indirect reference, the original loop has already been decomposed, so the process proceeds to step 146. Step 1 if there is an indirect reference
In step 41, the process for the indirect reference is performed. In step 141, a temporary array for holding the indirect reference value is generated. The size of the temporary array is the number of loop iterations, and the type is the type of the indirect reference array. Hereinafter, this temporary array will be referred to as _tmp []. Step 14
In step 2, it is determined whether the indirect reference is on the right side or the left side.
If it is the right side, the process proceeds to step 143, and if it is the left side, the process proceeds to step 144. In step 143, the next basic dereference loop is inserted before the original loop. for (i = ...) _ tmp [i] = indirect reference; where i represents a control variable of the loop. For example, the loop of the first and second lines of FIG. 17 is inserted into the indirect reference b [q [i]] of the second line of FIG. 16, and the indirect reference e [t [i of the third line of FIG. 16 is inserted. ]]], The basic indirect reference loop of the 3rd and 4th lines of the figure is inserted. In step 144, insert the next basic dereference loop after the original loop. for (i) indirect reference = _tmp [i]; If the addition assignment operator '+ =' is used in the original assignment statement, '+ =' is also included in the assignment statement of the inserted basic indirect reference loop.
To use. For example, indirect reference a [p in the second line of FIG.
The loop of the 9th and 10th lines of FIG. 17 is inserted into [i], and the 11th and 12th lines of FIG. 17 are inserted into the indirect reference d [s [i]] of the 3rd line of FIG. Insert the basic dereference loop of. In step 145, the indirect reference in the original loop is replaced with the temporary array reference _tmp [i]. If the indirection is on the left, replace it with '=', whatever the assignment operator for it. By this step 145, the original loop of FIG. 16 is transformed as in the fifth to eighth lines of FIG. By the conversion up to step 145, the indirect reference is deleted from the original loop, and instead, the indirect reference loop is generated in steps 143 and 145. The generated loop is the basic indirect reference loop targeted in the previous embodiment and can be parallelized in the manner described above. In step 146, parallelization is performed on each of the generated basic indirect reference loops according to the method described above.
With the above, parallelization of a loop including a plurality of indirect references is completed.

FIG. 19 shows the configuration of the parallelizing compiler 6 that executes the parallelizing method of the present invention. Parallelizing compiler 6
Is a syntactic analysis unit 60, a general indirect reference loop decomposition unit 61,
The basic indirect reference loop parallelization unit 62, the normal loop parallelization unit 63, and the code generation unit 64 are included. The general indirect reference loop decomposition unit 61 includes a temporary array generation unit 610, a basic indirect reference loop generation unit 611, and an indirect reference replacement unit 612.
The basic indirect reference loop parallelization unit 62 includes remote /
Local determination sentence insertion unit 620, information registration sentence insertion unit 62
1, a list exchange statement insertion unit 622, a remote assignment execution statement insertion unit 623, a value list creation statement insertion unit 624, and a final iteration array generation unit 625. The syntax analysis unit 60 reads the pre-parallelization program 30 and generates an intermediate word 70. The intermediate language 70 is the expression of the program inside the compiler, and its format is not particularly different from that of the case of a normal compiler, so it will not be described in detail here.

The general indirect reference loop decomposition unit 61 is shown in FIG.
The processing from step 140 to step 145 is performed. That is, the general indirect reference loop is decomposed into a combination of basic indirect reference loops. Among them, the temporary array generation unit 610 performs the process of step 141 of FIG. That is, a temporary array is generated for the indirect reference in the original loop. In addition, the basic indirect reference loop generation unit 611 is
8. Steps 143 and 144 are performed, that is, a basic indirect reference loop is generated before or after the original loop depending on whether the indirect reference is the right side or the left side.
The indirect reference replacement unit 612 performs the process of step 145 of FIG. That is, the indirect reference in the original loop is replaced with the reference of the temporary array generated by the temporary array generation unit 610.

The basic indirect reference loop parallelization unit 62 is shown in FIG.
The process of step 146 of 8 is performed. That is, the parallelization shown in FIGS. 1 and 13 is performed according to the type of the basic indirect reference loop. Among them, the remote / local determination sentence insertion unit 620 uses the step 100 of FIG.
The process of step 122 of 3 is performed. That is, a statement that determines whether the indirect reference is a remote reference or a local reference is inserted into the loop. Further, the information registration statement insertion unit 621 performs the processing of step 101 of FIG. 1 and step 124 of FIG. That is, a statement that registers information in the position list or the substitution list is inserted in the loop. The list exchange statement insertion unit 622 performs the processing of step 102 of FIG. 1 and step 125 of FIG. That is, a statement for exchanging the position list and the substitution list between the processors is inserted into the program. The remote assignment execution statement inserter 623 performs the processing of step 105 of FIG. 1 and step 126 of FIG. That is, using the exchanged list, a statement for performing substitution for a remote reference is inserted. The value list creation sentence inserting unit 624 performs the process of step 103 of FIG. That is, the statement that creates the value list is inserted after the position list exchange statement in the right side indirect reference loop. The final iteration array generation unit 625 uses step 1 of FIG.
20 and the processing of step 121 are performed. That is, the declaration statement and the initialization statement of the final iteration array are inserted into the indirect reference loop on the left side. The normal loop parallelization unit 63 parallelizes a loop that is not an indirect reference loop. Further, the code generator 64 reads the intermediate word 70 and generates the post-parallelization program 31. Since the contents of these processes are not particularly different from the case of the conventional parallelizing compiler, the details will not be described here.

[0031]

According to the present invention, a general indirect reference loop program can be parallelized for a distributed memory parallel computer. Further, the program of the indirect reference loop when the indirect reference is on the left side can be parallelized for the distributed memory parallel computer. Further, in a distributed memory type parallel computer, a general indirect reference loop can be executed in parallel. Further, in the distributed memory type parallel computer, the indirect reference loop when the indirect reference is on the left side can be executed in parallel.

[Brief description of drawings]

FIG. 1 is a diagram showing a flowchart of an embodiment of a method for parallelizing an indirect reference loop according to the present invention.

FIG. 2 is a diagram showing a configuration example of a distributed memory parallel computer that executes a program parallelized by the parallelization method of the present invention.

FIG. 3 is a diagram illustrating an example of a right-side indirect reference loop before parallelization.

4 is a diagram showing an indirect reference loop as a result of applying the parallelization method of FIG. 1 to the indirect reference loop of FIG.

FIG. 5 is a diagram showing a flowchart of an embodiment of a parallel execution method of a right side indirect reference loop according to the present invention.

6 is a diagram showing a structure of a position list used in the parallel execution method of FIG.

7 is a diagram showing the structure of a value list used in the parallel execution method of FIG.

8 is a diagram showing a configuration example of an apparatus that realizes the parallel execution method of FIG.

FIG. 9 is a diagram illustrating an example of a left-side indirect reference loop before parallelization.

10 is a diagram showing a program resulting from applying the parallelization method of the present invention to the indirect reference loop on the left side of FIG.

FIG. 11 is a diagram showing a flowchart of an embodiment of a parallel execution method of a left side indirect reference loop according to the present invention.

12 is a diagram showing a structure diagram of an assignment list used in the parallel execution method of FIG.

FIG. 13 is a diagram showing a flowchart of an embodiment of a method for parallelizing a left side indirect reference loop according to the present invention.

FIG. 14 is a diagram illustrating an example of an addition / substitution indirect reference loop before parallelization.

15 is a diagram showing an addition / substitution indirect reference loop of FIG.
It is a figure which shows the program as a result of applying the parallelization method of this invention.

FIG. 16 is a diagram showing an example of a general indirect reference loop.

17 is a diagram showing a program as a result of applying the method of the present invention to the general indirect reference loop of FIG. 16 and decomposing it into a combination of basic indirect reference loops.

FIG. 18 is a diagram showing a flowchart of an embodiment of a method for parallelizing a general indirect reference loop according to the present invention.

FIG. 19 is a diagram showing an example of a parallelizing compiler that executes the indirect reference loop parallelizing method of the present invention.

[Explanation of symbols]

 22 Mutual connection network 20, 201 to 20n Processor 21, 211 to 21n Local memory 230 Calculation unit 231 remote reference determination unit 232 Location information registration unit 233 Network control unit 234 Value list creation unit 235 remote reference substitution unit 240 Reference side position list 241 Owner side position list 242 Owner side value list 243 Referencer side value list 500, 510, 520 Header 501, 511, 521 List body

 ─────────────────────────────────────────────────── ─── Continuation of front page (72) Masahiro Kainaga, Inventor Masahiro Kainaga 1099, Ozenji, Aso-ku, Kawasaki, Kanagawa, Ltd.Inside Hitachi, Ltd. Systems Development Laboratory (72) Inventor, Yasuhiko Saito, 1099, Ozenji, Aso-ku, Kawasaki, Kanagawa Ceremony company Hitachi Systems Development Laboratory

Claims (20)

[Claims] 1. A program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, wherein a loop including an indirect reference whose array subscript is an array, Inserting a statement in the indirect reference loop to determine whether the referenced array element is in its own processor or another processor, and if the referenced array element is in another processor, the array element Inserting a statement for registering information on the list in the indirect reference loop, inserting a list exchange statement for exchanging the list between processors after the indirect reference loop, and the exchanged statement. Insert a statement that uses the list to assign the value of the array element of another processor to the array element of the local processor after the list exchange statement And a program parallelizing method. 2. A method for executing an indirect reference loop in which array subscripts are arrays in parallel in a distributed memory parallel computer, in which whether the referenced array element is in its own processor or another processor is indirect. A step of making a decision in a reference loop; a step of assigning to the array element when it is in its own processor; a step of registering information about the array element in a list when it is in another processor in the indirect reference loop And a step of exchanging the list between processors after the end of the indirect reference loop, and a step of substituting an array element value of another processor into an array element of the own processor using the exchanged list. Parallel execution method of indirect reference loop. 3. A program parallelizing apparatus for converting a serial processing program or a shared memory type parallel computer program into a distributed memory type parallel computer program, for a loop including an indirect reference whose array subscript is an array, Means for inserting into the indirect reference loop a statement that determines whether the referenced array element is in its own processor or another processor; and if the referenced array element is in another processor, the array element Means for inserting a statement for registering information on the list in the indirect reference loop, and means for inserting a list exchange statement for exchanging the list between processors after the indirect reference loop, and And a means for inserting a statement that substitutes the value of the array element of another processor into the array element of the own processor using the list, after the list exchange statement. Program parallelizing apparatus, characterized in that it comprises. 4. An apparatus for executing parallel execution of an indirect reference loop whose array subscript is an array in a distributed memory parallel computer, determines whether the referenced array element is in its own processor or another processor. Means, means for substituting to the array element when it is in its own processor, means for registering information about the array element in a list when it is in another processor, and means for exchanging the list between processors And a means for substituting the array element value of the other processor into the array element of the own processor by using the exchanged list. 5. A program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, for a loop including a plurality of indirect references in which array subscripts are arrays. And decomposing the loop to convert a combination of a plurality of loops each including one indirect reference, and parallelizing each of the decomposed loops according to the parallelization method of claim 1. A program parallelization method including: 6. The program parallelization method according to claim 5, wherein the step of decomposing an indirect reference loop and converting it into a combination of a plurality of loops each including one indirect reference is performed for each indirect reference. , Generating a temporary array,
A step of replacing the indirect reference in the indirect reference loop with a reference of the temporary array; and a new loop including an assignment statement having the indirect reference and the temporary array element on both sides, before or after the indirect reference loop. And a step of generating the program. 7. In a program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, an indirect reference in which an array subscript is an array appears on the right side of an assignment statement. For the loop, insert a statement in the indirect reference loop to determine whether the referenced array element is in its own processor or in another processor; Inserting a statement for registering position information in a position list into the indirect reference loop; inserting a position list exchange statement for exchanging the position list between processors after the indirect reference loop; Using the created position list, a statement to create a value list containing the values of the array elements referenced by other processors, Inserting after the position list exchange statement, inserting a value list exchange statement for exchanging the value list between processors after the value list creation statement, and using the exchanged value list for another processor And a statement for substituting the value of the array element into the array element of its own processor, after the value list exchange statement. 8. The program parallelization method according to claim 7, wherein the position information registered in the position list refers to the processor number of the processor that owns the array element being referenced, the index of the array element, and the array element. A method for parallelizing a program, which includes an index of a loop iteration being performed. 9. In a method of executing in parallel a loop in which an indirect reference in which an array subscript is an array appears on the right side of an assignment statement in a distributed memory parallel computer, whether the referenced array element is in its own processor or not In the indirect reference loop, it is determined whether it is in a processor, when it is in its own processor, it is assigned to the array element, and when it is in another processor, the position information about the array element is indirect. Registering in a position list in a reference loop, exchanging the position list between processors after the indirect reference loop, and using the exchanged position list, an array element referenced by another processor Creating a list of values containing values, exchanging the list of values between processors, and using the exchanged list of values Characterized in that it comprises a step of substituting the value of the array element processor array element of its own processor, parallel execution method of indirect reference loop. 10. The parallel execution method of an indirect reference loop according to claim 9, wherein the position information registered in the position list is the processor number of the processor owning the referenced array element, the index of the array element, and the array. A parallel execution method of an indirect reference loop, characterized by including an index of a loop iteration referencing an element. 11. In a program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, an indirect reference in which an array subscript is an array appears on the left side of an assignment statement. For the loop, insert a declaration statement of the final iteration array that records the index of the iteration in which the elements of the dereferenced array are last rewritten, and an initialization statement for the final iteration array. Is inserted before the indirect reference loop, a statement for determining whether the referenced array element is in its own processor or another processor is inserted in the indirect reference loop, and a final iteration is performed. Insert the statement that records the iteration index into the array in the indirect reference loop. A step of inserting, in the indirect reference loop, a statement for registering the assignment information about the array element in the assignment list when it is in another processor; and an assignment list exchange statement for exchanging the assignment list between the processors. A step of inserting after the substitution list exchange statement, a step of inserting after the indirection reference loop, and a statement for assigning the array element value of another processor to the array element of the own processor using the exchanged substitution list And a program parallelizing method including: 12. The program parallelization method according to claim 11, wherein the assignment information registered in the assignment list refers to a processor number of a processor that owns the array element being referred to, an index of the array element, and the array element. A method for parallelizing a program, which includes an index of a loop iteration being performed and a value to be assigned to the array element. 13. A method of executing in parallel a loop in which an indirect reference in which an array subscript is an array appears on the left side of an assignment statement in a distributed memory parallel computer, records the index of the iteration that rewrites the array element last. Initializing the final iteration array, determining in the indirect reference loop whether the referenced array element is in its own processor or another processor, and if it is in its own processor, the array A step of executing assignment to an element and recording an iteration index in the final iteration array; and a step of registering assignment information about the array element in another indirect reference loop in the assignment list in the indirect reference loop Exchanging the assignment list between processors after the indirect reference loop ends, and the exchanging step. And a step of substituting the array element value of another processor into the array element of the own processor using the assigned assignment list. 14. The parallel execution method for an indirect reference loop according to claim 13, wherein the assignment information registered in the assignment list includes a processor number of a processor which owns the array element being referred to, an index of the array element, and the array. A parallel execution method of an indirect reference loop, characterized by including an index of loop iteration referring to an element and a value to be assigned to the array element. 15. The parallel execution method of an indirect reference loop according to claim 13, wherein the step of substituting the array element value of another processor with the array element of the other processor by using the exchanged substitution list,
The step of comparing the index stored in the final iteration array with the loop iteration index in the assignment list, and when the former is less than the latter,
A parallel execution method of an indirect reference loop, which comprises the step of executing substitution and storing the latter in a final iteration array. 16. An element of an indirectly referenced array is rewritten last in a method of executing in parallel a loop in which an indirect reference in which an array subscript is an array appears on the left side of an assignment statement in a distributed memory parallel computer. A parallel execution method of an indirect reference loop, characterized in that an array for recording an iteration index is provided. 17. In a program parallelization method for converting a serial processing program or a shared memory parallel computer program into a distributed memory parallel computer program, an indirect reference whose array subscript is an array is on the left side of the addition assignment statement. For the loop that appears, insert a statement in the indirect reference loop that determines whether the referenced array element is in its own processor or in another processor, and if it is in another processor, Inserting a statement for registering the assignment information of the assignment list in the assignment list into the indirect reference loop, and inserting an assignment list exchange statement for exchanging the assignment list between processors after the indirect reference loop, Using the exchanged assignment list, add and assign the value of the array element of another processor to the array element of the local processor.
And a step of inserting after the substitution list exchange statement. 18. The program parallelization method according to claim 17, wherein the assignment information registered in the assignment list includes a processor number of a processor which owns the referenced array element, an index of the array element, and an array element. A program parallelization method including a value to be substituted. 19. In a method for executing in parallel a loop in which an indirect reference in which an array subscript is an array appears on the left side of an addition assignment statement in a distributed memory parallel computer, is the referenced array element in the own processor? Determining in the indirect reference loop whether it is in another processor, adding and assigning to the array element when it is in its own processor, and assigning information about the array element when it is in another processor Registering in the assignment list in the indirect reference loop, exchanging the assignment list between processors after the indirect reference loop, and using the exchanged assignment list to set the values of array elements of other processors. A parallel execution method of an indirect reference loop, comprising the step of adding and substituting to array elements of a processor. 20. The parallel execution method for an indirect reference loop according to claim 19, wherein the assignment information registered in the assignment list includes a processor number of a processor owning the referenced array element, an index of the array element, and an index of the array element. A parallel execution method of an indirect reference loop characterized by including values to be assigned to array elements.