WO2011065614A1

WO2011065614A1 - Pipeline multi-core system and method for effective task allocation in said pipeline multi-core system

Info

Publication number: WO2011065614A1
Application number: PCT/KR2009/007102
Authority: WO
Inventors: 신현철; 김종대; 김수현
Original assignee: 한양대학교 산학협력단
Priority date: 2009-11-25
Filing date: 2009-12-01
Publication date: 2011-06-03
Also published as: KR101086905B1; KR20110058092A

Abstract

A method for task allocation in a pipeline multi-core system is provided. The task allocation method comprises: initially distributing first to third task groups to a plurality of processors; grouping the tasks from the second task group and the third task group into r number of subgroups (where r≥2 and r is a natural number); secondarily distributing tasks in each subgroup to the plurality of processors, so that slack is maximized for all subgroups in the second task group, and secondarily distributing corresponding subgroups in the third task group in the same manner whenever each subgroup in the second task group is secondarily distributed; and allocating repetitively provided task groups to the plurality of processors in the same manner as the secondarily distributed second task group.

Description

Effective Task Assignment Methods for Pipelined Multicore Systems and Pipelined Multicore Systems

The present invention relates to a pipeline multi-core system and a task allocation method of a pipeline multi-core system.

A multi-core system is a system in which a plurality of tasks are assigned to and processed by a plurality of processors. In addition, a pipeline multi-core system is a system in which a task group including a plurality of tasks is repeatedly provided and processed in a plurality of processors.

Allocation problems including mapping and scheduling of tasks in the pipeline multi-core system are known as 'NP-hard', and many studies have been conducted to solve such allocation problems.

An object of the present invention is to provide a task allocation method of a pipeline multi-core system that efficiently processes a task group repeatedly provided within an appropriate execution time.

Another problem to be solved by the present invention is to provide a pipeline multi-core system that efficiently handles task groups that are repeatedly provided within an appropriate execution time.

Problems to be solved by the present invention are not limited to the above-mentioned problems, and other problems not mentioned will be clearly understood by those skilled in the art from the following description.

An aspect of the task allocation method of the pipeline multi-core system of the present invention for achieving the above object is to initially place the first to third task groups in a plurality of processors, the second task group and the third task Group the tasks in the group into r (r≥2, r is a natural number) subgroups, and assign the tasks belonging to each subgroup to multiple processors so that slack is maximum for all subgroups of the second task group. In a second arrangement, each subgroup of the second task group is disposed second, and the corresponding subgroup of the third task group is secondly arranged identically, and repeatedly to be identical to the second deployed second task group. Assigning the provided task group to multiple processors.

One aspect of the pipeline multi-core system of the present invention for achieving the above another object, iteratively repeats a plurality of processors, a storage in which a plurality of task groups including a plurality of tasks, and a plurality of task groups stored in the storage And a control unit for allocating the plurality of processors, wherein the plurality of task groups include first to third task groups, and the controller initially arranges the first to third task groups to the plurality of processors, and the second task group. And group the tasks of the third task group into r (r≥2, r is a natural number) subgroups, and assign tasks belonging to each subgroup such that slack is maximum for all subgroups of the second task group. A second arrangement on the plurality of processors, each time the respective subgroup of the second task group is placed second, and the corresponding subgroup of the third task group equally; Value and assigns the second task group supplied repeatedly to the same as the arrangement the second task group to the plurality of processors.

Other specific details of the invention are included in the detailed description and drawings.

According to the task allocation method of the pipeline multi-core system according to an embodiment of the present invention, the time required to process a single task group may be optimal, although it may be larger than that. Can be processed as

1 is a flowchart illustrating a task allocation method of a pipeline multi-core system according to an embodiment of the present invention.

5 to 14 are intermediate steps for explaining a task allocation method of a pipeline multi-core system according to an embodiment of the present invention.

15 is a structural diagram illustrating a pipeline multi-core system according to an embodiment of the present invention.

Advantages and features of the present invention and methods for achieving them will be apparent with reference to the embodiments described below in detail with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below, but will be implemented in various forms, and only the present embodiments are intended to complete the disclosure of the present invention, and the general knowledge in the art to which the present invention pertains. It is provided to fully convey the scope of the invention to those skilled in the art, and the present invention is defined only by the scope of the claims.

