JP2013200667A - Schedule creating method, and system and program therefor - Google Patents

Abstract

PROBLEM TO BE SOLVED: To create a schedule independent of an execution time of a task.SOLUTION: A schedule creating method includes the steps of: storing a direct precedence relationship and an indirect precedence relationship in precedence relationship storage means; calculating a start time of each task when setting an execution time of each task as one; generating a task arrangement structure having layers that correspond to the respective start times; dividing the layers in the task arrangement structure by the predetermined number of levels; arranging the tasks in an area divided so that each task and its subsequent task are at the same level; identifying the task y that cannot be arranged in the same level as a task subsequent to the task x, and storing the identified task y in event storage means; and creating a schedule on the basis of the task arrangement structure and the event storage means.

Description

  The present invention relates to a schedule creation method, a system thereof, and a program, and more particularly, to a method, a system, and a program for scheduling a plurality of tasks whose execution times are not specified based only on a prior relationship between the tasks.

  Cloud computing is expected as a next-generation computing environment. By using cloud services, it is possible to procure, augment, and degenerate system execution environments (servers, storage, networks, etc.) in a short time, and you only have to pay the usage fee for the time you use them. Conventionally, software systems have been built on the premise of a fixed execution environment that is sized based on peak performance that occurs only rarely during operation. As a result, low average load and high operation cost were incurred. In the cloud, the size of the execution environment can be changed as needed, so reduction in operating costs can be expected.

  FIG. 1 shows a schematic diagram of cloud computing. A plurality of servers 101a, 101b,..., 101n (hereinafter referred to as server 101) are connected to a plurality of client computers 103a, 103b,..., 103n (hereinafter referred to as client computers 103) via the Internet 102. Are connected so that they can communicate with each other.

  The server 101 has a memory for storing a program for realizing a service provided to the user, and uses data necessary for processing the program stored in the storage in response to a request from the user. Provide services.

  The client computer 103 is a terminal used by a cloud service user. The user uses the service provided by the server 101 via the client computer 103 without being aware of the server group.

  Conventionally, in the development stage of a software system, lack of machine resources often causes development schedule delay. For example, in the test process, a lot of time is spent due to lack of machine resources. By using cloud computing at the development stage, development that is not restricted by machine resources becomes possible, and shortening of the development period and reduction of development costs can be expected. In this way, cloud computing has the potential to solve problems of conventional software systems.

  Cloud computing also has challenges. In general, a software system needs to satisfy performance requirements in addition to function requirements. Conventionally, a constant performance has been guaranteed by performing a performance test in a fixed execution environment. This is because in the conventional system, the execution environment actually operated is fixed, so that it can be inferred that the test result in the execution environment holds at the time of operation. On the other hand, the cloud service provides an execution environment at best effort.

  In the best effort type, for example, when a user executes a program with a high CPU load with respect to the number of clocks of the CPU, the performance of another user who uses the same environment deteriorates. Further, regarding a storage, when a certain user processes a large number of transactions that place an excessive load on the storage, similarly, the I / O performance of another user who uses the same environment deteriorates. The same applies to the network. In this case, the execution environment cannot be specified, and therefore it cannot be inferred that the result of the performance test is valid even during operation.

  In order to solve such a problem, the present applicant has succeeded in providing a means for guaranteeing the performance (throughput) as a system in cloud computing in which the execution environment cannot be fixed. In order to guarantee the performance of the system, in the art, a predetermined process is performed by a timer, and when it is completed, the clock-driven programming (CDP) operates so as to rest until it is driven by the timer. Process the program. Using a high-speed machine reduces the execution time, but increases the pause time accordingly. If you use a slow machine, the execution time increases and the pause time decreases accordingly. That is, the number of execution steps per hour is the same regardless of whether a high-speed machine or a low-speed machine is used. Therefore, the performance (throughput) is the same regardless of hardware.

  However, in order to execute the program while maintaining the period T, the duty ratio (D) expressed by the following formula needs to be less than 1. τ is the execution time.

  In a conventional scheduling method that determines which CPU executes a plurality of tasks at which time, the prior relationship between tasks, the execution time of each task, the number of resources (number of CPUs) are specified, and the number of resources is limited. The purpose was to create a schedule that would minimize execution time.

  In this method, firstly, it is necessary to re-create a schedule every time the execution time of a task changes. The task execution time varies depending on CPU specifications (architecture, clock frequency, cache size, etc.). Today, CPU specifications vary widely. Therefore, it is difficult to support a wide variety of CPUs with the conventional method for creating a schedule corresponding to each CPU specification.

  Secondly, there is a question about setting restrictions on the number of resources. In a multi-core environment that is generally popular today, the number of CPUs can be increased freely. For example, 6 or 8 cores can be easily installed in a desktop computer, and several tens of cores can be easily installed in a server computer. Considering such technological advances, the number of resources can no longer be a critical constraint.

  Third, it cannot be used when the execution time is not specified. The aforementioned CDP is particularly effective in cloud computing where the execution environment cannot be fixed. However, since the execution time varies depending on the execution environment of the cloud computing such as the performance of the CPU, the execution time cannot be specified.

  The present invention has been made in view of such problems, and an object of the present invention is to provide means for scheduling a plurality of tasks whose execution times are not specified based only on the preceding relationship between the tasks. It is in.

  In order to solve the above-described problem, the schedule creation method according to the present invention includes a closed preceding relationship storage unit that stores a preceding task, a succeeding task, and a preceding relationship type, and a degeneration that stores the preceding task, the succeeding task, and the preceding relationship type. In a system comprising a prior relationship storage means and an event storage means for storing a notification task, a standby task, and an event identifier, the prior relationship management means of the system receives the prior relationship data between tasks of the program to be scheduled And the preceding relationship management means, based on the direct preceding relationship and the indirect preceding relationship included in the preceding relationship data, transition closure of the received preceding relationship data in the closure preceding relationship storage means, and Storing the transition reduction of the received preceding relation data in the reduction preceding relation storage means; The task placement unit of the system calculates the start time of each task when the execution time of each task is set to 1 using PERT analysis for the preceding relationship recorded in the degenerate precedence relationship storage unit The task placement means generates a task placement structure having a layer corresponding to each start time and finish time based on the calculated start time, and the task placement means converts layer 1 to layer 1 And dividing the task at the level of the number of tasks existing therein, placing the task in the divided area, the step of placing the task in the layer L, and the step of placing the task in the layer L A step of determining whether or not the layer t corresponds to the finish time, and in the case of the layer t, the task placement structure And creating a schedule based on the event storage means, and if not a layer t, the step of continuing the subsequent steps and the task placement means compare the number of tasks in the layer L and the layer L-1, When the number of tasks in one of the layers is less than the number of tasks in the other layer, a step of generating an empty task to make the number of tasks in both layers the same, and the task placement means includes the closure precedence relationship A step of determining a set of tasks (subsequent task candidates) in the layer L that can be subsequent to each task in the layer L-1 based on the storage means; Obtaining a maximum matching for each task in the layer L-1 and its subsequent tasks using an algorithm; and In the case where the number of matching of the maximum matching is less than the number of tasks in the layer L-1, the placement unit determines whether the number of matching and the number of tasks are increased until the matching number of the maximum matching matches the number of tasks in the layer L-1. Generating empty tasks in the layer L and the layer L-1, creating a new level area to place empty tasks, determining the set of subsequent task candidates, and the maximum Repeating the step of obtaining matching, and the task placement means divides the layer L at the level of the number of tasks existing in the layer, and each task in the layer L-1 and its subsequent task are A task is arranged in an area divided so as to be at the same level, and an event identification means of the system includes a task in the layer L-1. Identifying the task y that could not be placed in the layer L as a successor of the queue x and storing it in the event storage means; the task placement means sets layer L + 1 to the layer L; And returning to the step of determining whether or not the layer is a layer t corresponding to the finish time.

  According to the present invention, a schedule independent of task execution time can be created. Therefore, it is not necessary to recreate the schedule even if the task execution time changes. Moreover, the schedule obtained can guarantee execution in the minimum time in any execution environment.

  Furthermore, the schedule derived in the present invention can obtain the minimum number of resources to be executed in the minimum time. Knowing the minimum number of resources can avoid the disadvantage of maintaining unnecessary resources.

