WO2013058396A1 - Task allocation device and task allocation method - Google Patents

Abstract

Provided is a task allocation device that can better perform task allocation by further reducing the influence of dependencies between cores that are not uniform based on priority. The task allocation device includes: a task set parameter storage section (11) that stores task set parameters including information expressing inter-task dependency relationships for a task set which is a set of tasks to be allocated; a priority weight assigning section (12) that uses the task parameters and priority, that is, the order of execution for each task in the flow of execution of the entire task set, as a basis to assign each inter-task dependency relationship a priority weight which is a coefficient expressing a weight based on priority; and an allocation section (13) that, when allocating tasks belonging to the task set to more than one core in accordance with the dependency relationships, uses the priority weight assigned to the dependency relationship between two different tasks allocated to different cores to calculate an evaluation value, and allocates the tasks on the basis of the calculated evaluation value.

Description

Task placement device and task placement method

The present invention relates to a multi-core, and more particularly, to a task placement apparatus and a task placement method for an AMP (Asymmetric Multi Processing) type multi-core.

In response to the increasing demand for higher performance and lower power consumption of digital devices in recent years, a multi-core configuration that incorporates multiple processor cores (hereinafter also simply referred to as cores) in an embedded LSI (Large Scale Integration) has attracted attention. ing. This multi-core LSI is an important technology in a real-time system for the purpose of system control. Multi-core systems are mainly classified into SMP (Symmetric Multi Processing) and AMP.
In the SMP method, tasks are switched according to the availability of the core, the priority of the task currently being executed, and the like, and each task can be executed on any core. For this reason, the SMP method enables load distribution dynamically and improves the performance of the entire system. However, dynamic load balancing makes it difficult to predict real-time performance. Therefore, the SMP method is not suitable for application to a real-time system.
On the other hand, the AMP method has a function-distributed configuration in which each task is executed on a specific core. For this reason, the AMP method is suitable for a real-time system in which prediction of system behavior is important, a system in which a core to which specific hardware is connected is limited, and the like.
Such an AMP multi-core system has different performance based on which core the task is arranged. For this reason, the AMP multi-core system needs to search various task placements and determine the optimum placement so as to be in an optimal execution state.
Patent Document 1 describes an apparatus that supports such multi-core task placement. The apparatus described in Patent Document 1 first acquires information (granularity information) regarding the granularity allocated to each core. Here, the granularity is, for example, a unit of processing of the processor, and is a generic name for tasks, functions, and processes constituting the functions. Next, this apparatus calculates the number of appearances for each task or for each function of the task based on the acquired granularity information, and generates information (structure information) regarding the calculated number of appearances. In addition, this device generates information (dependence information) related to dependence on other tasks or functions for each task or for each function of the task based on the acquired granularity information. And this apparatus displays the information showing the dependence which exists between different cores based on granularity information, structure information, and dependence information. Based on this configuration, the device described in Patent Document 1 can support task placement that reduces the number of dependencies existing between different cores in a multi-core system.
JP 2007-264734 A

However, the task arrangement based on the device described in Patent Document 1 may cause a problem that the dead time based on inter-core dependence may not be sufficiently reduced.
Here, inter-core dependency refers to a dependency relationship between tasks arranged in different cores. The existence of such inter-core dependency is because a task placed on a core needs to wait for a task on another core to finish even though one core is free to execute the task. This is a cause of wasted time that it cannot be executed. For this reason, the apparatus described in Patent Document 1 has a certain effect on the reduction of dead time based on waiting for dependence, based on minimizing the number of inter-core dependences.
However, there is a case where dead time is not sufficiently reduced by minimizing inter-core dependence. Such a case will be described below.
For example, as the execution of the entire task group (hereinafter also referred to as a task set) approaches the end, the dependency between tasks may become a critical problem. The reason for this will be described.
Immediately after starting the execution of the task set, many tasks are ready to be executed. For this reason, immediately after the start of execution of the task set, even if there is some inter-core dependence, there is not much dependence waiting time. However, in a situation where the execution of the task set has advanced, the execution of many tasks has already been completed. This reduces the number of tasks that can be executed other than the task waiting for dependency. That is, the dependency waiting based on inter-core dependency is more likely to occur as the position where each task can be executed (hereinafter also referred to as an order) in the flow of execution of the entire task set is backward (closer to the end).
Moreover, even if it is not near the end of execution of the entire task set, a situation in which there are few executable tasks may occur. For example, there may be a problem of inter-core dependency between tasks having similar ranks in the flow of execution of the entire task set. The reason will be described.
When tasks having dependency relationships are arranged in different cores, if the end of execution of the dependency source task is delayed based on some factor, a situation in which the dependency destination task waits occurs. That is, inter-core dependencies between tasks with similar ranks can easily cause a dependency wait based on the execution status of each core.
Thus, the influence on the execution performance of the entire task set based on inter-core dependence is not uniform based on the rank of each task related to the dependence relation.
However, since the apparatus described in Patent Document 1 does not consider that the influence on the execution performance due to inter-core dependence is not uniform based on the order of related tasks, the dead time based on inter-core dependence cannot be sufficiently reduced. .
An object of the present invention is to solve the above-mentioned problems, and to reduce the influence of non-uniform inter-core dependence based on the order for AMP-based multi-core systems, and achieve task performance with higher performance. To provide an apparatus.

The task placement device of the present invention, for a task set that is a set of tasks to be placed, a task set parameter holding means for holding a task set parameter including information representing a dependency relationship between the tasks, the task set parameter, Based on the order in which each task can be executed in the execution flow of the entire task set, an ordering weight that is a coefficient representing a weight based on the order is assigned to each dependency relationship between the tasks. When the task belonging to the task set is placed in one or more cores according to the dependency relationship, the rank weight assigned to the dependency relationship between the two tasks placed in different cores. And an arrangement means for calculating an evaluation value by using and arranging a task based on the calculated evaluation value.
Further, the task placement method of the present invention holds a task set parameter including information representing a dependency relationship between the tasks for a task set that is a set of tasks to be placed, and the task set parameter and the entire task set And assigning rank weights, which are coefficients representing weights based on the ranks, to the dependency relationships between the tasks, based on ranks that are positions where each task can be executed in the flow of execution of When assigning a task belonging to 1 to one or more cores according to the dependency, an evaluation value is calculated using the rank weight assigned to the dependency between two tasks arranged in different cores. The task is arranged based on the evaluated value.
Further, the program of the present invention is a task set parameter holding process for holding a task set parameter including information representing a dependency relationship between tasks for a task set which is a set of tasks to be arranged, the task set parameter, Based on the order in which each task can be executed in the execution flow of the entire task set, an ordering weight that is a coefficient representing a weight based on the order is assigned to each dependency relationship between the tasks. In the order weight assignment process, and when a task belonging to the task set is placed in one or more cores according to the dependency relation, the order weight given to the dependency relation between two tasks placed in different cores And calculating an evaluation value using the computer, and causing the computer to execute a placement process for arranging a task based on the calculated evaluation value.