Like reference numerals refer to like elements throughout the specification, and "and / or" includes each and every combination of one or more of the mentioned items.

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. In this specification, the singular also includes the plural unless specifically stated otherwise in the phrase. As used herein, “comprises” and / or “made of” refers to a component, step, operation, and / or element that includes one or more other components, steps, operations, and / or elements. It does not exclude existence or addition.

Unless otherwise defined, all terms (including technical and scientific terms) used in the present specification may be used in a sense that can be commonly understood by those skilled in the art. In addition, the terms defined in the commonly used dictionaries are not ideally or excessively interpreted unless they are specifically defined clearly.

Allocation herein may be a concept including mapping and scheduling.

Hereinafter, a task allocation method of a pipeline multi-core system according to an embodiment of the present invention will be described with reference to FIGS. 1 to 14.

First, terms used in the present specification will be described with reference to FIGS. 2 to 4.

2 is a task flow diagram illustrating dependency between 15 tasks and data transfer time. 3 is a diagram illustrating a processing time for each of the 15 tasks to be processed in each of the three processors. 4 is a diagram for explaining a processing time, a data transfer time, a processing start time, and a processing completion time.

2, dependency is the priority of processing defined between multiple tasks. For example, in FIG. 2, since task 3 (T3) is a successor of task 1 (T1), processing may be started after task 1 (T1) is completed, and task 5 (T5) may be task 2 (T2). The task may be started after task 2 (T2) is completed because it is a successor.

Next, referring to FIG. 4, the data transfer time TTik is set to start processing of task Tk at processor Pu when Tk, which is a posture of task Ti, is processed on a processor different from processor Pj on which task Ti is processed. This is the time required for processing data to be transferred to processor Pu after completion of task Ti in processor Pj.

For example, if task 1 (T1) and task 3 (T3) of FIG. 2 are not processed in the same processor, task 3 (T3) is not processed after task 1 (T1) after two cycles. T1) may be processed in a processor different from the processed processor. More specifically, when task 1 (T1) is processed by processor 1 (P1), if task 3 (T3) is processed by processor 1 (P1), then task 3 (T3) is processed by processor 1 (P1). However, if task 3 (T3) is processed in processor 2 (P2) or processor 3 (P3), then two cycles after task 1 (T1) is processed in processor 1 (P1) or processor 2 (P2) or Task 3 (T3) may be processed in processor 3 (P3). That is, in FIG. 2, the data transfer time TT13 for task 1 (T1) and task 3 (T3) is two cycles. Similarly, the data transfer time TT14 for task 1 (T1) and task 4 (T4) is three cycles.

Next, referring to FIG. 4, the processing time PTij is a time required for the task i (Ti) to be processed by the processor j (Pj). For example, referring to FIG. 3, task 1 (T1) takes 5 cycles when processed by processor 1 (P1), 12 cycles when processed by processor 2 (P2), and processor 3 (P3). 8 cycles when processed at. That is, in this case, the processing time PT11 of the processor 1 P1 to the task 1 T1 is 5 cycles, and the processing time PT12 of the processor 2 P2 to the task 1 T1 is 12 cycles. The processing time PT13 of the processor 3 P3 with respect to the task 1 T1 is 8 cycles.

Again, referring to FIG. 4, the processing start time STi of the task i (Ti) is a time at which the task i (Ti) is disposed in the processor j (Pj) and processing starts. The processing completion time ETk is a time at which the processing of the task k Tk is completed when the task k Tk is disposed and processed in the processor u (Pu).

Here, the dependencies, processing time, and data transfer time shown in FIGS. 2 and 3 are merely examples and may be changed as much as possible.

A task allocation method of a pipeline multi-core system according to an embodiment of the present invention will now be described in detail with reference to FIGS. 1 and 5 to 14. In the present specification, for convenience, the 15 tasks illustrated in FIGS. 2 and 3 form one task group, and the pipeline multi-core system in which the task group is repeatedly provided and processed will be described by way of example. The present invention is not limited thereto.

1 is a flowchart illustrating a task allocation method of a pipeline multi-core system according to an embodiment of the present invention. 5 to 14 are intermediate steps for explaining a task allocation method of a pipeline multi-core system according to an embodiment of the present invention.