1 is a schematic diagram of cloud computing. FIG. It is a figure which shows the example of a program description of the task which concerns on one Embodiment of this invention. It is a figure which shows the example of a program description of the task which utilizes another task which concerns on one Embodiment of this invention. It is a figure which shows the example of a program description of the task arrangement | sequence which concerns on one Embodiment of this invention. It is a figure which shows the call graph of the task which concerns on one Embodiment of this invention. It is a PERT figure of the task concerning one embodiment of the present invention. It is a figure which shows the call graph of the task which concerns on one Embodiment of this invention. An example of program description of a task using polling is shown. An example of program description of a task using polling is shown. It is a PERT figure of the task concerning one embodiment of the present invention. It is a precedence relation table which shows precedence relation between tasks concerning one embodiment of the present invention. It is a figure which shows the example of a program description before applying a variable rename technique. It is a figure which shows the example of a program description after applying a variable rename technique. It is a figure which shows the call graph before and behind applying an individualization technique. It is a figure which shows the example of a program description of the task to which the lottery technique is applied. It is a figure which shows the example of a program description of the task to which the lottery technique is applied. It is a PERT figure of the task concerning one embodiment of the present invention. It is a figure which shows the example of a program description which performs the task which concerns on one Embodiment of this invention. It is a figure which shows the example of a program description which performs the task which concerns on one Embodiment of this invention. It is a sequence diagram which performs the task which concerns on one Embodiment of this invention in parallel. It is a block diagram which shows the structure of the schedule creation system which concerns on one Embodiment of this invention. It is a figure which shows an example of the information stored in the closure precedence relationship memory | storage means which concerns on one Embodiment of this invention. It is a figure which shows an example of the information stored in the degeneracy precedence relationship memory | storage means which concerns on one Embodiment of this invention. It is a figure which shows an example of the information stored in the event memory | storage means which concerns on one Embodiment of this invention. It is a flowchart which shows the process of producing the schedule which concerns on one Embodiment of this invention. It is a PERT figure of the task concerning one embodiment of the present invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is an image figure of the PERT figure arrange | positioned at the task structure which concerns on one Embodiment of this invention. It is a flowchart which shows the process of producing the schedule which concerns on one Embodiment of this invention.

(CDP program)
First, the CDP program will be described. CDP is part of Event Driven Programming (EDP). Thus, CDP can be practiced with any programming language and OS that supports EDP. In this embodiment, C language and Windows (registered trademark) are used, but the present invention is not limited to this.

  The difference between CDP and EDP is in the use of event handlers. In EDP, an arbitrary number of timers can be used, whereas in CDP, it is required to always use one timer that provides a timer event handler.

  In EDP, processing corresponding to an event is performed in all event handlers including a timer event handler. On the other hand, in CDP, in the event handlers other than the timer event handler, by setting a flag indicating the state, only the occurrence of the event is recorded, and the processing corresponding to the event is not performed here. In CDP, a timer event handler executes a task corresponding to the occurrence of an event based on a flag indicating a state.

  The CDP program is created by the following procedure. 1) Identify and describe the task. 2) Understand the prior relationship between tasks and create a PERT diagram. 3) Create a schedule that satisfies the precedence relationship given by the PERT diagram. Task description, PERT diagram creation, and schedule creation will be described in this order.

(Task description)
The CDP task will be described based on the program description example of FIG. CDP tasks are defined using the following elements:
Internal variable: One or more variable interface functions used to take over values between states: Zero or more function reset functions for other tasks to reference or update internal variables Function: Function task body for initializing internal variables Function: Function called by timer event handler

  The CDP task is a state machine whose operation to be executed changes depending on the state. Use internal variables to transfer values between states. In the example of FIG. 2, an internal variable taskA_data of the taskA_data_t structure type is defined at line number L5. Note that the taskA_data_t structure type includes, as members, taskA_state_t enumerated variable state, int type x, y, and result, as indicated by line numbers L2 to L4 in FIG.

  The CDP task defines an interface function for other tasks to refer to or update the internal variables as necessary. In the example of FIG. 2, the calc method defined by line numbers L13 to L31 and the get_result method defined by line numbers L33 to L43 are interface functions. The calc method is a function for requesting processing to TaskA described in FIG. 2, and the get_result method is a function for requesting a processing result.

  The CDP task also defines a reset function to initialize internal variables. In the example of FIG. 2, the taskA_RST method defined by line numbers L45 to L48 is a reset function. In this embodiment, the member variable state of the internal variable taskA_data is initialized in the reset function.

The CDP task defines a task body function called by the timer event handler. In the example of FIG. 2, the taskA_CLK method defined by line numbers L50 to L84 is a task body function. As shown in FIG. 2, the task body function executes calculation according to the value of taskA_data.state. When state is calc1, F (x) is calculated. Here, the function F is an external function defined in another module such as a standard library, as defined by the line number L11. When state is calc2, F (x) ^y is calculated with the constant LIMIT as the upper limit.

  Here, the task execution time needs to be shorter than the timer period. Therefore, the task needs to satisfy the following two requirements. 1) A task has an upper limit of execution steps. 2) Each statement of a task has an upper limit on execution time.

  In order to satisfy the requirement 1), each function is written in a form that syntactically guarantees termination. That is, it is described so that it can be expanded into a combination of selection (if then else) and sequential (;). Regarding loops, only loops with an upper limit on the number of iterations can be described, and it is not allowed to write a loop whose number of iterations is determined at execution time. The indefinite number of loops is realized by periodically executing a fixed number of loops as in the taskA_CLK method of FIG. In this case, although the number of steps varies depending on the selection (if then else), there is an upper limit to the number of steps executed in one cycle, so that the requirement 1) is satisfied.

  The problem in meeting requirement 2) is when the statement contains a function call. When the function to be called is an interface function of another task, there is no problem because there is an upper limit on the number of execution steps for the call destination function, resulting in an upper limit on the execution time. On the other hand, if the function to be called is a function that does not conform to CDP, such as an API that calls a library function or an OS function, there may be no upper limit on the execution time.

  Particularly problematic is blocking I / O existing in the OS API. For example, when a file is read using the blocking I / O READ function, control is not returned to the calling program until the file is read. This cannot satisfy the requirement 2). Thus, in principle, CDP tasks use non-blocking I / O instead of blocking I / O. Alternatively, blocking I / O is used after confirming that the block is not blocked using a select function or the like.

  Next, FIG. 3 shows a program description example of taskB that uses taskA shown in FIG. taskB has a structure type internal variable taskB_data including enumeration type variable state and int type a, b, and z as members. In the task body function of taskB, as indicated by the line number L34 in FIG. 3, when the state is state_10, processing is requested to taskA by calling the calc method. As shown in line number L23 of FIG. 2, 0 is returned as a return value only when the request is accepted according to the state of taskA. Therefore, taskB retries until the request is accepted, and transitions to state_11 when the request is accepted.

  Also, as indicated by the line number L40 in FIG. 3, when the state is state_11, an attempt is made to acquire the processing result by calling the get_result method. Again, as indicated by line number L40 in FIG. 2, 0 is returned as the return value only when the calculation is completed according to the state of taskA. Therefore, taskB calls the get_result method for each clock until a return value of 0 is obtained, and transitions to state_12 when the processing result is acquired.

(Task arrangement)
As shown in line number L18 in FIG. 2, taskA accepts a calculation request only when state is free. In other words, while taskA accepts a preceding calculation request and executes a calculation, it cannot accept a calculation request from another task. Therefore, in order to process a plurality of calculation requests at the same time, a task array in which tasks are arrayed is defined in order to prepare a plurality of tasks having the same function. FIG. 4 shows a program description example of a task array in which taskA shown in FIG. 2 is arrayed.

  As indicated by line number L4 in FIG. 4, in the task array, internal variables are arrayed. Then, as indicated by the line number L7, an index is received as an argument of the interface function calc, and the received index is designated when referring to or updating the internal variable. In other functions as well, tasks can be arranged by receiving an index as an argument, and specifying the received index and updating the reference of the internal variable. The number of elements in the internal variable array is referred to as task array multiplicity, and the multiplicity of unarranged tasks (for example, taskA in FIG. 2) is 1.

