JPH09293057A - Task allocation method in hierarchical structure type multiprocessor system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To perform efficient parallel processing by the hierarchical structure type multiprocessor system. SOLUTION: When a source program 10 is translated, a compiler 11 predicts the execution times of respective tasks which can be processed in parallel and overhead times at the time of the execution of the tasks by clusters different from a main cluster and incorporates them as prediction results 120 in an object program 12. A scheduler 13 when allocating the tasks to processors judges whether the tasks are completed earlier by expecting free processors to be obtained in the main cluster 2 or assigning the tasks to free processors in other clusters unless free processors to which all the tasks are assigned are present in the main cluster 2, and then allocates the tasks to the cluster which will complete the tasks.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a task allocation method for parallel processing in a hierarchical multiprocessor system.

[0002]

2. Description of the Related Art As shown in FIG. 6, a kind of multiprocessor system is provided with a plurality of clusters 2 each composed of a plurality of processors 4 and a local memory 3 shared by them, and these plurality of clusters 2 are commonly used. System bus 1
There is a hierarchical multi-processor system which is connected so that data can be transferred to each other. The characteristic of this hierarchical structure multiprocessor system is that each cluster 2 has a local memory 3, so that the frequency of memory access competition is higher than that of a normal tightly coupled multiprocessor system in which all the processors 4 share one memory. It is to fall. However, when the data in the local memory of another cluster is required, it is necessary to transfer the data to the local memory of its own cluster, which takes time.

Due to these characteristics, when a certain user program is executed in a hierarchical multiprocessor system, one cluster is selected as a main cluster from a plurality of clusters, and the user program is started and ended. A method of allocating each task constituting the user program to the processor in the main cluster is generally adopted.

[0004]

By the way, when a certain process of a user program is divided into a plurality of parts and each of them is processed in parallel by a multiprocessor system as a separate task, there are the following two division methods. . One of them is, for example, as disclosed in Japanese Laid-Open Patent Publication No. 1-152571, assuming the number of usable processors, the processing of a user program is equally divided by the number of usable processors, and each of them is regarded as one task. Another method is that the user pre-designates the number of parallelizations in the source program, divides the processing of the user program according to the parallelization instruction, and makes each one a task. is there.

In the case of the former division method, there is no problem even with the conventional task allocation method. This is because the number of tasks to be processed in parallel is determined based on the number of programs that can be used at the same time, and thus all tasks are processed in parallel.
However, in the case of the latter division method, there are not always free processors for the number of tasks.
There is no guarantee that all tasks will be processed in parallel. in this case,
In the conventional task allocation method, the tasks are always allocated to the processors in one main cluster. Therefore, if the number of free processors is insufficient, the remaining tasks must wait until there are free processors.

If there is no free processor in the main cluster, it is possible to assign a task to that processor immediately if there is a free processor in another cluster. However, as described above, when the data in the local memory of another cluster is needed, the data needs to be transferred to the local memory of the own cluster, which takes a certain amount of time. However, if the task is assigned to the processor of the cluster, the execution end time of the task or the start of the subsequent processing may be delayed, which is a problem.

Therefore, an object of the present invention is to basically allocate a task capable of parallel processing to a processor group of one cluster, but when there is no free processor for allocating all tasks, the allocation destination is set. Is not limited to one cluster, but if the processing is accelerated, it is assigned to another cluster to shorten the processing time of the user program.

[0008]

According to the present invention, there are provided a plurality of clusters each including a memory and a plurality of processors sharing the memory, and the plurality of clusters are connected to each other through a common system bus so that data can be transferred to each other. In a method of allocating tasks in a hierarchical multiprocessor system, when a compiler that translates a source program to generate a target program generates multiple tasks that can be processed in parallel according to the parallelization instructions, the execution time of each task A scheduler that predicts the overhead time when a task is executed in a cluster different from the main cluster that mainly executes the target program, adds these prediction results to the target program, and allocates the task of the target program to the processor. Can be processed in parallel Tasks are basically allocated to the processor group of the main cluster, but if there are not enough free processors to allocate all tasks, it is faster to wait for a free processor to occur in the main cluster, Alternatively, it is characterized in that whether or not it is earlier to allocate a task to a free processor of another cluster is determined by using the prediction result, and the task is allocated to a cluster on which processing is faster.

