JP3317816B2 - Data transfer processing allocation method in the compiler - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compiler for inputting a source program described in a data distributed description language and generating a target program for a memory distributed multiprocessor system.

[0002]

2. Description of the Related Art Among loops in a program, a loop having no data dependency between repetition processes can execute each repetition process independently, and thus can be distributed to a plurality of processors and executed in parallel. In this case, when each processor is executed by a shared memory type multiprocessor system in which a memory is shared, for example, Japanese Patent Laid-Open No. 4-2969 is disclosed.
No data transfer is required between processors as described in Japanese Patent Publication No. 62-62, but since each processor accesses the same shared memory, memory contention frequently occurs as the number of processors increases, The efficiency of parallelization decreases. Therefore, in order to solve the problem due to memory contention and increase the degree of parallelization, a memory distributed multiprocessor system in which a plurality of processors each having a local memory are connected by a network or the like is used.

However, in the case of a memory distributed type multiprocessor system, the array in the loop is distributed to the local memory of each processor. Even in a loop having no dependency, data transfer may be required between processors. That is, in parallelization of loop processing in a memory-distributed multiprocessor system, an array to be referenced or updated by a program is distributed to a local memory of each processor as specified by an instruction line in, for example, a data distribution description language. Each of the loops contained therein is divided and assigned to each processor, for example, as specified in the instruction line. Therefore, depending on the method of distributing the array and the method of dividing the loop, a situation arises in which the array elements that need to be accessed in the loop repetition processing assigned to each processor are not distributed to the local memory of the processor.

Therefore, in a conventional compiler which inputs a source program described in a data distribution description language and generates a target program for a memory distributed multiprocessor system, a distribution method of each array and a division method of a loop are determined. After that, if the array elements accessed in the repetitive processing of the loop handled by each processor are not distributed to the processors, the distributed state of the array is temporarily changed so that the distributed state of the array matches the distributed state of the loop in the section of the loop processing. Therefore, a data transfer process for transferring array elements between processors was inserted before and after the loop.

For example, an array element A as shown in FIG.
Array A consisting of (1) to A (12), array element B (1)
B, array elements C (1) to C (1) to B (12)
In order to execute a program declaring an array C consisting of (12) in parallel on four processors P (1), P (2), P (3), and P (4) of a memory distributed multiprocessor system, Arrays A, B, and C are sequentially assigned 3
Consider a case in which elements are distributed to the processors P (1) to P (4) one by one. In this case, a DO loop such as DO 20 J = 1,12 A (J) = B (J) + C (J) 20 CONTINUE existing in the program is processed by the processor P (1); DO 20 J = 1 , 3 A (J) = B (J) + C (J) 20 CONTINE processor P (2); DO 20 J = 4,6 A (J) = B (J) + C (J) 20 CONTINE processor P (3) DO 20 J = 7,9 A (J) = B (J) + C (J) 20 CONTINE Processor P (4); DO 20 J = 10,12 A (J) = B (J) + C (J) 20 When distributed to each processor as in CONTINE, it is not necessary to change the distributed state of the array in the loop processing section because the distribution of the array matches the distribution of the loop.

However, a DO loop such as DO 30 J = 2,12 A (J) = B (J-1) B (J-1) = C (J) 30 CONTINE in the same program, Processor P (1); DO 30 J = 2,3 A (J) = B (J-1) B (J-1) = C (J) 30 CONTINE Processor P (2); DO 30 J = 4,6 A (J) = B (J-1) B (J-1) = C (J) 30 CONTINE Processor P (3); DO 30 J = 7,9 A (J) = B (J-1) B ( J-1) = C (J) 30 CONTINE Processor P (4); DO 30 J = 10,12 A (J) = B (J-1) B (J-1) = C (J) 30 CONTINE Processor P, the processor P
Array element B (3) accessed when (2) is DO control variable J = 4 is not distributed to its own processor, and array element B (3) accessed when processor P (3) is DO control variable J = 7 B (6) is not distributed to its own processor, and array element B (9) accessed by processor P (4) when DO control variable J = 10 is not distributed to its own processor. The variance does not match the variance of the loop.