First, referring to FIG. 1, the first to third task groups are initially arranged in a plurality of processors (S100). In this case, the first to third task groups may be identical to each other. Specifically, referring to FIG. 5, a first task group including task 1 (T1) to task 15 (T15) is sequentially arranged in the first to third processors P1, P2, and P3, but the first task group By reflecting the dependency, data transfer time, and processing time of a task belonging to, through list scheduling, initial processing is performed so that the processing completion time of each task is minimized. The tasks belonging to the second and third task groups are arranged in the first to third processors P1, P2, and P3 in the same manner as the tasks belonging to the initially arranged first task group.

More specifically, task 1 T1 of the first task group may be processed at any time because there is no predecessor as shown in FIG. 2. Now, considering the processing time (PT11, PT12, PT13) for task 1 (T1) to obtain the processing completion time of task 1 (T1), if task 1 (T1) is processed in processor 1 (P1) processing time ( Since PT11) is 5 cycles, the processing completion time of task 1 (T1) is 5 cycles in this case. In addition, since the processing time PT12 is 12 cycles when processed by the processor 2 P2, the processing completion time of the task 1 T1 is 12 cycles in this case. Finally, when the processor 3 (P3) is processed, the processing time PT13 is 8 cycles. In this case, the processing completion time of the task 1 (T1) is 8 cycles.

In view of such dependency, data transfer time, and processing time PT11, PT12, PT13, since task 1 (T1) should be arranged in a processor in which the processing completion time of task 1 (T1) is minimized, Task 1 (T1) is arranged in processor 1 (P1).

Task 2 (T2) is considered next by the next list scheduling. Since task 2 (T2) has no preprocessor like task 1 (T1), it is placed in processor 2 (P2) with the smallest processing time.

Task 3 (T3) is considered next by the next list scheduling. Since task 3 (T3) is a successor of task 1 (T1), it can be processed after task 1 (T1) is processed. In addition, since task 1 (T1) is processed in processor 1 (P1), if task 3 (T3) is processed in processor 1 (P1), no data transfer time occurs, but processor 2 (P2) or processor 3 (P3). 2 cycles of data transfer time (TT13) occurs.

Now, if the processing completion time of task 3 (T3) is obtained by considering the processing time for task 3 (T3), the processing time is 14 cycles when task 3 (T3) is processed by processor 1 (P1). The processing completion time of (T3) is 19 cycles.

On the other hand, when task 3 (T3) is processed in processor 2 (P2), the processing time is 7 cycles, and assumes that task 2 (T2) is processed afterward because processor 2 (P2) has been processed before, task 3 The treatment completion time of (T3) is 15 cycles. At this time, since the data transfer time TT13 two cycles required after the task 1 (T1) are processed are satisfied, there is no problem.

When task 3 (T3) is processed in processor 3 (P3), the processing time is 9 cycles, and since task 1 (T1) has to satisfy the required data transfer time (TT13) 2 cycles after processing, in this case, task 3 ( The processing completion time of T3) is 16 cycles.

In the case where such a dependency, data transfer time, and processing time is taken into consideration, task 3 (T3) should be allocated to the processor whose processing completion time of task 3 (T3) is the minimum. ), Task 3 (T3) is arranged.

The same method is sequentially applied to task 4 (T4) to task 15 (T15) through list scheduling to initially place a task belonging to the first task group. If the tasks belonging to the second and third task groups are arranged in the processor 1 (P1) to the processor 3 (P3) in the same manner as the tasks of the first task group, the first to third tasks as shown in FIG. The group may be initially arranged in the processors 1 (P1) to 3 (P3). Referring to FIG. 5, initially arranged first task groups T1 to T15 are arranged from the beginning to 54 cycles, and second task groups T1 to T15 are arranged after the first task group up to 108 cycles. The third task groups T1 to T15 are arranged up to 162 cycles after the second task group.

Next, referring to FIG. 1, the first DII is calculated based on the initially arranged result (S101). As described above, DII (data input interval) may be defined as a time interval between processing start times of tasks having the fastest processing start time of each task group among repeatedly provided task groups. Therefore, referring to FIG. 5, the task having the earliest processing start time of the first to third task groups is task 1 (T1), and DII, which is the interval between the processing start times of this task 1 (T1), is 54 cycles. This 54 cycles becomes the first DII (DII_1).

Referring to FIG. 1, the processing completion time of each task in the initially deployed processor is maximized without changing the processing completion time of the task having the largest processing completion time among the tasks of the second task group that is initially arranged. Each task of the second task group is placed first (S102).

