JP2011197896A - Computer system and task management method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for efficiently moving a task composing a parallel calculation job between computers.SOLUTION: A computer system includes a plurality of computers connected via a network and is configured such that each computer executes a plurality of tasks composing a job in accordance with scheduling. When moving a task between the computers, execution states of the tasks are referred to and a task processing of which has ended is preferentially selected as a task to be moved.

Description

  The present invention relates to a computer system that performs parallel and distributed processing using a plurality of computers, and more particularly to a technique for moving a task constituting a parallel calculation job from a computer that is executing to another computer.

  Generally, when performing a large-scale calculation, the processing performance of a computer system is improved by performing parallel calculation with a plurality of computers. In such a parallel computer system, the load on the computer may be biased. For this reason, as a technique for leveling the load on a computer, a process migration technique for moving a process operating on a certain computer to another computer is known.

  For example, in Patent Document 1, a copy of a transfer source process is created in a transfer destination computer, during which the execution of the transfer source process is continued, and an execution record of the transfer source process is created on the transfer source computer. After the completion of the first transfer process, the execution record is transferred to the transfer destination computer. The execution of the transfer source process is continued during the second transfer process, and the execution record is created in the transfer source computer. As described above, the transfer of the execution record is repeated, and when the estimated transfer time becomes equal to or shorter than the predetermined length, the process execution is shifted from the transfer source process to the transfer destination process. As a result, the process can be moved with a reduced process stop time.

  Patent Document 2 discloses a technique for improving response from a computer server and saving computer resources by receiving a service from a computer server near a base station with which a mobile terminal is communicating. In the invention described in Patent Document 2, the destination of the mobile terminal is predicted, data in the process address space is moved in advance to the predicted destination computer, and the mobile terminal is moved to the predicted destination. If it becomes clear that moves, transition the execution of the process.

JP 2004-78465 A JP 2004-88200 A

  Since large-scale computation takes time, it is important to shorten the job execution time. For this reason, it is necessary to improve the utilization efficiency of computer resources such as a network and a CPU. According to the technique described in Patent Document 1, since untransferred differential data is repeatedly updated, the data transmitted and received between computers exceeds the amount of data managed by the transfer target process, and the network load increases. In addition, since data is transferred a plurality of times, the overhead of the transfer process increases. For these reasons, there is a problem that a large amount of computer resources such as a network and a CPU for moving processes are required, resulting in a long job execution time.

  The technique described in Patent Document 2 optimizes process movement specialized for services to mobile terminals, and cannot be applied to large-scale calculations using a plurality of computers.

  It is an object of the present invention to provide a method for efficiently moving tasks constituting a parallel calculation job between computers.

  A typical example of the present invention is as follows. That is, a computer system including a plurality of computers connected by a network, each computer executing a plurality of tasks constituting a job according to scheduling, and when a task is moved between the computers, the execution state of the task Referring to FIG. 4, the task that has been processed is selected as a task to be moved preferentially.

  According to the present invention, it is possible to suppress a decrease in the CPU utilization rate of the system during task movement processing. As a result, the overhead of task movement processing can be suppressed.

