Data updating method using overlap area and program converting device for converting update program in distributed-memory parallel processor

Abstract

In a parallel processor, a local area and an overlap area are assigned to the memory of each processing element (PE), and each PE makes calculations to update the data in both areas at the runtime. If the data in the overlap area is updated in processes closed in the PEs, the data transfer between adjacent PEs can be reduced and the parallel processes can be performed at a high speed.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to a method of executing a program at a high-speed through a distributed-memory parallel processor, and more specifically to a data updating method using an overlap area and a program converting device for converting a data update program.

2. Description of the Related Art

Recently, a parallel processor draws people's attention as a system of realizing a high-speed processor such as a super-computer in the form of a plurality of processing elements (hereinafter referred to as PE or processors) connected through a network. In realizing a high processing performance using such a parallel processor, it is an important problem to reduce the overheads of the data communications to the lowest possible level. One of the effective PE of reducing the overheads of the data communications between processors is to use an overlap area for specific applications.

The time required for data communications depends on the number of times of packet communications rather than the total volume of data. Therefore, integrating the communications and representing the messages by vector (S, WP, K. Kennedy, and C. WP "Compiler WP for Fortran D on WP Distributed-Memory Machines," in Proc. WP '91 pp. 86-100, Nov. 1991.) are important in reducing the communications overheads. An overlap area is a special type of buffer area for receiving vector data, and is assigned such that it encompasses a local data area (local area) to be used in computing data internally. The data value of the overlap area is determined by the adjacent processor.

FIG. 1 shows the program code (Jacobi code) of the Jacobi relaxation written in high performance Fortran (HPF). In the Jacobi code shown in FIG. 1, the values of element a (i, j) of the two-dimensional array A are updated using the values of four adjacent elements a (i, j+i), a(i, j-1), a(i+1, j), and a(i-,j). The size of the array a is specified by a (256, 256). The elements where i=1, 256, j=1, 256 are not updated. For example, the element a(2:255) in the DO loop of the update of data is an array description of Fortran 90, and the number of times of occurrences of the DO loop is t times. This code refers to a typical example of the update of data using an overlap area.

FIG. 2 shows an example of the overlap area in which the Jacobi code shown in FIG. 1 is executed. According to the data distribution specified in the program shown in FIG. 20, the elements in the array a (256, 256) are distributed into the local areas of 16 processors P (x, y) (x=1, 2, 3, 5, y=1, 2, 3, 4) and stored therein. For example, the processor p (2, 2) controls the range of a (65:128, 65:128) in the array a. In FIG. 2, the shadowed portion around the local area of the processor p(2,2) indicates the overlap area at p(2, 2).

The processor p(2, 2) has a considerably large area of a(64:129, 64:129) including an overlap area so that, when a(i, j) is calculated, the adjacent a(i, j+1), a(i, j-1), a(i+1, j), and a(i-1, j) can be locally accessed.

Without an overlap area, data should be read from adjacent processors in the DO loop and a small volume of data are frequently communicated, resulting in a large communications overheads. However, having an overlap area allows the latest data to be copied to the overlap area by collectively transferring data before an updating process. Therefore, data can be locally updated and the communications overheads can be considerably reduced.

Thus, the overlap area can be explicitly specified by VPP Fortran ("Realization and Evaluation of VPP Fortran Process System for AP1000" Vol. 93-HPC-48-2, pp. 9-16. Aug. 1993 published at SWOPP Tomonoura '93 HPC Conference by Tatsuya Sindoh, Hidetoshi Iwashita, Doi, and Jun-ichi Ogiwara). A certain compiler automatically generates an overlap area as a form of the optimization.

The data transmission patterns for performing parallel processes can be classified into two types. One is a single direction data transfer SDDT, and the other is a bi-directional data transfer BDDT. FIG. 3 shows an example of the SDDT, and FIG. 4 shows an example of the BDDT.

In FIGS. 3 and 4, processors i-1, i+1, and i+2 are arranged in a specified dimension and forms a processor array. The SDDT is a transfer method in which all transfer data are transferred in a single direction from the processor i toward the processor i+1 with time in the specified dimension. The BDDT is a transfer method in which data is transferred between adjacent processors in two directions. Thus, some pieces of data are transmitted from the processor i to the processor i+1 while other pieces of data are transmitted from the processor i+1 to the processor i.

FIG. 5 shows the program code of the Jacobi relaxation for a one-dimensional array. In the Jacobi code shown in FIG. 5, the value of the element a(i) of the one-dimensional array a is updated by the output of a function f obtained by inputting to the function f the two adjacent elements a(i-1) and a(i+1). The size of the array a is specified by a(28), and a(1) and a(28) are not updated. The data is updated repeatedly for the time specified by time.

FIG. 6 shows an example in which data is updated using the conventional overlap area when a program shown in FIG. 5 is executed. In FIG. 6, PE0, PE1, PE2, and PE3 are four PEs for dividing and managing the array a. Each PE has an area for storing 9 array elements. A dirty overlap area stores old data and a clean overlap area stores the same latest data as the adjacent PE. A local area stores data to be processed by each PE.

The word "INIT" indicates an initial state and "Update" indicates the data communications between adjacent PEs to update the overlap area. Iter 1, 2, 3, and 4 indicate parallel processes for the update of data at each iteration of the DO loop. In FIG. 6, the overlap area is updated by the BDDT for each iteration.

However, the data update method using the conventional overlap area has the following problems.

Each processor forming part of the parallel processor should update the data in the overlap area into the latest value before making a calculation using the data value of the overlap area. The update process is performed by reading the latest value from the adjacent processor through the communications between processors. In parallel processors, the overheads are heavy for a rise time. Therefore, the time required for the communications process depends on the number of times of data transfers rather than the amount of transferred data. If an overlap area is updated each time a calculation is made using the overlap area, then each communications rise time is accompanied by overheads.

In a parallel processor connected through a torus network such as an AP1000 ("An Architecture of Highly Parallel Computer AP1000," by H. Ishihata, T. Horie, T. Shimizu, and S. Kato, in Proc. IEEE Pacific Rim Conf. on Communications, Computers, and Signal Processing, pp. 13-16, May 1991), the SDDT excels to the BDDT in characteristic because the SDDT can reduce the time of data transfers and the overheads required in a synchronization process between adjacent processors more than the BDDT. However, in the conventional data update process as shown in FIG. 6, the data in the overlap areas should be exchanged between adjacent processors, and the data transfer pattern is based on the BDDT. In the BDDT, each processor should perform communications in synchronism with adjacent processors. As a result, the time of data transfers increases and the overheads for the synchronization processes become heavier than the SDDT.

3. Summary of the Invention

The present invention aims at updating data with the overheads for the communications between PEs reduced in the distributed-memory parallel processors, and providing a program converting device for generating a data updating program.

The program converting device according to the present invention is provided in an information processing device, and converts an input program into the program for a parallel processor. The program converting device is provided with a detecting unit, setting unit, size determining unit, and a communications change unit.

The detecting unit detects a portion including the description of the loop where optimization can be realized using an overlap area in the input program. The setting unit assigns an overlap area to the memory of the PE for processing the program at the description of the loop, generates a program code for calculating the data in the area, and then adds it to the initial program. Thus, each PE updates the data in the local area managed by the PE, and also updates the data in the overlap area managed by other PEs at the runtime of the program converted by the parallel processor. The overlap area updated by the closed calculation in each PE requires no data transfer for update, thereby improving the efficiency in parallel process.

The size determining unit estimate the runtime for the description of the loop and determines the optimum size of the overlap area. Normally, the larger the overlap area is, the smaller number of times the data is transferred while the longer time is taken for updating the data in the area. If the size of an overlap area is fixed such that the runtime is the shortest possible, the data update process can be efficiently performed.

The communications change unit checks the data dependency at the detected portion of the description of the loop. If the data is dependent bi-directionally, the description should be rewritten such that the data is dependent in a single direction, and subscripts are generated in the arrangement optimum for data transfer. Thus, each PE only has to communicate with the adjacent PE corresponding to either upper limit or lower limit of the subscripts in the array, thereby successfully, reducing the overheads of the communications.

Thus, the overlap area has been updated using the data transferred externally. However, it is updated in a calculation process in each PE, thereby reducing the overheads for the communications and performing the parallel process at a high speed.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows the Jacobi code in the two-dimensional array;

FIG. 2 shows the conventional overlap area;

FIG. 3 shows the data transfer in a single direction;

FIG. 4 shows the data transfer in two directions;

FIG. 5 shows the Jacobi code in a one-dimensional array;

FIG. 6 shows the update of data using the conventional overlap area;

FIG. 7 shows the configuration of the program converting device according to the embodiment of the present invention;

FIG. 8 shows the configuration of the parallel processor according to the embodiment of the present invention;

FIG. 9 shows the configuration of the host computer;

FIG. 10 shows the update of data using an extended overlap area;

FIG. 11 is an operating flowchart showing the extended overlap area setting process;

FIG. 12 is an operating flowchart showing the extended overlap area available portion detecting process;

FIG. 13 shows a two-dimensional extended overlap area;

FIG. 14 shows the relationship between the extended parameter and the runtime;

FIG. 15 is an operating flowchart showing the extended overlap area assigning process;

FIG. 16 shows the update of data through the data transfer in a single direction;

FIG. 17 is an operating flowchart showing the data update setting process through the data transfer in a single direction;

FIG. 18 shows the original program;

FIG. 19 shows the program after converting the calculation space;

FIG. 20 shows the program with uncalculated elements added;

FIG. 21 shows the program after converting indices;

FIG. 22 shows the distance vector for the original program;

FIG. 23 shows the distance vector after the conversion;

FIG. 24 is an operating flowchart showing the setting process;

FIG. 25 shows the update of data using an extended overlap area and data transfer in a single direction;

DESCRIPTION OF THE PREFERRED EMBODIMENTS

The embodiments of the present invention is described in detail by referring to the attached drawings.

FIG. 7 shows the configuration of the program converting device according to the embodiment of the present invention. The program converting device shown in FIG. 7 is provided in an information processing device and converts an input program into a program for a parallel processor comprising a plurality of PEs and a communications network. The program converting device comprises a detecting unit 1, a setting unit 2, a size determining unit 3, and communications change unit 4.

The detecting unit 1 detects a loop including one to be possibly optimized using an overlap area from the input program.

The setting unit 2 assigns an overlap area to a PE for processing the loop, generates a code for calculating the data in the overlap area, and outputs a converted program.

The size determining unit 3 estimates the runtime for processing the loop, determines the optimum size of the overlap area. The setting unit 2 assigns the overlap area having the size determined by the size determining unit 3 to the PE for processing the loop.

The communications change unit 4 changes the data dependency of the process of the loop from the bi-directional dependency to the uni-directional dependency to generate the subscripts of the array through which data is transferred uni-directionally (SDDT). The setting unit 2 generates a code for updating data through the uni-directional data transfer and adds the generated code to the converted program.

The detecting unit 1, setting unit 2, size determining unit 3, and communications change unit 4 shown in FIG. 7 correspond to a host computer 11 shown in FIGS. 8 and 9, and more specifically to each function of a compiler 25 shown in FIG. 9. The compiler 25 is activated by a central processing unit (CPU) 22.

The detecting unit 1 scans an input program and detects a loop to which an overlap area can be applied. For example, the portion where a calculation process capable of performing a parallel process by a plurality of PEs is encompassed by the serial DO loop is detected as shown in FIGS. 1 and 5.

The setting unit 2 assigns an overlap area to each PE for sharing the process for the detected loop, and generates a code for calculating and updating the data in the overlap area. Thus, at the runtime of a converted program, each PE locally calculates the data in the overlap area as well as the data in the local area. Therefore, the time of communications in which data in the overlap area is updated can be reduced, thereby also reducing the communications overheads.

The size determining unit 3 estimates the runtime for processing the loop, and determines, for example, the minimal size of the overlap area. If the overlap area of the optimum size is assigned to each PE, the throughput of the parallel processor can be considerably improved.

The setting unit 2 generates a code for updating data through the SDDT, act through the BDDT. As a result, each PE does not have to communicate with both adjacent PEs at the upper limit and lower limit of the subscript in the array. Therefore, the synchronizing process is not required for the PE not to communicate with, and saving the overheads for the synchronization.

The communications change unit 4 checks the data-dependent vector in the array data used in the above described loop, converts the data into uni-directional transfer from bi-directional transfer, and generates a subscript in the array to perform the SDDT. The setting unit 2 generates a code for updating data using the subscripts in the converted array.

Thus, a program for use in a parallel processor is generated by the program converting device shown in FIG. 7. As a result, the overheads for the communications can be reduced.

FIG. 8 shows the configuration of the parallel processor for realizing the present invention. The parallel processor shown in FIG. 8 comprises the host computer 11, a network 12, and a processor array 13 comprising a plurality of PEs (PE0, PE1, . . . , PEn). The host computer 11 controls the entire parallel processor and performs input and output processes. The processor array 13 performs a parallel process. The host computer 11 is connected to each PE through the network 12.

FIG. 9 shows the configuration of the host computer 11. The host computer 11 shown in FIG. 9 comprises an input/output unit 21, the CPU 22, and a memory 23. These units are connected via an internal bus 24. In the host computer 11, the CPU 22 converts (compiles) a single program 26 into a program to be executed in parallel by each PE using the compiler 25 stored in the memory 23. The compiled program code is downloaded to each PE through the input/output unit 21 and is executed by each PE. The network 12 is used in downloading a program code or transferring data between processors at runtime.

Two methods are used for the embodiments of the present invention. One is to use an extended overlap area, and the other is -to update data through the SDDT of the overlap area.

An extended overlap area is described by referring to FIGS. 10 through 15.

An extended overlap area is a data storage area which is multiple of common overlap areas. Using an extended overlap area reduces the total number of times of the communications performed to update the overlap area when a process effectively using the overlap area is repeated for plural times in a loop of the loops performed in parallel in a program. In the program according to the Jacobi relaxation shown in FIG. 1, data can be updated for e times after a data transfer if the width of the overlap area shown in FIG. 20 is extended e times.

FIG. 10 shows the update of data when the Jacobi codes shown in FIG. 5 are executed using the extended overlap area. In FIG. 10, the conventional overlap areas of P0, P1, P2, and P3 shown in FIG. 6 are three times extended. These PEs perform parallel processes using the extended overlap area. The meanings of the dirty overlap area, clean overlap area, local area, INIT, Update, and Iter 1, 2, 3, and 4 are the same as those in FIG. 6. By locally calculating a part of the data in the extended overlap area shown in FIG. 10, data can be transferred only once each time the data is updated three times.

For example, PE1 updates the elements in the range of a(9:16) of the array a, holds the elements in the local area, and contains the storage area as an extended overlap area for the elements in the range of a(6:8) and a(17:19) (INIT), PE1 first establishes communications between PE0 and PE2 and updates the data in the extended overlap area as the latest data (Update).

Then, the first calculation is made using the data in the range of a(6:19) to update the data a(9:16) in the local area and the data a (7:8) and a (17:18) in the extended overlap area (Iter 1). Then, the second calculation is made using the data in the range of a (7:18) to update the data a (9:16) in the local area and the data a (8) and a (17) in the extended overlap area (Iter 2). Then, the second calculation is made using the data in the range of a (8:17) to update only the data a (9:16) (Iter 3).

Since all data in the extended overlap area are dirty, that is, unavailable, PE1 establishes communications again with the adjacent PE to update the extended overlap area and similarly repeats the data updating process of and after Iter 4.

In FIG. 10, each element a(i) before the update of data and each element a(i) after the update of data are stored in physically different memory areas. That is, in each PE, the local area and extended overlap area are both provided with data before the update and data after the update. However, the memory area is automatically segmented at the compilation of the program 26.

When the conventional overlap area is compared with the extended overlap area of the present invention, the total quantity of data transferred for the update of the overlap area remains the same. Since the communications overhead time depends more seriously on the time of transfer than the total quantity of the transferred data, the communications overheads can be more efficiently reduced by using the extended overlap.

Since each PE should make a calculation on a part of the extended overlap area referred to by the subsequent iteration, the calculation and process for the present PE are the same as those for the update of data in the adjacent PE. Therefore, the larger the size of the extended overlap area is, the more heavily the parallelism of the processes is impaired. As an extreme example, if an extended overlap area is set such that a single PE stores the data for all PEs, no communications are required with no parallelism obtained, though. To determine the optimum size of the extended overlap area, the communications overheads and the process parallelism should be traded off.

FIG. 11 is an operating flowchart showing the extended overlap area setting process performed by the host computer 11 to realize the extended overlap area. The extended overlap area setting process shown in FIG. 11 is performed as a part of the optimizing process by the compiler 25. The input of the optimizing process refers to an instruction (directive) to start the program 26 (serial program) and the process, while the output refers to a program to be executed by each PE. After the program 26 is converted in the optimizing process into the program for each PE, the program and necessary data is downloaded to each PE to perform a parallel process.

If a process starts according to FIG. 11, the host computer 11 detects an applicable point for the extended overlap area contained in the program 26 (step S1). That is, the portion where a parallel loop applicable for the optimization using an overlap area is encompassed by a serial loop is detected as a portion to be effectively processed using the extended overlap area. The parallel loop refers to loop processes which can be processed in parallel by a plurality of PEs as the operations described in lines 6 and 7 shown in FIG. 1. The serial loop refers to loop processes repeatedly performed in series as a DO loop described in lines 5 and 8 shown in FIG. 1.

FIG. 12 is an operating flowchart showing an example of the process in step S1 shown in FIG. 11. When a process starts according to FIG. 12, the host computer 11 selects a DO loop contained in the program 26 (step S1-1) and checks whether or not the process can be performed in parallel (step S1-2). In the case shown in FIG. 1, the parallel loop corresponds to the selected DO loop. If it can be processed in parallel, then it is determined whether or not it is a DO loop applicable effectively using an overlap area (step S1-3). A Do loop effectively applicable using an overlap area refers to a process locally performed by each PE by providing an overlap area. If the overlap area is effective, then it is determined whether or not the DO loop (parallel loop) is tightly encompassed by a serial loop (step S1-4). If the DO loop is tightly encompassed, the selected DO loop is entered in an appropriate area in a memory 23 as an applicable portion for the extended overlap area (step S1-5).

Then, it is checked whether or not any other DO loops exist (step S1-6). If yes, the processes in and after step S1-1 is repeated. If not, the process terminates. If the determination results are "No" in steps S1-2, S1-3, and S1-4, control is passed to the process in step S1-6.

As a result of the extended overlap area applicable portion detecting process shown in FIG. 12, for example, the parallel loops shown in FIGS. 1 and 4 are entered as applicable portions.

In FIG. 11, the host computer 11 performs the process in step S1, generates an executable model using the extended overlap area, and estimates the runtime for the program (step S2). Described below is the method of estimating the runtime by referring to an example of the extended overlap area for a common two-dimensional array.

FIG. 13 shows an extended overlap area provided at and around the local area of a PE storing a two-dimensional array. In FIG. 13, l shows the size (number of array elements in each dimension) of a local area, w shows the size (width) of the conventional overlap area, e is a parameter showing how much the conventional overlap area is extended, and ew shows the size (width) of the extended overlap area.

Assuming that the calculation time for a unit area (1 element) in a local area or an extended overlap area is a, the overhead time (prologue and epilogue time) taken for the activation and termination of one data transfer process is c, and that the time taken for a data transfer per unit area is d, then the data transfer time is calculated by the equation c+d×size of transferred area.

In the optimization using an extended overlap area, communications are established first for e times of data update (e iteration). The data to be communicated is the extended overlap area shown as a shadowed portion in FIG. 13. The area (number of elements) of this portion is 4ew(ew+l). The communications are established 8 times between the eight PEs processing array elements in the upper, lower, right, left, and in four diagonal directions. Therefore, the total communications time required for the e iteration is calculated by the following equation:

8e+4dew(ew+l) (1)

The communications time for an iteration is obtained by dividing equation (1) by e as follows. $\begin{array}{cc}\frac{8\⁢c+4\⁢\mathrm{dew}\⁡\left(\mathrm{ew}+1\right)}{e}& \left(2\right)\end{array}$

Then, the time taken for the calculations for the update of data is estimated. Since the number of calculation elements in the local area is 1², the calculation time required for e iteration of the calculation for the local area is ae1². If the size (width) of the updated area in the extended overlap area is kw in each iteration, the number of calculation elements in the extended overlap area is 4kw(kw+1), where k is a parameter representing how many times of the conventional overlap area the update portion is in the extended overlap area in each iteration. If data is locally updated without communications, the extended overlap area sequentially becomes dirty from outside to inside for each iteration, the width of the updated portion in the extended overlap area decreases by w each time. Accordingly, the calculation time taken for calculating the extended overlap area during the e iteration is obtained by the following equation; $\begin{array}{cc}4\⁢a\⁢\underset{k=1}{\overset{e-1}{\∑}}\⁢\mathrm{kw}\⁡\left(\mathrm{kw}+1\right)& \left(3\right)\end{array}$

Since the calculation time taken for calculating the extended overlap area at the e-k-th iteration is 4akw(kw+1), the sum of k from 1 to e-1 is calculated by equation (3). The calculation time for an iteration is obtained by adding the calculation time for the local area for e iterations to the calculation time for the extended overlap area and then by dividing the sum by e as follows. $\begin{array}{cc}\frac{4\⁢a\⁢\underset{k=1}{\overset{e-1}{\∑}}\⁢\mathrm{kw}\⁡\left(\mathrm{kw}+1\right)+{\mathrm{ael}}^2}{e}& \left(4\right)\end{array}$

According to equations (2) and (4), the runtime T_ier (e) for one serial loop using the extended overlap area is represented as a function of e as follows. $\begin{array}{cc}{T}_{\mathrm{iwr}}\⁡\left(e\right)=\frac{8\⁢c+4\⁢\mathrm{dew}\⁡\left(\mathrm{ew}+1\right)}{e}+\frac{4\⁢a\⁢\underset{k=1}{\overset{e-1}{\∑}}\⁢\mathrm{kw}\⁡\left(\mathrm{kw}+1\right)+{\mathrm{ael}}^2}{e}=\frac{8\⁢c}{e}+\left(4\⁢{\mathrm{dw}}^2-2\⁢w^2\⁢a+2\⁢\mathrm{alw}\right)\⁢e+\frac{4\⁢w^2\⁢a}{3}\⁢e^2+\left(4\⁢\mathrm{dlw}+{\mathrm{al}}^2+\frac{2}{3}\⁢w^2\⁢a-2\⁢\mathrm{alw}\right)& \left(5\right)\end{array}$

If the calculation time is estimated, the host computer 11 determines the optimum size of the extended overlap area according to the estimate result (step S3). The optimum size of the extended overlap area refers to the size for the shortest possible runtime.

For example, assuming that, in equation (5), the coefficient of the term of e² is s, the coefficient of the term of e is t, the coefficient of the term of 1/e is u, and the term O is V for e, then equation (5) is rewritten as follows.

T_iter(e)=se²+te+μ+ν (6)

FIG. 14 is the graph showing the relationship between T_iter (e) and e in equation (6). The value e_O for e corresponding to the minimum value T_iter (e_O) for T_iter (e) shown in FIG. 14 can be obtained by solving the following equation for e. $\begin{array}{cc}\frac{\ⅆT_{\mathrm{iter}}\⁡\left(e\right)}{\ⅆe}=0& \left(7\right)\end{array}$

The obtained e_O is a value of the extension parameter for optimizing the size of the extended overlap area. The size of the extended overlap area is provided by the e_Ow.

If the optimum size of the extended overlap area is determined, the host computer 11 assigns the extended overlap area of the size to each PE (step S4).

FIG. 15 is an operating flowchart showing an example of the extended overlap area assigning process performed in step S4 shown in FIG. 11. When the process starts according to FIG. 15, the host computer 11 first adds the optimum size of the extended overlap area to the data size (original data size) of the local area of each PE as a new data size (step S4-1). The optimum size of the extended overlap area is obtained as a product of the optimum extension parameter obtained in step S3 by the width of the conventional overlap area. According to the example shown in FIG. 13, the optimum size is e_Ow. Then, the data is declared again with the new data size (step S4-2), and the process terminates.

Thus, the extended overlap area of each PE is assigned the data, of the size of the extended overlap area, of the local area for another PE.

If the process is step S4 is completed, the host computer 11 inserts a program code for use in calculating an extended overlap area (step S5). Thus, a code is generated such that the range of the process of each PE in a parallel loop can be extended by the size of the extended overlap area. The generated code is put into the program.

For example, the range of the indices in an array managed by the PE1 shown in FIG. 10 is originally 9-16. If a code is generated for the range 7-18 in Iter 1, new values of indices 7, 8, 17 and 18 are obtained from the values in the extended overlap area. Likewise, the calculation for the range 8-17 in Iter 2 can be made. Thus, the new values for the indices 8 and 17 can be obtained using the values in the extended overlap area obtained in Iter 1.

Then, a program code is inserted to update the extended overlap area (step S6). In this process, a code is generated such that communications are established each time a serial loop encompassing a parallel loop is repeated for the times indicated by the extension parameter to update the data in the extended overlap area. Then, the code is put into the program of each PE.

For example, communications are established for each iteration of three serial loops in the example shown in FIG. 10. In the example shown in FIG. 13, communications are established for each iteration of e_o serial loops. After step S6, the host computer 11 terminates the process.

The update by the SDDT of the overlap area is described below by referring to FIGS. 16 through 23. Even if the overlap areas are provided on both sides of the local area as shown in FIG. 6, the communications can be converted into the uni-directional communications by shifting the data layout into the communications direction between the PEs each time the data is updated.

FIG. 16 shows an example of updating data by the SDDT when the program shown in FIG. 5 is executed. In FIG. 16, the meanings of the dirty overlap area, clean overlap area, local area, INIT, Update, and Iter 1, 2, 3, . . . are the same as those shown in FIG. 6.

The storage position of the data is shifted for each iteration into one direction in a torus form in the system using the SDDT. To convert the conventional system in which an overlap area is updated by the BDDT into the system using the SDDT, the data required to obtain a new value is sent to the adjacent PE for one direction of the two-directional communications instead of receiving the data required to calculate the new value from the adjacent PE. As a result, the communications are established uni-directionally and the overlap area can be provided for only one side of the local area.

For example, at the initial state, PE1 holds the elements in the range of a (9:16) in the array a, and has the storage area for the elements in the range of a (7:8) as an overlap area (INIT). Then, the PE1 receives the data from the PE0, updates the data in the overlap area, and transmits the data in the range of a (15:16) to the PE2 (Update).

Then, the PE1 makes the first calculation using the data in the range of a (7:16), updates the data in a (8:15) (Iter 1), and stores the data after shifting the storage position in the communications direction by 1. At this time, the data in a (16) initially stored by the PE1 is updated in parallel by the PE2. Since the data in the overlap area have become all dirty, the PE1 established uni-directional communications between the PE1 and the adjacent PE, updates the extended overlap area, and performs the data update process for Iter 2.

Since repeating these processes sequentially shifts the storage positions of all data over the PE0 through PE3 in a torus form, after data update process for Iter 4, the data in a (27:28) of the PE3 is transferred to the overlap area of the PE0.

The result of the data updated by the SDDT shown in FIG. 16 matches the result conventionally updated by the BDDT. Between the BDDT and SDDT, the total volume of transferred data is the same, but the transfer time with the SDDT can be reduced into half the transfer time with the BDDT. Therefore, by using the SDDT, the overheads required to activate the data transfer and the overheads required in the synchronization process between adjacent PEs can be reduced.

FIG. 17 is an operating flowchart showing the setting process in updating the data by the SDDT. The setting process shown in FIG. 17 can be performed by the host computer 11 as a part of the optimizing process by the compiler 25.

When the process starts as shown in FIG. 17, the host computer 11 detects the point of data update by the SDDT contained in the program 26 (step S11). That is, the point where a parallel loop applicable for the optimization using the overlap areas is encompassed by a serial loop and the overlap areas are provided for both sides (at upper and lower limits) of the local area of each PE is detected as a point where the update by the SDDT effectively works.

Then, a computational transformation is made (step S12). In this process, the position of the data calculated according to the count of the outer serial loop is shifted and the SDDT is used in updating the overlap areas.

In the computational transformation, a loop nest for determining a computational space is converted such that all data-dependent vectors can be positive in the direction along the axis of the processor array 13. For the loop where the data-dependency is represented by a distance vector, the computational space conversion can be performed as an application of unimodular transformation (M. E. Wolf and M. S. Lam. "A loop transformation theory and an algorithm to maximize parallelism," in IEEE Transaction on Parallel and Distributed Systems, pp. 452-471, Oct. 1991). In this case, the transform matrix T can be represented as follows with the dimension of the array set to m, and with the parameter of the skew in each dimension set to a₁, a₂, . . . , a_m. $\begin{array}{cc}T=\left[\begin{array}{ccccc}1& 0& 0& \mathrm{\…}& 0\\ a_1& 1& 0& \mathrm{\…}& 0\\ a_2& 0& 1& \mathrm{\…}& 0\\ \mathrm{\⋮}& \mathrm{\⋮}& \mathrm{\⋮}& \mathrm{\⋰}& 0\\ a_m& 0& 0& \mathrm{\…}& 1\end{array}\right]& \left(8\right)\end{array}$

The skew vector S containing the parameters a₁, a₂, . . . , a_m of equation (8) can be defined as follows. $\begin{array}{cc}S=\left[\begin{array}{c}{a}_1\\ a_2\\ \mathrm{\⋮}\\ a_m\end{array}\right]& \left(9\right)\end{array}$

FIG. 18 shows the program (original program) rewritten from the parallel loop of the program shown in FIG. 5 in the FORALL syntax. FIG. 22 shows the distance vector (i, j) representing the data-dependency of the original program. In FIG. 22, i indicates a time axis and corresponds to the serial loop repetition parameter, and j indicates a space axis over the PEs and is mapped along the memory space axis corresponding to the PE-connection direction (PE arrangement direction). The "j" corresponds to the parameter of the FORALL syntax shown in FIG. 18.

In the program shown in FIG. 18, the communications for the update of the overlap area is the BDDT because the distance vector is bi-directional over a plurality of PEs if the j axis is mapped in the PE array. When a pair of distance vectors representing the program data dependency is D, the following equation exists.

D={(1,-1), (1,1)}

Next, a conversion matrix T in which the time axis is removed to make the program loop nest fully permutable is obtained. Since the array is one-dimensional, the conversion matrix T in equation (8) forms a 2×2 matrix (2 rows by 2 columns) and the following equation exists. $\begin{array}{cc}T=\left[\begin{array}{cc}1& 0\\ a_1& 1\end{array}\right]& \left(11\right)\end{array}$

With T set as shown above, the distance vector (1,-1) and (1, 1) are converted as follows. $\begin{array}{cc}\left[\begin{array}{cc}1& 0\\ a_1& 1\end{array}\right]\⁡\left[\begin{array}{c}1\\ -1\end{array}\right]=\left[\begin{array}{c}1\\ a_1-1\end{array}\right]& \left(12\right)\\ \left[\begin{array}{cc}1& 0\\ a_1& 1\end{array}\right]\⁡\left[\begin{array}{c}1\\ 1\end{array}\right]=\left[\begin{array}{c}1\\ a_1+1\end{array}\right]& \left(13\right)\end{array}$

Equation (12) indicates that the distance vector (1, -1) is converted by T into the distance vector (1, a₁-1). Equation (13) indicates that the distance vector (1, 1) is converted by T into the distance vector (1, a₁+1).

To make the loop nest fully permutable, both components a₁-1 and a₁+1 of the converted distance vector should be equal to or larger than 0. This condition is represented by the following equation.

a₁≧1 (14)

The minimum value of a₁, satisfying the conditions to make the loop nest permutable is 1. The "T" in equation (11) is represented as follows. $\begin{array}{cc}T=\left[\begin{array}{cc}1& 0\\ 1& 1\end{array}\right]& \left(15\right)\end{array}$

The converted distance vectors obtained from equations (12) and (13) are (1, 0) and (1, 2) respectively, and the skew vector S (a scalar in this case) is S=a₁=1 by equation (9).

FIG. 23 shows the distance vector obtained by applying the conversion matrix T of equation (15) to the distance vector shown in FIG. 22. In FIG. 23, the component j of all distance vectors is positive, and the data over all PEs depends uni-directionally.

If the "T" in equation (15) is applied to (i, j) of the program shown in FIG. 18, the converted values (i', j') are obtained by the following equation. $\begin{array}{cc}\left[\begin{array}{c}i\\ j\end{array}\right]=\left[\begin{array}{cc}1& 0\\ 1& 1\end{array}\right]\⁡\left[\begin{array}{c}i\\ j\end{array}\right]=\left[\begin{array}{c}i\\ i+j\end{array}\right]& \left(16\right)\end{array}$

FIG. 19 shows the program obtained by rewriting the virtual array a of the program shown in FIG. 18 by the paradigm of a shared memory. The actual array corresponding to the virtual array a is distributed over plural PEs and statically assigned a memory area.

When the computational space transform is completed, the host computer 11 performs an index transformation (step S13). In this process, the data layout is shifted according to the changes in data dependency.

With the changes in data dependency, the data layout in the memory space of each PE should be aligned into the mapping for the calculation process. However, it cannot be aligned into the mapping in which the calculation position is shifted with the static data layout declared in the data parallel language such as the HPF, thereby disabling the SDDT. As a result, the relationship between the virtual array and the actual array should be changed with time so that the data alignment to each PE can be shifted for each iteration of the serial loop.

Assuming that the subscript vector of the m-dimensional virtual array is I_ν1, I_ν2, . . . , I_νm) and the subscript vector of the corresponding actual array is I_p=(I_p1, I_p2, . . . , I_pm), the index transform from I_ν to I_p is represented as follows. $\begin{array}{cc}{I}_p=I_v+\mathrm{tS},I_p=\left[\begin{array}{c}{I}_{\mathrm{p1}}\\ I_{\mathrm{p2}}\\ \mathrm{\⋮}\\ I_{\mathrm{pm}}\end{array}\right],I_v=\left[\begin{array}{c}{I}_{\mathrm{v1}}\\ I_{\mathrm{v2}}\\ \mathrm{\⋮}\\ I_{\mathrm{vm}}\end{array}\right]& \left(17\right)\end{array}$

However, the time step t is used for the subscript in the virtual array before update while the time step t+1 is used for the subscript in the virtual array after update. After performing such indexing processes, the storage positions of all elements in an actual array can be sifted in each time step. However, since the elements at the upper and lower limits of the virtual array are not calculated and not updated unless new values are assigned, the storage positions should be shifted with the values of the elements stored. A code is inserted to ensure such consistency before applying the index conversion process.

FIG. 20 shows the program obtained by adding to the program shown in FIG. 19 a code to hold an uncalculated element value. In FIG. 20, the cases where j'=i=-1 and j'=i'+26 correspond to the processes of the element at the upper and lower limit respectively, and a statement is inserted to set these element values constant.

FIG. 21 shows the program obtained by applying the index conversion process to the program shown in FIG. 20. In FIG. 21, A shows an actual array corresponding to the virtual array a. At this time, the conversion of the parameter in the index conversion process is represented as follows.

J←j'+t (18)

t←i'+1 for LHS (left side) (19)

t←i' for RHS (right side) (20)

where the conversion by equation (18) replaces all j's in the program with J after converting j appearing in the equations shown in FIG. 20 into j'+t. The conversion by equation (19) substitutes i'+1 for t of the left part while the conversion by equation (20) substitutes i' for t of the right part.

According to the latest program shown in FIG. 21, the positions of the elements at both ends corresponding to J=i'-1, i'+26 are shifted by 1 per time step with their values remaining unchanged. Other elements are updated using the values of the adjacent elements in each time step, and the positions are shifted by 1. Thus, the data can be updated using the SDDT as shown in FIG. 16.

After the index conversion process, the host computer 11 inserts a code for use in restoring the data layout (step S14), and terminates the process. To restore data layout refers to a process of returning the storage position of each element shifted in the data update process using the SDDT to the initial position specified by the programmer.

For example, in the data update process shown in FIG. 16, the storage position of the actual array is shifted by 1 to right for each iteration of the serial loop, the position is shifted by i_f to the right of the initial position after i_f iterations. If it is returned to the original position by shifting all elements by i_f to the left after all serial loops are processed, then the influences by the shift can be ignored in the succeeding processes. Such restoration codes are further added to the program shown in FIG. 21.

In FIG. 16, the data transfer time in a single update process on the overlap area can be reduced by using the SDDT. However, since the overlap area is not updated through a calculation, the communications are erected for each iteration of the serial loop to update the overlap area. If the above described extended overlap area is applied to the data update using the SDDT, the overhead required for the communications can be further reduced.

FIG. 24 is an operating flowchart showing the setting process in which the extended overlap area is set and data update is set using the SDDT. The setting process shown in FIG. 24 is also performed by the host computer 11 as a part of the optimization process by the compiler 25. When the process starts as shown in FIG. 24, the host computer 11 first performs the extended overlap area setting process (step S21) shown in FIG. 11, then performs the data update setting process (step S22) using the SDDT shown in FIG. 17, and terminates the process. Thus, the program is generated such that the data can be updated using the SDDT in the extended overlap area.

FIG. 25 shows an example of updating data using both SDDT and extended overlap area when the program shown in FIG. 5 is executed. In FIG. 25, the meanings of the dirty overlap area, clean overlap area, local area, INIT, Update, and Iter 1, 2, 3, . . . are the same as those shown in FIG. 6.

For example, at the initial state, PE1 holds the elements in the range of a (9:16) in the array a in the local area, and has the storage area for the elements in the range of a (5:8) as an overlap area (INIT). Then, the PE1 receives the data from the PE0, updates the data in the overlap area, and transmits the data in the range of a (13:16) to the PE2 (Update).

Then, the PE1 makes the first calculation using the data in the range of a (5:16), updates the data in a (6:15) (Iter 1), and stores the data after shifting the storage position in the communications direction by 1. At this time, the data in a (16) initially stored by the PE1 is updated in parallel by the PE2. Then, the PE1 makes the second calculation using the data in the range of a (6:15), updates the data in a (7:14) (Iter 2), and stores the data after shifting the storage position in the communications direction by 1. At this time, the data in a (15) initially stored by the PE1 is updated in parallel by the PE2. Since the data in the extended overlap area have become all dirty, the PE1 established uni-directional communications between the PE1 and the adjacent PE, updates the extended overlap area, and performs the data update process for Iter 3.

According to the data update shown in FIG. 25, the data can be locally updated twice consecutively after the extended overlap area is updated through the communications. Therefore, the total volume of the transferred data is the same as that in FIG. 16. However, the overhead required for the communications can be reduced. In the example shown in FIG. 25, two overlap areas are added to the left of the overlap area of each PE shown in FIG. 16. An extended overlap area provided with additional overlap areas of an even number can also be used.

According to the present invention, the overhead synchronously used with the communications can be reduced when a parallel process is performed using an overlap area in a distributed-memory parallel processor, thereby realizing a high speed parallel process.

Claims

1. A program converting device for use in an information processing device for converting an input program into a program to be executed in a parallel processor comprising a plurality of processing elements and a communications network, comprising:

a detecting means for detecting unit to detect in the input program a loop portion in which optimization can be realized using an overlap area; and

a setting means for converting unit to convert the input program by assigning an overlap area to a processing element processing the loop portion and generating a code based on which data in the overlap area is calculated updated through calculations in multiple iterations using only the data in the processing element, and for outputting a converted program.

2. The program converting device according to claim 1, wherein said detecting means unit detects as said loop portion a parallel loop encompassed by a serial loop, said parallel loop being able to be optimized using the overlap area.

3. The program converting device according to claim 1, wherein said setting means unit generates a code such that data can be processed twice consecutively without communications after the processing element processing said loop portion updates the overlap area through communications with an adjacent processing element.

4. The program converting device according to claim 1

further comprising: a size determining means for unit determining an optimum size of the overlap area after estimating process time for said loop portion, and

wherein said setting means unit assigns the overlap area of a size determined by said size determining means unit to the processing element processing said loop portion.

5. The program converting device according to claim 4, wherein said size determining means unit determines the optimum size such that the process time for said loop portion becomes short.

6. A program converting device for use in an information processing device for converting an input program into a program to be executed in a parallel processor comprising a plurality of processing elements and a communications network, comprising:

a detecting means for detecting unit to detect in the input program a loop portion in which optimization can be realized using an overlap area; and

a setting means for converting unit to convert the input program by assigning an overlap area to a processing element processing the loop portion and generating a code based on which data is updated in the overlap area through single direction data transfer and data in the processing element is shifted in a direction of the data transfer, and for outputting a converted program.

7. The program converting device according to claim 6,

further comprising: a communications change means for changing unit to change data dependency in processing said loop portion from bi-directional transfer to single direction transfer and for generating a subscript of an array in which the single direction data transfer can be performed, and

wherein said setting means unit generates a code for use in updating the data using the subscript in said array generated by said communications change means unit.

8. The program converting device according to claim 7, wherein said communications change means unit changes a direction of a distance vector representing the data dependency into single direction among processing elements and generates the subscript of the array using a changed distance vector.

9. The program converting device according to claim 7, wherein said communications change means unit generates the subscript of the array such that a data layout of the processing element processing said loop portion can be shifted in a particular the direction of the data transfer each time data is processed, shifted data layout covering two processing elements.

10. The program converting device according to claim 9, wherein said setting means unit generates a code to return the shifted data layout after processing said loop portion to an original data layout.

11. A program converting device for use in an information processing device for converting an input program into a program to be executed in a parallel processor comprising a plurality of processing elements and a communications network, comprising:

a detecting means for unit detecting in the input program a loop portion in which optimization can be realized using an overlap area; and

a setting means for unit converting the input program by assigning an overlap area to a processing element processing the loop portion and generating a code based on which data in the overlap area is calculated updated through calculations in multiple iterations using only the data in the processing element and a code passed on which the data in the overlap area is updated through single direction data transfer, and for outputting a converted program.