According to the present invention, it is possible to provide a task arrangement with better performance by further reducing the influence of non-uniform core dependency based on the order.

FIG. 1 is a block diagram showing an example of a hardware configuration of a task placement device as a first exemplary embodiment of the present invention. FIG. 2 is a block diagram showing an example of the function of the task placement device as the first exemplary embodiment of the present invention. FIG. 3 is a block diagram showing an example of the configuration of the rank weight assigning unit in the first embodiment of the present invention. FIG. 4 is a block diagram illustrating an example of the configuration of the arrangement unit according to the first embodiment of the present invention. FIG. 5 is a flowchart for explaining an example of the operation of the task placement device as the first exemplary embodiment of the present invention. FIG. 6 is a schematic diagram showing an example of a task set targeted by the task placement device as the first exemplary embodiment of the present invention. FIG. 7A is a diagram illustrating an example of a data structure of a task set parameter holding unit according to the first embodiment of this invention. FIG. 7B is a diagram illustrating an example of a data structure of a task set parameter holding unit according to the first embodiment of this invention. FIG. 7C is a diagram illustrating an example of a data structure of a task set parameter holding unit according to the first embodiment of this invention. FIG. 8 is a schematic diagram illustrating an example of a sequence code assigned to each task according to the first embodiment of this invention. FIG. 9 is a schematic diagram illustrating another example of a sequence code assigned to each task in the first embodiment of the present invention. FIG. 10 is a schematic diagram showing still another example of the ordinal code assigned to each task in the first embodiment of the present invention. FIG. 11 is a schematic diagram illustrating an example of rank weights assigned to each dependency relationship according to the first embodiment of this invention. FIG. 12 is a schematic diagram illustrating another example of rank weights assigned to each dependency relationship according to the first embodiment of this invention. FIG. 13 is a schematic diagram showing still another example of the ordering weights given to each dependency relationship in the first embodiment of the present invention. FIG. 14 is a schematic diagram for explaining inter-core dependence existing in task placement candidates in the first exemplary embodiment of the present invention. FIG. 15 is a block diagram showing an example of the function of the task placement device as the second exemplary embodiment of the present invention. FIG. 16A is a diagram illustrating an example of a data structure of an ordinal code holding unit according to the second embodiment of the present invention. FIG. 16B is a diagram illustrating an example of a data structure of an ordinal code holding unit in the second embodiment of the present invention. It is a flowchart explaining an example of operation | movement of the task arrangement | positioning apparatus as the 2nd Embodiment of this invention.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings. The task placement apparatus according to each embodiment of the present invention described below is configured to configure each task set when designing and implementing a function-distributed AMP multicore system in which each task is executed by a specific core. This is a device that determines in which core a task is to be placed. As described above, the performance of an AMP multi-core system differs depending on which core the task is placed on. In the following, it will be described that task placement that enhances the performance of a multi-core system is possible based on the task placement device of each embodiment of the present invention. Hereinafter, an AMP multicore system targeted in each embodiment of the present invention is simply referred to as a multicore system.
(First embodiment)
FIG. 1 shows an example of the hardware configuration of the task placement device 1 as the first exemplary embodiment of the present invention. In FIG. 1, a task placement device 1 includes a CPU (Central Processing Unit) 1001, a RAM (Random Access Memory) 1002, a ROM (Read Only Memory) 1003, and a storage device 1004 such as a hard disk, and constitutes a computer. is doing.
The ROM 1003 and the storage device 1004 store programs and various data for causing a computer to function as the task placement device 1 of the present embodiment.
The CPU 1001 reads the program and various data stored in the ROM 1003 and the storage device 1004 into the RAM 1002 and executes them.
Next, an example of the functional block configuration of the task placement device 1 is shown in FIG. In FIG. 2, the task placement device 1 includes a task set parameter holding unit 11, an ordering weight assigning unit 12, and a placement unit 13.
Here, the task set parameter holding unit 11 is configured using, for example, a storage device 1004. Further, the rank weight assigning unit 12 and the arranging unit 13 are configured using, for example, a CPU 1001 that reads a computer program and various data stored in the ROM 1003 and the storage device 1004 into the RAM 1002 and executes them. Note that the hardware configuration configuring each functional block of the task placement device 1 is not limited to the configuration described above.
The task set parameter holding unit 11 holds task set parameters input from the outside. Here, the task set parameter is information representing the characteristics of individual tasks constituting a task set (a set of one or more tasks to be arranged). The task set parameter includes information representing a dependency relationship between tasks. In addition, the task set parameter may include information representing the task start cycle, execution time, required memory size, and the like.
In addition, when a task set parameter input from the outside is input in a format that can be referred to from other functional blocks such as a file, the task set parameter holding unit 11 copies the task set parameter. There is no need to hold it. In this case, the task set parameter holding unit 11 may hold information indicating the file or the like.
In addition, when the task set parameter input from the outside includes information indicating an order to be described later, the task set parameter holding unit 11 may further hold information indicating the order of each task.
The rank weight assigning unit 12 refers to the task set parameters held in the task set parameter holding unit 11 and assigns rank weights to each dependency based on the rank of each task. Here, the rank of each task means a position where each task can be executed in the flow of execution of the entire task set based on the dependency relationship. Further, the rank weight is a coefficient representing the weight based on the rank. Specifically, it can be said that the rank weight is a coefficient representing the degree of ease of execution waiting time based on the dependency. The ease of occurrence of such an execution waiting time changes based on the order of related tasks related to the dependency. Therefore, the rank weight is information based on the rank.
Specifically, the order weight assigning unit 12 includes an order code generation unit 121 and a weighting unit 122, as shown in FIG.
The order code generation unit 121 generates an order code indicating the order of each task in the target task set. Specifically, the order code generation unit 121 may calculate the order code of each task based on the task set parameter held in the task set parameter holding unit 11.
Alternatively, when the task set parameter holding unit 11 already holds information representing the rank of each task, the rank code generation unit 121 omits the process of calculating the rank code, and the task set parameter holding unit 11 What is necessary is just to acquire the order code of a task. In this case, the task set parameter holding unit 11 may hold an order code or may hold information on each task in an order corresponding to the order code.
The weighting unit 122 assigns a sequence weight to each dependency relationship between tasks based on the sequence code generated (or acquired) using the sequence code generation unit 121.
For example, the weighting unit 122 may increase the rank weight as the rank of each task having a dependency relationship is closer to the end in the flow of execution of the entire task set. Further, for example, the weighting unit 122 may increase the order weight as the order of two tasks having a dependency relationship is closer. Here, heavy ordering weight means that the dependency waiting time based on the dependency relationship is more likely to occur. The value of the ordering weight may be larger as it is heavier or smaller as it is heavier.
When the placement unit 13 places a task belonging to a task set on one or more cores according to the dependency relationship, the placement unit 13 calculates the order weights given to the dependency relationship between two tasks placed on different cores. The task is arranged based on the evaluated value. Hereinafter, the dependency relationship between two tasks arranged in different cores is also simply referred to as inter-core dependency.
Specifically, the arrangement unit 13 includes an evaluation value calculation unit 131 and an optimum arrangement search unit 132, as shown in FIG.
The evaluation value calculation unit 131 calculates an evaluation value that represents the goodness of the arrangement of a task arrangement candidate described later. Specifically, the evaluation value calculation unit 131 calculates an evaluation value by using the rank weight assigned to the inter-core dependency.
The optimum arrangement search unit 132 arranges tasks in one or more cores according to the dependency relationship, and generates task arrangement candidates. Then, the optimum arrangement search unit 132 searches for candidate task arrangements with good evaluation values calculated using the evaluation value calculation unit 131.
Here, as the simplest search method applicable to the optimum arrangement search unit 132, a full search can be cited. When using the full search, the optimal arrangement search unit 132 generates all task arrangement candidates, and outputs an arrangement with the best evaluation value among them as a search result.
However, it is more preferable that the optimum arrangement search unit 132 apply a generally known high-speed search method such as a branch and bound method, a greedy method, or a genetic algorithm as a search method more efficient than the full search.
The operation of the task placement apparatus 1 configured as described above will be described with reference to FIG.
First, the task set parameter holding unit 11 holds task set parameters input from the outside (step S101).
Next, the optimal arrangement search unit 132 generates task arrangement candidates (candidate data indicating which tasks are arranged in which cores) (S102).
Next, the order code generation unit 121 refers to the task set parameters held in the task set parameter holding unit 11 and obtains the order codes for each task. As described above, the order code generation unit 121 may calculate the order code of each task, or may obtain the order code already assigned to each task. Then, the weighting unit 122 generates an ordering weight based on the ordering code of each task (step S103).
At this time, the weighting unit 122 may give rank weights to all the dependency relationships existing in the task set.
However, the weighting unit 122 may give an ordering weight for the dependency necessary for the evaluation value calculation unit 131.
Based on this operation, the task placement device 1 can improve the efficiency of the grant process. For example, when the evaluation value calculation unit 131 calculates the evaluation value using the ordering weight assigned to the inter-core dependency, the weighting unit 122 determines the order for the inter-core dependency in the task placement candidate generated in step S102. What is necessary is just to give a weight.
Note that when ordering weights are assigned to all the dependency relationships, the above-described steps S102 and S103 are in no particular order. For example, the task placement device 1 can also execute step S103 and step S102 in this order, and simultaneously execute step S102 and step S103.
Next, the evaluation value calculation unit 131 calculates an evaluation value indicating the goodness of task arrangement using the rank weights given to the inter-core dependence in step S103 for the task arrangement candidates generated in step S102 (step S103). S104).
Next, the optimum arrangement search unit 132 determines whether or not the generated task arrangement candidate and its evaluation value satisfy a task arrangement search termination condition (step S105).
If the task placement search termination condition is not satisfied, the task placement device 1 repeats the processing from step S102 again.
On the other hand, when the task placement search termination condition is satisfied, the optimum placement search unit 132 outputs the task placement candidate having the best evaluation value among the task placement candidates generated so far as the optimization result (step S106). . Then, the task placement device 1 ends the operation.
Here, the task placement search termination condition differs according to the optimization algorithm employed by the optimum placement search unit 132. For example, when a simple full search is used as the optimization algorithm, the task layout search end condition is the generation end of all task layout candidates that can be generated. In this case, the optimum arrangement search unit 132 outputs a task arrangement candidate having an optimum evaluation value among all the task arrangement candidates as an optimization result.
Further, for example, when another general optimization algorithm is adopted as the optimization algorithm, the task placement search termination condition may be a determination that the evaluation value does not become better in the optimization algorithm. Alternatively, the task placement search termination condition may be a determination that the evaluation value does not improve even if the task placement candidate generation is repeated a predetermined number of times.
Above, description of operation | movement of the task placement apparatus 1 is complete | finished.
Next, a detailed configuration and operation of the task placement device 1 as the first exemplary embodiment of the present invention will be described using a specific example.
First, a specific example of task set parameters held in the task set parameter holding unit 11 in step S101 will be described with reference to FIG. 6 and FIGS. 7A to 7C.
FIG. 6 is a graph representation of the dependency relationships existing in the task set composed of tasks 1 to 6. Hereinafter, such a graph is also referred to as a task graph. In such a task graph, arrows connecting the tasks represent dependency relationships between the tasks at both ends. Further, the arrow indicating the dependency relationship indicates that it is necessary to end the task on the start point side in order to start the task on the end point side. It can be said that such a task graph represents the flow of execution based on the dependency of the entire task set.
An example of the data structure of the task set parameters of the task set represented by such a task graph is shown in FIGS. 7A to 7C.
For example, as shown in FIG. 7A, the task set parameter holding unit 11 may hold the dependency destination task in association with each task constituting the task set. For example, in FIG. 7A, for task 1, tasks 2, 4 and 5 are held as the dependency destination tasks. Further, the task set parameter holding unit 11 may hold other parameters for each task. Other parameters may be, for example, the task start cycle, execution time, and required memory size, as described above.
Alternatively, as illustrated in FIG. 7B, the task set parameter holding unit 11 may hold a dependency source task in association with each task constituting the task set. For example, in FIG. 7B, tasks 3, 4, and 5 are held as the dependency source task for task 6. Also in this case, the task set parameter holding unit 11 may further hold other parameters as described above for each task.
Alternatively, as illustrated in FIG. 7C, the task set parameter holding unit 11 may hold information representing a combination of a dependency source task and a dependency destination task for each dependency relationship. In FIG. 7C, the dependency number is information for identifying the dependency relationship. As an example, dependency number 1 represents a dependency relationship from task 1 (dependency source task) to task 2 (dependency destination task). Further, in such a case, in order to hold other parameters as described above, the task set parameter holding unit 11 sets other parameters for each task as a table different from the table holding the dependency relationship. You can hold it.
Next, a specific example of processing in which the order code generation unit 121 calculates the order code of each task in step S103 will be described.
For example, the order code generation unit 121 assigns an order code having a smaller numerical value to a task whose order is higher in the task graph (closer to the start task), that is, a task that is more likely to be executed in an earlier order / time zone. Also good. In other words, the order code generation unit 121 may assign an order code having a larger numerical value to a task whose order is backward (far from the start task), that is, a task that is likely to be executed in a later order / time zone. .
Note that the order code assigned to each task may be different from the actual execution order. This is because the task execution order when the task set is actually executed is not uniquely determined. Generally, when there are a plurality of tasks that can be executed simultaneously, which task is executed first is determined at the time of execution based on various other factors.
A specific example of a method for calculating an ordinal code in the case of assigning an ascending code having a smaller value in the earlier order will be described. Here, three specific method examples for calculating an order code will be described using the above-described task graph of FIG. 6 representing the flow of execution based on the dependency of the entire task set.
A method using topological sort will be described as a specific example of the first order code calculation method.
FIG. 8 shows an example of a sequence code assigned to each task using the topological sort. In FIG. 8, the numerical value surrounded by a circle indicates an ordinal code assigned to each task. Here, the topological sort means that each node (task in the present invention) is ordered in an acyclic directed graph so that any node (task in the present invention) comes before the node ahead of its output edge (dependency based on the present invention). It is a technique to arrange them. This method outputs a sequence of nodes as a result. As a result, the rank code calculated using the topological sort is a unique value for each task.
As an algorithm for realizing the topological sort, generally, the publicly known document “Kahn, AB (1962),“ Topological sorting of large networks ”, Communications of the ACM 5 (11): 558-562”. Known techniques such as an algorithm based on the described Kahn and an algorithm using a depth-first search can be applied.
As a specific example of the second order code calculation method, a method using breadth-first search will be described.
Based on this method, the order code generation unit 121 assigns task order codes based on the number of each task in the flow that continues from the start task through dependency. Further, when this method is used, the order code generation unit 121 assigns an order code based on a flow having the largest number of tasks for a task that passes through a plurality of flows from the start task.
FIG. 9 shows an example of a sequence code assigned to each task using the breadth-first search.
In the task graph of FIG. 6, task 1 is a start task. Therefore, as shown in FIG. 9, the order code generation unit 121 assigns an order code 0 to the task 1. In addition, task 2, task 4, and task 5 are the first task in the flow that continues from the start task through dependency. Therefore, the order code generation unit 121 assigns order code 1 to these tasks. Task 3 is the second task that follows task 2 in the flow that continues from the start task through dependency. Therefore, the order code generation unit 121 assigns the order code 2 to the task 3. The task 6 is the third task from the start task in the flow following the task 3, and is the second task from the start task in the flow following the tasks 4 and 5. At this time, when an order code is assigned based on the flow having the largest number of tasks, the order code generation unit 121 assigns an order code 3 to the task 6.
Here, an example has been described in which 0 is assigned as the order code of task 1, which is the start task, but the order code assigned to the start task may be any other value. For example, the order code generation unit 121 may assign 1 to the order code of the start task, or may assign other values.
As a specific example of the third order code calculation method, a method using execution time information will be described.
When this method is used, the task set parameter holding unit 11 holds the execution time of each task. In this example, the order code generation unit 121 assigns an order code to each task in consideration of the execution time of each task based on the breadth-first search method. Specifically, the order code generation unit 121 assigns a task order code based on the total execution time of each task in a flow that continues from the start task through dependency.
Further, when this method is used, the order code generation unit 121 assigns an order code based on the longest total execution time for a task that passes through a plurality of flows from the start task. The order code calculated in this way is an order code that reflects the difference in the effect of a task with a long execution time and a task with a short execution time.
FIG. 10 shows an example of a sequence code assigned to each task using the execution time information.
As shown in FIG. 10, the order code generation unit 121 assigns 2 as the execution time to the task 1 as the start task as the order code. Further, the order code generation unit 121 assigns to the task 2 6 as an order code, which is obtained by adding the execution time 4 of the task 2 to the order code (execution time) 2 of the task 1. Similarly, the order code generation unit 121 assigns an order code 5 to the task 4 and assigns an order code 7 to the task 5. Further, the order code generation unit 121 executes the task 6 with respect to the task 6 in the order code 8 of the task 3 having the largest order code (that is, the longest total execution time) among the tasks that depend on the task 6. 11 with time 3 added is assigned as an ordinal code.
In step S103, the order code generation unit 121 may use the order code of each task input from the outside, instead of calculating the order code of each task used to assign the order weight as described above.
In this case, in step S101, information corresponding to the order code of each task is input from the outside, and the task set parameter holding unit 11 holds it. Then, the ordinal code generation unit 121 may acquire the ordinal code of each task with reference to the task set parameter holding unit 11. For example, the task set parameter holding unit 11 may hold information related to each task in an order corresponding to topological sorting. In this case, the order code generation unit 121 may acquire the order in which the information about each task held in the task set parameter holding unit 11 is held as an order code. Or the task set parameter holding | maintenance part 11 may hold | maintain the information containing the numerical value showing an ordinal code as another parameter regarding each task.
Next, three specific examples of processing in which the weighting unit 122 assigns rank weights to each dependency relationship in step S103 will be described.
Here, the higher the order weight, the larger the order weight value. The description will be made assuming that the arrangement unit 13 searches for an arrangement that is as far away as possible (an arrangement on the same core as much as possible) as the dependency relationship has a larger numerical value of the ordering weight.
As a first specific example of assigning rank weights, a method will be described in which the rank order weights are made heavier as the dependency relationship between tasks in the task graph is closer to the rear (distant from the start task).
As described above, the closer to the rear in the task graph, the greater the influence on the execution performance of the entire task set when arranged between different cores. Therefore, the weighting unit 122 may increase the numerical value of the rank weight as the rank becomes backward (away from the start task).
As a simple example of increasing the order weight as the order is closer to the rear, consider the case where a unique order code is assigned to each task shown in FIG. 8 based on topological sort. In this case, the weighting unit 122 sets the dependency relationship with 1 / n tasks (where n represents a positive integer and “/” represents division) as the dependency source in order from the smallest sequence code. On the other hand, an order weight 1 may be assigned. Similarly, the weighting unit 122 may assign the ordering weight 2 to the dependency having the whole task of 1 / n to 2 / n as a dependency source, and may be repeated in the same manner.
As another example of increasing the order weight as the order is closer to the rear, consider the case where an order code is assigned to each task based on the breadth-first search shown in FIG. In such a case, the weighting unit 122 may assign an ordering weight based on the ordering code assigned to the dependency source task (the task executed first) of each dependency relationship. For example, the weighting unit 122 may assign the numerical value of the ordinal code assigned to the dependency source task of each dependency relationship to the dependency relationship as it is as the order weight.
The rank weights assigned in this way are shown in FIG. In FIG. 11, a numerical value surrounded by a circle represents an ordering code, and a numerical value surrounded by a double circle represents an ordering weight. In FIG. 11, an order weight 0 is assigned to each dependency relationship from task 1 to tasks 2, 4, and 5 with order code 0. Further, an order weight 1 is assigned to each dependency relationship from task 2 to task 3 with order code 1 and tasks 4 and 5 with order code 1 from task 4. In addition, the order weight 2 is given to the dependency relation of the order code 2 from the task 3 to the task 6.
As yet another example in which the rank weight is increased as the rank is closer to the rear, a case where a rank code is assigned by combining the execution time information of each task with the breadth-first search shown in FIG. Also in this case, the weighting unit 122 may assign the ordering weight based on the ordering code assigned to the dependency source task (task to be executed first) of each dependency relationship.
FIG. 12 shows the sequence weights assigned in this way.
In FIG. 12, a numerical value surrounded by a circle represents an ordering code, and a numerical value surrounded by a double circle represents an ordering weight. In FIG. 12, an order weight 2 is assigned to each dependency relationship from task 1 to task 2, 4, and 5 with order code 2. In addition, the dependency weights from task 2 to task 3 with order code 6, task 4 to task 6 with order code 5, and task 5 to task 6 with order code 7 are assigned as order weights 6, 5 and 7 respectively. Is granted. Further, an order weight 8 is given to the dependency relationship of the order code 8 from task 3 to task 6.
As described above, the weighting unit 122 increases the ordering weight as the dependency relationship between the tasks whose order is closer to the rear in the task graph.
As a second specific example of assigning rank weights, a method for increasing the rank weight as the rank order of two tasks having a dependency relationship is closer will be described.
Again, the higher the order weight, the larger the order weight value. As a simple example, the weighting unit 122 may use a value obtained by subtracting the absolute value of the difference between the order codes of two tasks having a dependency relationship from the maximum value of the order code in the entire task set as the dependency order weight. . Alternatively, the weighting unit 122 subtracts the absolute value of the difference between the order codes of two tasks having the corresponding dependency from the maximum value of the difference between the order codes of the two tasks having the dependency. It is good also as an ordering weight of a dependency.
For example, consider a case where an ordinal code is assigned to each task based on the breadth-first search shown in FIG.
In this case, as shown in FIG. 13, the weighting unit 122 gives an ordering weight to each dependency relationship. In FIG. 13, a numerical value surrounded by a circle represents an order code, a numerical value surrounded by a dotted triangle represents an absolute value of a difference between the order codes, and a numerical value surrounded by a double circle represents an order weight. . In FIG. 13, the absolute value of the difference between the order codes at both ends of the dependency relationship between tasks 4 to 6 and tasks 5 to 6 is 2. In addition, the absolute value of the difference between the order codes at both ends of the other dependency relationships is 1. The maximum value of the ordinal code is 3. Therefore, the order weight of each dependency relationship between tasks 4 to 6 and tasks 5 to 6 is 1 obtained by subtracting the absolute value 2 of the difference between the order codes at both ends from the maximum value 3. The ordering weight of other dependency relationships is 2 obtained by subtracting the absolute value 1 of the difference between the ordering codes at both ends from the maximum value 3.
In this way, the weighting unit 122 increases the ordering weight as the dependency relationship between the tasks having a similar order on the task graph.
As a specific example of the third order weighting, a method combining the above two methods is also possible.
As a simple example, the weighting unit 122 uses the maximum value of the order code of the second example with respect to the order weight value generated by the method of increasing the order weight by 1 / n of the whole of the first example. Thus, the order weight may be a value obtained by multiplying the order weights obtained by subtracting the absolute value of the difference between the order codes at both ends of each dependency.
In this way, the weighting unit 122 can generate an ordering weight that is heavier as a dependency relationship between tasks whose order is closer to the rear on the task graph and heavier as a dependency relationship between tasks whose order is closer on the task graph.
In addition to the above-described method, the weighting unit 122 assigns an order weight that reflects the degree of ease of occurrence of the dependency waiting time in accordance with the order of two tasks having the dependency relation for each dependency relation. May be generated. Further, the weighting unit 122 may generate the rank weight by combining these various methods.
In general, as each dependency relationship between tasks existing in a task set, there are mixed dependency relationships that differ in communication method, transfer data amount, and the like related to the dependency relationship. For this reason, the task set targeted by the task placement apparatus 1 according to the present embodiment may have as a parameter a weight based on these other factors relating to the dependency between tasks in advance. In this case, the weighting unit 122 sets, for each dependency relationship, a value (for example, a multiplication value) that is a combination of the weight value based on other factors given in advance and the order weight value calculated as described above. You may give with respect to each dependence.
Next, a specific example of a process in which the evaluation value calculation unit 131 calculates an evaluation value in step S104 will be described.
The evaluation value calculation unit 131 calculates an evaluation value indicating the goodness of task arrangement using the rank weight assigned to the inter-core dependency.
As a simple example, the evaluation value calculation unit 131 may calculate, as an evaluation value, a value obtained by adding or multiplying all rank weights assigned to inter-core dependence.
For example, when the addition value is used, the evaluation function F _w Is represented by the following equation (1). In Expression (1), the inter-core dependence in the target task placement candidate is n. W _i Represents the rank weight assigned to each inter-core dependency i (i = 0 to n−1).