It is a block diagram of the computer system of embodiment of this invention. It is a hardware block diagram of the computer of embodiment of this invention. It is an internal block diagram of the job management process of the embodiment of the present invention. It is an internal block diagram of the intra-node job management process of the embodiment of the present invention. It is an internal block diagram of the job execution process of embodiment of this invention. It is a block diagram of the slave management table in the job management process of the embodiment of this invention. It is a block diagram of the job management table in the job management process of the embodiment of this invention. It is a block diagram of the task management table in the job management process of embodiment of this invention. FIG. 6 is a configuration diagram of a moving task management table in the job management process according to the embodiment of this invention. It is a block diagram of the internal table of the job management process in a node of embodiment of this invention. It is a block diagram of the internal table of the job management process in a node of embodiment of this invention. It is a block diagram of the internal table of the job management process in a node of embodiment of this invention. It is a block diagram of the internal table of the job execution process of embodiment of this invention. It is a block diagram of the internal table of the job execution process of embodiment of this invention. It is a task state transition diagram of an embodiment of the present invention. It is a sequence diagram which shows the interprocess communication at the time of performing the task of embodiment of this invention. It is a flowchart which shows the scheduling method of the task of embodiment of this invention. It is a flowchart which shows the swap-out method of the task of embodiment of this invention. It is a flowchart which shows the selection method of the movement object task of embodiment of this invention. It is a flowchart which shows the movement method of the task of embodiment of this invention.

  Embodiments of the present invention will be described below with reference to the drawings.

  FIG. 1 is a configuration diagram illustrating an example of a computer system that executes a parallel calculation job using a plurality of nodes (computers) according to the embodiment of this invention.

  The computer system of this embodiment includes a client node 10, a master node 20, and a slave node 30. The client node 10 is a computer that instructs execution of a job. The master node 20 is a computer that manages job execution. The slave node 30 is a computer that executes the job body. This computer system includes one master node 20 and a required number of slave nodes 30. By increasing the number of slave nodes 30, the computing capacity of the computer system can be increased.

  This computer system is a system for executing a parallel calculation job composed of a plurality of tasks. When the client node 10 instructs the master node 20 to execute a job, the master node 20 assigns each task constituting the job to the slave node 30 and executes the task to which the slave node 30 is assigned. Executed.

  The client node 10 executes a client process P1 that instructs execution of a job. The master node 20 executes a job management process P2 that controls the execution of the entire job and a distributed file system (FS) process P5. The slave node 30 executes an in-node job management process P3 that controls execution of jobs that operate in the node, a job execution process P4 that executes jobs, and a distributed FS process P5.

  The job execution process P4 is dynamically created when the client process P1 instructs execution of a job. In the same node, an instance of the job execution process P4 is created for each job. Therefore, when one node executes a plurality of jobs simultaneously, a plurality of job execution processes are generated in the node. After the job processing is completed, the job execution process P4 disappears.

  The distributed FS is a file system in which the main body of a file is distributed to a plurality of nodes, and all the files can be accessed from any node using the same path name. When the file size is large, one file is divided into a plurality of nodes. The distributed FS process P5 is a process for realizing the distributed FS, and each process can access a file on the distributed FS via the distributed FS process. Hereinafter, accessing the distributed FS via the distributed FS process is simply expressed as accessing the distributed FS, reading a file from the distributed FS, or the like.

  FIG. 2 is a hardware configuration diagram of each node (computer) according to the embodiment of this invention.

  As shown in FIG. 2, each node includes a processor (CPU) 101, a network interface (LAN I / F) 102, an input / output interface 103, a memory 104, and a storage interface 105. These units are connected inside the node. Has been.

  The processor 101 executes a program stored in the memory. A keyboard 106, a mouse 107 and a display 108 are connected to the input / output interface 103. A user of the system instructs execution of a job using a device connected to these input / output interfaces 103. A storage device 109 such as a hard disk drive is connected to the storage interface 105. The storage device 109 stores an operating system, a process program operating on each node, and data analyzed by parallel calculation.

  When the system is activated, a program is stored in the memory 104 from the storage device 109, and the CPU 101 executes the program stored in the memory 104. Note that the master node 20 and the slave node 30 do not need to include the keyboard 106, the mouse 107, and the display 108 because the user does not directly perform input / output operations.

  3A to 3C are diagrams showing an internal configuration of a process executed in each node according to the embodiment of this invention.

  The job management process P2 shown in FIG. 3A includes a job control program P21, a slave management table P22, a job management table P23, a task management table P24, and a moving task management table P25. For example, the job management process P2 is stored in the storage device 109, read into the memory 104, and executed by the CPU 1010.

  The job control program P21 is a subprogram that controls jobs. Accordingly, the job control program P21 is stored in the memory, and is read from the memory by the processor 101 and executed. The slave management table P22 holds information for managing information of the slave nodes 30 in the system (see FIG. 4A). The job management table P23 holds information for managing the job being executed (see FIG. 4B). The task management table P24 holds information for managing the task of the job being executed (see FIG. 4C). The moving task management table P25 holds information for managing the moving task (see FIG. 4D).

  4A to 4D are configuration diagrams of tables included in the job management process P2 according to the embodiment of this invention.

  The slave management table P22 illustrated in FIG. 4A includes a slave ID, a node address, a maximum number of tasks, a maximum memory amount, and a task ID list, and stores information on all slave nodes in the system. Each entry in the slave management table P2 corresponds to each slave node.

  The slave ID is an identifier for uniquely identifying the slave node 30. The node address is an address on the network of the slave node 30. The maximum number of tasks is the number of tasks that can be executed simultaneously on the slave node. The maximum amount of memory is the amount of memory that can be used by a task in the slave node. For example, the unit is expressed in MB (megabyte). The task ID list is an identifier of a task being executed on the slave node.

  In the task ID list, for example, a combination of a job identifier (job ID) and a task number is described. Specifically, as shown in FIG. 4A, “J01: 1, J01: 2” in the task ID list of the first entry (slave ID = 01) has a job ID “J01” and a task number “1”. And the task with the job ID “J01” and the task number “2” are being executed.

  The job management table P23 illustrated in FIG. 4B includes job IDs, job programs, initial data, and task number lists, and stores information on all jobs being executed in the computer system. Each entry in the job management table P23 corresponds to each job being executed.

  The job ID is an identifier for uniquely identifying a job. The job program is a job execution format program, and is executed in the job execution process P4. The initial data is data read by each task when each task is initialized, and is represented by the file name of the file stored in the distributed FS. The task number list is the task numbers of all tasks constituting this job. Since an entry in the job management table P23 is provided for each job ID, the task number list in the job management table P23 does not include a job ID.

  The task management table P24 illustrated in FIG. 4C includes a job ID, task number, execution state, total data amount, swap amount, and swap flag, and stores information on all tasks being executed in the system. Each entry in the task management table P24 corresponds to a task being executed.

  The job ID is an identifier for uniquely identifying a job. The task number is a number for identifying a task in the job. The execution state indicates the execution state of each task, and is one of the states shown in the state transition diagram shown in FIG. The total data amount is the total data amount used by this task. For example, the unit is expressed in MB (megabyte). Note that the total amount of data includes the amount of data in the swap state. The swap amount is the amount of swapped data, and for example, the unit is expressed in MB (megabyte). The swap flag indicates the status of task data swap processing, and is one of IDLE (not in swap processing), BUSY (in swap processing), or PRE_OUT (immediately before performing swap-out processing).

  Note that the process of moving the data held in the memory 104 by the task to the storage device 109 is swap-out, and the process of returning the data moved to the storage device 109 to the memory 104 is swap-in.

  The moving task management table P25 illustrated in FIG. 4D includes a job ID, a task number, a moving source slave ID, a moving destination slave ID, and an execution state, and stores information on all moving tasks. Each entry in the moving task management table P25 corresponds to each moving task.

  The job ID is an identifier for uniquely identifying a job. The task number is a number for identifying a task in the job. The source slave ID and the destination slave ID are respectively an identifier of the source slave node 30 and an identifier of the destination slave node 30 of the task to be moved. The execution state indicates a state before the movement of the task being moved, and is used to save the state before the movement in order to return the execution state of the task to the execution state before the movement after the task movement.

  Next, the configuration of the intra-node job management process P3 shown in FIG. 3B will be described. For example, the intra-node job management process P3 is stored in the storage device 109, read into the memory 104, and executed by the CPU 1010.

  The intra-node job management process P3 includes an intra-node job control program P31, an intra-node job management table P32, a task management table P33, and a memory management table P34. The intra-node job control program P31 is a program that controls job execution. Therefore, the job control program P31 is stored in the memory, and is read from the memory by the processor 101 and executed. The intra-node job management table P32 holds information for managing jobs being executed on the own node (see FIG. 5A). The task management table P33 holds information for managing the task being executed (see FIG. 5B). The memory management table P34 holds information for managing the memory usage state of the task being executed on the own node (see FIG. 5C).

  5A to 5C are configuration diagrams of tables included in the intra-node job management process P3.

  The intra-node job management table P32 illustrated in FIG. 5A includes a job ID, a job program, initial data, and a task number list, and includes only information on a job being executed on this node. Each entry in the intra-node job management table P32 corresponds to each job being executed on the node.

  The intra-node job management table P32 has the same configuration as the job management table P23 held in the job management process P2, and each item having the same name holds the same data. However, the intra-node job management table P32 includes only information on jobs executed on the node.

  A task management table P33 illustrated in FIG. 5B includes information on a task being executed in the system, including a job ID, a task number, an execution state, and a node address. Note that the task management table P33 includes not only information on tasks being executed on this node but also information on tasks being executed on other nodes, but tasks corresponding to jobs other than jobs being executed on this node. Information on the execution status of is not included. Each entry in the task management table P33 corresponds to a task being executed.

  The job ID is an identifier for uniquely identifying a job. The task number is a number for identifying a task in the job. The execution state indicates the execution state of the task, and the execution state indicates the execution state of each task, which is one of the states shown in the state transition diagram shown in FIG. Only the execution state of the task being executed in this node is stored. The node address is an address on the network of the slave node 30 that is executing this job. Note that only the node address of a task being executed on another node is stored.

  The memory management table P34 illustrated in FIG. 5C includes a job ID, a task number, a data name, a data amount, and a swap state, and includes information on memory areas allocated to all tasks being executed on this node. Each entry in the memory management table P34 corresponds to a memory area.

  The job ID is an identifier for uniquely identifying a job. The task number is a number for identifying a task in the job. The data name is the name of data held by each task. The data amount is the amount of data held by each task. For example, the unit is represented by MB (megabyte). The swap state indicates a state related to memory swap (in particular, swap-out). Specifically, the swap state indicates “no swap”) “NONE”, “PRE_OUT” indicating immediately before swap-out, “OUT” indicating that swap-out is in progress, “SWAP” indicating that swap-out has been completed, swap-in processing One of “IN” indicating the inside is stored.

  The intra-node job management process P3 uniquely identifies a task by a job ID and a task number, and stores data information held by the identified task in a data name, a data amount, and a swap state. Each task holds three types of data: internal data, buffer, and reception buffer. The internal data is a work memory area, and each task can hold a plurality of work memory areas by naming each memory area. When the task holds the memory area, the name of the work memory area is stored in the data name of the memory management table P34. “Buf” may be stored in the buffer memory area, and “buf_recv” may be stored in the data name of the memory management table P34 in the reception buffer.

  Next, the configuration of the job execution process P4 shown in FIG. 3C will be described. For example, the job execution process P4 is stored in the storage device 109, read into the memory 104, and executed by the CPU 1010.

  The job execution process P4 includes a task control program P41, a data movement program P42, a task movement program P43, a task management table P44, a memory management table P45, and a task P46. The task control program P41 is a program that controls the execution of tasks. The data movement program P42 is a program that performs data swap processing. The task movement program P43 is a program for performing a task inter-node movement process. . Therefore, the task control program P41, the data movement program P42, and the task movement program P43 are stored in the memory, and are read from the memory by the processor 101 and executed. The task management table P44 manages information on tasks being executed on the own node (see FIG. 6A). The memory management table P45 manages the memory usage state of the task being executed in the own node (see FIG. 6B).

  A plurality of tasks P46 can be generated in the job execution process P4. The upper limit of the number of tasks P46 is the number described in the maximum number of tasks in the slave management table P22. The task includes a task processing code P47, which is a user program, internal data (data), a buffer (buf), and a reception buffer (buf_recv).

  The internal data is a work memory area used internally by a task. Each task can use a plurality of memory areas by naming each memory area. The task processing code P47 can use internal data by requesting a memory area from the task control program P41. The task control program P41 manages the memory area used by the task processing code P47, and if necessary, requests the data movement program P42 to perform swap processing.

  Tasks can communicate with each other by exchanging messages. The message received by the task is temporarily stored in the reception buffer (buf_recv). On the other hand, the task processing code P47 takes out a message from the buffer (buf) and uses it. This system operates on a processing model that alternately executes parallel processing and synchronous processing of a plurality of tasks. A message transmitted in a certain parallel processing phase is stored in the reception buffer (buf_recv) of the destination task in the parallel processing phase. Thereafter, the message is moved from the reception buffer (buf_recv) to the buffer (buf) in the synchronization phase, and the task processing code P47 of the destination task can use the message moved to the buffer in the next parallel processing phase. Details of operations for alternately performing parallel processing and synchronous processing will be described later.

  6A and 6B are configuration diagrams of tables included in the job execution process P4.

  The task management table P44 shown in FIG. 6A includes a job ID, a task number, an execution state, and a node address, and describes information on all tasks corresponding to the job executed by the job execution process P4. Each entry in the task management table P44 corresponds to each task being executed on the node.

  The task management table P44 has the same configuration as the task management table P33 included in the intra-node job management process P3, and the meaning of each item is also the same. However, the task management table P44 does not include information on tasks corresponding to jobs other than jobs executed by the job execution process P4.

  The memory management table P45 shown in FIG. 6B includes a job ID, a task number, a data name, a data amount, a data ID, and a swap file name, and a memory area held by all tasks executed by the job execution process P4. Information is written. Each entry in the memory management table P45 corresponds to each memory area.

  The job ID, task number, data name, and data amount in the memory management table P45 have the same meaning as the items in the memory management table P34 held in the in-node job management process P3. The data ID is an identifier of the memory area, and the task processing code P47 accesses the memory area using the data ID. Specifically, the handle number or address of the memory area is used as the data ID. The swap file name is the name of the swap file when this memory area is swapped out. This swap file is not stored on the distributed FS but on the local file system of each slave node.

  Next, the transition of the task execution state will be described.

  FIG. 7 is a task state transition diagram according to the embodiment of this invention. The task status names described below are the task management table P24 included in the job management process P2, the task management table P33 included in the in-node job management process P3, and the task management table P44 included in the job execution process P4. It is described in the execution state.

  When a task is newly generated in the job execution process P4, the task state becomes “INIT”, and the files described in the initial data of the job management table P23 and the intra-node job management table P32 are read from the distributed FS. After the file is read, the task state becomes “WAIT”. This means a standby state, and waits until there is a task execution instruction from the client process P1.

  When a task execution instruction is received, after the message in the reception buffer (buf_recv) in the task P46 is moved to the buffer (buf), the task state becomes “PRE_RUN”. This state is a state waiting for a task to be scheduled.

  After that, when the task is scheduled, after the swapped-out data is read into the memory area, the task state becomes “RUN” and the execution of the task processing code P46 is started. While the task processing code P46 is being executed, the data managed by the task P46 is not swapped out. After the execution of the task processing code P46 is completed, the task state returns to “WAIT”. When the task status is “WAIT”, if there is a task end instruction from the client process P1, the task releases the used memory area and disappears. In FIG. 7, this state is described as “END”. However, this state is described for convenience, and the state “END” is not described in the table because the task actually disappears. .

  When the task state is “WAIT” or “PRE_RUN”, it is possible to move the task to a job execution process on another slave node. When the movement of the task starts, the state of the movement source task becomes “MIG_SEND”, and when the movement of the task ends, the movement source task disappears. When the source task starts to move, a task with a state of “MIG_RECV” is generated on the job execution process of the destination slave node. When the movement process is completed, the task state becomes “WAIT” or “PRE_RUN”, and the state before the movement is restored. Therefore, there are two tasks (movement source task and movement destination task) having the same job ID and task number during task movement.

  FIG. 8 is a sequence diagram showing inter-process communication with task execution according to the embodiment of this invention, and shows a cooperative operation of each process when a task makes a state transition. Each process is executed by the CPU of the computer to which each process belongs.

  When starting job processing, the client process P1 transmits a job start request (M01) to the job management process P2. The job start request includes the file name of the job program and the file name of the initial data. The job program and initial data are stored on the distributed FS, and the file name is a file name on the distributed FS.

  Upon receiving the job start request (M01), the job management process P2 assigns a job ID to the job to be executed and transmits a process generation request (M02) to the intra-node job management process P3. The process generation request (M02) includes a job ID, a file name of the job program, and a file name of initial data.

  Upon receipt of the process generation request (M02), the intra-node job management process P3 generates a job execution process P4 (M03). A file specified by the file name of the job program and the file name of the initial data included in the process generation request (M02) is read from the distributed FS, and a job execution process P4 including a program file using the read initial data as a parameter is to start. The job execution process P4 transmits a process generation notification (M04) to the in-node job management process P3 after starting.

  Upon receipt of the process generation notification (M04), the intra-node job management process P3 adds information on the newly generated job to the intra-node job management table P32 and transfers the process generation notification (M05) to the job management process P2. To do. At this point, one entry describing the job ID, job program, and initial data is generated in the intra-node job management table P32. However, the task number list is empty because no task has been generated yet.

  Upon receipt of the process generation notification (M05), the job management process P2 adds job information to the job management table P23 and transmits a job start notification (M06) to the client process P1 as in the in-node job management process P3. To do.

  Upon receiving the job start notification (M06), the client process P1 transmits a task generation request (M07) to the job management process P02.

  Upon receiving the task generation request (M07), the job management process P2 assigns a task number to the generated task and transfers the task generation request to the job execution process P4 via the intra-node job management process P3 (M08, M09). . The task number assigned by the job management process P2 is added to the task generation request (M8, M9) and sent to the job execution process P4.

  Upon receiving the task generation request (M9), the job execution process P4 generates a task P46, and after the generation of the task is completed, adds the generated task information to the task management table P44, and generates a job for the generated task A state transition notification [INIT] (M10) including the ID, task number state, and task state (INIT) is transmitted to the intra-node job management process P3.

  Upon receiving the state transition notification (M10), the intra-node job management process P3 adds the received task information (job ID, task number, execution state) to the task management table P33, and sends the state transition notification (M10) to the job. Transfer (M11) to the management process P2.

  Upon receiving the job management process P2, the job management process P4 adds task information to the task management table P24 as in the in-node job management process P3. Since the task has not yet read data, the total data amount and the swap amount described in the task management table P24 are set to 0, and the swap flag is set to “IDLE”. At this time, the execution state of this task described in the task management table included in each of the processes P2, P3, and P4 is “INIT”.

  Further, the job management process P2 searches for an entry in which the node address of the slave management table P22 matches the transmission source node address of the received state transition notification [INIT], and is newly created in the task ID list of the entry. Task information (job ID and task number) is added.

  Although not shown, when the job management process P2 receives the state transition notification [INIT] (M11), the job management process P2 searches the slave management table P22 and sets the job ID included in the received state transition notification [INIT] (M11) as a task. Search for an entry included in the ID list. Since the retrieved entry is an entry corresponding to the node that is executing the job that started the task, the state transition notification [INIT] is sent to a node other than the transmission source of the state transition notification [INIT] (M11) at the node corresponding to these entries. ] A state transition notification [INIT] to which the address of the transmission source node of (M11) is added is transmitted. Upon receiving this state transition notification [INIT], the intra-node job management process P3 adds an entry corresponding to the generated task to the task management table P33. At this time, since this task is executed in the remote node, nothing is described in the execution state of the task management table P33, and the node address of the task management table P33 contains a job in the received state transition notification [INIT]. Enter the address added by the management process.

  As described above, when a new task is generated, the task information is transferred from the job execution process P4 to the job management process P2, and further transferred to the in-node job management process P3 of the other node. The task information is transmitted to the intra-node job management process P3 related to the job.

  Next, the job execution process P4 reads initial data from the distributed FS, and stores the read data in the memory area as internal data (data) of the task. The file name of the initial data is described in the job start request (M01) and the process generation request (M02), and is sent to the job execution process P4 by the start option of the job execution process.

  After the job execution process P4 completes the reading of the initial data, the job execution process P4 updates the execution state of the entry corresponding to the task described in the task management table P44 to “WAIT”, the job ID, the task A state transition notification [WAIT] (M12) including the number and task state (WAIT) is transmitted to the intra-node job management process P3.

  Upon receiving the state transition notification [WAIT] (M12), the intra-node job management process P3 updates the execution state of the entry of the task in the task management table P33 to “WAIT”, as in the job execution process P4. Then, the intra-node job management process P3 transfers the state transition notification [WAIT] to the job management process P2 (M13).

  Upon receiving the state transition notification [WAIT] (M13), the job management process P2 searches the task management table P24 for an entry having a matching job ID and task number, and updates the execution state of the searched entry to “WAIT”. To do.

  Thus, when the task execution state is changed, the state transition notification is sequentially transferred from the job execution process P4 to the in-node job management process P3 and the job management process P2. Upon receipt of the state transition notification, the in-node job management process P3 and the job management process P2 search the entry corresponding to the task from the task management tables P33 and P24 using the job ID and task number as a key, respectively. Change the execution status of the entry to the reported value.

  Even when the memory usage amount or the swap state of the task is changed, the state transition notification is transferred from the job execution process P4 to the job management process P2, similarly to the case where the task execution state is changed. In this case, the intra-node job management process P3 changes the addition / deletion of entries in the memory management table P34, the data amount, and the swap state in accordance with the state transition notification. The job management process P2 also changes the total data amount, the swap amount, and the swap flag in the task management table P24 according to the state transition notification.

