WO2014108000A1

WO2014108000A1 - Task allocation method and system

Info

Publication number: WO2014108000A1
Application number: PCT/CN2013/088488
Authority: WO
Inventors: 谢静宇
Original assignee: 苏州亿倍信息技术有限公司
Priority date: 2013-01-09
Filing date: 2013-12-04
Publication date: 2014-07-17
Also published as: CN103064745B; CN103064745A

Abstract

Provided are a task allocation method and system, the method comprising the following steps: a client terminal submits a task to a task processor; the task processor puts the tasks having a dependency relationship into a task queue, establishes a task dependency comparison table according to the dependency relationship between tasks, and synchronizes the task dependency comparison table to a time slice allocator and a mapping relationship server; the time slice allocator acquires the total distribution number of the idle time slices of each dependent task according to the task dependency comparison table and a first policy; the mapping relationship server determines the periods corresponding to each dependent task according to the received task dependency comparison table, the total distribution number of the idle time slices of each dependent task, and a second policy; and the task processor processes the tasks having the dependency relationship in the task queue according to the received total distribution number of the idle time slices of each dependent task and the period corresponding to each dependent task.

Description

One

Method and system for task assignment processing

The invention belongs to the technical field of computers, and in particular relates to a method and a system for task assignment processing. Background technique

Currently, in the field of computer technology, a complex computing task model is encountered that consists of multiple computational tasks with dependencies. Among them, dependent tasks can only be calculated after being completed by dependent tasks, and computing tasks without dependencies can be calculated in parallel. For this kind of task model, how to allocate resources to tasks to get the optimal task processing time is an important issue. Summary of the invention

The present invention provides a method and system for task assignment processing to solve the above problems.

The present invention provides a method of task assignment processing. The above method comprises the following steps: the client submits the task to the task processor; the task processor puts the task with the dependency into the task queue, and establishes a task dependency comparison table according to the dependency relationship between the tasks, and the task dependency comparison table Synchronizing to the time slice allocator and the mapping relationship server; the time slice allocator obtains the total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and sends the total number of idle time slice allocations of each dependent task To the mapping relationship server and the task processor; the mapping relationship server determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and each dependent task The corresponding period is sent to the task processor; the task processor processes the task having the dependency in the task queue according to the received total number of idle time slice allocations of each dependent task and the period corresponding to each dependent task.

The present invention also provides a system for task allocation processing, including a client, a task processor, a time slice allocator, and a mapping relationship server. The client connects to the task processor, the task processor connects to the time slice allocator and the mapping relation server, and the mapping relationship server connects the time slice allocator. Among them, the client submits the task to the task processor. The task processor puts the tasks with dependencies into the task queue, and establishes a task dependency comparison table according to the dependencies between the tasks, and synchronizes the task dependency comparison table to the time slice allocator and the mapping relationship server. The time slice allocator obtains the total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and sends the total number of idle time slice allocations of each dependent task to the mapping relationship server and the task processor. The mapping relationship server determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and sends each cycle corresponding to the dependent task to the task processor. Task processor based on each received task ―

The total number of idle time slice allocations and the period corresponding to each dependent task, processing tasks with dependencies in the task queue.

Compared with the prior art, according to the method and system for task allocation processing provided by the present invention, the time slice allocator obtains the total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and each is dependent The total number of free time slice allocations for the task is sent to the mapping server and the task processor. Moreover, the mapping relationship server determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and sends each cycle corresponding to the dependent task to the task processing. Device. The task processor processes the tasks having dependencies in the task queue according to the total number of free time slice allocations of the respective dependent tasks received and the periods corresponding to the respective dependent tasks. In this way, the resource allocation efficiency of the task with dependencies is improved, and the task with dependency relationship is better executed and the efficiency is improved. DRAWINGS

The drawings are intended to provide a further understanding of the present invention, and are intended to be a part of the present invention, and the description of the present invention is not intended to limit the invention. In the drawing:

1 is a flow chart showing a method of task assignment processing according to a preferred embodiment of the present invention;

2 is a schematic diagram of a system for task assignment processing in accordance with a preferred embodiment of the present invention. detailed description

The invention will be described in detail below with reference to the drawings in conjunction with the embodiments. It should be noted that the embodiments in the present application and the features in the embodiments may be combined with each other without conflict.

1 is a flow chart of a method of task assignment processing in accordance with a preferred embodiment of the present invention. As shown in FIG. 1, the method for task assignment processing provided by the preferred embodiment of the present invention includes steps 101-105.