The evaluation value calculated in this way indicates that the smaller the value is, the smaller the influence of inter-core dependence on the execution performance of the entire task set is, that is, the better the task placement.
An example of the evaluation value calculated by the evaluation value calculation unit 131 based on the formula (1) will be described with reference to FIG.
FIG. 14 shows a task placement candidate. In this task arrangement candidate, tasks 2, 3 and 6 are arranged on the core 0, and tasks 1, 4 and 5 are arranged on the core 1. In addition, the inter-core dependence in this task placement candidate is the dependence from task 1 to 2, the dependence from task 4 to 6, and the dependence from task 5 to 6. Thus, the number of inter-core dependencies in this task placement candidate is three. Further, the ordering weights assigned to these inter-core dependencies are 0 for the dependency from task 1 to 2, 1 for the dependency from task 4 to 6, and 1 from the dependency from task 5 to 6, respectively. Is granted. Therefore, the evaluation value calculation unit 131 calculates 2 as the evaluation value based on the formula (1) for this task placement candidate.
Note that FIG. 14 illustrates an example of calculating the evaluation value when the number of cores is 2. However, the evaluation value calculation unit 131 can similarly calculate the evaluation value even when the number of cores is 3 or more. It is.
In step S104, the evaluation value calculation unit 131 may calculate an evaluation value based on other evaluation functions other than the expression (1).
For example, the evaluation value calculation unit 131 may calculate, as the evaluation value, a value obtained by subtracting all the order weights given to inter-core dependence from a predetermined value. In this case, the evaluation value calculated in this way represents that the influence of inter-core dependence on the execution performance of the entire task set is relatively small as the value is large, that is, the task arrangement is good.
In step S104, the evaluation value calculation unit 131 calculates an evaluation value using the start cycle, execution time, required memory size, etc. of each task in addition to the ordinal weight given to inter-core dependency. Also good. In this case, information such as the activation period, execution time, or required memory size is held in the task set parameter holding unit 11.
For example, a system is assumed in which it is appropriate that the total execution time of tasks assigned to each core is equal in each core. In this case, the evaluation value calculation unit 131 additionally calculates an evaluation value based on the difference in the total execution time of the tasks assigned to each core in addition to the evaluation value based on the rank weight assigned to the inter-core dependency. An evaluation value obtained by integrating these may be calculated.
In addition, in a task activated at regular intervals, the core utilization rate of each task can be calculated as “task execution time ÷ task activation cycle”. Here, a system is assumed in which it is appropriate that the utilization rate of the cores is equal in each core. In this case, the evaluation value calculation unit 131 additionally calculates an evaluation value based on the difference in the core utilization rate of each core in addition to the evaluation value based on the order weight given to the inter-core dependency, and integrates these. An evaluation value may be calculated.
A system is assumed in which the required memory size is appropriate for each core. In this case, in addition to the evaluation value based on the rank weight assigned to the inter-core dependency, the evaluation value calculation unit 131 additionally calculates an evaluation value based on the difference in the required memory size of each core, and integrates them. An evaluation value may be calculated.
As described above, when the task set parameter holding unit 11 holds other task set parameters in addition to the dependency relationship between tasks, the evaluation value calculation unit 131 adds these other task set parameters incidentally. The evaluation value can be calculated by using this. In this case, the placement unit 13 can perform task placement in consideration of factors other than these inter-core dependencies.
As described above, various methods can be applied to the evaluation value calculation method using the rank weight assigned to the inter-core dependency.
Next, a specific example of the search end condition used by the optimum arrangement search unit 132 in step S105 will be described.
As described above, the optimal placement search unit 132 generates task placement candidates, and using the evaluation values calculated for the generated task placement candidates, the generated task placement candidates and their evaluation values are used as search end conditions. It is determined whether or not it is satisfied.
If the task placement is better as the evaluation value is smaller, the optimum placement search unit 132 searches for task placement candidates that minimize the evaluation value.
At this time, the task placement search termination condition differs based on the optimization algorithm employed by the optimum placement search unit 132. For example, when a simple full search is adopted as an optimization algorithm, the generation of all task placement candidates that can be generated as the search end condition ends. In this case, the optimum arrangement search unit 132 outputs the task arrangement candidate for which the minimum evaluation value is calculated among all the task arrangement candidates as the optimization result.
Further, for example, when another general optimization algorithm is adopted, the search end condition is determined that the evaluation value based on the algorithm is not further reduced, and generation of task placement candidates is repeated a predetermined number of times. It may be determined that the evaluation value does not become small.
As described above in detail, the task set parameter holding unit 11, the order weight assigning unit 12, the evaluation value calculating unit 131, and the optimum arrangement searching unit 132 can employ various data structures and various methods. In the present embodiment, the data structures and methods employed for each of these functional blocks can be employed in various combinations. Further, this embodiment can also employ a combination of a plurality of methods in each functional block.
Next, effects of the first exemplary embodiment of the present invention will be described.
The task placement apparatus according to the first exemplary embodiment of the present invention can perform task placement with higher performance by further reducing the influence of non-uniform inter-core dependence based on the rank.
The reason is that the ordering weight assigning unit assigns ordering weights to each dependency existing between tasks based on the order in which each task can be executed in the execution flow of the entire task set. It is. When the placement unit places the task in one or more cores according to the dependency relationship, the evaluation value calculated based on the rank weight assigned to the dependency relationship between the tasks placed between different cores is This is because tasks are arranged so as to improve. Based on this, the task placement device as the present embodiment is for a task set in which an inter-core dependency waiting time occurs even if the number of inter-core dependencies based on the device described in Patent Document 1 is minimized. It is possible to generate a task arrangement that further reduces the dependency waiting time. As a result, the task placement apparatus according to the first exemplary embodiment of the present invention can output a task placement that can fully exhibit the multi-core performance. That is, the task placement apparatus according to the present embodiment can realize task placement reflecting the magnitude of the influence on the execution performance depending on the order of the cores in the multi-core system.
In addition, the task placement device as the first exemplary embodiment of the present invention can perform task placement with higher performance by further reducing the dependency waiting time at a position near the end of execution of the task set.
The reason is that the order weight assigning unit increases the order weights as the dependency relationship between the tasks whose order in the task graph is closer to the rear. Based on this operation, the placement unit calculates an evaluation value indicating that the placement is worse as the inter-core dependency between the tasks whose ranks are closer to the rear is larger. Then, the placement unit searches for a task placement that improves the evaluation value. Therefore, in the task placement searched in this way, a task having a dependency relationship near the end of execution of the entire task set is less likely to be placed on a different core. Therefore, the task placement device as the first exemplary embodiment of the present invention can cope with the critical dependency problem that appears behind the rank on the task graph.
In addition, the task placement device as the first exemplary embodiment of the present invention can reduce task dependency waiting time between tasks having similar execution orders in a task set, and perform task placement with higher performance.
The reason for this is that the ordering weight assigning unit increases the ordering weight as the dependency between tasks having a small difference in the ordering code in the task graph. Based on this operation, the placement unit calculates an evaluation value indicating that the placement is worse as the inter-core dependency between tasks having similar ranks increases. Then, the placement unit searches for a task placement that improves the evaluation value. Therefore, in the task placement searched in this way, the tasks having the dependency in the task set that are close to each other are less likely to be placed in different cores. Therefore, the task placement device as the first exemplary embodiment of the present invention can cope with the problem of dependency between tasks having similar ranks on the task graph.
(Second Embodiment)
Next, a second embodiment of the present invention will be described in detail with reference to the drawings. In each drawing referred to in the description of the present embodiment, the same reference numerals are given to the same configuration and steps that operate in the same manner as in the first embodiment of the present invention, and the details in the present embodiment will be described. The detailed explanation is omitted.
First, FIG. 15 shows a block of an example of the function of the task placement device 2 as the second exemplary embodiment of the present invention. 15, the task placement device 2 further includes an order code holding unit 24 and an order weight holding unit 25 in addition to the same configuration as the task placement device 1 as the first embodiment of the present invention.
Here, the task placement device 2 may be configured using a computer device including the configuration shown in FIG. 1, similarly to the task placement device 1 as the first exemplary embodiment of the present invention. In that case, the order code holding unit 24 and the order weight holding unit 25 are configured using the storage device 1004. Note that the hardware configuration constituting each of these functional blocks is not limited to the above-described configuration.
The rank code holding unit 24 holds the rank code calculated by the rank weight assigning unit 12. An example of information held by the ordinal code holding unit 24 is shown in FIGS. 16A and 16B. For example, the ordinal code holding unit 24 may hold an ordinal code for each task as shown in FIG. 16A. Alternatively, as shown in FIG. 16B, the order code holding unit 24 may hold information for identifying a task to which the order code is assigned for each order code value. For example, FIG. 16B shows that the order code 1 is assigned to tasks 2, 4 and 5.
Note that the ordinal code holding unit 24 may be included in the task set parameter holding unit 11.
For example, when a unique order code is assigned to each task as in the case where an order code based on topological sort is generated using the order code generation unit 121, the order code storage unit 24 includes the task set parameter storage unit 11. The order code may be held using an expression obtained by rearranging the information on each task held in the order in the order of the order. Based on this operation, the rank code holding unit 24 can hold the calculated rank code without using an area of the storage device for holding the rank code.
The order weight holding unit 25 uses the order weight generation unit 12 to hold the order weight assigned to each dependency relationship.
The operation of the task placement apparatus 2 configured as described above will be described with reference to FIG.
First, the task set parameter holding unit 11 holds task set parameters input from the outside (step S101).
Next, the order code generation unit 121 refers to the task set parameters held in the task set parameter holding unit 11 and calculates an order code for each task (step S201). For example, the order code generation unit 121 can apply the technique described in detail in the first embodiment of the present invention as a technique for calculating the order code.
Next, the rank code holding unit 24 holds the calculated rank code (step S202).
Next, the weighting unit 122 assigns an ordering weight to each dependency relationship based on the ordering code held in the ordering code holding unit 24 (step S203). For example, the weighting unit 122 can apply the method described in detail in the first embodiment of the present invention as a weighting method.
Next, the rank weight holding unit 25 holds the rank weight generated using the weighting unit 122 (step S204).
Next, the optimum arrangement search unit 132 generates task arrangement candidates (step S102).
Next, the evaluation value calculation unit 131 calculates an evaluation value, which is an evaluation value indicating the goodness of task placement, for the generated task placement candidate using the rank weight held in the rank weight holding unit 25 (step S104). For example, the evaluation value calculation unit 131 can apply the method described in detail in the first embodiment of the present invention as the evaluation value calculation method.
Next, the optimum placement search unit 132 determines whether the task placement candidate and the evaluation value satisfy a task placement search termination condition (step S105). For example, as the search end condition, the condition described in detail in the first embodiment of the present invention is applicable.
If the task placement search termination condition is not satisfied, the task placement device 2 repeats the processing from step S102 again.
On the other hand, when the task placement search termination condition is satisfied, the optimum placement search unit 132 outputs a task placement optimization result (step S106). Then, the task placement device 2 ends the operation.
Note that in step S203, the weighting unit 122 may assign rank weights to inter-core dependence in task placement candidates. In this case, the task placement device 2 may execute steps S203 to S204 after generating task placement candidates in step S102.
Above, description of operation | movement of the 2nd Embodiment of this invention is complete | finished.
Next, the effect of the second exemplary embodiment of the present invention will be described.
The task placement apparatus as the second exemplary embodiment of the present invention, when placing a task for a multi-core system, performs a process of calculating an ordering weight reflecting the ease of occurrence of dependency waiting time depending on the core. Increase efficiency.
The reason is that the rank code holding unit holds the rank code of each task used for calculating the rank weight. Here, when a certain task has a plurality of dependency relationships, the order weight assigning unit refers to the order code of the task a plurality of times in order to calculate the order weight. In such a case, the task placement device as the second exemplary embodiment of the present invention can further reduce the processing time of the rank weight assigning unit based on the hold of the rank code holding unit of the rank code once calculated. Because.
In addition, the task placement apparatus as the second exemplary embodiment of the present invention can further improve the efficiency of the process of searching for a better performance task placement by reducing the influence of non-uniform inter-core dependence based on the order. .
The reason is that the rank weight holding unit holds the rank weight generated by using the rank weight generation unit. Here, the rank weights are invariable once calculated and often need not be recalculated. Therefore, the order weight need not be recalculated every time the evaluation value is calculated for different task placement candidates. Therefore, the task placement device according to the second exemplary embodiment of the present invention can shorten the task placement search time based on holding the rank weights of the rank weight holding unit.
In each of the embodiments of the present invention described above, the order code is mainly described as having a smaller value as it is closer to the start task on the task graph. However, the order code in the present invention is, for example, on the task graph. The closer to the start task, the larger the value may be.
Further, in each of the embodiments of the present invention described above, the order weight is mainly described as having a value that is large enough to generate the dependency waiting time. However, the order weight in the present invention generates, for example, the dependency waiting time. You may have a small value that is easy to do.
In each of the embodiments of the present invention described above, the evaluation value is mainly described as having a smaller value as the task arrangement is better. However, the evaluation value in the present invention has a larger value as the task arrangement is better. Also good. In this case, the placement unit may search for a task placement candidate that increases the evaluation value.
In each of the embodiments of the present invention described above, the operation of the task placement device described with reference to each flowchart is stored in a storage device (storage medium) of a computer as a program of the present invention. The CPU may read and execute. In such a case, the present invention is configured using the code or storage medium of the program.
Moreover, each embodiment mentioned above can be implemented in combination as appropriate.
The present invention is not limited to the above-described embodiments, and can be implemented in various modes.
Moreover, although a part or all of said embodiment can be described also as the following additional remarks, it is not restricted to the following.
(Appendix 1)
A task set parameter holding means for holding a task set parameter including information representing a dependency relationship between the tasks for a task set which is a set of tasks to be arranged;
Using the reference to the task set parameter, a weight based on the order is assigned to each dependency between the tasks based on an order that is a position where each task can be executed in the execution flow of the entire task set. An order weight assigning means for assigning an order weight that is a coefficient representing;
When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And placement means for placing tasks based on the calculated evaluation value;
Including a task placement device.
(Appendix 2)
The rank weight assigning means includes
The closer the order of each task having the dependency is to the end in the flow of execution of the entire task set, the heavier the order weight given to the dependency
The task placement device according to Supplementary Note 1, wherein:
(Appendix 3)
The rank weight assigning means includes
The closer the order of the two tasks having the dependency relationship is, the heavier the order weight given to the dependency relationship is.
The task placement device according to Supplementary Note 1 or Supplementary Note 2, wherein:
(Appendix 4)
The rank weight assigning means includes
Based on the task set parameter held in the task set parameter holding means, an order code representing the order to be used for giving the order weight is calculated.
The task placement device according to any one of supplementary notes 1 to 3, characterized in that:
(Appendix 5)
Further comprising an order code holding means for holding an order code calculated using the order weight assigning means;
The rank weight assigning means includes
Using the reference of the order code held in the order code holding means, the order weight is given to each dependency.
The task placement device according to appendix 4, wherein
(Appendix 6)
And further comprising an order weight holding means for holding the order weight given using the order weight giving means,
The arrangement means includes
The evaluation value is calculated using the order weight held in the order weight giving means.
The task placement device according to any one of Supplementary Note 1 to Supplementary Note 5, wherein
(Appendix 7)
For a task set that is a set of tasks to be arranged, a task set parameter including information indicating dependency between the tasks is retained,
Using the reference to the task set parameter, a weight based on the order is assigned to each dependency between the tasks based on an order that is a position where each task can be executed in the execution flow of the entire task set. Giving rank weights that are coefficients to represent,
When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And task placement based on the calculated evaluation value,
Task placement method.
(Appendix 8)
When assigning the order weights to the dependency relationships, the order weights of the tasks having the dependency relationships are closer to the end in the execution flow of the entire task set, and the order weights to be assigned to the dependency relationships are heavier. Do
The task placement method according to appendix 7, characterized in that:
(Appendix 9)
When assigning the order weights to each dependency relationship, the closer the order of the two tasks having the dependency relationship is, the heavier the order weight given to the dependency relationship is.
9. The task placement method according to appendix 7 or appendix 8, characterized by the above.
(Appendix 10)
A task set parameter holding process for holding a task set parameter including information representing a dependency relationship between the tasks for a task set which is a set of tasks to be arranged;
Using the reference to the task set parameter, a weight based on the order is assigned to each dependency between the tasks based on an order that is a position where each task can be executed in the execution flow of the entire task set. An order weighting process for assigning an order weight that is a coefficient to be represented;
When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And placement processing for task placement based on the calculated evaluation value;
A program that causes a computer to execute.
(Appendix 11)
In the order weight assigning process, the order weights assigned to the dependency relations are made heavier as the order of the tasks having the dependency relations approaches the end in the execution flow of the entire task set.
The program according to appendix 10, characterized by:
(Appendix 12)
In the order weighting process, the closer the order of the two tasks having the dependency relation is, the heavier the order weight given to the dependency relation is.
The computer program according to appendix 10 or appendix 11, characterized in that
While the present invention has been described with reference to the embodiments, the present invention is not limited to the above embodiments. Various changes that can be understood by those skilled in the art can be made to the configuration and details of the present invention within the scope of the present invention.
This application claims the priority on the basis of Japanese application Japanese Patent Application No. 2011-231283 for which it applied on October 21, 2011, and takes in those the indications of all here.