(Create a PERT diagram)
After the task is described, the prior relationship between the tasks is grasped and a PERT diagram is created. The timer event handler calls a task body function, and the precedence relationship between tasks is a precedence relationship between task body functions. A certain task calls an interface function of another task in its task body function, and acquires a processing result of the other task. For example, taskB shown in FIG. 3 calls the get_result method of taskA in the task body function, and acquires the processing result F (x) ^y of taskA. The call graph of FIG. 5 shows the static call relationship of this interface function.

  Here, in order for taskB to obtain a processing result, the task body function of taskA needs to be completed before the task body function of taskB is executed. In this case, taskA precedes taskB. A PERT diagram showing the completion order can be obtained by reversing the direction of the arrows in the call graph (FIG. 6). However, PERT diagrams cannot be obtained from all call graphs.

  In order to obtain a PERT diagram, the call graph needs to be acyclic (no loop). As shown in FIG. 7, when the call graph is not acyclic, it is necessary to change the interface direction between tasks by using polling. Since the call graph between taskA and taskB is acyclic, there is no need to change the interface direction between tasks. As a reference example using polling, FIGS. 8A and 8B show program description examples of taskA and taskB with the interface direction changed.

  Tasks that can be executed simultaneously can be determined from the obtained PERT diagram. Assume that the PERT diagram shown in FIG. 9 is obtained based on the call graph. Here, the graph G in the PERT diagram shown in FIG. 9 is composed of a set of nodes corresponding to tasks 1 to 9 and a set of arrows representing the preceding relationship between tasks. In the PERT diagram, in addition to the nodes corresponding to the original tasks 1 to 9, end points s and t representing the start and finish of the entire program are described.

  FIG. 10 shows a prior relationship table showing the prior relationship between tasks included in the PERT diagram of FIG. In the figure, ◎ indicates that two tasks have a direct preceding relationship. For example, task 1 and task 4 (calling the interface function of task 1), task 1 and task 6 (calling the interface function of task 1) have a direct precedence relationship. ○ in the figure indicates that the two tasks have an indirect precedence relationship. For example, task 1 and task 7, task 1 and task 8, task 1 and task 9, etc. have an indirect precedence relationship. X in the figure indicates that two tasks cannot have a preceding relationship.

  An indirect predecessor relationship occurs between two tasks that do not have a direct predecessor relationship but have a predecessor relationship via one or more tasks. For example, task 1 and task 7 have a leading relationship via task 4 that calls the interface function of task 1 and that interface function is called by task 7. Similarly, task 1 and task 8 have a preceding relationship via task 4. Task 1 and task 9 have a preceding relationship via task 4 and task 7, or via task 6.

  Here, when the task u calling the interface function of the specific task v and the task w have a direct or indirect precedence relationship, the task u and the task w are not executed simultaneously. For example, the task 4 and the task 6 that call the interface function of the task 1 have a direct precedence relationship as shown in FIG. On the other hand, the task 5 and the task 8 that call the interface function of the task 3 do not have a preceding relationship as shown in FIG.

  When multiple tasks call the interface function of the same task at the same time, the result may change depending on the order in which the tasks are executed or the order in which the interface functions are executed. Therefore, an interface function that can be called simultaneously from a plurality of tasks needs to satisfy Bernstein's conditions. Bernstein's conditions are well-known sufficient conditions that allow program fragments to be executed in parallel.

For example, functions f and g included in task 3 that can be called from task 5 and task 8 at the same time are a set of internal variables (R (f)) syntactically referenced in function f, in function f. A set of internal variables (W (f)) that are syntactically assigned in, a set of internal variables that are syntactically referenced in function g (R (g)), and a syntactic assignment in function g When the following (1) to (3) are satisfied for the set of internal variables (W (g)), Bernstein's conditions are satisfied and parallel execution can be performed.
R (f) ∩ W (g) = φ ・ ・ ・ (1)
R (g) ∩ W (f) = φ ・ ・ ・ (2)
W (f) ∩ W (g) = φ ・ ・ ・ (3)

(Rewriting technique to a program that satisfies Bernstein's conditions)
If tasks that can be executed simultaneously do not meet Bernstein's conditions, the program must be modified using rewrite techniques. Three typical rewriting techniques are introduced below.

  There is a variable renaming technique as the first rewriting technique. 11A and 11B show program description examples before and after applying the variable renaming technique. In the example of the program description before application, as shown in FIG. 11A, in the interface functions read and write, R (read) ∩W (write) = {taskA_x} ≠ φ, and Bernstein's conditions are not satisfied. On the other hand, in the example of the program description after application, as shown in FIG. 11B, R (read) ∩W (write) = φ is satisfied by separately modifying the program using internal variables, and Bernstein's conditions are satisfied. it can.

  As a second rewriting technique, there is an individualization technique. In the individualization technique, tasks having interface functions that do not satisfy Bernstein's conditions are arranged. FIG. 12 shows call graphs before and after applying the individualization technique. In the call graph before application, as shown in FIG. 12 (left), competition of the interface function calc_F occurs, R (calc_F) ∩W (calc_F) = {taskB_data} ≠ φ, and Bernstein's conditions are not satisfied. On the other hand, in the call graph after application, as shown in FIG. 12 (right), by arranging taskB, R (calc_F (0)) ∩) W (calc_F (1)) = {taskB_data [0] } ∩ {taskB_data [1]} = φ, and Bernstein's conditions can be satisfied.

  As a third rewriting technique, there is a lottery technique. The personalization technique described above cannot be applied when only one resource is used. In this case, competition of interface functions is prevented by a lottery technique in which only internal variables are arranged and tasks are not arranged. Specifically, as shown in FIG. 13A, in the task body function of taskB that is the target of competition, one of a plurality of interface function calls is selected (lottery), and only the selected (winned) call is selected. Execute the process and return an error for calls that were not selected (declined). Further, as shown in FIG. 13B, in the task C (and task D (not shown)) which is the calling task, the interface function is repeatedly called until it is won.

(Create schedule)
Once the PERT diagram is obtained, a schedule is created next. The schedule defines which task is assigned to which resource at which timing so as to satisfy the preceding relationship given in the PERT diagram. It is desirable to create a schedule that minimizes the completion time under the constraints of available resources. A schedule is created based on the PERT diagram shown in FIG.

(Schedule creation-sequential execution)
In the case of sequential execution, a schedule can be easily created by topologically sorting the PERT diagrams using a known algorithm. In the case of the PERT diagram of FIG. 14, the following three schedules are created. It is assumed that task body functions of taskX, taskY, taskZ, and taskW are taskX_CLK (), taskY_CLK (), taskZ_CLK (), and taskW_CLK (), respectively.
Schedule 1 = taskX_CLK (); taskY_CLK (); taskW_CLK (); taskZ_CLK ();
Schedule 2 = taskX_CLK (); taskY_CLK (); taskZ_CLK (); taskW_CLK ();
Schedule 3 = taskX_CLK (); taskZ_CLK (); taskY_CLK (); taskZ_CLK ();

  As long as the preceding relationship in the PERT diagram is satisfied, the same result can be obtained in any order, and the same completion time can be obtained. Therefore, an arbitrary schedule can be selected. FIG. 15 shows an example of a program description for executing a task according to schedule 1. In line number L25 in FIG. 15, the timer is set so that the function specified by the fourth argument (OnTimer) is called every 100 milliseconds specified by the third argument (presiod). In this embodiment, in order to execute the schedule 1, the task execution order is defined as indicated by line numbers L6 to L9 in FIG.

(Schedule creation-parallel execution)
When executing in parallel, the precedence relationship between tasks is realized using synchronization primitives. In this embodiment, an Event Object provided by Windows is used as a synchronization primitive. The Event Object has two states (signal state / non-signal state). By calling SetEvent (e), the Event Object specified by the handle of the argument e becomes a signal state. When WaitForSingleObject (e) is called, if the Event Object specified by the handle of the argument e is in a non-signal state, the calling thread of WaitForSingleObject (e) continues to wait until it becomes a signal state. When SetEvent (e) is called by another thread and the Event Object specified by e is in a signal state, control is returned and the calling thread can execute the subsequent processing.