Specifically, in consideration of dependency between each task, processing time, and data transfer time, the processing completion time of the plurality of tasks initially disposed in the initially deployed processor for the task belonging to the second initially deployed task group is maximum. A first arrangement is made so that the processing completion time of each task is maximized (ALAP; As Late As Possible) without changing the processing completion time of the task.

FIG. 6 considers the dependency, processing time and data transfer time between tasks without changing the processing completion time of the task (T15, 108 cycles) having the maximum processing completion time among the tasks belonging to the second task group. The result of the first arrangement is such that the processing completion time of the other tasks T1 to T14 belonging to the second task group is maximum.

Next, referring to FIG. 1, the tasks of the first and second task groups disposed in the third task group are equally grouped into r (r≥2, r is a natural number) subgroups, and all subgroups of the second task group are Secondly deploying tasks belonging to each subgroup to a plurality of processors such that the slack is maximum for the second processor; each subgroup of the second task group is placed in the second, corresponding subgroup of the third task group 2 is arranged in the same manner (S103).

Specifically, first, the tasks of the first and second task groups that are arranged first and the third task group, which are initially arranged, are equally grouped into three subgroups. Referring to FIG. 6, the tasks of the first arranged second task group and the initially arranged third task group include the first subgroup G1 = {T1, T2, T3, T4, T7} in order of increasing processing start time. ), The second subgroup G2 = {T5, T6, T8, T9, T10}, and the third subgroup G3 = {T11, T12, T13, T14, T15}. Here, although FIG. 6 illustrates grouping into three subgroups in the order of rapid start of processing, this is only one example and the present invention is not limited thereto. That is, in the task allocation method of the pipeline multi-core system according to another embodiment of the present invention, grouping into three subgroups in order of completion of processing time may be illustrated. It is also possible to group into four or five subgroups rather than three subgroups.

In addition, although FIG. 6 illustrates that the same number of tasks belonging to each subgroup is five, this is only one example and the number of tasks belonging to each subgroup may be different.

Next, tasks belonging to each of the subgroups G1, G2, and G3 are secondly arranged in the plurality of processors such that slack is maximized for all the subgroups G1 to G3 of the second task group. Specifically, first, as shown in FIG. 6, for the first subgroup G1, the first group zone GZ1 is set, and the first subgroup ( The second task belongs to G1).

More specifically, the first sub group zone GZ1 defined as follows is selected.

* The ceiling of the subgroup Gp (where p is a natural number of 2 ≦ p ≦ r) = the processing completion time of the task having the maximum processing completion time for each processor among the tasks belonging to the second arranged subgroup G (p-1) However, the ceiling of the subgroup G1 = the processing completion time of the task having the maximum processing completion time for each processor among the tasks belonging to the first task group that is initially arranged.)

* The bottom of the subgroup Gp (where p is a natural number of 1≤p≤ (r-1)) = of the task having the minimum processing start time for each processor among the tasks belonging to the first arranged subgroup G (p + 1) Processing start time (the bottom of the subgroup Gr = processing start time of the task whose processing start time is minimum for each processor among the tasks belonging to the second arranged third task group)

Referring to FIG. 6, the ceiling ceiling_1 of the first subgroup G1 completes the processing of tasks T13, T14, and T15 having a maximum processing completion time for each processor among tasks belonging to the first task group that is initially arranged. It's time. A floor_1 of the first subgroup G1 is a processing start time of tasks T5, T6, and T11, which are tasks having a minimum processing start time for each processor among tasks belonging to the second subgroup G2. Accordingly, as shown in FIG. 6, the subgroup zone GZ1 of the first subgroup G1 may be formed of a ceiling ceiling_1 and a floor_1.

In each case, a slack is obtained in consideration of all cases in which a task belonging to the first subgroup G1 can be relocated within the first subgroup zone GZ1 for the first subgroup G1. The task belonging to the first subgroup G1 is secondly arranged by finding an arrangement in which the obtained slack is the maximum.

Specifically, the second arrangement means to arrange in the following order. First, in the first subgroup zone GZ1 of the first subgroup G1, the first subgroup is reflected by reflecting the dependency, data transfer time, and processing time of a task belonging to the first subgroup G1. Consider all the relocatable cases where tasks belonging to (G1) are placed on processors P1, P2, and P3 and can be processed fastest. Next, the slack is calculated for each possible placement. In this case, the slack may be defined as an allowance for rearranging a task belonging to the first subgroup G1 to advance the processing start time of all tasks belonging to the second subgroup G2 which is the next subgroup. Finally, each case is compared to find a case where the calculated slack is the maximum, and the tasks belonging to the first subgroup G1 are secondly arranged according to the arrangement.