Therefore, in such a DO loop 30, immediately before the processing section of the loop, the processor P
Array element B from (1) to processor P (2)
(3) is transferred from the processor P (2) to the processor P
The array element B (6) is transferred to (3), and the array element B (6) is transferred from processor P (3) to processor P (4).
Data transfer processing for transferring (9) is inserted, and immediately after the processing section of the loop, the array element B (3) is transferred from the processor P (2) to the processor P (1), and the processor P (3) is transferred. ) From the processor P (2) to the processor P (2), and a data transfer process for transferring the array element B (9) from the processor P (4) to the processor P (3). Was.

If the distribution states of the arrays A, B, and C are dispersed in advance so as to match the DO loop 30, DO
Although it is not necessary to change the array distribution state in the processing section of the loop 30, it is necessary to change the array distribution state in the processing section of the DO loop 20.

[0009]

As described above, in the related art, for an array element in a loop that does not match the distribution state of the loop, data transfer processing is always performed before and after the loop. This data transfer processing is an overhead caused by parallelization not directly related to the actual loop processing. In parallelization, one problem is how to reduce the overhead and increase the parallelization efficiency.

For example, in the same program as above, there is a DO loop 10 such as DO 10 J = 2,12 A (J) = B (J-1) + C (J) 10 CONTINE.
Processor P (1); DO 10 J = 2,3 A (J) = B (J−1) + C (J) 10 CONTINE processor P (2); DO 10 J = 4,6 A (J) = B (J-1) + C (J) 10 CONTINE processor P (3); DO10J = 7,9 A (J) = B (J-1) + C (J) 10 CONTINE processor P (4); DO10 J = 10,12 A (J) = B (J-1) + C (J) When distributed to each processor as in 10 CONTINE, the processor P
Array element B (3) accessed when (2) is DO control variable J = 4 is not distributed to its own processor, and array element B (3) accessed when processor P (3) is DO control variable J = 7 B (6) is not distributed to its own processor, and array element B (9) accessed by processor P (4) when DO control variable J = 10 is not distributed to its own processor. Since the variance and the variance of the loop do not match, conventionally, similarly to the DO loop 30,
Also for such a DO loop 10, immediately before the processing section of the loop, the processor P (1)
The array element B (3) is transferred to (2), and the array element B (3) is transferred from the processor P (2) to the processor P (3).
(6) is transferred from the processor P (3) to the processor P
Data transfer processing for transferring array element B (9) to (4) is inserted, and immediately after the processing section of the loop, processor P (2) transfers array element B (3) to processor P (1). ), The array element B (6) is transferred from the processor P (3) to the processor P (2), and the array element B (6) is transferred from the processor P (4) to the processor P (3).
A data transfer process for transferring (9) is inserted.

However, such a DO loop 10
, Array elements B (3), B (6), and B (9) are only referred to in the iterative processing.
Since the value does not change before and after the repetition of the loop, the data transfer processing immediately after the loop is unnecessary. However, conventionally, the insertion position of the data transfer process cannot be controlled by detecting such a situation, and the data transfer process is inserted before and after the loop as in the case of the DO loop 30 described above.

It is therefore an object of the present invention to investigate a method of accessing an array element accessed in a loop repetition process and determine a position where a data transfer process is to be inserted in accordance with the result of the search, thereby making the loop parallel. An object of the present invention is to improve the execution performance of a data distribution program by reducing data transfer and overhead.

[0013]