Further, the overhead time when a task is executed in a cluster different from the main cluster is transferred from the local memory of the main cluster to the local memory of that cluster so that the processor of the other cluster can execute the task. A prediction is made by at least considering the transfer time of data that needs to be stored and the time to transfer the data of the local memory of the other cluster rewritten by the processing of the task to the local memory of the main cluster. And

Further, an overhead time of a task to be assigned next among a plurality of tasks that can be processed in parallel,
Compare the execution time of tasks that are already assigned to the main cluster among the tasks that can be processed in parallel and the waiting time until the free processor occurs, which is known from the assignment time, and check whether the free processor occurs in the main cluster. It is characterized by determining whether it is faster to wait or it is faster to assign a task to a free processor of another cluster.

[0011]

BEST MODE FOR CARRYING OUT THE INVENTION Next, an example of an embodiment of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a system configuration diagram of an embodiment of the present invention. In the figure, the MPS is the hierarchical multi-processor system described in FIG. 6, and a plurality of clusters 2 each composed of a plurality of processors 4 and a local memory 3 shared by them are shared by a common system bus 1. They are connected to each other so that data can be transferred. Also,
Reference numeral 10 is a source program created by the user. The source program 10 has its processing described in a high-level language, and in particular, the parallelization instruction in which the user has instructed the number of parallelizations in advance is embedded in the portions that can be processed in parallel. Further, 11 is a compiler that translates the source program 10 to generate a target program 12 for the hierarchical structure type multiprocessor system MPS. This compiler 11
In the target program 12 generated by
By the processing of 1 described later, the prediction result 120 of the execution time and the overhead time regarding the tasks that can be processed in parallel is embedded. Further, 13 is a scheduler that allocates each task constituting the target program 12 to the processor 4 of the cluster 2 so that the target program 12 can be executed in the hierarchical structure multiprocessor system MPS. The scheduler 13 selects one cluster 2 having at least one free processor for executing the target program 12 as a main cluster, and basically assigns the task of the target program 12 to a processor group in the main cluster. However, when allocating a plurality of tasks that can be processed in parallel, the allocation destination is not limited to the main cluster, and if the processing becomes faster, it is allocated to another cluster.

FIG. 2 shows a configuration example of the compiler 11 and a processing example thereof. The compiler 11 reads the input source program 10, performs parsing to generate the intermediate text 113, and the intermediate text 113, reads the intermediate text 113, and parallelizes the processing according to the parallelization instruction instructed by the user. The parallelizing unit 111 that generates the parallelized intermediate text 114, and the parallelized intermediate text 114
And an execution time / overhead time predicting means 1110 are provided in the parallelizing section 111.

This execution time / overhead time predicting means 1110 is used when a certain processing part in the source program 10 is divided into a plurality of parts according to the parallelization instruction in the parallelization part 111 and each of them is regarded as one task. , Fig. 2
Is a means for predicting an execution time when each task is executed by a processor of the main cluster and an overhead time when the task is executed by a processor of a cluster different from the main cluster by performing the processing of steps S1 to S3. . The prediction result including the predicted execution time and overhead time of each task is embedded in the target program 12 as the prediction result 120 via the generation unit 112.

Execution time / overhead time predicting means 11
In the case of the present embodiment, reference numeral 10 finds the sum of the execution times of the instructions created for each task (in the case of a loop, the number of iterations is also taken into consideration), and sets this as the execution time of each task ( S1).

In the present embodiment, the execution time / overhead time predicting means 1110 allocates each task to a processor of a cluster different from the main cluster, considering that most of the overhead time is occupied by the data transfer time. In this case, the size of the data required to be transferred between the main cluster and the cluster is calculated (S2), and the calculated data size is multiplied by the data transfer time per unit size to obtain the total data transfer time. Is obtained and is set as the overhead time of the task (S3).

When a certain task is assigned to the processors of the main cluster and another cluster, the data that needs to be transferred between the main cluster and the cluster is, for example, as follows.

First, as a pre-stage for performing the processing of the task, there are text and minimum input data required for performing the processing. Since these data exist in the local memory of the main cluster that has executed the target program so far, it is necessary to transfer them from the local memory to the local memory of the cluster in which the task is executed. .

The other one is data predicted to be rewritten by the task. Since such data is rewritten in the local memory of the cluster in which the task is executed, it is necessary to transfer it to the local memory of the main cluster for subsequent processing in the main cluster of the target program.