For example, consider a case where the PERT diagram of FIG.
Schedule 4-0 = taskX_CLK (); SetEvent (e1); SetEvent (e2);
Schedule 4-1 = WaitForSingleObject (e1); taskZ_CLK ();
Schedule 4-2 = WaitForSingleObject (e2); taskY_CLK (); SetEvent (e3);
Schedule 4-3 = WaitForSingleObject (e3); taskW_CLK ();

  In the schedule 4-0, when the taskX_CLK method is completed, the Event Object specified by e1 and e2 is set in the signal state. In the schedule 4-1, WaitForSingleObject (e1) is called, and it waits until the Event Object specified by e1 becomes a signal state. When SetEvent (e1) is called upon completion of the taskX_CLK method, control is returned to the thread corresponding to the schedule 4-1, and the taskZ_CLK method is executed. Similarly, in schedule 4-2, WaitForSingleObject (e 2) is called, and the process continues to wait until the Event Object specified by e 2 becomes a signal state. When SetEvent (e2) is called by completing the taskX_CLK method, the thread control corresponding to the schedule 4-2 is returned, and the taskY_CLK method is executed. In the schedule 4-2, when the taskY_CLK method is completed, the Event Object specified by e3 is set in the signal state. The schedule 4-3 also calls WaitForSingleObject (e3) and keeps waiting until the Event Object specified by e3 becomes a signal state. When SetEvent (e3) is called upon completion of the taskY_CLK method, control is returned to the thread corresponding to the schedule 4-3, and the taskW_CLK method is executed.

  FIG. 16 shows an example of a program description for executing tasks according to schedules 4-0 to 4-3. In line number L43 in FIG. 16, the timer is set so that the function specified by the fourth argument (OnTimer) is called every 100 milliseconds specified by the third argument (presiod). In this embodiment, threads corresponding to schedules 4-1 to 4-3 are prepared as indicated by line numbers L3 to L14 in FIG.

  In the OnTimer method, first, Event Objects specified by s [0], s [1], and s [2] corresponding to the thread 1, thread 2, and thread 3 are set in a signal state. Thereafter, schedule 4-0 is executed in the main thread, and the WaitForSingleObject method of the Event Object specified by t [0], t [1], and t [2] corresponding to thread 1, thread 2, and thread 3 is called. Thus, it continues to wait until the Event Object becomes a signal state, that is, until the corresponding thread is completed. FIG. 17 shows a sequence diagram of parallel execution.

  The thread 1 corresponding to the schedule 4-1 calls WaitForSingleObject (s [0]) and keeps waiting until the Event Object specified by s [0] becomes a signal state. As indicated by the line number L18 in FIG. 16, when SetEvent (s [0]) is called in the OnTimer method, control is returned to the thread 1 and WaitForSingleObject (e1) is called. After that, it continues to wait until the Event Object specified by e1 becomes a signal state. When SetEvent (e1) is called upon completion of the taskX_CLK method, control is returned to the thread 1 and the taskZ_CLK method is executed. When the taskZ_CLK method is completed, the thread 1 notifies the completion of the thread by setting the Event Object specified by t [0] to the signal state.

  Similarly to thread 1, thread 2 (not shown) corresponding to schedule 4-2 calls WaitForSingleObject (s [1]) and waits until the Event Object specified by s [1] becomes a signal state. to continue. As indicated by the line number L19 in FIG. 16, when SetEvent (s [1]) is called in the OnTimer method, control is returned to the thread 2 and WaitForSingleObject (e2) is called. After that, it continues to wait until the Event Object specified by e2 becomes a signal state. When SetEvent (e2) is called upon completion of the taskX_CLK method, control is returned to the thread 2 and the taskY_CLK method is executed. When the taskY_CLK method is completed, the thread 2 calls SetEvent (e3) that notifies the completion of taskY, and then notifies the completion of the thread by setting the Event Object specified by t [1] as a signal state.

  Similarly to thread 1, thread 3 (not shown) corresponding to schedule 4-3 calls WaitForSingleObject (s [2]) and waits until the Event Object specified by s [2] becomes a signal state. to continue. As indicated by the line number L20 in FIG. 16, when SetEvent (s [2]) is called in the OnTimer method, control is returned to the thread 3 and WaitForSingleObject (e3) is called. After that, it continues to wait until the Event Object specified by e3 becomes a signal state. When SetEvent (e3) is called upon completion of the taskY_CLK method, control is returned to the thread 3 and the taskW_CLK method is executed. In the thread 3, when the taskW_CLK method is completed, the completion of the thread is notified by setting the Event Object specified by t [2] to the signal state.

(Schedule creation-Task arrangement)
There is no predecessor relationship between each task in the task array. Therefore, each task may be scheduled in any order. In addition, since all codes of the task array are the same and only the location of the internal variable is different, it can be expected that the average execution time of each task in the task array is the same. Therefore, when the multiplicity of tasks is m and the number of available CPUs is n, m / n tasks are distributed to each CPU.

If taskY in the PERT diagram shown in FIG. 14 is a task array with a multiplicity of 4, and the number of available CPUs is 5, the following schedule can be created.
Schedule 5-0 = taskX_CLK (); SetEvent (e1); SetEvent (e21); SetEvent (e22);
Schedule 5-1 = WaitForSingleObject (e1); taskZ_CLK ();
Schedule 5-2 = WaitForSingleObject (e21); taskY_CLK (0); taskY_CLK (2);
SetEvent (e31);
Schedule 5-3 = WaitForSingleObject (e22); taskY_CLK (1); taskY_CLK (3);
SetEvent (e32);
Schedule 5-4 = WaitForSingleObject (e31); WaitForSingleObject (e32);
taskW_CLK ();

  In this way, a task body function that exists in the number of multiplicity can be indexed and distributed to each CPU, whereby a schedule can be created according to the number of available CPUs.

  So far, the CDP program has been described in detail. In particular, the chapter on schedule creation describes creation of a schedule that satisfies the precedence relationship given in the PERT diagram. As described above, in the case of sequential execution, a schedule can be easily created by topologically sorting the PERT diagrams using a known algorithm. However, no useful scheduling techniques are currently shown for parallel execution. In the following chapters, a technique for scheduling a plurality of tasks whose execution times are not specified based only on the preceding relationship between the tasks is disclosed.