According to a first aspect of the present invention, there is provided a method for allocating data transfer processing in a compiler, wherein an array declared in a source program described in a data distributed description language constitutes a distributed memory type multiprocessor system. A compiler that distributes the loop to a local memory of a plurality of processors and has no data dependency between each iteration of the loop, and transforms the loop into a form that can be executed in parallel by the plurality of processors.
In the instruction line regarding the distribution of the array in the source program
Therefore, the array is distributed, and each iteration of the loop is performed.
Check the processor where the array element is distributed for each
Most of the array elements accessed in that iteration
Assign the repetitive processing to distributed processors
Disperse the loop so that
Detects array elements that are not distributed to the processor that executes the iterative processing among array elements to be accessed in processing and investigates the access method to the array of the array elements. In some cases, a data transfer process that transfers the contents of the array element from the processor in which it is distributed to the processor that accesses it is inserted immediately before the loop, and the access method for the array of array elements is only update. In some cases, a data transfer process for transferring the contents of the accessed array element from the processor accessing the element to the processor in which the array element is distributed is inserted immediately after the loop. In the data transfer processing allocation method in the second compiler according to the present invention, an array declared in a source program described in a data distribution description language is distributed to local memories of a plurality of processors constituting a distributed memory multiprocessor system. with a loop for no data dependence between each iteration loop, the compiler for deforming the loop in parallel executable form by the plurality of processors, instructions about the distribution of the sequences in the source program
Disperse the array according to the rows, each iteration of the loop
For each process, adjust the processor in which the array elements are distributed.
In addition, the array elements accessed in the
Assign the repetitive processing to many distributed processors.
Disperse the loop so that
Detects array elements that are not distributed to the processor that executes the iterative processing among the array elements to be accessed in the return processing, investigates the access method to the array of the array elements, and refers only to the access method to the array of the array elements. In the case of, insert a data transfer process that transfers the contents of the array element from the processor in which it is distributed to the processor that accesses it, immediately before the loop, and the access method for the array of array elements is updated only. In the case of, a data transfer process for transferring the contents of the accessed array element from the processor that accessed it to the processor in which the array element is distributed is inserted immediately after the loop, and the access to the array of the array element is performed. Otherwise, the contents of the array element are distributed A data transfer process for transferring the data from the processor to the processor accessing the data is inserted immediately before the loop, and the content of the accessed array element is transferred from the processor accessing the data to the processor where the array element is distributed. A data transfer process is inserted immediately after the loop.

[0014]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram showing an example of a compiler to which the present invention is applied. The compiler 1 of this example receives a source program 2 described in a data distribution description language that can specify the distribution of data and processing for each processor, and generates a target program 3 for a memory distributed multiprocessor system. A parsing unit 11 that inputs the source program 2 and performs a syntax analysis to generate an intermediate text 4, and a parallelization that inputs the intermediate text 4 and performs parallel processing and generates a parallelized intermediate text 5 It comprises a unit 12 and a generating unit 13 for generating the target program 3 from the parallelized intermediate text 5. Since the features of the present invention reside in the parallelization unit 12 in the compiler 1, the parallelization unit 12 will be described in detail below.

As shown in FIG. 1, the parallelizing unit 12 includes an array distributing unit 121, a loop distributing unit 122, a distribution comparing unit 123, an access analyzing unit 124, a data transfer processing generating unit 125, And means 126.

The array distributing means 121 determines which element of each array declared in the source program 2 is distributed to which of a plurality of processors that execute the program in parallel. The distribution is determined according to the instruction line that specifies the array distribution method in the source program 2 if the instruction line is specified, and according to a predetermined value if there is no such instruction line. When the generated target program 3 is executed, the elements of the array are allocated to local memories of a plurality of processors that execute the program in parallel according to the distribution state determined here.

For example, as shown in FIG. 2, a memory in which four processors P (1) to P (4) each having a local memory, a CPU and a data transfer device are connected via a network, for example, a transmission line. In a distributed multiprocessor system, four processors P (1) to P (4)
In contrast, elements A (1) to A (12) as shown in FIG.
In the case of distributing the array A composed of the following evenly, a storage area for storing the entire array A as shown by reference numerals M1 to M4 in FIG. 3 is secured in the local memories of the processors P (1) to P (4). Then, array elements A (1) to A (3) are loaded into the first to third entries of the storage area M1 of the processor P (1), and the fourth to sixth elements of the storage area M2 of the processor P (2) are loaded. Are loaded with array elements A (4) to A (6), and array elements A (7) to A (9) are loaded into the seventh to ninth entries of the storage area M3 of the processor P (3). The array elements A (10) to A (1) are stored in the tenth to twelfth entries of the storage area M4 of the processor P (4).
2) is loaded. Note that, instead of the storage area for storing the entire array A, there is also a method of securing a minimum storage area required for the sum of the array elements for the distributed portion and the array elements for data transfer between the processors.

On the premise of the distribution state of the array determined by the above-described array distribution unit 121, a loop distribution unit 122, a distribution comparison unit 123, an access analysis unit 124, a data The transfer processing generating means 125 and the loop deforming means 126 execute the following processing. The current loop is called the current loop.