In step 101, the client submits the task to the task processor. Here, tasks include tasks with dependencies and tasks that are independent of each other. However, the present invention is not limited thereto.

In step 102, the task processor puts a task with a dependency into a task queue, and establishes a task dependency comparison table according to the dependency relationship between the tasks, and synchronizes the task dependency comparison table to the time slice allocator and the mapping. Relational server. Here, the tasks in the task queue are sorted according to the dependencies, and are executed by the dependent tasks first.

In this embodiment, the task dependency table established by the task processor is as shown in Table 1. However, the present invention is not limited thereto.

One

Task 3 Task 6 Table 1

In step 103, the time slice distributor obtains a total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and sends the total number of idle time slice allocations of each dependent task to the Mapping the relationship server and the task processor.

The first policy is: the time slice distributor separately calculates the proportion of the dependent tasks corresponding to the respective dependent tasks according to the task dependency comparison table, and according to the proportion of the dependent tasks corresponding to the respective dependent tasks and the current time The total amount of system idle time slices, calculated to obtain the total number of free time slice allocations for each dependent task. The proportion of the dependent tasks corresponding to each dependent task is the ratio of the number of dependent tasks corresponding to the corresponding dependent task to the total number of tasks. The total number of idle time slice allocations for each dependent task is the product of the corresponding dependent task's dependent task percentage and the current system idle time slice total.

In the present embodiment, Table 1 is taken as an example. As can be seen from Table 1, the total number of current tasks is six. In addition, for example, the total amount of system idle time slices at the current moment is a, then the proportion of dependent tasks dependent on task 1 is =3/6=0.5, and the total number of idle time slices allocated to task 1 is =0.5*a; The proportion of dependent tasks of task 2 = 2/6 = 1/3, and the total number of idle time slices allocated by task 2 = ( 1/3 ) * a; the proportion of dependent tasks dependent on task 3 = 1 / 6, And the total number of idle time slices allocated by task 3 = (1/6) *a. In this case, after the time slice allocator obtains the total number of idle time slice allocations corresponding to the tasks 1~3, the total number of free time slice allocations corresponding to the tasks 1~3 is sent to the mapping relationship server and the task processor.

In step 104, the mapping relationship server determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and corresponding each dependent task The cycle is sent to the task processor.

The second policy is: the period corresponding to each dependent task is determined according to the total number of idle time slice allocations of each dependent task and the number of dependent tasks corresponding to each dependent task. Specifically, the period corresponding to each dependent task is equal to the ratio of the total number of idle time slice allocations of the corresponding dependent task to the number of dependent tasks corresponding to the corresponding dependent task. However, the present invention is not limited thereto. In other embodiments, the period corresponding to each dependent task may also be equal to the ratio of the total number of idle time slice allocations of the corresponding dependent task to the preset constant. The setting of the preset constant can be set according to actual needs.

In this embodiment, Table 1 in step 102 is still taken as an example for description. The mapping relationship server receives the task dependency comparison table (ie, Table 1) from the task processor, and receives the total number of idle time slice allocations corresponding to the dependent tasks 1~3 from the time allocator. According to the second policy, the corresponding task 1 corresponds to Period Tl=0.5*a/3=(1/6) *a, the period corresponding to task 2 is T2=( 1/3 ) *a/2= ( 1/6) *a, which is dependent on task 3 Period T3 = (1/6) *a. _ . . .

In step 105, the task processor processes the task having the dependency relationship in the task queue according to the received total number of idle time slice allocations of the dependent tasks and the period corresponding to each of the dependent tasks.

Specifically, the task processor receives the total number of idle time slice allocations of each of the dependent tasks from the time slice allocator, and receives the period corresponding to each of the dependent tasks from the mapping relationship server. The task processor judges whether the dependent task in the task queue can be processed according to the result of one cycle feedback of the dependent task. If it cannot be processed, it continues to wait for the result of the next cycle feedback of the dependent task until the dependent task can process it.