After transmitting the task generation request (M07), the client process P1 transmits a synchronization request (M14) to the job management process P2. The synchronization request (M14) includes a task ID list of tasks to be synchronized. The job management process P2
When receiving the synchronization request (M14), it waits until all task IDs described in the synchronization request (M14) are in the “WAIT” state. If the task described in the synchronization request (M14) has already been completed or has been completed while waiting for synchronization, the job management process P2 returns an error notification to the client process P1. In FIG. 8, since the task status is “WAIT”, a synchronization completion notification (M15) is returned to the client.

  In FIG. 8, there is only one task that is generated and synchronized, but in practice a plurality of tasks are generated and synchronized. Specifically, the task generation request (M07) describes information about a plurality of tasks, and the job management process P2 generates a plurality of tasks described in the task generation request (M07) within the node. Request to the job management process P3. At this time, the job management process P2 refers to the maximum number of tasks and the task ID list in the slave management table P22, and confirms whether there is room for generating a new task in a node for which task generation is requested. When the requested number of tasks cannot be generated in one slave node, the job management process P2 transmits a task generation request to the job management process P3 in another node in order to generate a task in another slave node. .

  Therefore, the job execution process P4 for executing the task operates on a plurality of nodes, but the state transition notification from each task is always transmitted to the job management process P2. When the job management process P2 receives the synchronization request (M14) from the client process P1, the job management process P2 confirms the status of all tasks described in the synchronization request (M14), and when the status of all tasks becomes “WAIT”, A synchronization completion notification (M15) is returned to the client process P1.

  Upon receiving the synchronization completion notification (M15), the client process P1 transmits a task execution instruction (M16) to the job management process P2. The task execution instruction (M16) describes the task ID of the task to be executed, and the job management process P2 refers to the task ID list in the slave management table P22 and the task corresponding to the specified task ID operates. Get the node address of the slave inside. The job management process P2 transmits a task execution instruction (M17) to the intra-node job management process of the node. The task execution instruction (M16) describes the task ID of the task to be executed at the node. When the task described in the task execution instruction (M16) is being executed in a different node, the task execution instruction (M17) is transmitted to the intra-node job management process of each node.

  Upon receiving the task execution instruction (M17), the intra-node job management process P03 extracts the job ID included in the task ID, and executes the task execution instruction (M18) including the extracted job ID as the job execution responsible for the job. Transfer to process.

  Upon receiving the task execution instruction (M18), the job execution process P4 extracts the task number from the task ID included in the task execution instruction (M18), and responds to the task from the task management table P44 using the extracted task number as a key. The entry to be searched is searched, and the execution state of the searched entry is changed to “PRE_RUN”. Then, the job execution process P4 moves the message stored in the reception buffer (buf_recv) in the task P46 to the buffer (buf), and clears the contents of the reception buffer (buf_recv). Thereafter, the job execution process P4 returns a state transition notification [PRE_RUN] to the intra-node job management process P03.

  Upon receiving the state transition notification [PRE_RUN] (M20), the in-node job management process P3 extracts the job ID and task number from the task ID included in the received task execution instruction (M17), and extracts the extracted job ID and task. The task management table P33 is searched using the number as a key, and the execution state of the searched entry is changed to “PRE_RUN”. Then, the intra-node job management process P3 transfers the state transition notification (M21) to the job management process P2.

  Upon receiving the state transition notification (M21), the job management process P2 changes the execution state of the entry corresponding to this task in the task management table P24 to “PRE_RUN”, as in the in-node job management process P3.

  Next, the intra-node job management process P3 confirms the task management table P33, and the number of entries in which the execution state is “RUN” for a task for which a node address is not set (task being executed on the own node). Calculate This number is the number of tasks actually scheduled at that node. If this number is smaller than the maximum number of tasks of the own node, the task execution is permitted and a scheduling request (M22) is transmitted to the job execution process P4. The scheduling request (M22) includes the task number of the task to be scheduled.

  Upon receiving the scheduling request (M22), the job execution process P4 searches the task management table P44 using the task number included in the scheduling request (M22) as a key, and changes the execution state of the searched entry to “RUN”. .

  Then, the job execution process P4 returns a state transition notification [RUN] to the intra-node job management process P3, and starts executing the task processing code P47 of the task P46. The task processing code P47 is executed asynchronously with a thread assigned to each task. The task processing code P47 reads a message transmitted to another task or a message received from another task from the buffer (buf) of the task P46.

  When the execution of the task processing code P47 is completed, the job execution process P4 searches the task management table P44 using the task number of the task that has been executed as a key, and changes the execution state of the searched entry to “WAIT”. Then, a state transition notification [WAIT] (M25) including the job ID and task number of the task whose execution has been completed is transmitted to the intra-node job management process P3.

  Upon receiving the state transition notification [WAIT] (M25), the intra-node job management process P3 searches the task management table P33 using the job ID and task number of the task included in the state transition notification [WAIT] (M25) as keys. Then, the execution state of the retrieved entry is changed to “WAIT”. Furthermore, the intra-node job management process P3 transfers the state transition notification [WAIT] (M26) to the job management process P2.

  Upon receiving the state transition notification [WAIT] (M26), the job management process P2 changes the execution state of the entry corresponding to this task to “WAIT” in the task management table P24, as in the in-node job management process P3. To do. Thereafter, the job management process P2 returns a synchronization completion notification (M27) to the client process P1.

  After transmitting the task execution instruction (M16), the client process P1 transmits a synchronization request (M19) to the job management process and waits until the state of the executed task becomes “WAIT”. This process is the same as the synchronization process indicated by M14.

  In this way, task execution proceeds by alternately performing task processing start by task execution instructions from the client process P1 and task synchronization.

  In the above description, the intra-node job management process P3 schedules the task when the task is in the “PRE_RUN” state. However, if the client process issues a task execution instruction to many tasks, the maximum task of the slave node The number of tasks exceeding the number simultaneously enter the “PRE_RUN” state, and the task in the “PRE_RUN” state cannot be scheduled immediately. The internal data (data) and buffer (buf) of the task can be swapped out. If the memory area is already swapped out when executing the task processing code, it is necessary to swap in. If the memory in the node is insufficient, it is necessary to swap out the internal data (data) and the buffer (buf) managed by another task that can be swapped out before executing the task processing code. Hereinafter, the scheduling process will be described in detail with reference to FIGS. 9 and 10.