When the current loop described in the source program 2 is a parallelizable loop having no data dependency between the iterative processes, the loop distributing means 122 Decide which of a plurality of processors to be executed in parallel is distributed. The distribution is determined according to the instruction line specifying the distribution method of the current loop in the source program 2 if there is no such instruction line, and if there is no such instruction line, the array is set for all the arrays included in the current loop. The determination is made based on the distribution state determined by the distribution unit 121.

Next, the distribution comparing means 123 determines, for each processor which executes the program in parallel, the array elements accessed in the repetition part of the current loop determined by the loop distributing means 122 to be distributed to the processors. , Array elements that have not been determined to be distributed to the processor by the array
All such array elements are referred to as unallocated array elements).

Next, the access analysis means 124 examines the access method in the current loop regarding the unallocated array element detected by the distribution comparison means 123, and classifies it into the following three types. 1) Only reference is made to an unallocated array element. 2) Only the update is performed on the unallocated array elements. 3) Other than the above 1) and 2). That is, reference and update are performed on the unallocated array elements.

Next, the data transfer processing generating means 125 calculates the unallocated array element detected by the distribution comparing means 123,
Based on the access method investigated by the access analysis means 124 for the array element, a description of the data transfer processing is generated and added to the current loop as follows. A) For the unallocated array element whose access method is 1), the data transfer processing for transferring the contents of the array element from the processor in which the array element is distributed to the processor in which the unallocated array element exists is described. Insert the description just before the current loop. B) For the unallocated array element whose access method is 2), the content of the updated unallocated array element is transferred from the processor in which the unallocated array element exists to the processor in which the array element is distributed. The description of the data transfer process is inserted immediately after the current loop. C) For the unallocated array element whose access method is 3), the data transfer processing for transferring the contents of the array element from the processor in which the array element is distributed to the processor in which the unallocated array element exists. Data transfer processing for inserting a description immediately before the current loop and transferring the contents of the updated unallocated array element from the processor in which the unallocated array element was present to the processor in which the array element is distributed. Is inserted immediately after the current loop.

Next, the loop transforming means 126 transforms the loop control statement and the like of the current loop so that each repetitive processing of the current loop is processed on the processor determined by the loop distributing means 122. Then, if a loop that has not yet been noticed remains in the source program 2, the loop distribution unit 122
And the process is terminated if there is no remaining one.

The operation of this embodiment will be described below with reference to a specific example. As an example, a data distributed description language HPF (High Performance) as shown in FIG.
The case where the source program 2 described in FORTRAN) is compiled will be described. In the source program 2 of FIG. 4, "! HPF @ PRO"
“CESSORS P (4)” is an HPF instruction line that specifies the number of processors that execute the program in parallel, and “! HPF @ DISTRIBUTE” on the fourth line.
(BLOCK (3)) ONTO P :: A, B,
“C” is an HPF instruction line that specifies the distribution method of the arrays A to C.

When the source program 2 as shown in FIG. 4 is input, the analysis unit 11 of the compiler 1 analyzes the syntax to generate an intermediate text 4, and the parallelization unit 12 inputs the intermediate text 4 and The following processing is executed.

First, the array dispersing means 121 divides the arrays A, B, and C according to the contents of the instruction lines because there are instruction lines for specifying the distribution method for the arrays A to C declared in the program. Four processors (P (1), P (2), P
(3), P (4)). FIG. 5 shows each processor P (1), P of the arrays A, B, C at this time.
(2), the distribution status to P (3) and P (4) is shown.

Next, the loop distributing means 122 pays attention to one loop described in the source program 2, and if the loop has no data dependency in the repetitive processing, sets it as a target of parallelization and determines the distribution of the loop. . Now, if attention is paid to the DO loop 10 including DO 10 J = 2, 12 A (J) = B (J−1) + C (J) 10 CONTINUE including the access of the array shown in FIG. Since there is no data dependency in the processing, it is determined that parallelization is possible. Further, since there is no instruction line of the distribution instruction for the loop, based on the distribution state shown in FIG. 5 for the arrays A, B, and C in the loop, it is determined which repetitive processing of the loop is to be allocated to which processor. decide.

In this determination, in order to avoid data transfer of array elements between processors as much as possible, at each repetition processing, the array elements accessed in the repetition processing and the processors in which the array elements are distributed are examined. The repetition processing is assigned to the processor in which the array elements accessed in the repetition processing are distributed most (in other words, the processor having the least unallocated array elements).