In the present embodiment, Table 1 in step 102 is still taken as an example for description. Here, the task processor judges whether it is possible to continue processing the dependent task 4, the dependent task 5, or the dependent task 6 according to the result of the feedback of the dependent task 1. If the dependent task 4, the dependent task 5, or the dependent task 6 cannot be processed, the task processor deletes the result fed back by the dependent task 1, and the task processor determines the dependent task according to the result of the feedback of the next cycle T1 of the dependent task 1. 4. Depends on task 5 or depends on whether task 6 can handle it. The above process continues until it depends on task 4, dependent task 5, or dependent task 6. If the task processor determines that the dependent task 5 can be processed according to the result of the feedback from the dependent task 1, for example, the partial processing of the dependent task 5 is started. At this time, the task processor temporarily stores the received result of the dependent task 2 feedback, and After the partial processing of the dependent task 5 is completed, it is judged according to the result of the feedback of the dependent task 2 whether the dependent task 5 can continue processing, and if the processing can be continued, the task processor continues to process the dependent task 5, if the feedback is based on the dependent task 2 As a result, it is judged that the dependent task 5 cannot be processed, and the task processor deletes the result of the temporary dependent task 2 feedback, waits for the result of the next task T2 feedback of the dependent task 2, and continues to judge until the dependent task 5 can process. . In addition, the process of relying on task 6 is dependent on task 5, and therefore will not be described here.

For example: dependent task 1 is updated data table a, b, c, d; dependent task 2 is updated data table e, f, g, h; dependent task 5 is query data table a, g; if dependent task 1 In the first cycle T1, the update of the data table a is completed; when the task 2 is dependent on the first cycle T2, the update of the data table e is completed, and the task processor returns the result according to the task 1 (data table a). Update), if it is judged that the dependent task 5 can be processed, the partial processing of the task 5 is started (query data table a); at this time, the task processor temporarily stores the received result of the dependent task 2 feedback (update of the data table e) . After the partial processing of the dependent task 5 (query data table a) is completed, the task processor judges that the dependent task 5 cannot continue processing according to the result of the feedback of the dependent task 2 (update of the data table e), and the task processor deletes the temporary storage. The result of the feedback of the dependent task 2 (update of the data table e) waits for the result of the feedback of the next cycle T2 of the dependent task 2, and continues the determination until the dependent task 5 can process.

In addition, in this embodiment, if any of the task queues are completed by the dependent task, the task processor update task depends on the lookup table, and the updated task dependency comparison table is sent to the time slice allocator and the mapping relationship server. Still taking Table 1 in step 102 as an example, if it is completed by dependent task 3, the task processor updates Table 1, as shown in Table 2.

Dependent task dependent task

Table 2

At this point, the task processor synchronizes the updated task dependency table (ie, Table 2) to the time slice allocator and the mapping relationship server. According to Table 2 and the first policy, the time slice allocator regains the total number of idle time slice allocations of each dependent task, and sends it to the mapping relationship server and the task processor, and the mapping relationship server according to Table 2, the idle time of each dependent task The total number of slices is allocated and the second strategy regains the period corresponding to each dependent task and sends it to the task processor. The task processor processes the tasks having dependencies in the task queue according to the updated total number of free time slice allocations of the dependent tasks and the corresponding periods until all tasks in the task queue are processed.

2 is a schematic diagram of a system for task assignment processing in accordance with a preferred embodiment of the present invention. As shown in FIG. 2, the system for task assignment processing provided by the preferred embodiment of the present invention includes a client 10, a task processor 12, a time slice distributor 13 and a mapping relationship server 14. The client 10 is connected to the task processor 12, the task processor 12 is connected to the time slice allocator 13 and the mapping relationship server 14, and the mapping relationship server 14 is connected to the time slice allocator 13.

In the present embodiment, the client 10 submits the task to the task processor 12. The task processor 12 puts the tasks having the dependencies into the task queue, and establishes a task dependency comparison table according to the dependencies between the tasks, and synchronizes the task dependency comparison table to the time slice allocator 13 and the mapping relationship server 14. The time slice allocator 13 obtains the total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and sends the total number of idle time slice allocations of each dependent task to the mapping relationship server 14 and the task processor 12 . The mapping relationship server 14 determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and sends each cycle corresponding to the dependent task to the task processor. 12. The task processor 12 processes the tasks having dependencies in the task queue according to the received total number of idle time slice allocations of each dependent task and the period corresponding to each dependent task. The specific operation process of the above system is the same as that described above, and therefore will not be described again.