When the intra-node job control program P31 starts processing, it checks the task management table P33 and searches for an entry whose execution state is “PRE_RUN” (S101).

  If there is no entry in the “PRE_RUN” state, the process waits until a task in the “PRE_RUN” state appears (S102).

  In S101, if there is an entry in the “PRE_RUN” state, a set of job ID and task number of the entry in “PRE_RUN” state found in S101 is selected, and the selected entry matches the job ID and task number. The entry of the memory management table P34 is searched. These entries correspond to the memory area used by this task.

  Then, the swap state of these entries is confirmed, and if the swap state of all entries is “NONE”, the task is selected as a scheduling target. On the other hand, if the swap state is other than “NONE”, a combination of the job ID and task number of another entry found in S101 is selected, and the memory management table P34 is confirmed by the above-described procedure.

  When the swap state of the memory management table P34 is “NONE”, the memory area is not swapped out and is not scheduled to be swapped out most recently. Therefore, in this step, processing for preferentially scheduling tasks that do not require swap-in is performed. By performing such control, the idle time of the slave node CPU is minimized and efficient scheduling becomes possible. As will be described later, when a task is moved, a task having a large swapped data size is preferentially selected as a task movement target (S103). Since a task in the “RUN” state cannot be moved, the control described above has an effect of leaving a task having a large swapped data size as a movement target without scheduling.

  If a task can be selected in S103, the selected task is scheduled. Therefore, the intra-node job control program P31 changes the execution state of the task management table P33 corresponding to the task to “RUN”. Then, the memory usage status of the own node is confirmed, and if necessary, other tasks are swapped out (S105). Details of the swap-out process will be described later with reference to FIG. When this process ends, the process proceeds to S111.

  If a task that does not require swap-in cannot be selected in S106, another task found in S101 is selected. At this time, the data amount of the entry whose swap state is “SWAP” (swapped) in the memory management table P34 is added for each task, and the one with the smallest calculated data amount is selected as a scheduling target (S106). The amount of data in the memory management table P34 represents the data size of the memory area. For this reason, the swap-in process in the scheduling is minimized by selecting the data having the smallest swapped data size. Further, similarly to S103, there is an effect that a task having a large swapped data size is left as a movement target without being scheduled.

  Thereafter, the intra-node job control program P31 changes the execution state of the task management table P33 corresponding to the task to “RUN”. Then, other tasks are swapped out in the same procedure as S105 (S107). Details of this processing will be described later.

  Next, the intra-node job control program P31 searches the memory management table P34 using the task number of the task selected as the scheduling target as a key, and the swap status among the searched tasks is “PRE_OUT” and “OUT”. A thing is found (S108). An entry whose swap status is “PRE_OUT” is a memory area that is scheduled to be swapped out soon. If this entry exists, the swap status of the entry is changed to “NONE”. An entry whose swap state is “OUT” is a memory area currently being swapped out. When there is an entry whose swap status is “OUT”, the in-node job control program P31 requests the job execution process P4 to cancel the swap-out process of this memory area, and when the cancel process is completed, the entry The swap state is changed to “NONE” (S109).

  Next, the intra-node job control program P31 refers to the memory management table P34, searches the memory management table P34 using the task number of the task selected as the scheduling target as a key, and the swap status among the searched entries is “ Search for “SWAP”. Since the memory area of the entry whose state is “SWAP” has already been swapped out, the intra-node job control program P31 requests the job execution process P4 to swap in the memory area (S110). When the swap-in process by the job execution process P4 is completed, the process proceeds to S111.

  Next, the intra-node job control program P31 creates a scheduling request including the job ID and task number of the task selected as the scheduling target, and transmits the scheduling request to the job execution process P4 corresponding to the job ID. Then, it waits for a status transition notification to be returned from the job execution process P4. When the state transition notification is received, it can be confirmed that scheduling has been performed, and the process returns to S101 (S111).

  Next, details of the swap-out process (S105) will be described.

  FIG. 10 is a flowchart showing a procedure for swapping out a task according to the embodiment of this invention.

  The intra-node job control program P31 obtains the amount of memory installed in the own node and the amount of used memory, and whether the used memory amount is below a certain standard (for example, 80% or less of the installed memory amount). It is determined whether or not (S201). The used memory amount is obtained by summing up the data amounts of entries other than “SWAP”, “OUT”, and “PRE_OUT” in the swap state of the memory management table P34. If the amount of used memory is less than or equal to the reference, it is determined that the amount of free memory is sufficient, and the process ends. On the other hand, if the amount of used memory exceeds the reference, it is determined that the amount of free memory is insufficient, and the process proceeds to the next step in order to perform swap-out processing (S201).

  The intra-node job control program P31 refers to the task management table P33 and searches for an entry whose execution state is “WAIT”. When an entry whose execution state is “WAIT” is found, an entry whose job ID and task number of the found entry match the entry searched from the task management table P33 and whose swap state is “SWAP” is stored in the memory. Search from the management table P34. When an entry satisfying this condition is found, one of those memory areas is selected as a swap target.

  On the other hand, when an entry satisfying this condition is not found, the task management table P33 is referred to, an entry whose execution state is “PRE_RUN” is searched, and the job ID and task number of the found entry are stored in the memory management table P34. The memory management table P34 is searched for an entry that matches the job ID and task ID and whose swap state is “SWAP”. When an entry satisfying this condition is found, one of those memory areas is selected as a swap target.

  As described above, the task whose execution state is “WAIT” is controlled to be preferentially swapped out. For this reason, the task scheduled immediately (task whose execution state is “PRE_RUN”) is set in a state where it is not swapped out as much as possible, and the swap-in processing at the time of scheduling is reduced. Further, as will be described later, in the present invention, tasks that are swapped out and tasks that are scheduled to be swapped out are preferentially set as tasks to be moved. Therefore, the above-described control has an effect of preferentially setting a task that takes time until the next scheduling (a task whose execution state is “WAIT”) as a movement target task (S202).

  If the swap target cannot be selected in S202, the process is terminated because it cannot be swapped out. On the other hand, if the swap target can be selected, the process proceeds to S204 (S203).

  Next, the intra-node job control program P31 transmits a swap pre-notification including the job ID and task number of the memory area selected as the swap target in S202 to the job management process P2 (S204), and waits for a predetermined time (S204). S205). The job management process P2 searches the task management table P24 using the job ID and task number included in the received prior notice of swap as keys, and changes the swap flag of the searched entry to “PRE_OUT”. This process notifies the job management process P2 that the memory area has been swapped, and increases the possibility of being selected as a task movement target. Details of the task movement process will be described later.

  The intra-node job control program P31 waits for a predetermined time, and then searches the task management table P33 using the job ID and task number of the memory area selected as the swap target in S202 as a key. When the corresponding entry is searched, it is confirmed that the execution state of the searched entry is “PRE_RUN” or “RUN”. Further, the memory management table P34 is searched using the job ID, task ID, and data name of the selected memory area as a key, and it is confirmed that the swap state of the searched entry is “PRE_RUN”. If all the above conditions are confirmed, the memory area can be swapped out, and the process proceeds to the next step. On the other hand, if some of the conditions described above cannot be confirmed, swap-out cannot be performed, and the process returns to S201 (S206).

  The intra-node job control program P31 transmits a swap request including the job ID, task number, and data name of the swap-out target memory area to the job execution process P4 and instructs the job execution process P4 to perform swap-out. Further, the intra-node job control program P31 changes the swap state of the entry in the memory management table P34 corresponding to the memory area to “OUT”, and performs swap management notification including the job ID and task number of the memory area. Send to process P2. The job management process P2 searches the task management table P24 using the job ID and task number included in the swap start notification as keys, and changes the swap flag of the searched entry to “BUSY”. After the swap process is started, the process returns to S201 (S207).