For example, for the above DO loop 10, DO
For each value of the control variable J, that is, for each iterative process, the relationship between the array element accessed in the iterative process and the processor in which the array element is distributed is examined. As shown in FIG. Therefore, the processor to which each repetition process is assigned is as shown in FIG. That is, considering the first iteration of the DO control variable J of 2, the array elements to be accessed are A (2), B
(1) and C (2), and since these array elements are all distributed to the processor P (1), the first round of repetitive processing is assigned to the processor P (1). Similarly, the second repetition process in which the DO control variable J is 3 is also assigned to the processor P (1). DO control variable J is 4
In the third iteration of the processing, among the three array elements to be accessed, one array element B (3) is assigned to the processor P (1) and the remaining two array elements A (4) and C (4)
Are distributed to the processor P (2), and are thus assigned to the processor P (2). Similarly, the repetition processing of the fourth and fifth rounds in which the DO control variable J is 5 and 6 is performed on the processor P (2), and the sixth, seventh and eighth rounds in which the DO control variable J is 7, 8, and 9 are performed. Iterative processing is processor P (3)
, Where the DO control variable J is 10, 11, 12
The repetition processing of the 0th and 11th rounds is performed by the processor P (4).
Assigned respectively.

Next, for each of the processors P (1) to P (4), the distribution comparing means 123 selects, for each processor P (1) to P (4), All array elements that are not distributed to the array (unallocated array elements) are detected. For example, in the above-described loop 10, the array element B (3) accessed by the processor P (2) to which the third iteration of the DO control variable J is 4 is distributed to the processor P (2). Array element B (6) accessed by processor P (3) to which the sixth iteration of DO control variable J of 7 has been assigned
Is not distributed to the processor P (3), and the array element B accessed by the processor P (4) to which the ninth iteration processing in which the DO control variable J is 10 is assigned
Since (9) is not distributed to the processor P (4), three array elements B of the array B shown in FIG.
(3), B (6), and B (9) are detected as unallocated array elements.

Next, the access analyzing means 124 calculates the unallocated array element detected by the distribution comparing means 123
The contents of the access in the loop are analyzed and classified into the three cases 1), 2) and 3) described above. D above
Unallocated array element B detected for O loop 10
As for (3), B (6), and B (9), only the reference is performed, so the case of the above 1) is determined.

Next, the data transfer processing generating means 125 calculates the unallocated array element detected by the distribution comparing means 123,
Based on the access method investigated by the access analysis means 124, the method shown in the above A) to C) is used.
Add a description of the data transfer process to the loop. Therefore, the unallocated array elements B (3), B
For (6) and B (9), since the access method corresponds to the case of the above 1), the method of the above A) is applied, and a description of the data transfer process is inserted immediately before the DO loop 10. The description of the data transfer process inserted at this time includes a description for transferring the contents of the array element B (3) on the processor P (1) to the processor P (2) and a description for the processor P (2).
(2) The contents of the array element B (6) above are
The description includes a description to be transferred to (3) and a description to transfer the contents of array element B (9) on processor P (3) to processor P (4).

Next, the loop transformation means 126 transforms the loop so that each iteration of the loop is processed on the processor determined by the loop distribution means 122. For example, in the case of the DO loop 10, the start and end values given to the DO control variable J are defined as start () and end (
). Note that the function sta
rt () and function end () are functions generated by the compiler 2 in the target program 3, and the processor P
2 and 3 when called from (1), 4 and 6 when called from processor P (2), 7 and 9 when called from processor P (3),
When called from the processor P (4), 10 and 12 are returned.

Accordingly, in the case of the above-described DO loop 10, the loop is eventually transformed into a loop as shown in FIG. In FIG. 7, the description of the data transfer process on the first line is
The description for transferring the contents of the array element B (3) on the processor P (1) to the processor P (2) is described in the description of the data transfer processing on the second line.
The description for transferring the content of (6) to the processor P (3) is as follows:
The description of the data transfer processing in the third line is described in the processor P (3).
The description for transferring the contents of the above array element B (9) to the processor P (4) is shown, and is executed only by the corresponding processor.