In summary, according to the method and system for task allocation processing provided by the preferred embodiment of the present invention, the time slice allocator obtains the total number of idle time slice allocations of each dependent task according to the task dependency comparison table and the first policy, and The total number of idle time slice allocations of each dependent task is sent to the mapping relationship server and the task processor. Moreover, the mapping relationship server determines the period corresponding to each dependent task according to the received task dependency comparison table, the total number of idle time slice allocations of each dependent task, and the second policy, and sends each cycle corresponding to the dependent task to the task processing. Device. The task processor processes the tasks having dependencies in the task queue according to the received total number of idle time slice allocations of each dependent task and the period corresponding to each dependent task. In this way, the resource allocation efficiency of the task with dependencies is improved, and the tasks with dependencies are better executed and the efficiency is improved.

The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention, and is to those skilled in the art. ―

The present invention is susceptible to various modifications and changes. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and scope of the present invention are intended to be included within the scope of the present invention.

Claims

Claims - WO 2014/108000 PCT/CN2013/088488

1. A method for task allocation processing, which is characterized by including the following steps:

The client submits the task to the task processor;

The task processor puts tasks with dependencies into the task queue, establishes a task dependency comparison table based on the dependency relationships between tasks, and synchronizes the task dependency comparison table to the time slice allocator and mapping relationship server;

The time slice allocator obtains the total number of idle time slice allocations for each dependent task based on the task dependency comparison table and the first strategy, and sends the total number of idle time slice allocations for each dependent task to the mapping relationship server and The task processor;

The mapping relationship server determines the cycle corresponding to each dependent task based on the received task dependency comparison table, the total number of idle time slice allocations for each dependent task, and the second strategy, and sends the cycle corresponding to each dependent task to The task processor;

The task processor processes tasks with dependencies in the task queue based on the received total number of idle time slice allocations for each dependent task and the cycle corresponding to each dependent task.

2. The method according to claim 1, characterized in that, the first strategy is: the time slice allocator calculates the proportion of dependent tasks corresponding to each dependent task according to the task dependency comparison table. The proportion of dependent tasks corresponding to the dependent tasks and the total amount of system idle time slices at the current moment are calculated to obtain the total number of idle time slices allocated to each dependent task.

3. The method according to claim 1, characterized in that, the second strategy is: the period corresponding to each dependent task is based on the total number of idle time slice allocations of each dependent task and the number of dependent tasks corresponding to each dependent task. The number is determined.

4. The method according to claim 1, characterized in that, tasks in the task queue are sorted according to dependency relationships, and dependent tasks are executed first.

5. The method according to claim 1, characterized in that, the task processor determines whether it can process the dependent task in the task queue based on the result of one cycle of feedback from the dependent task. If it cannot process it, it continues to wait for all the dependent tasks. Describe the results of the dependent task's feedback in the next cycle until the dependent task can process it.

6. The method according to claim 1, characterized in that if any dependent task in the task queue is completed, the task processor updates the task dependency comparison table and adds the updated task to The dependency comparison table is sent to the time slice allocator and the mapping relationship server.

7. A system for task allocation processing, characterized in that it includes a client, a task processor, a time slice allocator and a mapping server, the client is connected to the task processor, and the task processor is connected to the A time slice allocator and the mapping relationship server, the mapping relationship server is connected to the time slice allocator,

Wherein, the client submits the task to the task processor, claims

― WO 2014/108000 PCT/CN2013/088488

The task processor puts tasks with dependencies into the task queue, establishes a task dependency comparison table based on the dependency relationships between tasks, and synchronizes the task dependency comparison table to the time slice allocator and the mapping. Relational server, the time slice allocator obtains the total number of idle time slice allocations for each dependent task based on the task dependency comparison table and the first policy, and sends the total number of idle time slice allocations for each dependent task to the mapping relational server and said task handler,

The mapping relationship server determines the cycle corresponding to each dependent task based on the received task dependency comparison table, the total number of idle time slice allocations for each dependent task, and the second strategy, and sends the cycle corresponding to each dependent task to the task processor,

8. The system according to claim 7, characterized in that, the first strategy is: the time slice allocator calculates the proportion of dependent tasks corresponding to each dependent task according to the task dependency comparison table, and according to each The proportion of dependent tasks corresponding to the dependent tasks and the total amount of system idle time slices at the current moment are calculated to obtain the total number of idle time slices allocated to each dependent task.

9. The system according to claim 7, wherein the second strategy is: the period corresponding to each dependent task is allocated according to the total number of idle time slices of each dependent task and the number of dependent tasks corresponding to each dependent task. The number is determined.

10. The system according to claim 7, characterized in that, tasks in the task queue are sorted according to dependency relationships, and dependent tasks are executed first.