FIG. 7 illustrates an example in which task v1 (Tv1) and task v2 (Tv2) belonging to the first subgroup G1 are disposed in the processor 1 P1 and the processor 2 P2, respectively.

Specifically, task v1 (Tv1) is arranged in processor 1 (P1) to reflect the dependency, processing time, and data transfer time as soon as possible, and task v2 (Tv2) is defined in processor 2 (P2). It is arranged to be processed as soon as possible by reflecting dungeon, processing time and data transfer time. The tasks w1 (Tw1) and the tasks w2 (Tw2) belonging to the second subgroup G2 are first disposed in the processor 1 P1 and the processor 2 P2, respectively.

Here, if task w1 (Tw1) and task w2 (Tw2) are not the postures of task v1 (Tv1) and task v2 (Tv2), in the case of FIG. 7, the slack is the processing start time STw1 of task w1 (Tw1) The minimum value is the difference between the processing completion time ETv1 of task v1 (Tv1) and the processing starting time STw2 of task w2 (Tw2) and the processing completion time ETv2 of task v2 (Tv2). In this case, since the difference between the processing start time STw2 of task w2 (Tw2) and the processing completion time (ETv2) of task v2 (Tv2) is smaller, this value becomes a slack in this case, and task w1 (Tw1) And since task w2 (Tw2) is not a posture of task v1 (Tv1) and task v2 (Tv2), it is not necessary to consider additional data transfer time. Therefore, in this case, all tasks belonging to the group G2 may be advanced by the difference between the processing start time STw2 of the task w2 (Tw2) and the processing completion time (ETv2) of the task v2 (Tv2).

However, if task w2 (Tw2) is a posture of task v1 (Tv1), and task w1 (Tw1) is a posture of task v2 (Tv2), the data transfer time must be considered between the tasks, so the slack is as follows. Calculated as

Slack = MIN {(STw1-ETv1), (STw2-ETv2), (STw2-ETv1-TTv1w2), (STw1-ETv2-TTv2w1)}

That is, since task w2 (Tw2) is a stoner of task v1 (Tv1) and task w1 (Tw1) is a stoner of task v2 (Tv2), additionally, task v1 (Tv1) and task w2 (Tw2) are calculated. The data transfer time between TTv1w2 and the data transfer time TTv2w1 between task v2 (Tv2) and task w1 (Tw1) should be additionally considered. In this case, similarly, all tasks belonging to the second subgroup G2 may have their processing start time advanced by the slack calculated previously.

Of all the cases in which tasks belonging to the first subgroup G1 are arranged in the processors P1, P2, and P3, the case where the calculated slack is the maximum is found, and the second arrangement is performed according to the arrangement.

Referring to FIG. 8, a state in which tasks T1, T2, T3, T4, and T7 belonging to the first subgroup G1 are disposed in the first subgroup zone GZ1 in the same manner is illustrated. have.

Next, the first subgroup of the third task group is also placed in a second manner as a result of the first arrangement of the second subgroup of the second task group. 9 is a result of second arrangement of the first subgroup of the third task group in the same manner as the first subgroup of the second task group.

Next, referring to FIG. 10, in the second subgroup zone GZ2 of the second subgroup G2 of the second task group, the second subgroup () reflects the dependency, the data transfer time, and the processing time. Consider all the cases where a task belonging to G2) is arranged in the processors P1, P2, and P3, and can be processed as soon as possible, and the second arrangement is performed so that the above-described slacks calculated for the arranged task are maximized. .

The second disposition method of the second subgroup G2 belonging to the second task group is basically the same as the second disposition method of the first subgroup G1, and thus the detailed description thereof will not be repeated here, and only the differences will be described herein. do.

Referring to FIG. 10, the second subgroup zone GZ2 of the second subgroup G2 includes a ceiling ceiling_2 and a floor_2.

The ceiling ceiling_2 is the processing completion time of the task having the maximum processing completion time for each processor among the tasks belonging to the second sub-group G1 that has been arranged. Since the task belonging to the second sub-group G1 disposed in the first processor P1 does not exist, the task disposed in the first processor P1 among the tasks belonging to the first task group and having the maximum processing completion time The processing completion time of becomes the ceiling (ceiling_2). Therefore, the processing completion time of task 15 (T15), task 7 (T7), and task 4 (T4) becomes the ceiling (ceiling_2).