When the modification of the current loop is completed, the loop transformation means 126 returns the control to the loop distribution means 122 if there is a loop which has not been parallelized yet in the program, and terminates the processing if there is no remaining loop. .

After the processing by the parallelizing unit 12 as described above, the generating unit 13 generates the target program 3 from the parallelized intermediate text 5.

[0038]

As described above, according to the present invention, when an array element which is not distributed among processors which execute the iterative processing among array elements to be accessed in a loop iterative processing is detected, the array element After investigating the access method, if it is a reference only, insert a data transfer process just before the loop, and if it is only an update, insert a data transfer process only immediately after the loop, In any case, the number of times of data transfer processing can be reduced compared to the related art in which data transfer processing is uniformly inserted before and after a loop, and overhead in parallelizing a data distribution program can be reduced. .

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of a compiler to which the present invention is applied.

FIG. 2 is an explanatory diagram of an example of a method of allocating an array to a local memory of each processor.

FIG. 3 is a block diagram illustrating an example of a memory distributed multiprocessor system.

FIG. 4 is a diagram showing an example of a source program described in a data distribution description language.

FIG. 5 is a diagram illustrating an example of arrangement of arrays;

FIG. 6 is a diagram illustrating an example in which loop iteration processing is distributed to a plurality of processors, and an example of array elements that are not distributed among processors that execute the iteration processing among array elements accessed in loop iteration processing. It is.

FIG. 7 is a diagram illustrating an example of a loop after parallelization.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... Compiler 11 ... Analysis part 12 ... Parallelization part 121 ... Array distribution means 122 ... Loop distribution means 123 ... Distribution comparison means 124 ... Access analysis means 125 ... Data transfer processing generation means 126 ... Loop transformation means 13 ... Generation part 2 ... Source program 3 ... Objective program 4 ... Intermediate text 5 ... Parallelized intermediate text

────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-7-1114516 (JP, A) "Parallel Processing Symposium JSPP'95 Transactions" (1995-5-15) 361-368 "Information Processing" Vol. 34, no. 9 (1993-9) p. 1179-1185 "Parallel Processing Symposium JSPP'94" (1994-5) 156-158 (58) Field surveyed (Int. Cl. ⁷ , DB name) G06F 9/45

Claims (2)

(57) [Claims] 1. A source described in a data distribution description language
Arrays declared in the program can be
Localizers of multiple processors that make up a processor system
And iterative processing of each loop
Loops that have no data dependencies between them
To a form that can be executed in parallel by the multiple processors
CompilerIn the instruction line regarding the distribution of the array in the source program
Therefore, dispersing the array, The array elements are distributed for each iteration of the loop.
Check the processor that is
Processor with the most distributed array elements
The loop is divided so that
Scattered In the loop iteration process Array required to access
Distributed to processors that execute the repetition of the element
Undetected array element and add it to the array
Investigate the access method for the
When the contents of an array element are
Transfer from the processor to the accessing processor
Insert the data transfer process just before the loop, and the access method to the array
Sometimes, after access from the processor that accessed it
The contents of the array element
Data transfer processing to be transferred to the processor immediately after the loop
Characterized by being inserted intoData in the compiler
Transfer processing allocation method. 2. A source described in a data distribution description language.
Arrays declared in the program can be
Localizers of multiple processors that make up a processor system
And iterative processing of each loop
Loops that have no data dependencies between them
To a form that can be executed in parallel by the multiple processors
CompilerIn the instruction line regarding the distribution of the array in the source program
Therefore, dispersing the array, The array elements are distributed for each iteration of the loop.
Processor Search, and access
Processor with the most distributed array elements
The loop is divided so that
Scattered In the loop iteration process Array required to access
Distributed to processors that execute the repetition of the element
Undetected array element and add it to the array
Investigate the access method for the
When the contents of an array element are
Transfer from the processor to the accessing processor
Insert the data transfer process just before the loop, and the access method to the array
Sometimes, after access from the processor that accessed it
The contents of the array element
Data transfer processing to be transferred to the processor immediately after the loop
And the access method to the array of array elements is other than the above.
If the contents of that array element it is scattered
Transfer it from the processor to the accessing processor
Inserting a data transfer process immediately before the loop
Distribution from the processor that accessed it.
The contents of a column element are
Insert the data transfer process to be transferred to the
Characterized byData transfer in the compiler
Processing allocation method.