Since the types of data described above are known at the time of compiling the source program 10, the execution time / overhead time predicting means 1110 obtains the sum of the sizes of these data, and the data transfer time is transferred. Since it is almost proportional to the size of the data, the overhead time when the task is assigned to another cluster is obtained by multiplying the calculated size by the data transfer time per unit size.

As the data that needs to be transferred between the clusters, the above-mentioned data has the largest size, and therefore the overhead time may be obtained by that alone. However, for example, another task may be performed during the processing. If the synchronization processing is required, it is necessary to transfer the data that must be synchronized. Therefore, the transfer time of this kind of data may be taken into consideration. However, this kind of data transfer may be performed not only once but also a plurality of times, and since it is transferred bidirectionally, it is necessary to determine the data transfer time in consideration of it.

Next, the operation of the scheduler 13 shown in FIG. 1 will be described. The scheduler 13 uses the target program 12
When executing the above, one cluster in which at least one free processor exists among the plurality of clusters 2 is
It is selected as the main cluster for executing the target program 12. Then, basically, the task of the target program 12 is assigned to the processor group in the main cluster. However, if there are insufficient free processors when allocating multiple tasks that can be processed in parallel, it is faster to wait for the processors to become free in the main cluster, or the tasks are allocated to free processors in other clusters. By using the prediction result 120 in the target program 12 to determine whether it is earlier, the task is assigned to the faster processing. Note that the task to be assigned first among a plurality of tasks that can be processed in parallel is always assigned to the processor of the main cluster, so if there is no free processor, it will be in a waiting state.

FIG. 3 shows an example of processing performed by the scheduler 13 for the second and subsequent tasks when sequentially allocating a plurality of tasks that can be processed in parallel. As shown in the figure, when allocating the next task that can be processed in parallel, the scheduler 13 first confirms the usage status of the processors in the main cluster and checks whether or not there is a free processor (S11). If there is a free processor in the main cluster, the task is assigned to that processor (S16).

On the other hand, when there is no free processor in the main cluster, it is faster to allocate the task to the free processor after waiting for the free processor to be generated in the main cluster, or the free processor of another cluster is assigned. It is determined whether the task is assigned faster. For this purpose, first, the waiting time X until a free processor is formed in the main cluster is predicted (S12). The waiting time X is the time until the end time of the task that finishes the earliest among the plurality of tasks that can be processed in parallel and are already assigned to the main cluster. The task execution end time is predicted result 1 at the allocation time.
The execution time of the task described in 20 is added and obtained. Next, the overhead time of the task to be allocated this time (this is also described in the prediction result 120)
Is less than the waiting time X (S1
3). If the overhead time is less than the waiting time X,
Since it is more likely that the task will be faster if the task is assigned to a free processor in another cluster, it is checked whether or not there is a free processor in another cluster (S14). If there is, the task is assigned to the free processor. Is assigned (S15). If there is no free processor in another cluster, the process returns to step S11 to repeat the above process. On the other hand, the overhead time is the waiting time X
If it is not smaller, it is more likely that the process will be faster if there is a free processor in the main cluster, so the process returns to step S11 and the above-described process is repeated.

For example, as a result of the compiler 11 translating the source program 10 composed of processing A, processing B, and processing C as shown in FIG. 4A, processing A as shown in FIG. 4B is executed. Task TA and process B are executed in parallel 3
A target program 12 including one task TB0, TB1, TB2, and a task TC that executes a process C is generated, a task TA is executed by a certain processor of the main cluster, and three tasks TB0 and TB1 are triggered by the end of the task TA. , T
When allocating B2, if there are three free processors in the main cluster, as shown in FIG.
All of TB1 and TB2 are assigned to the processors in the main cluster. However, if, for example, there are only two free processors, tasks TB0 and TB as shown in FIG.
When 1 is assigned to the free processor of the main cluster,
There are no free processors. Therefore, the scheduler 13
3 determines that there is no free processor in the main cluster in the process of FIG. 3 related to the allocation of the task TB2 (S11), it predicts the waiting time X until a free processor is formed in the main cluster (S12). When the current time is the time immediately after the task TB2 is assigned, the waiting time X is the time X shown in FIG. 5 (B). Therefore,
The scheduler 13 examines the magnitude relationship between the waiting time X and the overhead time of the task TB2 (time of a + b in FIG. 5B) (S13). Then, when the overhead time is smaller than the waiting time X, as shown in FIG. 5B, if there is a free processor in another cluster, the task TB2 is assigned to that processor. By doing this, the processing time can be shortened by the time Y shown in FIG. 5B as compared with the case where the task TB2 is allocated after waiting for the availability of the main cluster. Since there are no free processors in other clusters, steps S11 to S14
When the loop is repeated, the waiting time X gradually decreases, but the overhead time is fixed. Therefore, the waiting time X finally becomes equal to or less than the overhead time. When this happens, task TB2 is no longer assigned to another cluster and waits for a free processor to occur in the main cluster.