(System configuration)
The configuration of the schedule creation system 1 will be described in detail with reference to the block diagram of FIG. In FIG. 18, only a necessary functional configuration is shown assuming a single computer system. However, the schedule creation system 1 may be configured as a part of a multi-function distributed system including a plurality of computer systems. it can.

  In the schedule creation system 1, a RAM 12, an input device 13, an output device 14, a communication control device 15, and a storage device 16 including a nonvolatile storage medium (ROM, HDD, etc.) are connected to a CPU 10 via a system bus 11. Have a configuration. The storage device 16 includes a program storage area for storing a software program for performing the above-described functions, and a data storage area for storing data acquired at any time, data as a processing result, and the like. Each means of the program storage area described below is actually an independent software program, its routine, component, etc., which is called from the storage device 16 by the CPU 10 and expanded in the work area of the RAM 12 while appropriately referring to the database and the like. Each function is performed by being executed sequentially.

  The data storage area includes a closure precedence relationship storage unit 17, a degenerate precedence relationship storage unit 18, a task arrangement storage unit 19, and an event storage unit 20. Both are fixed storage areas secured in the storage device 16.

  As shown in FIGS. 19 and 20, the closure precedence relationship storage unit 17 and the degenerate precedence relationship storage unit 18 store the precedence task, the succession task, and the precedence relationship type. In this embodiment, the preceding relationship type stores either 2 indicating a direct preceding relationship or 1 indicating an indirect preceding relationship.

  The task placement storage unit 19 stores a task placement structure having m layers and n levels and divided into m × n areas. Each area stores 0 or 1 task. Layers and levels will be described later.

  As shown in FIG. 21, the event storage unit 20 stores a notification task, a standby task, and an event identifier. When the task x is stored in the notification task and the task y is stored in the waiting task, it is understood that the task y should be executed after the execution of the task x is completed. The event identifier uniquely identifies the event.

  The software program stored in the program storage area includes a prior relationship management means 21, a task placement means 22, an event identification means 23, and a schedule conversion means 24, if only those relevant to the present invention are listed.

  The preceding relationship management means 21 receives the preceding relationship data between tasks of the schedule creation target program. In one embodiment, a PERT diagram that is an example of prior relationship data is received. In addition, the preceding relationship management unit 21 extracts a set of nodes corresponding to the task and a set of arrows representing the preceding relationship between tasks from the received preceding relationship data. The preceding relationship management means 21 identifies an indirect preceding relationship that occurs between tasks. The indirect precedence relationship will be described later. Based on the direct preceding relationship and the indirect preceding relationship between tasks, the preceding relationship management unit 21 sends a transition closure (Transitive Closure) of the received preceding relationship data to the closed preceding relationship storage unit 17 and the received preceding relationship data. The transition reduction (Transitive Reduction) is registered in the reduction preceding relationship storage means 18.

  The task placement unit 22 uses PERT analysis to calculate the fastest start time of each task when the execution time of each task is 1. Based on the calculated start time, the task placement means 22 generates a task placement structure having layers corresponding to the start time, each start time, and the finish time.

  The task placement unit 22 compares the number of tasks in the layer L and the layer L-1, and if the number of tasks in one of the layers is smaller than the number of tasks in the other layer, the task placement unit 22 generates an empty task and Make the number of tasks in the layer the same. The empty task will be described later. Further, the task placement unit 22 determines a set of tasks in the layer L (subsequent task candidates) that can be subsequent to each task in the layer L- 1 based on the closure precedence relationship storage unit 17. The task placement unit 22 obtains the maximum matching for each task in the layer L-1 and its subsequent tasks using the maximum matching algorithm of the graph.

  The task placement means 22 compares the obtained maximum matching number with the number of tasks in the layer L-1. When the number of matching is smaller than the number of tasks, empty tasks are generated in the difference between the number of matching and the number of tasks, layer L and layer L-1, and a new level area is created in order to place empty tasks. If the number of matching matches the number of tasks, an area for placing each task is created in layer L, and the task is placed in the created area.

  The event identifying means 23 identifies the task y that could not be placed in the layer L as a successor of the task x in the layer L-1, and stores it in the event storage means 20. Even if there is a task y that could not be placed in the layer L as a successor of the task x in the layer L-1, if an empty task is placed as a successor of the task x, this empty Only when the task y is not arranged as a successor of the task, it is stored in the event storage means 20.

  The schedule conversion unit 24 extracts a level for which no schedule has been created from the levels of the task structure. The schedule conversion unit 24 identifies tasks arranged in the layer C. Based on the event storage unit 20, the schedule conversion unit 24 determines whether there is an event to be waited for before executing the identified task. When there is an event to be waited for, the event to be waited for is described as a schedule. In one embodiment, an Event Object is used to describe an event to wait for.

  If the identified task is not an empty task, the schedule conversion unit 24 describes the execution of the task as a schedule. Based on the event storage unit 20, the schedule conversion unit 24 determines whether there is an event that should be notified of the completion of the identified task. When there is an event to be notified, the event to be notified is described as a schedule. In one embodiment, an event to be notified is described using an Event Object.