In addition, the floor floor_2 is a processing start time of a task having a minimum processing start time among tasks belonging to the third arranged subgroup G3. Therefore, the processing start time of task 12 (T12), task 11 (T11), and task 13 (T13) becomes the floor (floor_2).

In this second subgroup zone GZ2, tasks belonging to the second subgroup G2 are placed in the processors P1, P2, and P3 to reflect the dependency, data transfer time, and processing time. Consider all cases that can be handled, with the second arrangement so that the slacks calculated for the deployed task are maximized.

FIG. 11 illustrates a second arrangement of the second subgroup G2 belonging to the second task group such that the slack is the maximum, and as a result, the second arrangement of the second subgroup belonging to the third task group equally second. have.

Using the same method, the third subgroup G3 belonging to the second task group as shown in FIG. 12 is secondly arranged to have the maximum slack, and as a result, the third subgroup belonging to the third task group is arranged. In the second arrangement, a result as shown in FIG. 13 can be obtained.

Referring to FIG. 1, a second DII is calculated based on the second arranged result (S104). Referring back to FIG. 13, it can be seen that the second DII (DII_2) calculated based on the second arranged result is 44 cycles.

Referring to FIG. 1, when the calculated second DII is smaller than the calculated first DII, the first to third task groups are initially disposed in the plurality of processors in the same manner as the second arranged second task group, and then the first And the second arrangement is repeated (S105). If the calculated second DII is greater than or equal to the calculated first DII as a result of the repetition, the task group repeatedly provided to be identical to the second arranged second task group is allocated to the plurality of processors (S106).

In the case of this example, the second arranged result is as shown in FIG. At this time, it can be seen that DII (DII_F) is 44 cycles. Task groups that are repeatedly provided are now assigned to multiple processors as shown in FIG. 14.

The easiest way to find a way to assign multiple task groups to multiple processors is to find the optimal solution, taking into account all assignable cases. In this case, we can find the optimal solution that can process one task group as soon as possible, but it takes a lot of execution time to find the optimal solution.

On the other hand, DII (data input interval) can be defined as the interval between the processing start time of the task that has the fastest processing start time of each task group among the repeatedly provided task group, thereby minimizing such DII in pipeline multi-core system In this case, the time required to process one task group may be more optimal than the optimal one, but the task group that is repeatedly provided may be efficiently processed within a proper execution time.

That is, by minimizing DII in the above-described manner, it is possible to efficiently process a task group repeatedly provided within an appropriate execution time.

Next, a pipeline multicore system according to an embodiment of the present invention will be described with reference to FIG. 15.

Referring to FIG. 15, a pipelined multicore system includes a plurality of processors 100, a storage 102, and a controller 103.

The plurality of processors 100 serve to process the plurality of task groups 101.

The storage unit 102 stores the same task group 101 including a plurality of tasks in which dependency is defined and a plurality of tasks.

The controller 103 assigns the task group 101 stored in the storage 102 to the plurality of processors 100.

In detail, the controller 103 may initially arrange the first to third task groups in a plurality of processors, calculate a first data input interval (DII) as a result of the initial arrangement, and among the tasks of the second task group that are initially arranged. Each task of the second task group is first disposed to maximize the processing completion time of each task in the initially deployed processor without changing the processing completion time of the task having the maximum processing completion time, and the first arranged first Group the tasks of the 2 task group and the third task group equally into r (r≥2, r is a natural number) subgroups, and each sub group so that the slack is maximum for all subgroups of the second task group. Secondly placing tasks belonging to the group to a plurality of processors, each time corresponding to each subgroup of the second task group; Calculate the second DII based on the second arranged result, and if the calculated second DII is less than the calculated first DII, the first to third task groups may be the same as the second arranged second task group. A task group repeatedly provided to be identical to the second deployed second task group if the calculated second DII is greater than or equal to the calculated first DII, after the initial placement in the processor 101 may be allocated to a plurality of processors 100.

Other details can be inferred by those skilled in the art through the task allocation method of the pipeline multi-core system according to an embodiment of the present invention as described above, and thus a detailed description thereof will be omitted.

Although embodiments of the present invention have been described above with reference to the accompanying drawings, those skilled in the art to which the present invention pertains may implement the present invention in other specific forms without changing the technical spirit or essential features thereof. I can understand that. Therefore, it should be understood that the embodiments described above are exemplary in all respects and not restrictive.