DESCRIPTION OF SYMBOLS 1, 2 Task arrangement | positioning apparatus 11 Task set parameter holding part 12 Ordering weight provision part 13 Arrangement part 24 Order code holding part 25 Ordering weight holding part 121 Order code generation part 122 Weighting part 131 Evaluation value calculation part 132 Optimal arrangement search part 1001 CPU
1002 RAM
1003 ROM
1004 Storage device

Claims (12)

1. A task set parameter holding means for holding a task set parameter including information representing a dependency relationship between the tasks for a task set which is a set of tasks to be arranged;
   Based on the task set parameters and an order that is a position where each task can be executed in the execution flow of the entire task set, a coefficient representing a weight based on the order for each dependency relationship between the tasks An order weighting means for assigning a certain order weight;
   When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And placement means for placing tasks based on the calculated evaluation value;
   Including a task placement device.
2. The rank weight assigning means includes
   2. The task arrangement according to claim 1, wherein as the order of each task having the dependency relationship is closer to the end in the flow of execution of the entire task set, the order weight given to the dependency relationship is increased. apparatus.
3. The rank weight assigning means includes
   The task placement device according to claim 1, wherein the rank weight assigned to the dependency relation is increased as the rank order of the two tasks having the dependency relation is closer.
4. The rank weight assigning means includes
   4. The rank code representing the rank to be used for assigning the rank weight is calculated based on the task set parameter held in the task set parameter holding means. The task placement device according to claim 1.