The embodiments of the present invention have been described above.
The present invention is not limited to the above embodiments, and various other additions and changes are possible. For example, in the embodiment described above,
The overhead time was predicted for each of the multiple tasks that can be parallelized. However, if the allocation order of the multiple tasks that can be processed in parallel is fixed and the first task is always assigned to the main cluster as described above. Therefore, it is possible to omit the overhead time prediction for the first task of the plurality of tasks that can be processed in parallel.

[0027]

As described above, according to the present invention, at the time of translation of a source program, the execution time of each task that can be processed in parallel and the overhead time when the task is executed in a cluster different from the main cluster are calculated. Predicted and included in the target program, and when the scheduler allocates tasks to the processor, if there are no free processors in the main cluster to allocate all of the multiple tasks that can be processed in parallel, the prediction included in the target program Use the result to determine whether it is faster to wait for a free processor to occur in the primary cluster, or to assign a task to a free processor in another cluster. Since it is allocated, more efficient parallel processing becomes possible.

[Brief description of drawings]

FIG. 1 is a system configuration diagram of an embodiment of the present invention.

FIG. 2 is a diagram illustrating a configuration example and a processing example of a compiler.

FIG. 3 is a flowchart showing a processing example of a scheduler.

FIG. 4 is a diagram showing an example of a source program and a target program.

FIG. 5 is a diagram showing a relationship between allocation of tasks capable of parallel processing to clusters and execution time.

FIG. 6 is a block diagram showing an example of a hierarchical structure multiprocessor system.

[Explanation of symbols]

 MPS ... Multiprocessor system 1 ... Common system bus 2 ... Cluster 3 ... Local memory 4 ... Processor 10 ... Source program 11 ... Compiler 12 ... Object program 120 ... Prediction result 13 ... Scheduler

Claims (3)

[Claims] 1. A hierarchical multi-processor system comprising a plurality of clusters each comprising a memory and a plurality of processors sharing the memory, and the plurality of clusters being connected to each other through a common system bus so that data can be transferred to each other. In the task assignment method, when a compiler that translates a source program to generate a target program generates a plurality of tasks that can be processed in parallel according to a parallelization instruction, the execution time of each task is predicted and In a scheduler that predicts the overhead time when a program is executed in a cluster different from the main cluster that executes it, adds these prediction results to the target program, and assigns the tasks of the target program to the processor Basically the lord Allocate to the raster processor group, but if there are not enough free processors to allocate all tasks, it is better to wait for a free processor in the main cluster, or free processor in another cluster. A method for allocating a task in a hierarchical structure multiprocessor system, characterized in that it is determined whether or not a task is to be allocated to a cluster by using the prediction result, and the task is allocated to a cluster on the side of faster processing. 2. The overhead time when a task is executed in a cluster different from the main cluster is transferred from the local memory of the main cluster to the local memory of that cluster so that the task of the task is executed by a processor of another cluster. It is necessary to predict at least the transfer time of the data that needs to be stored and the time to transfer the data of the local memory of the other cluster rewritten by the processing of the task to the local memory of the main cluster. A task allocation method in a hierarchical structure multiprocessor system according to claim 1. 3. Overhead time of a task to be assigned next among a plurality of tasks that can be processed in parallel, and execution time and assignment time of a task that has already been assigned to the main cluster among the plurality of tasks that can be processed in parallel. Compare with the waiting time until there is a free processor, which is determined from, and determine whether it is faster to wait for a free processor to occur in the main cluster, or to allocate a task to a free processor in another cluster. 3. A task allocation method in a hierarchical structure type multiprocessor system according to claim 1 or 2.