The present invention is applicable to the electronics industry using a multi-core system. However, it is not limited thereto.

Claims

Initially deploying the first to third task groups to multiple processors,

Group the tasks of the second task group and the third task group into r (r≥2, r is a natural number) subgroups, so that slack is maximum for all subgroups of the second task group. Secondly, a task belonging to each subgroup is arranged in the plurality of processors, and each corresponding subgroup of the second task group is identically arranged in a second subgroup of the third task group whenever each subgroup of the second task group is disposed in the second. and,

And allocating a task group repeatedly provided to be identical to the second deployed second task group to the plurality of processors.
The method of claim 1,

After the initial arrangement, the processing completion time of each task in the initially arranged processor is maximized without changing the processing completion time of the task having the maximum processing completion time among the tasks of the second task group which is initially arranged. And disposing each task of the second task group first.
The method of claim 2,

Calculate a first data input interval (DII) as a result of the initial arrangement after the initial arrangement,

Calculate a second DII as the result of the second placement after the second placement,

When the calculated second DII is smaller than the calculated first DII, the first to third task groups are initially disposed in the plurality of processors in the same manner as the second arranged second task group, and then the first and second DIIs. Repeating the second batch, and if the calculated second DII is greater than or equal to the calculated first DII, repeating the provided task group to the plurality of processors so as to be equal to the second deployed second task group. The task assignment method of the pipeline multi-core system further comprising the assignment.
The method of claim 1,

The first to third task groups each include a plurality of tasks,

The plurality of tasks is a task assignment method of a pipeline multi-core system, each task is a different task.
The method of claim 1,

And the first to third task groups are the same task group.
The method of claim 1,

Initially disposing the first to third task groups to the plurality of processors initializes tasks belonging to the first task group to the plurality of processors such that processing completion time of each task belonging to the first task group is minimal. And arranging a task belonging to the second and third task groups to the plurality of processors to be identical to a task belonging to the first task group.
The method of claim 1,

Arranging a task belonging to each subgroup so that the slack is maximum sets a subgroup zone consisting of a ceiling and a floor for each subgroup, the dependency, the data transfer time, and A second arrangement in which the task belonging to each subgroup in each subgroup zone is disposed in the plurality of processors in the sub-group zone reflecting the processing time, in which case the slack becomes the maximum among all the cases that can be processed fastest. How tasks are assigned in pipeline multicore systems.
The method of claim 1,

Grouping the tasks of the first and second task groups and the third task group into r subgroups equally processes the tasks of the first and second task groups and the third task group for each task. Task assignment method for pipelined multicore systems, including groupings in ascending order of start time.
The method of claim 1,

The task allocation method of the pipeline multi-core system with the same number of tasks belonging to each subgroup.
A plurality of processors;

A storage unit for storing a plurality of task groups including a plurality of tasks; And

And a controller for repeatedly allocating the plurality of task groups stored in the storage to the plurality of processors.

The plurality of task groups includes first to third task groups,

The controller initially arranges the first to third task groups in the plurality of processors, and groups the tasks of the second task group and the third task group into r subgroups (r ≧ 2, r is a natural number). In addition, a second task is placed in the plurality of processors so that a slack is maximized for all subgroups of the second task group in the plurality of processors, wherein each subgroup of the second task group is the first group. Secondly arranging corresponding subgroups of the third task group equally every time they are deployed, and allocating the repeatedly provided task groups to the plurality of processors to be identical to the second deployed second task group; Pipeline multi-core system.
The method of claim 10,

The controller is configured to maximize the processing completion time of each task in the initially arranged processor without changing the processing completion time of the task having the maximum processing completion time among the tasks of the second task group that is initially arranged after the initial arrangement. And further disposing each task of the second task group to a first position.
The method of claim 11,

The controller calculates a first data input interval (DII) as a result of the initial arrangement after the initial arrangement,

Calculate a second DII as the result of the second placement after the second placement,

When the calculated second DII is smaller than the calculated first DII, the first to third task groups are initially disposed in the plurality of processors in the same manner as the second arranged second task group, and then the first and second DIIs. Repeating the second batch, and if the calculated second DII is greater than or equal to the calculated first DII, repeating the provided task group to the plurality of processors so as to be equal to the second deployed second task group. Pipeline multi-core system further comprising allocating.
The method of claim 10,

And the first to third task groups are the same task group.