5. Further comprising an order code holding means for holding an order code calculated using the order weight assigning means;
   The rank weight assigning means includes
   The task placement apparatus according to claim 4, wherein the order weight is assigned to each dependency relationship based on the order code held in the order code holding unit.
6. And further comprising an order weight holding means for holding the order weight given using the order weight giving means,
   The arrangement means includes
   The task placement apparatus according to any one of claims 1 to 5, wherein the evaluation value is calculated using a rank weight held in the rank weight assigning unit.
7. For a task set that is a set of tasks to be arranged, a task set parameter including information indicating dependency between the tasks is retained,
   Based on the task set parameters and an order that is a position where each task can be executed in the execution flow of the entire task set, a coefficient representing a weight based on the order for each dependency relationship between the tasks A certain ordering weight,
   When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And task placement based on the calculated evaluation value,
   Task placement method.
8. When assigning the order weights to the dependency relationships, the order weights of the tasks having the dependency relationships are closer to the end in the execution flow of the entire task set, and the order weights to be assigned to the dependency relationships are heavier. The task placement method according to claim 7, wherein:
9. 8. When assigning the order weight to each dependency, the order weight given to the dependency is increased as the order of two tasks having the dependency is closer. Item 9. The task placement method according to Item 8.
10. A task set parameter holding process for holding a task set parameter including information representing a dependency relationship between the tasks for a task set which is a set of tasks to be arranged;
    Based on the task set parameters and an order that is a position where each task can be executed in the execution flow of the entire task set, a coefficient representing a weight based on the order for each dependency relationship between the tasks An order weighting process for assigning a certain order weight;
    When a task belonging to the task set is arranged in one or more cores according to the dependency relationship, an evaluation value is calculated using the order weights given to the dependency relationship between two tasks arranged in different cores And placement processing for task placement based on the calculated evaluation value;
    A program that causes a computer to execute.
11. In the order weight assigning process, the order weight of each task having the dependency relationship is made heavier as the order weight given to the dependency relationship becomes closer to the end in the flow of execution of the entire task set. Item 13. The program according to item 10.
12. 12. The program according to claim 10, wherein, in the rank weight assigning process, the rank weight assigned to the dependency relation is increased as the rank order of the two tasks having the dependency relation is closer.

Images