Next, details of the task movement process will be described. When there is a bias in the load (memory usage rate, CPU usage rate) of the slave nodes constituting the system, the load bias is leveled by moving the task from the slave node having a high load to the slave node having a low load. In general, there is a high possibility that a plurality of tasks are executed by a slave with a high load, and there are a plurality of tasks that are movement candidates. In the present invention, a task that is a movement candidate is selected in the following priority order.
(1) Task immediately before swap-out.
(2) Tasks that are not scheduled immediately (in WAIT state).
(3) A task in which a part of the memory is swapped out.
(4) Tasks that have not been swapped out.

  To schedule a task with a swapped-out memory area, swap-in is required. For this reason, when swap-out occurs, the CPU utilization efficiency decreases. Further, in the present embodiment, all memory areas held by the moved task are allocated on the real memory. Therefore, by preferentially moving the task immediately before the swap-out, the occurrence of the swap-out is suppressed and a decrease in the CPU utilization efficiency is prevented.

  In addition, if the task immediately before scheduling is swapped out, swap-in occurs immediately, which reduces the CPU utilization efficiency. In addition, since a task that is moving cannot be scheduled, if the task immediately before scheduling is selected as a movement target, there is a possibility of reducing the CPU utilization efficiency. Therefore, a task that is not scheduled immediately is selected as a scheduling target with priority.

  In this embodiment, all the memory areas that hold the task after the move are allocated on the real memory. Therefore, when the swapped-out task is moved, the swap-in is performed at the same time. Therefore, by preferentially moving the swapped-out task, the swap-in is substantially performed during the task movement, and the processing time is shortened.

  Next, a method for controlling task movement will be described in detail. The movement of this task is controlled by the job management unit P21 of the job management process P2.

  FIG. 11 is a flowchart illustrating a procedure by which the job control program P21 selects a movement target task.

  When the task execution state changes, the load on the slave node changes. Also, when the number of slave nodes in this system changes, the load balance of the slave nodes changes. For this reason, it is necessary to determine whether to start moving the task. For example, when a slave node is added, the job control program P12 registers the information of the added slave node in the slave management table P22 and determines whether to start moving a task in the next step. Proceed (S301).

  Next, the job control program P21 determines whether there are slave nodes with sufficient computer resources and slave nodes with insufficient computer resources (S302). Specifically, a slave node in which either one of the CPU resource and the memory resource is insufficient determines that the computer resource is insufficient. On the other hand, a slave node that has a margin in both cases determines that there is a margin in computer resources.

  As for the CPU resource, it is determined whether or not the CPU resource has a margin by comparing the maximum number of tasks described in the slave management table P22 with the number of execution tasks. Specifically, when the maximum number of tasks is smaller than the number of execution tasks, it is determined that CPU resources are insufficient. Further, if the number of execution tasks is equal to or less than a certain ratio (for example, 30%) of the maximum number of tasks, it is determined that there is a margin in CPU resources.

  The number of execution tasks is calculated as follows. First, referring to the slave management table P22, an entry corresponding to the slave node whose number of execution tasks is to be checked is selected. Next, the task ID list (task ID set) of the entry is acquired, and the task ID set is temporarily held. Since the task ID includes a job ID and a task number, they are separated. The moving task management table P25 is searched using the job ID and task number included in the task ID as keys, and the source slave ID of the searched entry matches the slave ID of the entry of the first selected slave management table P22. If so, it is removed from the task ID set because it is moving to another node. Furthermore, if there is an entry that matches the slave ID of the entry of the slave management table P22 selected first in the movement destination slave ID of the moving task management table P25, the task is moving from another node to itself. Therefore, it is added to the task ID set. The number of task IDs included in the task ID set created in this way is the number of execution tasks.

  For the memory resource, it is determined whether or not there is a margin in the memory resource by comparing the maximum memory amount described in the slave management table P22 with the used memory amount. Specifically, when the maximum memory amount is smaller than the used memory amount, it is determined that memory resources are insufficient. Further, if the used memory amount is equal to or less than a certain percentage (for example, 30%) of the maximum memory amount, it is determined that there is a margin in memory resources.

  The amount of memory used is calculated as follows. The task ID set obtained in the CPU resource confirmation process is separated into a job ID and a task number, and the task management table P24 is searched using the separated job ID and task number as a key. The retrieved entry corresponds to a task that operates on the slave node (actually, it operates after completion of task movement). The sum of the total data amounts of these entries is the used memory amount in the node.

  As described above, when both the slave node having sufficient computer resources and the slave node having insufficient computer resources exist in the system, the process proceeds to S303. On the other hand, if only one of the slave node having sufficient computer resources and the slave node having insufficient computer resources exists in the system, the task is not moved and the process is finished (S302).

  Next, the job control program P21 extracts a moveable task among the tasks being executed in the slave node in which the computer resources investigated in S302 are insufficient (S303). Specifically, the slave management table P22 is referred to, and a task ID list of entries corresponding to slave nodes having insufficient computer resources is acquired. Further, the task management table P24 is searched using the job ID and task number of the task ID described in the task ID list as a key, and an entry group having the matching job ID and task number is extracted. This entry group is an entry corresponding to a task being executed on the slave node. In this entry group, a task whose execution state is “PRE_RUN” or “WAIT” is extracted. A task whose execution state is one of the above can be moved.

  If it is determined in S303 that there is no entry that matches the condition, there is no task that can be moved, so the task is not moved and the process ends. On the other hand, if an entry matching the condition can be extracted in S303, the process proceeds to S305 (S304).

  Next, the job control program P21 determines whether or not there is an entry whose swap flag is “PRE_OUT” among the entries of the task management table P24 extracted in S303 (S305).

  If there is an entry whose swap flag is “PRE_OUT”, the task corresponding to this entry is in the state immediately before the swap-out, so it is selected as the task to be moved. Further, one of the slave nodes having sufficient computer resources obtained in S302 is selected as the movement destination node. Then, the job ID and task number of the task to be moved are added to the moving task management table P25, the slave ID of the node that is executing the task is described in the movement source slave ID of the moving task management table P25, and the movement destination node Is described in the destination slave ID, and the execution state of the movement target task is described in the execution state of the moving task management table P25. Thereafter, the process returns to S302 (S306).

  If there is no entry whose swap flag is “PRE_OUT” in S305, an entry whose execution state is “WAIT” is extracted from the entry group extracted in S303. If there is an entry whose execution state is “WAIT”, the process proceeds to S308. If there is no entry whose execution state is “WAIT”, the process proceeds to S311 (S307).

  In S308, the job control program P21 confirms the swap flag of each entry of the entry group extracted in S306, and determines whether or not a task whose swap flag is “SWAP” or “BUSY” exists (S308).

  If it is determined in S308 that there is a task whose swap flag is “SWAP” or “BUSY”, one of the tasks is selected as the movement target task. Subsequently, in the same procedure as in S306, the movement destination node of the movement target task is determined, the information of the movement target task is registered in the moving task management table P25, and the process returns to S302 (S309).

  If it is determined in S308 that there is no task whose swap flag is “SWAP” or “BUSY”, there is no task being swapped, so one of the entry groups extracted in S307 is set as the movement target task. select. Thereafter, the destination node of the movement target task is determined by the same procedure as S306, the information of the movement target task is registered in the moving task management table P25, and the process returns to S302 (S310).

  If it is determined in S307 that there is no entry whose execution state is “WAIT”, the execution state of all entries in the entry group extracted in S303 is “PRE_RUN”. The swap flags of the entries of these entry groups are confirmed, and it is determined whether or not there is a task whose swap flag is “SWAP” or “BUSY” (S311).

  If it is determined in S311 that there is a task whose swap flag is “SWAP” or “BUSY”, one of the tasks is selected as a movement target task. Thereafter, the destination node of the movement target task is determined in the same procedure as in S306, the information of the movement target task is registered in the moving task management table P25, and the process returns to S302 (S312).

  If it is determined in S311 that there is no task whose swap flag is “SWAP” or “BUSY”, there is no task being swapped, and therefore one of the entry groups extracted in S303 is set as the movement target task. select. Subsequently, a destination node of the movement target task is determined in the same procedure as in S306, information on the movement target task is registered in the moving task management table P25, and the process returns to S302 (S313).

  By such a procedure, information on the movement target task is created in the moving task management table P25. After the movement target task selection process is completed, the job control program P21 moves each task described in the moving task management table P25.

  Next, details of the task movement process will be described.

  FIG. 12 is a flowchart illustrating a procedure for moving a task according to the embodiment of this invention.

  The job control program P21 extracts one entry from the moving task management table P25 (S401), and performs a task moving process according to the following procedure. Note that the task corresponding to the entry extracted in S401 is the movement target task.

  First, it is determined whether or not the movement has been completed for all tasks described in the moving task management table P25 (S402). As a result, when all the tasks have been moved, the task moving process is terminated (S402).

  In S403, the job control program P21 transmits a movement start request including the job ID and task number of the movement target task to the intra-node job management process P3 of the slave node that is executing the movement target task. The task ID list in the slave management table P22 is searched using the job ID and task number as keys. The node address of the retrieved entry is the address of the node that is executing the movement target task.

  Upon receiving the movement start request, the intra-node job management process P3 searches the task management table P33 using the job ID and task number included in the movement start request as keys, and confirms the execution status of the searched entry.

  If the execution state is “PRE_RUN” or “WAIT”, the state is changed to “MIG_SEND”. Further, the intra-node job management process P3 requests the job execution process P4 that is executing this task to change the execution state of the migration target task to “MIG_SEND”. Receiving this, the job execution process P4 changes the execution state of the entry of the task management table P44 corresponding to the movement target task to “MIG_SEND”. Thereafter, the intra-node job management process P3 returns a movement start notification to the job management process P2.

  When the job control program P21 receives a movement start notification from the intra-node job management process, it changes the execution state of the entry in the task management table P24 corresponding to the movement target task to “MIG_SEND” (S403), and proceeds to S405 ( S404).

  If the execution state of the entry in the task management table P33 corresponding to the movement target task is other than “PRE_RUN” or “WAIT”, the intra-node job management process P3 returns an error to the job management process P2. When the job control program P21 receives this error, it cannot move the task to be moved, so the movement process is interrupted and the process returns to S401 (S404).

  The job control program P21 refers to the movement destination slave ID of the entry in the moving task management table P25 corresponding to the movement target task, and searches the slave management table P22 using this slave ID as a key. The node address of the retrieved entry is the address of the node that generates the destination task. The job control program P21 determines whether or not the task ID list of the entry retrieved from the slave management table P22 includes a task ID having a job ID that matches the job ID of the movement target task.

  As a result of the determination, if such a task ID is not included, the job execution process P4 is not executed on that node, so a process generation request (M02 in FIG. 8) is sent to the intra-node job management process P3 of the destination node. To generate a job execution process P4 for executing the task to be moved.

  Thereafter, the job control program P21 transmits a task generation request (M08 in FIG. 8) to the intra-node job management process P3 of the movement destination node, and generates a movement destination task (S405). At this time, the task generation request describes that the job ID, task number, and initial state are “MIG_RECV”. Upon receiving the task generation request, the intra-node job management process P3 transfers the task generation request to the job execution process P4, and generates a destination task in the job execution process P4. At this time, in the task management table P44 of the job execution process P4 and the task management table P33 in the intra-node job management process P3, the execution state is “MIG_RECV”, and the job ID and task number are the same as those of the migration target task. A matching entry is created.

  Next, the job control program P21 generates an entry corresponding to the movement target task in the task management table P24. The job ID and task number of the newly generated entry match those of the migration target task, the execution state is “MIG_RECV”, the total data amount and the swap amount are 0, and the swap flag is “IDLE”. It is.

  Next, the job control program P21 transmits a transfer destination task generation notification to all the job execution processes P4 that execute the job of the transfer target task. First, the job control program P21. The entry including the job ID of the task to be moved is extracted by referring to the task ID list in the slave management table P22. Since jobs are being executed at the nodes corresponding to these entries, a destination task generation notification including the job ID of the task to be moved, the task number, and the address of the destination node is transmitted to the node addresses of these entries.

  When the intra-node job management process P3 operating at each node receives the migration destination task generation notification, it registers information on the migration destination task in the task management table P33. Here, the execution state of the newly generated entry is “MIG_RECV”. Next, the intra-node job management process P3 transfers the transfer destination task generation notification to the job execution process P4 that is executing the job corresponding to the job ID included in the transfer destination task generation notification.

  When the job execution process P4 receives the transfer destination task generation notification, the job execution process P4 registers the information of the transfer destination task in the task management table P44. Here, the execution state of the newly generated entry is “MIG_RECV”. When the entry is generated, the job execution process P4 returns a migration preparation completion notification to the in-node job management process P3.

  Upon receiving the migration preparation completion notification, the intra-node job management process P3 transfers the migration preparation completion notification to the job management process P2. The job control program P21 proceeds to S407 after receiving the migration preparation completion notification from all the nodes that transmitted the migration destination task generation notification (S406).

  The job control program P21 transmits a data movement request including the job ID of the movement target task, the task number, and the address of the movement destination node to the job execution process that is executing the movement source task. Specifically, a data movement request is transmitted via the intra-node job management process, similarly to the procedure described in S403.

  Upon receiving the data movement request, the task movement program P43 of the job execution process P4 searches the memory management table P45 using the task number included in the data movement request as a key. The retrieved entry corresponds to a memory area that needs to be moved. The task migration program P43 refers to the data ID of the retrieved entry, reads the data from the corresponding memory area, and transmits it to the job execution process P4 of the migration destination node. When the job execution process P4 of the migration destination node receives the data, it registers the received data information in the memory management table P45. However, since the data ID is an ID of a memory area managed for each node, it does not have the same value as the memory management table P45 of the migration source node.

  When the data has been swapped out, the data ID of the memory management table 45 is blank, and the name of the swap file is described in the swap file name. In this case, the contents of the swap file are transmitted. When data is transmitted from the swap file, the swap file is not created in the migration destination node, and the data is allocated to the real memory area. After all data transmission is completed, the job execution process P4 of the transfer source node deletes the entry corresponding to the data transmitted from the memory management table P45, and releases the corresponding memory area. Then, a data movement completion notification is transmitted to the job management process P2 via the intra-node job management process P3 (S407).

  Upon receiving the data movement completion notification, the job control program P21 transmits a task discard request including the job ID and task number of the movement target task to the job execution process P4 that is executing the movement source task. Specifically, a task discard request is transmitted via the intra-node job management process, as in the procedure described in S403. When the task execution process P4 receives the task discard request, the task execution process P4 deletes the task requested to be discarded, and deletes the entry corresponding to the deleted task from the task management table P44.

  Further, the job control program P21 searches the entry corresponding to the movement target task from the moving task management table P25, and acquires the execution state of the searched entry. Then, the job control program P21 transmits a movement task return request including the execution state, the job ID of the movement target task, and the task number to the job execution process P4 of the movement destination node. Specifically, a moving task return request is transmitted via the intra-node job management process P3 as in the procedure described in S403.

  When the job execution process P4 receives the move task return request, the job execution process P4 searches the task management table P44 using the task number included in the move task return request as a key, and executes the execution state of the retrieved entry included in the move task return request. The state is changed (S408).

  The task moving process is completed by the above steps. The job control program P21 returns to S401, moves other tasks described in the moving task management table P25, and repeats this process until all the tasks have been moved.

  The present invention includes within its scope a range that can be changed by a person skilled in the art from the content disclosed in the specification. For example, in this embodiment, three types of computers (client node 10, master node 20, and slave node 30) are used, but these computers may be common. For example, the client process P1 may operate on the master node 20, and the master node 20 may be operated in common with the client node 10. Further, the in-node job management process P3 and the job execution process P4 may operate on the master node 20 and the master node 20 may be operated as one of the slave nodes 30.

  In the embodiment of the present invention, the distributed FS is used as a storage location of initial data. However, other file systems may be used as long as the file system can be accessed from all nodes with the same path name. Is possible. For example, NFS (Network File System) may be used.