(Schedule creation method-Create task layout structure)
Next, a process of creating a schedule according to the present embodiment will be described with reference to the flowchart of FIG. In the present embodiment, a plurality of tasks represented by the PERT diagram shown in FIG. 9 are scheduled based only on the prior relationship between the tasks.

  In process S1, the preceding relationship management means 21 receives the preceding relationship data between tasks of the program to be scheduled. In the present embodiment, it is assumed that the PERT diagram shown in FIG. This prior relationship data can be received from a user or from an external system via a computer.

  In process S2, the preceding relationship management means 21 extracts a set of nodes corresponding to the task and a set of arrows representing the preceding relationship between tasks from the received preceding relationship data. In this embodiment, nodes corresponding to a total of nine tasks from task 1 to task 9, arrows <1, 4> indicating the preceding relationship from task 1 to task 4, and the preceding relationship from task 1 to task 6 A total of twelve arrows, such as the indicated arrows <1, 6>,.

  In process S3, the preceding relationship management means 21 identifies an indirect preceding relationship that occurs between tasks. In the present embodiment, an indirect precedence relationship that occurs between task 1 and task 6 having a precedence relationship via task 4, between task 1 and task 7 having a precedence relationship via task 4, and the like. Is identified.

  In process S4, the preceding relation management means 21 performs transition closure of the received preceding relation data based on the direct preceding relation between tasks extracted in process S2 and the indirect preceding relation between tasks identified in process S3. The transitional degeneracy of the received predecessor relation data is registered in the closure predecessor relation storage means 17 and the degeneracy advance relation storage means 18. In this embodiment, records as shown in FIGS. 19 and 20 are registered.

  In the closure precedence relationship storage unit 17, records between all tasks having a precedence relationship are registered. Here, for example, task 1 and task 6 have a direct preceding relationship as shown in FIG. 9, and also have an indirect preceding relationship as described above. That is, the fact that task 1 precedes task 6 is represented by the direct precedence relationship between task 1 and task 6, and the direct precedence relationship between task 1 and task 4, and task 4 and task 6, It is also expressed by its direct precedence relationship. Thus, in the case of having a direct preceding relationship and an indirect preceding relationship, the indirect preceding relationship is preferentially registered. By doing so, it is possible to eliminate a redundant relationship represented by another direct preceding relationship among the direct preceding relationships.

  Further, only the records indicating the direct preceding relationship among the records registered in the closing precedence relationship storage unit 17 are registered in the degenerate precedence relationship storage unit 18. FIG. 23 shows a PERT diagram at the time of process S4. As shown in FIG. 23, the arrow indicating the direct preceding relationship between task 1 and task 6 is deleted at the time of process S4.

  Next, in process S5, the task placement unit 22 uses the PERT analysis for the preceding relationship recorded in the degenerate precedence relationship storage unit 18 to set the fastest speed of each task when the execution time of each task is 1. Calculate the start time. In the present embodiment, the start of the entire program is set to 0, task 1, task 2, and task 3 are started at execution time 1, task 4 and task 5 are started at execution time 2, task 6 and task are started at execution time 3. 7 and task 8 are started, and task 9 is started at execution time 4 and finishes.

  In step S6, the task placement unit 22 generates a task placement structure having layers corresponding to the start time, each start time, and finish time based on the start time calculated in step S5. In the present embodiment, a task arrangement structure having a total of six layers is generated. FIG. 24 is an image diagram of the PERT diagram arranged in the task structure.

  In process S7, the task placement unit 22 determines the allocation of layer 1. Specifically, layer 1 is divided into the number of tasks existing in the layer, and tasks are arranged in the divided areas. In this embodiment, since there are three tasks in layer 1, task 1, task 2, and task 3 are arranged by dividing layer 1 into three levels. FIG. 25 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S7. After completing the assignment of the layer 1, the task placement unit 22 sets the layer 2 to the layer L.

  In step S8, the task placement unit 22 determines whether or not the layer L is the layer t corresponding to the finish time. When it is not layer t, it progresses to process S9, and when it is layer t, it progresses to process S17. In the present embodiment, since the layer L is the layer 2, the process proceeds to step S9.

  In process S9, the task placement unit 22 compares the number of tasks in the layer L and the layer L-1, and if the number of tasks in one of the layers is smaller than the number of tasks in the other layer, the task placement unit 22 Generate the same number of tasks in both layers. In this embodiment, the number of tasks in layer L (layer 2) is 2, and the number of tasks in layer L-1 (layer 1) is 3, so one empty task is generated in layer 2. FIG. 26 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S9. In FIG. 26, the empty task is represented as ε. An empty task is a task that has no execution step and is used for creating a schedule.

  In process S10, the task placement unit 22 determines a set of tasks (subsequent task candidates) in the layer L that can be subsequent to each task in the layer L-1, based on the closure precedence relationship storage unit 17. . Here, when task x and task y have a preceding relationship, task y can be a successor of task x. An empty task can be a successor to any task. In this embodiment, task 4 and empty task 1 are determined as subsequent task candidates for task 1, task 4 and empty task 1 are determined as subsequent task candidates for task 2, and task 5 and empty task 1 are determined as subsequent task candidates for task 3. .

  In process S11, the task placement unit 22 obtains the maximum matching for each task in the layer L-1 and its subsequent task using the maximum matching algorithm of the graph. In this embodiment, combination 1 {[task 1 → task 4], [task 2 → empty task 1], [task 3 → task 5]} and combination 2 {[task 1 → empty task 1], [task 2 → Two types of maximum matching of [task 4] and [task 3 → task 5]} are obtained.

  In step S12, the task placement unit 22 compares the number of matching of the maximum matching obtained in step S11 with the number of tasks in the layer L-1. If the number of matching is less than the number of tasks, the process proceeds to step S13. If the number of matching matches the number of tasks, the process proceeds to process S14. In this embodiment, since the number of matching and the number of tasks match 3, the process proceeds to step S14. The process S13 will be described later.

  In process S14, the task placement unit 22 divides the layer L into the number of tasks existing in the layer, and places the task in the divided area. Here, the same number of areas are created in the layer L and the layer L-1. As shown in FIG. 27, a vertical unit that divides a task arrangement structure is called a layer, and a horizontal unit is called a level. The task placement unit 22 places tasks so that each task and the subsequent task are at the same level. When a plurality of maximum matchings are obtained in the process S11, any one can be selected. In this embodiment, the combination 1 is selected, the task 4 is arranged at the level 1 of the layer 2, the empty task 1 is arranged at the level 2 of the layer 2, and the task 5 is arranged at the level 3 of the layer 2. FIG. 27 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S14.

  In process S15, the event identification unit 23 identifies the task y that could not be placed in the layer L as a successor of the task x in the layer L-1, and stores the task y in the event storage unit 20. In the present embodiment, first, task 4 that could not be arranged as a successor of task 2 is identified and stored in event storage means 20. Also, the task 8 that could not be placed in the layer 2 as a successor of the task 3 in the layer 1 is identified and stored in the event storage means 20. Here, records identified by event identifiers e0 and e1 in FIG. 21 are registered.

  Processes S8 to S15 are processes for one layer. In process S16, the task placement unit 22 sets a layer next to the layer currently being processed in layer L, and returns to process S8. In the present embodiment, the task placement unit 22 sets layer 3 to layer L, and returns to step S8.

  In the present embodiment, in process S8 (second week), the task placement unit 22 determines whether or not the layer L is the layer t corresponding to the finish time. move on.

  In process S9 (second week), the task placement unit 22 compares the number of tasks in layer 3 and layer 2. In this embodiment, since the number of tasks in both layers is the same, the process proceeds to step S10 without generating an empty task.

  In the process S10 (second week), the task placement unit 22 determines a set of tasks in the layer 3 that can be subsequent to each task in the layer 2, based on the closure precedence relationship storage unit 17. In the present embodiment, first, task 6, task 7, and task 8 are determined as subsequent task candidates for task 4. Here, the successor candidate of the empty task is the task y in which the highest layer task x has a direct or indirect preceding relationship among tasks other than the empty task preceding the empty task. In this embodiment, among the tasks other than the empty task preceding the empty task, the task 6, task 7 and task 8 in which the highest layer task 2 has an indirect preceding relationship are determined as the subsequent task candidates of the empty task 1. Is done. On the other hand, there is no subsequent task candidate for task 5.

  In the process S11 (second week), the task placement unit 22 obtains the maximum matching for each task in the layer 2 and the subsequent task using the maximum matching algorithm of the graph. In the present embodiment, a combination 1 {[task 4 → task 6], [empty task 1 → task 7]}, a combination 2 {[task 4 → task 7], [empty task 1 → task 6]}, etc. Maximum matching is obtained.

  In the process S12 (second week), the task placement unit 22 compares the matching number 2 of the maximum matching obtained in the process S11 with the task number 3 in the layer 2. In this embodiment, since the number of matching is less than the number of tasks, the process proceeds to step S13.

  In the process S13 (second week), the task placement unit 22 generates a blank task in the number of matching and the difference between the number of tasks, layer L and layer L-1, and sets a new level to place a blank task. Create an area for. In this embodiment, empty task 2 and empty task 3 are generated in layer 2 and layer 3, respectively, and a level 4 area is generated in order to place empty task 2. FIG. 28 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S13.

  After the process S13, the process returns to the process S10 again. In process S10 (second time and second time), the task placement unit 22 determines a set of tasks in the layer 3 that can be subsequent to each task in the layer 2, based on the closure precedence storage unit 17. To do. In the present embodiment, task 6, task 7, task 8, and empty task 3 are all determined as the succeeding task candidates of task 4, empty task 1, and empty task 2, and empty task 3 is determined as the subsequent task candidate of task 5. The

  In the process S11 (second time and second time), the task placement unit 22 obtains the maximum matching for each task in the layer 2 and the subsequent task using the maximum matching algorithm of the graph. In this embodiment, combination 1 {[task 4 → task 6], [empty task 1 → task 7], [task 5 → empty task 3], [empty task 2 → task 8]}, combination 2 {[task 4 → task 7], [empty task 1 → task 6]} and the like are obtained.

  In process S12 (second week, second time), the task placement unit 22 compares the matching number 4 of the maximum matching obtained in process S11 with the task number 4 in the layer 2. In this embodiment, since the number of matching matches the number of tasks, the process proceeds to step S14.

  In process S14 (second week), the task placement unit 22 divides layer 3 into four levels, which is the number of tasks existing in layer 3, and places tasks in the divided areas. In this embodiment, task 6 is arranged at level 3 of layer 3, task 7 is arranged at level 2 of layer 3, empty task 3 is arranged at level 3 of layer 3, and task 8 is arranged at level 4 of layer 3. FIG. 29 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S14 (second week).

  In the process S15 (second week), the event identifying unit 23 identifies the task y that could not be placed in the layer 3 as a successor of the task x in the layer 2, and stores it in the event storage unit 20. In this embodiment, task 7 that could not be placed as a successor of task 4 and task 8 that could not be placed as a successor of task 4 are identified and stored in event storage means 20. Note that task 9 that could not be placed in layer 3 as a successor of task 5 in layer 2 is not stored here. Even if there is a task y that could not be placed in the layer L as a successor of the task x in the layer L-1, if an empty task is placed as a successor of the task x, the empty task Only when the task y is not arranged as a successor, it is stored in the event storage means 20. Therefore, here, the record identified by the event identifiers e2 and e3 in FIG. 21 is registered.

  In the process S16 (2nd week), the task placement unit 22 sets the layer 4 to the layer L and returns to the process S8.

  In the present embodiment, in process S8 (third week), the task placement unit 22 determines whether or not the layer L is the layer t corresponding to the finish time. move on.

  In process S9 (third week), task placement means 22 compares the number of tasks in layer 4 and layer 3. In this embodiment, since the number of tasks in layer 4 is 1 and the number of tasks in layer 3 is 4, three empty tasks are generated in layer 4. FIG. 30 is an image diagram of a PERT diagram arranged in the task structure at the time of processing S9 (third week).

  In process S10 (third week), the task placement unit 22 determines a set of tasks in the layer 4 that can be subsequent to each task in the layer 3, based on the closure precedence relationship storage unit 17. In the present embodiment, task 9, empty task 4, empty task 5, and empty task 6 are all determined as subsequent task candidates for task 6, task 7, task 8, and empty task 3.

  In the process S11 (third week), the task placement unit 22 obtains the maximum matching for each task in the layer 3 and the subsequent task using the maximum matching algorithm of the graph. In this embodiment, a plurality of maximum matchings such as a combination 1 {[task 6 → empty task 4], [task 7 → empty task 5], [empty task 3 → task 9], [task 8 → empty task 6]}, etc. Is obtained.

  In the process S12 (third week), the task placement unit 22 compares the matching number 4 of the maximum matching obtained in the process S11 with the task number 4 in the layer 3. In this embodiment, since the number of matching matches the number of tasks, the process proceeds to step S14.

  In process S14 (third week), the task placement unit 22 divides the layer 4 into four levels that are the number of tasks existing in the layer, and places the tasks in the divided areas. In this embodiment, an empty task 4 is arranged at level 4 of layer 4, an empty task 5 is arranged at level 2 of layer 4, a task 9 is arranged at level 3 of layer 4, and an empty task 6 is arranged at level 4 of layer 4. FIG. 31 is an image diagram of the PERT diagram arranged in the task structure at the time of processing S14 (third week).

  In process S15 (third week), the event identifying unit 23 identifies the task y that could not be placed in the layer 4 as a successor of the task x in the layer 3, and stores the task y in the event storage unit 20. In this embodiment, task 9 that could not be placed as a successor of task 6, task 9 that could not be placed as a successor of task 7, and task 9 that could not be placed as a successor of task 8 are identified and stored in event storage means 20. Is done. Note that the task 9 that could not be placed in the layer 3 as a successor of the task 5 in the layer 2 is placed as a successor of the task 5 in the layer 4 via an empty task in the layer 3, so that event storage means 20 is not stored. Therefore, here, the record identified by the event identifiers e4, e5 and e6 in FIG. 21 is registered.

  In the process S16 (third week), the task placement unit 22 sets the layer t to the layer L and returns to the process S8.

  In the present embodiment, in process S8 (fourth week), the task placement unit 22 determines whether or not the layer L is the layer t corresponding to the finish time, and the layer L is the layer t. move on.

  In process S <b> 17, the task placement unit 22 stores the task placement structure information obtained by the above-described process in the task placement storage unit 19.

  In process S 18, the schedule conversion unit 24 creates a schedule based on the task arrangement structure of the task arrangement storage unit 19 and the event storage unit 20.

(Schedule creation method-conversion from task allocation structure)
Next, the process of creating a schedule based on the task arrangement structure of the task arrangement storage means 19 and the event storage means 20 will be described in detail with reference to the flowchart of FIG. In the present embodiment, an Event Object is used as in the (Schedule creation-Parallel execution) chapter.

  In process S1, the schedule conversion means 24 determines whether there is a level for which no schedule has been created. If there is an uncreated level, the process proceeds to step S2, and if there is no uncreated level, the process ends. In this embodiment, since there is an uncreated level, the process proceeds to step S2.

  In process S2, the schedule conversion means 24 extracts a level for which no schedule is created from the levels of the task structure, and sets layer 1 to layer C. In this embodiment, level 1 is extracted.

  In process S3, the schedule conversion means 24 determines whether or not the layer C is the layer t corresponding to the finish time. If it is not layer t, the process proceeds to process S4. If it is layer t, the process returns to process S1. In this embodiment, since layer C is layer 1, the process proceeds to step S4.

  In process S4, the schedule conversion means 24 identifies the task arranged in the layer C. In the present embodiment, task 1 arranged in layer 1 is identified.

  In the process S5, the schedule conversion unit 24 determines whether or not there is an event to be waited for before executing the task identified in the process S4 based on the event storage unit 20. If there is an event to be waited for, the process proceeds to process S6, and if not, the process proceeds to process S7. In the present embodiment, the determination can be made based on whether or not the target task is stored in the standby task of the event storage unit 20. Here, as shown in FIG. 21, since there is no record in which task 1 is stored in the waiting task, the process proceeds to step S7. The process S6 will be described later.

  In process S7, if the task identified in process S4 is not an empty task, the schedule conversion unit 24 describes the execution of the task as a schedule. In this embodiment, execution of task 1 is described as task1 ().

  In step S8, the schedule conversion unit 24 determines whether there is an event to be notified of the completion of the task identified in step S4 based on the event storage unit 20. If there is an event to be notified, the process proceeds to step S9, and if not, the process proceeds to process S10. In the present embodiment, the determination can be made based on whether or not a target task is stored in the notification task of the event storage unit 20. Here, as shown in FIG. 21, since there is no record in which task 1 is stored in the notification task, the process proceeds to step S10. The process S9 will be described later.

  Processes S3 to S9 are processes for one layer. In process S10, the schedule conversion means 24 sets the layer next to the layer currently being processed in layer C, and returns to process S3. Here, layer 2 is set to layer C.

  In the process S3 (second week), the schedule conversion means 24 determines whether or not the layer C is the layer t corresponding to the finish time. Since the layer C is the layer 2, the process proceeds to the process S4.

  In the process S4 (second week), the schedule conversion unit 24 identifies the task 4 arranged in the layer 2. In the process S5 (second week), the schedule conversion unit 24 determines whether or not there is an event to wait before executing the task 4 based on the event storage unit 20. In the present embodiment, as shown in FIG. 21, there is an event that should be waited before executing task 4, so the process proceeds to step S <b> 6.

  In the process S6 (second week), the schedule conversion means 24 describes an event to be waited for as a schedule. In the present embodiment, a call to WaitForSingleObject (e0) is described in order to continue waiting until the Event Object specified by e0 becomes a signal state.

  In the process S7 (second week), the schedule conversion unit 24 describes the execution of the task 4 identified in the process S4 as a schedule. In this embodiment, execution of task 4 is described as task4 (). In the process S8 (second week), the schedule conversion unit 24 determines, based on the event storage unit 20, whether there is an event to be notified of the completion of the task 4 identified in the process S4. In the present embodiment, as shown in FIG. 21, there is an event that should be notified of the completion of task 4, and therefore the process proceeds to step S9.

  In the process S9 (second week), the schedule conversion means 24 describes the event to be notified as a schedule. In the present embodiment, calls to SetEvent (e2) and SetEvent (e3) are described in order to set the Event Object specified by e2 and e3 to the signal state.

  In process S10, the schedule conversion means 24 sets layer 3 to layer C, and returns to process S3. Similarly, processing from processing S3 to processing S9 is performed on layer 3 and layer 4. Finally, when layer t is set to layer C in processing S10, the processing in processing S3 is performed and the processing returns to processing S1. Return. By the processing so far, the following schedule 6-0 is created as a schedule corresponding to level 1.

Similarly, by performing processing from the process S1 according to the flowchart, the schedule corresponding to the level 2 is the schedule 6-1, the schedule corresponding to the level 3 is schedule 6-2, and the schedule corresponding to the level 4 is schedule 6-3. Is obtained.
Schedule 6-0 = task1 (); WaitForSingleObject (e0); task4 (); SetEvent (e2);
SetEvent (e3); task6 (); SetEvent (e4);
Schedule 6-1 = task2 (); SetEvent (e0); WaitForSingleObject (e2); task7 ();
SetEvent (e5);
Schedule 6-2 = task3 (); SetEvent (e1); task5 (); WaitForSingleObject (e4);
WaitForSingleObject (e5); WaitForSingleObject (e6); task9 ();
Schedule 6-3 = WaitForSingleObject (e1); WaitForSingleObject (e3); task8 ();
SetEvent (e6);

  Through the above processing, a plurality of tasks represented by the PERT diagram shown in FIG. 9 can be scheduled based only on the prior relationship between the tasks. Since it does not depend on the task execution time, the schedule need not be recreated even if the task execution time changes.

  The schedule derived by the present invention has a minimum execution time when there is no restriction on the number of resources, and can guarantee the execution in the minimum time in any execution environment. Furthermore, the schedule derived by the present invention can obtain the minimum number of resources for executing the schedule having the minimum execution time. Knowing the minimum number of resources can avoid the disadvantage of maintaining unnecessary resources.

Claims (8)

Closure precedence relationship storage means for storing the preceding task, successor task, and precedence relationship type, degenerate precedence relationship storage means for storing the precedence task, successor task, and precedence relationship type, notification task, standby task, and event for storing the event identifier In a system comprising storage means,
The preceding relationship management means of the system receives preceding relationship data between tasks of a program to be scheduled;
Based on the direct preceding relationship and the indirect preceding relationship included in the preceding relationship data, the preceding relationship management unit sends a transition closure of the received preceding relationship data to the closure preceding relationship storage unit, and the received preceding relationship. Storing transition degeneration of relational data in the degeneracy preceding relation storage means;
The task placement unit of the system calculates the start time of each task when the execution time of each task is set to 1 using PERT analysis for the preceding relationship recorded in the degenerate precedence relationship storage unit When,
The task placement means generating a task placement structure having a layer corresponding to each start time and finish time based on the calculated start time;
The task placement means divides layer 1 at the level of the number of tasks existing in layer 1 and places tasks in the divided areas;
The task placement means sets layer 2 to layer L;
The task placement unit is a step of determining whether or not the layer L is a layer t corresponding to the finish time. When the layer L is a layer t, based on the task placement structure and the event storage unit, Create a schedule and if not layer t, continue with the following steps;
The task placement unit compares the number of tasks in the layer L and the layer L-1, and if the number of tasks in one of the layers is smaller than the number of tasks in the other layer, generates a blank task. Making the number of tasks in both layers the same,
The task placement means determining, based on the closure precedence relationship storage means, a set of tasks in the layer L (subsequent task candidates) that can be subsequent to each task in the layer L-1.
The task placement means obtains a maximum matching for each task in the layer L-1 and its subsequent tasks using a maximum matching algorithm of a graph;
When the task placement means has a matching number of the maximum matching smaller than the number of tasks in the layer L-1, the matching number and the task until the matching number of the maximum matching matches the number of tasks in the layer L-1. Generating empty tasks in the layer L and the layer L-1, creating a new level area for placing empty tasks, and determining the set of subsequent task candidates; and Repeating the step of obtaining the maximum matching; and
The task placement unit divides the layer L at the level of the number of tasks existing in the layer, and each task in the layer L-1 and its subsequent task are divided into regions that are divided at the same level. Placing a task,
An event identifying means of the system for identifying a task y that could not be placed in the layer L as a successor of the task x in the layer L-1, and storing it in the event storage means;
The task placement means includes a step of setting layer L + 1 to the layer L and returning to the step of determining whether or not the layer L is a layer t corresponding to a finish time. Based on the task arrangement structure and the event storage means, creating a schedule includes:
A schedule conversion unit of the system determines whether or not a non-scheduled level exists in the task arrangement structure, and if it exists, continuing the subsequent processing; and
The schedule conversion means extracting a level in which no schedule is created from the levels of the task arrangement structure, and setting 1 in the layer C;
The schedule conversion means is a step of determining whether or not the layer C is the layer t. If the layer C is the layer t, it is determined whether or not there is a non-scheduled level in the task arrangement structure. Returning to step, if not layer t, continuing the following steps;
The schedule conversion means identifying a task placed in the layer C;
Based on the event storage means, the schedule conversion means determines whether there is an event to wait before executing the identified task, and if so, describes the event to wait as a schedule And steps to
The schedule conversion means, if the identified task is not an empty task, describing the execution of the task as a schedule;
The schedule conversion means determines, based on the event storage means, whether or not there is an event that should be notified of completion of the identified task, and if so, describes the event to be notified as a schedule When,
2. The method according to claim 1, further comprising: setting the layer C + 1 to the layer C and returning to the step of determining whether or not the layer C is the layer t. The preceding relationship data is a PERT diagram,
The preceding relationship management means extracting a set of nodes corresponding to tasks and a set of arrows representing preceding relationships between tasks from the preceding relationship data;
The method according to claim 1 or 2, further comprising the step of: the prior relationship management means identifying an indirect prior relationship that occurs between tasks.   4. The predecessor relation management means preferentially registers an indirect predecessor relation in the closure precedence relation storage means when having a direct predecessor relation and an indirect predecessor relation. The method according to any one.   The method according to claim 2, wherein the schedule conversion means describes the event to be waited and the event to be notified by using a synchronization primitive.   6. The method according to claim 1, further comprising the step of storing the task arrangement structure in a task arrangement storage unit of the system. A closure precedence relationship storage means for storing a precedence task, a succession task, and a precedence relationship type;
Degenerate predecessor storage means for storing a predecessor task, a follower task, and a predecessor relationship type;
An event storage means for storing a notification task, a standby task, and an event identifier;
Receiving precedence relationship data between tasks of the program to be scheduled, and based on the direct precedence relationship and indirect precedence relationship included in the precedence relationship data, the transitional closure of the received precedence relationship data is the closure precedence relationship Preceding relationship management means for storing in the storage means and the transition reduction of the received preceding relation data in the reduced preceding relation storage means;
Using PERT analysis for the preceding relationship recorded in the degenerate precedence relationship storage means, the start time of each task is calculated when the execution time of each task is 1, and based on the calculated start time , Generate a task placement structure having a layer corresponding to each start time and finish time, divide layer 1 at the level of the number of tasks existing in layer 1, place the task in the divided area, and Layer 2 is set, and it is determined whether or not the layer L is the layer t corresponding to the finish time. If the layer L is not the layer t, the task placement means repeats steps (1) to (6),
(1) When the number of tasks in the layer L and the layer L-1 is compared and the number of tasks in one of the layers is smaller than the number of tasks in the other layer, an empty task is generated and The number of tasks is the same,
(2) Based on the closure precedence relationship storage means, for each task in the layer L-1, determine a set of tasks in the layer L (subsequent task candidates) that can be subsequent,
(3) Using the maximum matching algorithm of the graph, obtain the maximum matching for each task in the layer L-1 and its subsequent tasks,
(4) If the maximum matching number is less than the number of tasks in the layer L-1, the difference between the matching number and the task number until the maximum matching number matches the number of tasks in the layer L-1. Generate empty tasks in the layer L and the layer L-1, create a new level area to place empty tasks, repeat (2) and (3),
(5) The layer L is divided at the level of the number of tasks existing in the layer, and the tasks are arranged in the divided areas so that each task in the layer L-1 and its subsequent task are at the same level. And
(6) When the layer L is set to the layer L and the layer L is not the layer t corresponding to the finish time, the task placement unit that returns to (1);
Event identifying means for identifying a task y that could not be placed in the layer L as a successor of the task x in the layer L-1, and storing it in the event storage means;
A system comprising: schedule conversion means for creating a schedule based on the task arrangement structure and the event storage means. Closure precedence relationship storage means for storing the preceding task, successor task, and precedence relationship type, degenerate precedence relationship storage means for storing the precedence task, successor task, and precedence relationship type, notification task, standby task, and event for storing the event identifier A program for causing a system having a storage means to create a schedule based on a prior relationship between tasks,
The preceding relationship management means of the system receives preceding relationship data between tasks of a program to be scheduled;
Based on the direct preceding relationship and the indirect preceding relationship included in the preceding relationship data, the preceding relationship management unit sends a transition closure of the received preceding relationship data to the closure preceding relationship storage unit, and the received preceding relationship. Storing transition degeneration of relational data in the degeneracy preceding relation storage means;
The task placement unit of the system calculates the start time of each task when the execution time of each task is set to 1 using PERT analysis for the preceding relationship recorded in the degenerate precedence relationship storage unit When,
The task placement means generating a task placement structure having a layer corresponding to each start time and finish time based on the calculated start time;
The task placement means divides layer 1 at the level of the number of tasks existing in layer 1 and places tasks in the divided areas;
The task placement means sets layer 2 to layer L;
The task placement unit is a step of determining whether or not the layer L is a layer t corresponding to the finish time. When the layer L is a layer t, based on the task placement structure and the event storage unit, Create a schedule and if not layer t, continue with the following steps;
The task placement unit compares the number of tasks in the layer L and the layer L-1, and if the number of tasks in one of the layers is smaller than the number of tasks in the other layer, generates a blank task. Making the number of tasks in both layers the same,
The task placement means determining, based on the closure precedence relationship storage means, a set of tasks in the layer L (subsequent task candidates) that can be subsequent to each task in the layer L-1.
The task placement means obtains a maximum matching for each task in the layer L-1 and its subsequent tasks using a maximum matching algorithm of a graph;
When the task placement means has a matching number of the maximum matching smaller than the number of tasks in the layer L-1, the matching number and the task until the matching number of the maximum matching matches the number of tasks in the layer L-1. Generating empty tasks in the layer L and the layer L-1, creating a new level area for placing empty tasks, and determining the set of subsequent task candidates; and Repeating the step of obtaining the maximum matching; and
The task placement unit divides the layer L at the level of the number of tasks existing in the layer, and each task in the layer L-1 and its subsequent task are divided into regions that are divided at the same level. Placing a task,
An event identifying means of the system for identifying a task y that could not be placed in the layer L as a successor of the task x in the layer L-1, and storing it in the event storage means;
The task placement means sets the layer L + 1 to the layer L, and returns to the step of determining whether or not the layer L is the layer t corresponding to the finish time.

Images