10 client node 20 master node 30 slave node P1 client process P2 job management process P21 job control program P22 slave management table P23 job management table P24 task management table P25 moving task management table P3 intra-node job management process P31 intra-node job control program P32 Job management table in host P33 Task management table P34 Memory management table P4 Job execution process P41 Task control program P42 Data movement program P43 Task movement program P44 Task management table P45 Memory management table P46 Task P47 Task processing code P5 Distributed FS
101 CPU
102 LAN I / F
103 I / O I / F
104 Memory 105 Storage I / F
106 Keyboard 107 Mouse 108 Display 109 Storage Device

Claims (12)

A computer system comprising a plurality of computers connected by a network, each computer executing a plurality of tasks constituting a job according to scheduling,
When a task is moved between the computers, a computer system characterized by selecting a task that has been processed as a task to be moved with priority by referring to an execution state of the task. The computer system constitutes a parallel execution environment in which each computer executes a plurality of tasks in parallel,
The processing of each task and the processing of waiting for the completion of the processing of all the tasks constituting the job are defined in one processing phase,
2. The task according to claim 1, wherein when a task is moved between the computers, a task that has been processed in the processing phase is selected as a task to be preferentially moved with reference to an execution state of the task. Computer system. Each of the computers has a swap-out function for saving data stored in a memory area used by a task to a secondary storage device and a swap-in function for storing the saved data in a memory,
2. The computer system according to claim 1, wherein a task that uses the saved data is selected as a task to be moved with priority.   The computer system according to claim 3, wherein each of the computers schedules a task with less data to be swapped in so that the task is preferentially executed.   4. The computer system according to claim 3, wherein each of the computers selects data to be used by a task for which processing has been completed as data to be swapped out preferentially. Each of the computers is
Set the waiting time before swapping out the data stored in the memory area used by the task,
4. The computer system according to claim 3, wherein the task in the standby state is selected as a task to be moved with priority. A method for managing tasks in a computer system that executes a plurality of tasks constituting a job according to scheduling on a plurality of computers connected to each other via a network,
The method
When moving a task between the computers, determining the execution state of the task;
Selecting a task that has been processed as a task to be preferentially moved based on the determined execution state of the task. The computer system constitutes a parallel execution environment in which each computer executes a plurality of tasks in parallel,
The processing of each task and the processing of waiting for the completion of the processing of all the tasks constituting the job are defined in one processing phase,
8. The task management method according to claim 7, wherein, in the step of selecting the task, a task that has been processed in the processing phase is selected as a task to be moved preferentially. Each of the computers has a swap-out function for saving data stored in a memory area used by a task to a secondary storage device and a swap-in function for storing the saved data in a memory,
The method according to claim 7, wherein the method includes a step of selecting a task that uses the saved data as a task to be preferentially moved.   The method according to claim 9, wherein the method includes a step of scheduling so that a task with a small amount of data to be swapped in is preferentially executed.   The method according to claim 9, wherein the method includes a step of selecting data to be preferentially swapped out as data to be used by a task for which processing has been completed. The method
Setting a waiting time before swapping out data stored in a memory area used by the task;
The task management method according to claim 9, further comprising: selecting the task in the standby state as a task to be moved preferentially.

Images