Job scheduling method and information processing equipment

Abstract

The invention provides a job scheduling method and information processing equipment. The computer identifies an update job to update the control software and two or more user jobs each having a specification for the number of nodes used and an expected execution time. The computer is based on the number of used nodes and expected execution time. The scheduling of the update job and the two or more user jobs is planned in a manner that each of the two or more user jobs is allocated to one or more nodes having the same version of the control software to reduce the total latency of the two or more user jobs. The computer controls an execution order of the update job and the two or more user jobs according to the planned schedule.

Description

Technical Field

[0001] The embodiments discussed herein relate to a job scheduling method and an information processing device. Background Art

[0002] One form of information processing system is a parallel processing system including a plurality of nodes capable of executing threads in parallel. The parallel processing system can be designed to accept a user job with a provision for the number of nodes to be used from a user, and allocate a specified number of available nodes to execute the user job. If the specified number of nodes is not available, the parallel processing system registers the user job in an execution waiting queue, and waits until the specified number of nodes are available. In view of the waiting time of the user job, the utilization efficiency of the node, etc., the parallel processing system allocates multiple user jobs to the nodes according to an appropriate scheduling algorithm.

[0003] In this regard, a patch application method has been proposed that applies a patch to an operating system (OS) of each computer during a time period when the computer is under low load and does not overlap with a time period for other computers. In addition, a software modification management device has been proposed that selects a certain number of idle nodes that have software that has not been updated and does not execute any job from a plurality of nodes, and updates the software on the selected idle nodes.

[0004] Further, a patch application method has been proposed in which a thread running in kernel mode checks a patch flag in response to a certain function being called, and jumps to a patch module when the patch flag has a specified value. Still further, a dynamic patching method has been proposed, which detects a kernel thread that uses a function to be patched and determines when the function becomes free.

[0005] Japanese Patent Publication No. 2003-15894

[0006] International Gazette Pamphlet No. WO 2008 / 126221

[0007] U.S. Patent Application Publication No. 2015 / 0178071

[0008] U.S. Patent Application Publication No. 2017 / 0010879

[0009] The parallel processing system can execute an update job for updating control software such as an OS or middleware on each of the multiple nodes. Since the nodes complete their currently executed user jobs at different times, the parallel processing system can allow the update job to be started on different nodes at different times.

[0010] However, if update jobs are started at different times on different nodes, the update jobs on some nodes may cause long delays in the execution of user jobs registered after the update jobs in the parallel processing system. Summary of the invention

[0011] According to one aspect, the present disclosure is directed to reducing waiting time for user jobs.

[0012] According to one aspect, a non-transitory computer-readable storage medium storing a computer program is provided, wherein the computer program causes a computer to perform processing, the processing comprising: identifying, among multiple execution waiting jobs, an update job that updates control software of a target node among multiple nodes and two or more user jobs, each having a provision for the number of nodes used and an expected execution time, wherein the number of nodes used indicates how many nodes are used among the multiple nodes; planning the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time, in a manner such that each of the two or more user jobs is assigned to one or more nodes among the multiple nodes that are available and have the same version of the control software, so as to reduce the total waiting time of the two or more user jobs; and controlling the execution order of the update job and the two or more user jobs according to the planned scheduling. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 is a diagram for describing an information processing apparatus according to a first embodiment;

[0014] Figure 2 An example of an information processing system according to a second embodiment is shown;

[0015] Figure 3 is a block diagram showing an example of a hardware configuration of a scheduler;

[0016] Figure 4 is a block diagram showing an example of a functional configuration of a scheduler;

[0017] Figure 5 is a block diagram showing an example of a functional configuration of a patch server;

[0018] Figure 6 A first job scheduling example is shown;

[0019] Figure 7 A second job scheduling example is shown;

[0020] Figure 8 An example of a worksheet is shown;

[0021] Fig. 9 An example of a node table is shown;

[0022] Fig.10 An example of a scheduling plan table for a first job is shown;

[0023] Fig.11 An example of a scheduling plan for subsequent jobs is shown;

[0024] Fig.12 A third job scheduling example is shown;

[0025] Fig.13 A fourth job scheduling example is shown;

[0026] Fig.14 A fifth job scheduling example is shown;

[0027] Fig.15 A sixth job scheduling example is shown;

[0028] Fig.16 A seventh job scheduling example is shown;

[0029] Fig.17 An eighth job scheduling example is shown;

[0030] Fig.18 is a flow chart illustrating an example process of patch job creation;

[0031] Fig.19 is a flow chart illustrating an example process for job acceptance;

[0032] Fig. 20 is a flow chart illustrating an example process for job scheduling; and

[0033] Fig.21 is a continuation of a flowchart illustrating an example process for job scheduling. DETAILED DESCRIPTION

[0034] Hereinafter, embodiments will be described with reference to the accompanying drawings.

[0035] First embodiment

[0036] A first embodiment will be described.

[0037] Figure 1 It is a diagram for describing the information processing apparatus according to the first embodiment.

[0038] In a parallel processing system including a plurality of nodes, the information processing apparatus 10 of the first embodiment performs job scheduling to allocate jobs to available nodes. The information processing apparatus 10 may be a client device or a server device. The information processing apparatus 10 may be referred to as a computer or a job scheduler.

[0039] The information processing apparatus 10 includes a storage unit 11 and a processing unit 12. The storage unit 11 may be a volatile semiconductor memory such as a random access memory (RAM) or a nonvolatile storage device such as a hard disk drive (HDD) or a flash memory.

[0040] For example, the processing unit 12 is a processor such as a central processing unit (CPU), a graphics processing unit (GPU), or a digital signal processor (DSP). The processing unit 12 may include an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), or other electronic circuits. For example, the processor executes a program stored in a memory such as a RAM (e.g., the storage unit 11). A group of processors may be referred to as a multiprocessor or simply a "processor".

[0041] The storage unit 11 stores job information indicating a plurality of execution waiting jobs. The job information may be stored in an execution waiting queue. The plurality of execution waiting jobs include one or more update jobs and two or more user jobs. For example, the one or more update jobs include update jobs 13 and 14, and the two or more user jobs include user jobs 15 and 16. The jobs are registered in the information processing device 10 in the order of update job 13, update job 14, user job 15, and user job 16.

[0042] An update job is to update the control software of a target node among multiple nodes. An update job may be referred to as a patch job. An update job may be to replace a program included in the control software. An update job may be to strengthen the security of the control software or to expand the functionality of the control software. The execution of the update job upgrades the version of the control software of the target node. Control software is basic software for running application software. Examples of control software include operating systems and middleware. "Version" is an attribute that identifies an updated copy of the control software and may be referred to as an edition or revision.

[0043] A user job is a job that is executed in response to a request from a user. A user job is executed using control software. A user job may include a user program created by a user. For a user job, the number of nodes used and the expected execution time are specified. The number of nodes used indicates how many nodes are used in parallel for the user job. The expected execution time is an estimate of the processing time from the start to the completion of the user job. The number of nodes used and the expected execution time may be specified by the user. In addition, the expected execution time may be estimated by the information processing device 10 based on similar user jobs in the past.

[0044] Here, since different jobs running on different nodes may be completed at different times, nodes may become available at different times. For this reason, the information processing device 10 does not force the update job to be executed on all nodes at the same time, but allows the update job to be executed on different nodes at different times. Note that different versions of the control software may exhibit different behaviors. Therefore, in the case where a user job uses two or more nodes, the information processing device 10 distributes the user job to nodes with the same version of the control software. Such two or more nodes with the same version are nodes that do not perform the update job or nodes that all perform the update job.

[0045] The processing unit 12 plans the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time of the two or more user jobs. At this time, the processing unit 12 plans the scheduling that satisfies the following constraints: the available nodes to be allocated to the same user job need to have the same version of the control software at the start time of the user job.

[0046] The processing unit 12 may preferably allocate the two or more user jobs to the available nodes in the order in which the two or more user jobs are registered in the information processing device 10. In addition, even in the case where the update job is registered in the information processing device 10 earlier than the user job, the processing unit 12 may prioritize the execution of the user job while delaying the update job. Note that in order to ensure nodes with the same version, the processing unit 12 may determine to execute the update job before the user job. Delaying the update job may sometimes reduce the waiting time of the two or more user jobs, and executing the update job first may result in a reduction in the waiting time of the two or more user jobs.

[0047] For example, for the first user job, the processing unit 12 calculates a plurality of first patterns that can ensure as many available nodes with the same version as the specified number of used nodes. Each of the plurality of first patterns indicates a node to be allocated to the first user job and a start time of the first user job. The plurality of first patterns may include a pattern in which the first user job is first executed while delaying the update job, and a pattern in which the update job is first executed and then the first user job is executed.

[0048] Thereafter, for the second user job, the processing unit 12 calculates one or more second patterns, which can ensure as many available nodes with the same version as the specified number of used nodes. One or more second patterns are calculated for each of the plurality of first patterns. As a schedule following a certain first pattern, the processing unit 12 calculates a second pattern that can allocate the second user job to the available nodes in consideration of the expected execution time of the first user job. Each of the one or more second patterns indicates the node to be allocated to the second user job and the start time of the second user job.

[0049] In the case where the update job is not executed in the first mode, the one or more second modes may include a mode in which the second user job is first executed while further delaying the update job, and a mode in which the update job is first executed and then the second user job is executed. In the manner described above, for example, the processing unit 12 plans a schedule including schedules 17 and 18. Schedule 17 executes user job 15, executes update job 13 and user job 16 after user job 15, and then executes update job 14 after user job 16. Schedule 18 executes update jobs 13 and 14, executes user job 15 after update jobs 13 and 14, and then executes user job 16 after user job 15.

[0050] The processing unit 12 calculates the total waiting time of two or more user jobs for each schedule. The waiting time is the length of time that passes from the current time or the reference time to the scheduled start time. The processing unit 12 can calculate the average waiting time by dividing the total waiting time by the number of user jobs. The processing unit 12 searches for a schedule to reduce the total waiting time. For example, the processing unit 12 selects a schedule with a minimum total waiting time or a minimum average waiting time from a plurality of planned schedules. The processing unit 12 then controls the execution order of the update job and the two or more user jobs according to the selected schedule.

[0051] For example, the processing unit 12 determines when to execute the update job during the execution of two or more user jobs. The processing unit 12 can instruct multiple nodes to execute the update job and the two or more user jobs according to the selected schedule. In addition, the processing unit 12 can store the selected schedule in a non-volatile storage device, display it on a display device, or send it to another information processing device.

[0052] As described above, the information processing device 10 of the first embodiment identifies an update job that updates the control software of a target node and two or more user jobs each having a provision for the number of nodes used and the expected execution time in the execution waiting job. The information processing device 10 plans the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time of the user jobs, in a manner such that each user job is assigned to an available node with the same version of the control software. At this time, the information processing device 10 plans the scheduling to reduce the total waiting time of the two or more user jobs. The information processing device 10 controls the execution order of the update job and the two or more user jobs according to the planned scheduling.

[0053] By using the above method, the information processing device 10 allows update jobs to be executed on nodes at different times. Compared with the case where the operation of the parallel processing system is temporarily suspended and the update jobs are executed on all nodes at the same time, the availability of the parallel processing system is improved. In addition, since the same user job is assigned to the nodes with the same version of the control software, the accurate calculation result of each user job is guaranteed.

[0054] In addition, even in the case where the update job is registered earlier than the user job, it is possible to delay the update job and execute the user job first. Compared with the case where the jobs are simply executed in the order of registration, this case suppresses the delay in the execution of the user job registered after the update job. In addition, the information processing device 10 selects a schedule with the minimum total waiting time of two or more user jobs. Therefore, compared with the case where only the waiting time of one user job immediately after the update job is considered, the average waiting time of the user job is reduced and the fairness between two or more user jobs waiting to be executed is improved. For example, the information processing device 10 can reduce the risk of minimizing the waiting time of the user job immediately after the update job and ultimately increasing the waiting time of its subsequent user jobs.

[0055] At this point, the update job may be a job placed at the top of the execution waiting queue, and two or more user jobs may be jobs placed after the update job in the execution waiting queue. This reduces the inefficiency caused by simply executing the jobs in the order of registration. In addition, the scheduling of multiple plans may include a scheduling for executing the update job before the user job and a scheduling for executing at least one of the user jobs before the update job. Therefore, the information processing device 10 is able to select a scheduling with the minimum total waiting time from the schedulings that define different execution timings of the update job.

[0056] In addition, the information processing device 10 can calculate a plurality of first patterns, each of which allocates the first user job to as many available nodes of the same version as the prescribed number of used nodes. Then, for each first pattern, the information processing device 10 can calculate a second pattern, each of which allocates the second user job to as many available nodes of the same version as the prescribed number of used nodes. By doing so, various schedules for allocating two or more user jobs to available nodes are planned in the order of priority of the two or more user jobs.

[0057] Second embodiment

[0058] A second embodiment will be described.

[0059] Figure 2 An example of the information processing system according to the second embodiment is shown.

[0060] The information processing system of the second embodiment includes a switch 31 , a client device 32 , a patch distribution server 33 , a login server 34 , a patch server 35 , a plurality of nodes including nodes 41 to 45 , and a scheduler 100 .

[0061] The switch 31, the client device 32, and the patch distribution server 33 are connected to the network 30. For example, the network 30 is a wide area data communication network such as the Internet. The login server 34, the patch server 35, the nodes 41 to 45, and the scheduler 100 are connected to the switch 31. The switch 31 is a wired communication device included in a local area network (LAN). The switch 31 transmits packets. The scheduler 100 corresponds to the information processing device 10 of the first embodiment.

[0062] Client device 32 is a client computer used by a user of the information processing system. Client device 32 logs into login server 34 via network 30. Client device 32 uses login server 34 to create a user job request that specifies a user program, the number of nodes used, and the maximum execution time.

[0063] The patch distribution server 33 is a server computer that distributes patches for the OS. Patches may sometimes be referred to as update programs or update modules. The patch distribution server 33 receives access via the network 30. In response to the access, the patch distribution server 33 sends the patch itself and specification information such as the version of the patch and the application requirements of the patch.

[0064] The login server 34 is a front-end server computer that accepts user access. The login server 34 authenticates the client device 32. When the authentication is successful, the login server 34 receives the specifications of the user program, the number of nodes used, the maximum execution time, etc. from the client device 32. The login server 34 creates a user job request based on these specifications and sends the user job request to the scheduler 100.

[0065] The patch server 35 is a server computer that applies a new patch to the nodes 41 to 45. Note that the information processing system may include a client computer used by an administrator instead of the patch server 35. In addition, the function of the patch server 35 may be incorporated into the scheduler 100.

[0066] The patch server 35 periodically accesses the patch distribution server 33 to determine whether a new patch has been distributed. When it is determined that a new patch has been distributed, the patch server 35 determines whether each node 41 to 45 meets the application requirements of the new patch. The patch server 35 creates a patch job request to apply the patch to the nodes that meet the application requirements, and sends the patch job request to the scheduler 100. Note that the patch job request is created for each node.

[0067] Nodes 41 to 45 are server computers that execute specific programs. Nodes 41 to 45 can be referred to as computing nodes. OS has been installed on nodes 41 to 45. The same user job or different user jobs can be assigned to nodes 41 to 45. Two or more user jobs are not assigned to the same node at the same time. In addition, patch jobs can be assigned to nodes 41 to 45. When a node is executing a patch job, no user job is assigned to the node until the patch job is completed.

[0068] The scheduler 100 is a server computer that performs job scheduling to allocate multiple jobs to the nodes 41 to 45. The scheduler 100 receives a user job request from the login server 34 and registers the user job at the end of the waiting job list. The scheduler 100 also receives a patch job request from the patch server 35 and registers the patch job at the end of the waiting job list.

[0069] The scheduler 100 monitors the job execution status of nodes 41 to 45. In principle, the scheduler 100 preferably distributes each job to one or more nodes in the order starting from the top of the waiting job list (i.e., in the order of arrival). In the case where the user job is placed at the top, when the number of available nodes becomes greater than or equal to the number of nodes used, the scheduler 100 distributes the user job to as many available nodes as the specified number of used nodes. Note that it is not allowed to distribute the same user job to nodes with different versions of OS. Therefore, the nodes distributed to the user job are nodes that are not patched or nodes that are all patched.

[0070] On the other hand, in the case where the patch job is placed at the top, when the patch application target node is available, the scheduler 100 causes its patch application target node to execute the patch job. However, note that the scheduler 100 may determine to temporarily delay the patch job and first execute the user job that arrives after the patch job, as will be described later.

[0071] Figure 3 is a block diagram showing an example of a hardware configuration of a scheduler.

[0072] The scheduler 100 includes a CPU 101, a RAM 102, a HDD 103, a GPU 104, an input interface 105, a medium reader 106, and a communication interface 107 connected to a bus. The CPU 101 corresponds to the processing unit 12 of the first embodiment. The RAM 102 or the HDD 103 corresponds to the storage unit 11 of the first embodiment. The client device 32, the patch distribution server 33, the login server 34, the patch server 35, and the nodes 41 to 45 can each have the same hardware configuration as the scheduler 100.

[0073] The CPU 101 is a processor that executes program commands. The CPU 101 loads a program and data from the HDD 103 to the RAM 102 and executes the program. The scheduler 100 may be provided with a plurality of processors.

[0074] The RAM 102 is a volatile semiconductor memory that temporarily stores programs executed by the CPU 101 and data used in processing by the CPU 101. The scheduler 100 may be provided with a volatile memory of a different type from the RAM.

[0075] The HDD 103 is a non-volatile storage device that stores software programs and other data. The software includes OS, middleware, application software, etc. The scheduler 100 may be provided with another type of non-volatile storage device, such as a flash memory or a solid state drive (SSD).

[0076] The GPU 104 performs image processing in cooperation with the CPU 101 and outputs an image to a display device 111 connected to the scheduler 100. Examples of the display device 111 include a cathode ray tube (CRT) display, a liquid crystal display, an organic electroluminescent (EL) display, and a projector. Another type of output device such as a printer may also be connected to the scheduler 100.

[0077] In addition, the GPU 104 may be used as a general purpose computing graphics processing unit (GPGPU). The GPU 104 can execute a program according to a command from the CPU 101. The scheduler 100 may be provided with a volatile semiconductor memory other than the RAM 102 as a GPU memory.

[0078] The input interface 105 receives an input signal from an input device 112 connected to the scheduler 100 . Examples of the input device 112 include a mouse, a touch panel, and a keyboard. Various types of input devices may be connected to the scheduler 100 .

[0079] The medium reader 106 is a reading device that reads programs and data from the storage medium 113. Examples of the storage medium 113 include a magnetic disk, an optical disk, and a semiconductor memory. The magnetic disk includes a floppy disk and an HDD. The optical disk includes a compact disk (CD) and a digital versatile disk (DVD). The medium reader 106 copies the program and data from the storage medium 113 to another storage medium such as the RAM 102 or the HDD 103. The read program can be executed by the CPU 101.

[0080] The storage medium 113 may be a portable storage medium. The storage medium 113 may be used to distribute programs and data. In addition, the storage medium 113 and the HDD 103 may be referred to as computer-readable storage media.

[0081] The communication interface 107 is a wired communication interface connected to the switch 31 with a cable. The communication interface 107 communicates with the login server 34, the patch server 35, and the nodes 41 to 45 via the switch 31. In this regard, the scheduler 100 may include a wireless communication interface connected to a wireless communication device such as a base station or an access point.

[0082] Figure 4 is a block diagram showing an example of a functional configuration of a scheduler.

[0083] The scheduler 100 includes a job information storage unit 121, a node information storage unit 122, a job history storage unit 123, and a patch history storage unit 124. These storage units are realized by using, for example, the RAM 102 or the HDD 103. In addition, the scheduler 100 includes a job acceptance unit 131, a job management unit 132, a node management unit 133, a job execution unit 134, an executability determination unit 135, a scheduling planning unit 136, a completion time determination unit 137, and a patch time determination unit 138. These processing units are realized by using the CPU 101, the communication interface 107, and a program.

[0084] The job information storage unit 121 stores information about execution waiting jobs and running jobs. The information about execution waiting jobs includes the job type, the number of nodes used, and the processing time. The job type is a patch job or a user job. The information about the running job includes the job type, the number of nodes used, the processing time, and the start time.

[0085] The node information storage unit 122 stores information indicating the current state of each node 41 to 45. The information about the current state includes the current version number of the OS. In addition, the information about the current state includes a flag indicating whether the node is available, and when the node is not available, it also includes the job name of the job running on the node.

[0086] The job history storage unit 123 stores the execution history of user jobs. The execution history includes job attribute information, such as the job name and program size. The execution history also includes the measurement value of the execution time of each user job. The patch history storage unit 124 stores the execution history of patch jobs. The execution history includes patch attribute information, such as version number and patch type. For example, the patch type indicates the purpose of the patch, such as function addition, security update, or vulnerability correction. The execution history also includes the measurement value of the execution time of each patch job.

[0087] The job accepting unit 131 accepts a user job request from the login server 34. The job accepting unit 131 also accepts a patch job request from the patch server 35. The job accepting unit 131 outputs the received job request to the job management unit 132.

[0088] The job management unit 132 manages information about execution of waiting jobs and running jobs. The job management unit 132 obtains a job request from the job acceptance unit 131, and registers a job based on the conditions specified by the job request at the end of the waiting job list. When the executability determination unit 135 determines that the job is executable, the job management unit 132 allocates the job to an available node. Then, the job management unit 132 deletes the job from the waiting job list, manages it as a running job, and issues an instruction for executing the job to the job execution unit 134.

[0089] The node management unit 133 collects and manages information about the current state from each node 41 to 45. The node management unit 133 may be designed to periodically access the nodes 41 to 45 to actively collect information. In addition, when any one of the nodes 41 to 45 has started a new job or completed the execution of a running job, the node management unit 133 may passively receive information from the nodes 41 to 45.

[0090] The job execution unit 134 causes the nodes 41 to 45 to execute the job in response to the instruction from the job management unit 132. More specifically, the job execution unit 134 issues a notification specifying the job name, the program to be executed, and the maximum execution time of the job to one or more nodes assigned to the job by the job management unit 132. The assigned node then activates the specified program. When the program stops or the maximum execution time is reached, the assigned node completes the job.

[0091] The executable determination unit 135 determines whether the execution waiting job registered in the waiting job list is executable. Regarding the user job, when the number of available nodes having the same version of OS is greater than or equal to the prescribed number of used nodes, the executable determination unit 135 determines that the user job is executable. Regarding the patch job, when the patch application target node is available, the executable determination unit 135 determines that the patch job is executable. However, it is noted that the executable determination unit 135 may determine to temporarily delay the executable patch job, as will be described later.

[0092] The scheduling planning unit 136 comprehensively creates multiple scheduling candidates, each of which assigns each single execution waiting job to a node to be used and specifies the start time of the execution waiting job. At this time, the scheduling planning unit 136 allows the later registered user job to be executed before the earlier registered patch job. However, in the second embodiment, the scheduling planning unit 136 does not perform backfilling that allows the later registered user job to be executed before the earlier registered user job. In addition, the scheduling planning unit 136 imposes the following requirement: the available nodes to be assigned to the same user job need to have the same version of OS at the start time of the user job.

[0093] The scheduling planning unit 136 selects a schedule with a minimum total waiting time of the user jobs from the plurality of scheduling candidates. The total waiting time is the sum of the remaining waiting time from the current time to the start time of each user job. In the schedule as described above, the scheduling planning unit 136 determines when to execute the execution waiting patch job during the execution of the execution waiting user job. The execution waiting patch job may be executed before all user jobs, may be executed after the execution of at least one of the user jobs, or may be delayed until all user jobs are completed.

[0094] The completion time determination unit 137 determines the completion time of running the user job. In principle, the completion time determination unit 137 calculates the completion time by adding the maximum execution time to the start time. Note that the completion time determination unit 137 may estimate the execution time with reference to the execution history of past user jobs. For example, the completion time determination unit 137 estimates the execution time of the user job based on the average execution time of past user jobs with similar job names.

[0095] In addition, for example, the completion time determination unit 137 estimates the execution time based on the size of the user program. Alternatively, the completion time determination unit 137 can estimate the execution time by obtaining the progress of the user job from the node assigned to the user job. For example, the information about the progress includes the execution amount of the program and the processing amount of data.

[0096] The patch time determination unit 138 determines the processing time of executing the waiting patch job. If the patch for a certain version has not been applied to any node, the patch time determination unit 138 estimates the processing time with reference to the execution history of the past patch jobs. For example, the patch time determination unit 138 estimates the processing time of the patch job based on the average execution time of the past patch jobs of the same patch type as the patch job. If the patch for a certain version has been applied to at least one node, the patch time determination unit 138 uses the execution time of the past patch jobs completed for the same version.

[0097] Figure 5 is a block diagram showing an example of a functional configuration of a patch server.

[0098] The patching server 35 includes a patch monitoring unit 141, a patch information receiving unit 142, a patch job creating unit 143, and a patch job requesting unit 144. These processing units are realized by using a CPU, a communication interface, and a program, for example.

[0099] The patch monitoring unit 141 periodically accesses the patch distribution server 33 to determine whether the patch distribution server 33 has started distributing a new patch.

[0100] When the patch monitoring unit 141 detects a new patch, the patch information receiving unit 142 receives specification information from the patch distribution server 33. The patch information receiving unit 142 determines whether each of the nodes 41 to 45 meets the application requirements. The application requirements include hardware requirements that the node needs to have specified hardware and software requirements that the node needs to have a specified version of software.

[0101] With respect to each node that meets the application requirements, the patch job creation unit 143 creates a patch job request for applying a new patch. The patch job request specifies the patch application target node and the patch itself. At this point, the patch itself can be received by the patching server 35 or by each node.

[0102] The patch job request unit 144 sends the patch job request created by the patch job creation unit 143 to the scheduler 100 .

[0103] Job scheduling is described below.

[0104] In the case where the waiting job list contains both patch jobs and user jobs, the following three scheduling methods are considered. The first scheduling method executes jobs in the order of registration in the waiting job list regardless of their type, whether they are patch jobs or user jobs. The second scheduling method determines whether to execute a patch job or delay a patch job to reduce the waiting time of a user job next to the patch job. The third scheduling method determines the time each patch job is delayed to reduce the total waiting time of all user jobs waiting to be executed at that point in time.

[0105] The first scheduling method may greatly increase the waiting time of user jobs registered after the patch job due to the execution of the patch job. The second scheduling method may increase the average waiting time of the waiting user jobs due to the reduction of the waiting time of the user jobs immediately adjacent to the patch job, which eventually increases the waiting time of the subsequent user jobs. For this reason, the scheduler 100 of the second embodiment adopts the third scheduling method for job scheduling.

[0106] Figure 6 A first job scheduling example is shown.

[0107] Graph 161 shows a schedule planned for the waiting job list 171 using the second scheduling method described above. Time t3 shows the current time. At time t3, node 41 is executing job b, node 42 is available, nodes 43 and 44 are executing job d, and node 45 is executing job e. Job b is completed at time t5, job d is completed at time t6, and job e is completed at time t7. The patch has been applied to nodes 41 and 45, but has not yet been applied to nodes 42 to 44.

[0108] The waiting job list 171 includes jobs p#2, p#3, p#4, f, g, h, and i in order. Job p#2 is a patch job for node 42, and the processing time is 4. Job p#3 is a patch job for node 43, and the processing time is 4. Job p#4 is a patch job for node 44, and the processing time is 4. Job f is a user job that specifies the number of nodes used as 3 and the maximum execution time as 2. Job g is a user job that specifies the number of nodes used as 4 and the maximum execution time as 2. Job h is a user job that specifies the number of nodes used as 3 and the maximum execution time as 1. Job i is a user job that specifies the number of nodes used as 5 and the maximum execution time as 3.

[0109] Using the second scheduling method, the scheduler 100 minimizes the waiting time of job f. To this end, the scheduler 100 waits for the completion of job d and allocates job f to nodes 42 to 44 at time t6 while delaying job p#2. After job f is completed at time t8, the scheduler 100 strives to minimize the waiting time of job g. At this time, since the number of nodes with the same version of OS is less than 4, the scheduler 100 determines to execute jobs p#2, p#3, and p#4.

[0110] After jobs p#2, p#3, and p#4 are completed at time t12, the scheduler 100 allocates job g to nodes 41 to 44. After job g is completed at time t14, the scheduler 100 allocates job h to nodes 41 to 43. After job h is completed at time t15, the scheduler 100 allocates job i to nodes 41 to 45.

[0111] Taking time t3 as a reference point, the schedule results in a waiting time of 3 for job f, 9 for job g, 11 for job h, and 12 for job i. Therefore, the total waiting time for executing waiting jobs f, g, h, and i is 35, and their average waiting time is calculated as 35 / 4=about 8.8.

[0112] Figure 7 A second job scheduling example is shown.

[0113] Graph 162 shows the schedule planned for the waiting job list 171 using the third scheduling method described above. The scheduler 100 determines to execute job p#2 at time t3. The scheduler 100 then determines to execute jobs p#3 and p#4 after job d is completed at time t6. After jobs p#2 and e are completed at time t7, the scheduler 100 allocates job f to nodes 41, 42, and 45.

[0114] After jobs p#3 and p#4 are completed at time t10, nodes 41 to 45 have the same version of OS. The scheduler 100 then distributes job g to nodes 41 to 44. After job g is completed at time t12, the scheduler 100 distributes job h to nodes 41 to 43. After job h is completed at time t13, the scheduler 100 distributes job i to nodes 41 to 45.

[0115] Taking time t3 as a reference point, this schedule results in a waiting time of 4 for job f, 7 for job g, 9 for job h, and 10 for job i. Therefore, the total waiting time for executing waiting jobs f, g, h, and i is 30, and the average waiting time thereof is calculated as 30 / 4=7.5. Compared with graph 161, the waiting time for job f is long. However, nodes 41 to 45 are able to have the same version of OS earlier, which reduces the waiting time for jobs g, h, and i, and correspondingly reduces the average waiting time for jobs f, g, h, and i.

[0116] The following describes how the schedule represented by diagram 162 is planned.

[0117] Figure 8 An example of a work table is shown.

[0118] The scheduler 100 stores a job table 151. The job table 151 has a plurality of records, each of which has the following items: job name, job type, number of nodes used, processing time, and job status. One record corresponds to one job. The job name identifies the job. Patch jobs for different application target nodes are considered different jobs. The job type is a patch job or a user job.

[0119] The number of nodes used for a user job is specified by the user. The number of nodes used for a patch job is 1. The processing time of a user job is the maximum execution time specified by the user or the execution time estimated by the scheduler 100. The processing time of a patch job is the execution time measured by applying the same patch on the node for the first time or by applying another similar patch in the past. The completion time of each job is estimated by adding its processing time to the start time of the job. The job status is one of waiting, running, and completed.

[0120] Fig. 9 An example of a node table is shown.

[0121] The scheduler 100 stores a node table 152. The node table 152 has a plurality of records corresponding to nodes 41 to 45, respectively. Each record has the following items: a node number and an OS version. The node number identifies the node. The OS version indicates the version of the OS. When a patch is applied, the OS version is incremented. Therefore, the OS version of the patched node is greater than the OS version of the unpatched node.

[0122] Fig.10 An example of a scheduling plan for the first job is shown.

[0123] First, the scheduler 100 schedules job f, which is the first user job. In this way, the scheduler 100 creates a separate scheduling candidate for job f in its entirety. Separate scheduling is scheduling for a single job and forms part of scheduling for all execution waiting job plans. At this point, regarding patch jobs p#2, p#3, and p#4, the scheduler 100 only needs to determine appropriate execution timing through scheduling of user jobs f, g, h, and i, and does not need to perform independent scheduling for them.

[0124] The scheduler 100 creates a scheduling schedule table 153. The scheduling schedule table 153 comprehensively contains individual scheduling candidates that are executable plans for job f. Since job f specifies that the number of nodes used is 3, 10 individual scheduling candidates are considered as a result of selecting 3 nodes from nodes 41 to 45. The selected 3 nodes do not always have the same version of OS. If the nodes do not have the same version of OS and the patch job that adjusts their OS versions has not been executed, the scheduler 100 creates an individual scheduling candidate that executes the patch job before job f.

[0125] Each individual scheduling candidate has the following items: number, node, node to be patched, patch duration, job duration, and wait time. The number identifies the individual scheduling candidate. Node specifies one or more nodes to be assigned to the job in question (here job f). Node to be patched specifies the node that needs to perform the patch job before the job in question among the one or more nodes to be assigned.

[0126] The patch duration is the length of time from the current time to the scheduled completion time at which the patch job of the node to be patched is scheduled to be completed. In the case of two or more nodes to be patched, the patch duration is calculated based on the latest scheduled completion time. The job duration is the length of time from the current time to the scheduled completion time at which the running job is scheduled to be completed. In the case of different jobs running on different nodes in the nodes to be assigned, the job duration is calculated based on the latest scheduled completion time. The waiting time is the length of time from the current time to the possible start time of the job in question and is the larger of the patch duration or the job duration.

[0127] After creating the scheduling schedule table 153 , the scheduler 100 comprehensively creates an individual scheduling candidate for the next job g, premised on each of the 10 individual scheduling candidates included in the scheduling schedule table 153 .

[0128] Here, the third and seventh individual scheduling candidates are considered. The third individual scheduling candidate is to make node 42 execute job p#2 and allocate job f to nodes 41, 42, and 45. In this case, the waiting time of job f is 4. On the other hand, the seventh individual scheduling candidate allocates job f to nodes 42 to 44. Jobs p#2, p#3, and p#4 are not executed before job f. In this case, the waiting time of job f is 3, which is less than the waiting time of the third individual scheduling candidate.

[0129] Fig.11 An example of a scheduling plan for subsequent jobs is shown.

[0130] The scheduler 100 creates a scheduling plan table 154. The scheduling plan table 154 comprehensively includes individual scheduling candidates that are executable plans for job g, assuming that job f is executed according to the seventh individual scheduling candidate.

[0131] Since job g specifies that the number of nodes used is 4, 5 individual scheduling candidates are considered as a result of selecting 4 nodes from nodes 41 to 45. In this case, the patch has been applied to nodes 41 and 45, but has not yet been applied to nodes 42 to 44. Therefore, all 5 individual scheduling candidates have nodes to be patched. Therefore, the patch duration of all individual scheduling candidates is 9 and the waiting time is 9.

[0132] In addition, the scheduler 100 creates a scheduling schedule 155. The scheduling schedule 155 comprehensively contains the individual scheduling candidates that are executable plans for job g, assuming that job f is executed according to the third individual scheduling candidate. In this case, the patch has been applied to nodes 41, 42, and 45, but has not been applied to nodes 43 and 44. Therefore, all 5 individual scheduling candidates have nodes to be patched. Therefore, the patch duration of all individual scheduling candidates is 7 and the waiting time is 7.

[0133] As can be seen above, in view of the waiting time of job f, the seventh individual scheduling candidate is more favorable than the third individual scheduling candidate. On the other hand, in view of the waiting time of job g, selecting the third individual scheduling candidate for job f is more favorable than selecting the seventh individual scheduling candidate. Therefore, from the perspective of executing the waiting user jobs as a whole, selecting the seventh individual scheduling candidate for job f is not necessarily a better choice.

[0134] Similarly, the scheduler 100 comprehensively creates individual scheduling candidates for job h, based on each of the individual scheduling candidates created for job g. Since job h specifies that the number of nodes used is 3, 10 individual scheduling candidates are considered as a result of selecting 3 nodes from nodes 41 to 45. Then, the scheduler 100 comprehensively creates individual scheduling candidates for job i, based on each of the individual scheduling candidates for job h. Since job i specifies that the number of nodes used is 5, one individual scheduling candidate is considered as a result of selecting 5 nodes from nodes 41 to 45.

[0135] The scheduler 100 calculates the total waiting time of jobs f, g, h, and i for each scheduling candidate that is a combination of the individual scheduling candidates created for jobs f, g, h, and i. A plurality of scheduling candidates may be found using a tree structure. The scheduler 100 selects a schedule with a minimum total waiting time from the plurality of scheduling candidates. If there is a patch job whose start time has not yet been determined, the scheduler 100 may place the patch job after job i. Alternatively, the scheduler 100 may insert the patch job at idle time during the execution of jobs f, g, h, and i if the insertion does not result in any difference in the OS version for the subsequent jobs.

[0136] The scheduler 100 controls the execution of jobs p#2, p#3, p#4, f, g, h, and i according to the selected schedule. For example, the scheduler 100 causes the node 42 to execute job p#2 at time t3. The selected schedule is used until the scheduler 100 performs a rescheduling. For example, the scheduler 100 performs a rescheduling when a new job is registered in the waiting job list 171 or when the running job is completed.

[0137] The following describes Figure 6 and Figure 7 The following description involves comparing the results of the first scheduling method, the second scheduling method, and the third scheduling method described above.

[0138] Fig.12 A third job scheduling example is shown.

[0139] Graph 163 shows a schedule planned for the waiting job list 172 using the first scheduling method described above. Time t1 shows the current time. At time t1, nodes 41 to 45 are available. Patches have been applied to nodes 41 and 45, but have not yet been applied to nodes 42 to 44.

[0140] The waiting job list 172 includes jobs p#2, p#3, p#4, b, c, d, e, f, g, h, and i in order. Job p#2 is a patch job for node 42, and the processing time is 4. Job p#3 is a patch job for node 43, and the processing time is 4. Job p#4 is a patch job for node 44, and the processing time is 4.

[0141] Job b is a user job that specifies that the number of nodes used is 1 and the maximum execution time is 4. Job c is a user job that specifies that the number of nodes used is 1 and the maximum execution time is 2. Job d is a user job that specifies that the number of nodes used is 2 and the maximum execution time is 5. Job e is a user job that specifies that the number of nodes used is 1 and the maximum execution time is 6. Job f is a user job that specifies that the number of nodes used is 3 and the maximum execution time is 2. Job g is a user job that specifies that the number of nodes used is 4 and the maximum execution time is 2. Job h is a user job that specifies that the number of nodes used is 3 and the maximum execution time is 1. Job i is a user job that specifies that the number of nodes used is 5 and the maximum execution time is 3.

[0142] The first scheduling method executes jobs p#2, p#3, p#4, b, c, d, e, f, g, h, and i in the order of registration, regardless of whether their types are patch jobs or user jobs. The scheduler 100 causes nodes 42 to 44 to execute jobs p#2, p#3, and p#4 at time t1. In addition, the scheduler 100 assigns job b to node 41, and assigns job c to node 45.

[0143] After jobs p#2, p#3, p#4, and b are completed at time t5, the scheduler 100 allocates job d to nodes 41 and 42 and allocates job e to node 43. After job d is completed at time t10, the scheduler 100 allocates job f to nodes 41, 42, and 44. After job f is completed at time t12, the scheduler 100 allocates job g to nodes 41 to 44. After job g is completed at time t14, the scheduler 100 allocates job h to nodes 41 to 43. After job h is completed at time t15, the scheduler 100 allocates job i to nodes 41 to 45.

[0144] Taking time t1 as a reference point, this schedule results in a waiting time of zero for jobs b and c. In addition, the waiting time for job d is 4, the waiting time for job e is 4, the waiting time for job f is 9, the waiting time for job g is 11, the waiting time for job h is 13, and the waiting time for job i is 14. Therefore, the total waiting time for executing waiting jobs b, c, d, e, f, g, h, and i is 55, and their average waiting time is calculated to be 55 / 8=about 6.9.

[0145] Fig.13 A fourth job scheduling example is shown.

[0146] Graph 164 shows a schedule planned using the second scheduling method for the waiting job list 172. At time t1, the scheduler 100 assigns job b to node 41, job c to node 42, job d to nodes 43 and 44, and job e to node 45. Since jobs b, c, d, and e can be executed immediately, the scheduler 100 delays jobs p#2, p#3, and p#4.

[0147] After job d is completed at time t6, the scheduler 100 distributes job f to nodes 42 to 44. After job f is completed at time t8, the scheduler 100 causes nodes 42 to 44 to execute jobs p#2, p#3, and p#4 because there are only three nodes with the same version of OS. After jobs p#2, p#3, and p#4 are completed at time t12, the scheduler 100 distributes job g to nodes 41 to 44.

[0148] After job g is completed at time t14, the scheduler 100 distributes job h to nodes 41 to 43. After job h is completed at time t15, the scheduler 100 distributes job i to nodes 41 to 45. In this regard, the graph 164 corresponds to the process started at time t1 by Figure 6 The diagram 161 shows the schedule.

[0149] Taking time t1 as a reference point, this schedule results in a waiting time of zero for jobs b, c, d, and e. In addition, the waiting time for job f is 5, the waiting time for job g is 11, the waiting time for job h is 13, and the waiting time for job i is 14. Therefore, the total waiting time for executing waiting jobs b, c, d, e, f, g, h, and i is 43, and their average waiting time is calculated as 43 / 8=about 5.4.

[0150] Fig.14 A fifth job scheduling example is shown.

[0151] Graph 165 shows the schedule planned using the third scheduling method for waiting job list 172. At time t1, scheduler 100 assigns job b to node 41, job c to node 42, job d to nodes 43 and 44, and job e to node 45.

[0152] After job c is completed at time t3, the scheduler 100 causes node 42 to execute job p#2. After job d is completed at time t6, the scheduler 100 causes nodes 43 and 44 to execute jobs p#3 and p#4. After jobs p#2 and e are completed at time t7, the scheduler 100 distributes job f to nodes 41, 42, and 45.

[0153] After jobs p#3 and p#4 are completed at time t10, the scheduler 100 allocates job g to nodes 41 to 44. After job g is completed at time t12, the scheduler 100 allocates job h to nodes 41 to 43. After job h is completed at time t13, the scheduler 100 allocates job i to nodes 41 to 45. In this regard, the graph 165 corresponds to the process started at time t1 by Figure 7 The diagram 162 shows the schedule.

[0154] Taking time t1 as a reference point, this schedule results in a waiting time of zero for jobs b, c, d, and e. In addition, the waiting time for job f is 6, the waiting time for job g is 9, the waiting time for job h is 11, and the waiting time for job i is 12. Therefore, the total waiting time for executing waiting jobs b, c, d, e, f, g, h, and i is 38, and the average waiting time thereof is calculated as 38 / 8=about 4.8. The schedule represented by graph 165 provides a shorter average waiting time than the schedules represented by graphs 163 and 164.

[0155] Fig.15 A sixth job scheduling example is shown.

[0156] Graph 166 shows the schedule planned for the waiting job list 173 using the first scheduling method described above. Time t3 indicates the current time. At time t3, node 41 is executing job b, node 42 is executing job p#2, node 43 is executing job p#3, node 44 is executing job p#4, and node 45 is available. Jobs b, p#2, p#3, and p#4 are completed at time t5. The patch has been applied to nodes 41 and 45, and is currently applied to nodes 42 to 44.

[0157] The waiting job list 173 includes jobs d, e, f, g, h, and i in sequence. Job d is a user job that specifies the number of nodes used as 2 and the maximum execution time as 5. Job e is a user job that specifies the number of nodes used as 1 and the maximum execution time as 6. Job f is a user job that specifies the number of nodes used as 3 and the maximum execution time as 2. Job g is a user job that specifies the number of nodes used as 3 and the maximum execution time as 2. Job h is a user job that specifies the number of nodes used as 1 and the maximum execution time as 3. Job i is a user job that specifies the number of nodes used as 4 and the maximum execution time as 3.

[0158] At time t3, there is a lack of available nodes for executing job d. After jobs b, p#2, p#3, and p#4 are completed at time t5, the scheduler 100 allocates job d to nodes 41 and 42, and allocates job e to node 43. After job d is completed at time t10, the scheduler 100 allocates job f to nodes 41, 42, and 44. After job f is completed at time t12, the scheduler 100 allocates job g to nodes 41, 42, and 44, and allocates job h to node 45. After job g is completed at time t14, the scheduler 100 allocates job i to nodes 41 to 44.

[0159] Taking time t3 as a reference point, the schedule results in a waiting time of 2 for job d, 2 for job e, 7 for job f, 9 for job g, 9 for job h, and 11 for job i. Therefore, the total waiting time for executing waiting jobs d, e, f, g, h, and i is 40, and their average waiting time is calculated as 40 / 6=about 6.7.

[0160] Fig.16 A seventh job scheduling example is shown.

[0161] Graph 167 shows a schedule planned for the waiting job list 174 using the second scheduling method described above. Time t3 shows the current time. Since a different scheduling method is used, the state of the nodes 41 to 45 at time t3 is different from the state shown in graph 166.

[0162] At time t3, node 41 is executing job b, node 42 is available, nodes 43 and 44 are executing job d, and node 45 is executing job e. Job b is completed at time t5, job d is completed at time t6, and job e is completed at time t7. The patch has been applied to nodes 41 and 45, but has not yet been applied to nodes 42 to 44. The waiting job list 174 contains jobs p#2, p#3, p#4, f, g, h, and i in order. The details of jobs b, c, d, e, f, g, h, i are as follows: Fig.15 Same as what you see.

[0163] At time t3, the scheduler 100 determines to delay job p#2 in order to execute job f early. After job d is completed at time t6, the scheduler 100 allocates job f to nodes 42 to 44. After job f is completed at time t8, the scheduler 100 allocates job g to nodes 42 to 44 and allocates job h to node 45.

[0164] After job g is completed at time t10, the scheduler 100 causes the nodes 42 to 44 to execute jobs p#2, p#3, and p#4. After jobs p#2, p#3, and p#4 are completed at time t14, the scheduler 100 distributes job i to the nodes 41 to 44.

[0165] Taking time t3 as the reference point, the schedule results in job f's waiting time being 3, job g's waiting time being 5, job h's waiting time being 5, and job i's waiting time being 11. Therefore, the total waiting time for executing waiting jobs f, g, h, and i is 24, and their average waiting time is calculated as 24 / 6=4.

[0166] Fig.17 An eighth job scheduling example is shown.

[0167] Graph 168 shows the schedule planned using the third scheduling method for the waiting job list 174. At time t3, the scheduler 100 causes the node 42 to execute job p#2. After job d is completed at time t6, the scheduler 100 causes the node 43 to execute job p#3.

[0168] After jobs p#2 and e are completed at time t7, the scheduler 100 allocates job f to nodes 41, 42, and 45. After job f is completed at time t9, the scheduler 100 allocates job g to nodes 41, 42, and 45, and allocates job h to node 44. After job g is completed at time t11, the scheduler 100 allocates job i to nodes 41 to 43 and 45. After job h is completed at time t12, the scheduler 100 allocates node 44 to job p#4.

[0169] Taking time t3 as a reference point, the schedule results in a waiting time of 4 for job f, a waiting time of 6 for job g, a waiting time of 6 for job h, and a waiting time of 8 for job i. Therefore, the total waiting time for executing waiting jobs f, g, h, and i is 24, and the average waiting time thereof is calculated as 24 / 6=4. As can be seen above, the schedule represented by graph 168 provides a shorter average waiting time than the schedule represented by graph 166 and the same average waiting time as the schedule represented by graph 167. In addition, the completion time of job i, which is the last user job, is earlier than the completion time indicated in graph 167.

[0170] The following describes how the information handling system operates.

[0171] Fig.18 is a flow chart illustrating an example process of patch job creation.

[0172] S10 : The patch monitoring unit 141 accesses the patch distribution server 33 to confirm whether the patch distribution server 33 has started distributing a new patch.

[0173] S11: The patch monitoring unit 141 determines whether a new patch exists. If a new patch exists, the process proceeds to step S12; otherwise, the process is completed.

[0174] S12: The patch information receiving unit 142 receives specification information about a new patch. The patch information receiving unit 142 selects a node. The patch information receiving unit 142 determines whether the selected node is a patch application target. If the selected node is a patch application target, the process proceeds to step S13; otherwise, the process proceeds to step S17.

[0175] S13: The patch job creation unit 143 determines the urgency of the patch based on the specification information.

[0176] S14: The patch job creation unit 143 creates a patch job request for updating the OS of the node selected at step S12. The patch job request specifies the patch application target node and the update program to be executed.

[0177] S15: The patch job creation unit 143 gives priority to the patch job request based on the urgency determined at step S13. For example, in the case where the urgency of the patch is determined to be high, the patch job creation unit 143 gives priority indicating a high urgency level to the patch job request. In the case where the urgency of the patch is determined to be medium or low, the patch job creation unit 143 gives priority indicating a normal urgency level to the patch job request.

[0178] S16 : The patch job request unit 144 sends the patch job request created through steps S13 to S15 to the scheduler 100 .

[0179] S17: The patch information receiving unit 142 determines whether all nodes have been checked at step S12. If all nodes have been checked, the process is completed; otherwise, the process returns to step S12 to select another node.

[0180] Fig.19 is a flow chart illustrating an example process for job acceptance.

[0181] S20: The job accepting unit 131 receives a job request. The received job request is a patch job request as described above or a user job request from the login server 34. The user job request specifies a user program, the number of nodes used, and the maximum execution time.

[0182] S21: The job management unit 132 registers the job specified by the job request received at step S20 at the end of the waiting job list.

[0183] S22: The job management unit 132 sorts the jobs registered in the waiting job list in descending order of priority. In the waiting job list, jobs with a high urgency level are arranged before jobs with a normal urgency level. Jobs with the same priority are arranged in the order of registration.

[0184] Fig. 20 is a flow chart illustrating an example process for job scheduling.

[0185] For example, the job schedule is triggered by adding a new job to the waiting job list or by the completion of any of the running jobs.

[0186] S30: The scheduling planning unit 136 checks the waiting job list.

[0187] S31: The scheduling unit 136 determines whether the waiting job list contains a patch job. If the waiting job list contains a patch job, the process proceeds to step S32; otherwise, the process proceeds to step S35.

[0188] S32: The scheduling unit 136 selects all patch jobs from the waiting job list and executes the following steps S33 and S34 for each patch job.

[0189] S33: The scheduling unit 136 determines whether the priority of the patch job is a high urgency level. If the priority is a high urgency level, the process proceeds to step S34; if the priority is a normal urgency level, the process proceeds to step S35.

[0190] S34: The scheduling planning unit 136 determines a separate schedule for each patch job whose priority is a high emergency level before the user job and other patch jobs. The separate schedule specifies the earliest time when the patch application target node becomes available next time as the start time. This allows the patch job to be executed at the earliest possible time.

[0191] S35: The scheduling unit 136 determines whether the waiting job list contains a user job. If the waiting job list contains a user job, the process proceeds to step S36; otherwise, the process proceeds to step S43.

[0192] S36: The scheduling unit 136 selects a first user job from the waiting job list. The first user job is the user job placed closest to the top of the waiting job list among the user jobs, that is, the user job registered earliest in the waiting job list.

[0193] S37: The scheduling planning unit 136 creates a separate scheduling candidate for the selected user job. Fig.10 The described method comprehensively creates a pattern of selecting as many nodes as the specified number of used nodes. Each individual scheduling candidate specifies the node and start time to be assigned to the user job. In the case where an individual schedule for any patch job is first determined at step S34, the scheduling planning unit 136 creates an individual scheduling candidate for the user job so as not to cause any conflict with the determined individual schedule. The individual scheduling candidate can first execute the patch job to adjust the version of the OS.

[0194] S38: The scheduling unit 136 determines whether the waiting job list contains a user job after the currently selected user job. If the waiting job list contains a subsequent user job, the process proceeds to step S39; if the waiting job list does not contain any subsequent user job, the process proceeds to step S41. The latter case is the case where the currently selected user job is a user job placed at the end.

[0195] S39: The scheduling unit 136 selects the next user job from the waiting job list. The next user job is a user job registered immediately after the currently selected user job in the waiting job list.

[0196] S40: The scheduling planning unit 136 creates a separate scheduling candidate for the user job selected in step S39. Here, the scheduling planning unit 136 uses the reference Fig.11 The described method comprehensively creates a pattern of selecting as many nodes as the specified number of used nodes for each individual scheduling candidate created for a previous user job. The individual scheduling candidate may first perform a patch job to adjust the version of the OS. The process then proceeds to step S38.

[0197] Fig.21 is a continuation of a flowchart illustrating an example process for job scheduling.

[0198] S41: After creating individual scheduling candidates for all user jobs in order from the first user job to the last user job, the scheduling planning unit 136 creates scheduling candidates that combine one individual scheduling candidate for each individual user job. The scheduling planning unit 136 calculates the total waiting time of the user job for each of the multiple scheduling candidates.

[0199] S42: The schedule planning unit 136 adopts a schedule with the smallest total waiting time among multiple schedule candidates.

[0200] S43: The schedule planning unit 136 determines whether a separate schedule has been determined for each patch job included in the waiting job list based on the schedule adopted at step S42. The separate schedule for the patch job may be determined at step S34 or during step S37 or step S40. If separate schedules have been determined for all patch jobs, the process proceeds to step S45. If there is a patch job for which a separate schedule has not been determined, the process proceeds to step S44.

[0201] S44: The scheduling unit 136 determines a separate schedule for each remaining patch job for which a separate schedule has not yet been determined. At this point, the scheduling unit 136 determines whether there is a sufficiently long idle time between user jobs for executing the remaining patch jobs. If such an idle time is found, and executing the patch job in the idle time does not result in any difference in the OS version for subsequent user jobs, the scheduling unit 136 places the patch job in the idle time. Otherwise, the scheduling unit 136 places the patch job after the last executed user job on the patch application target node of the patch job.

[0202] S45: The executability determination unit 135 causes the nodes 41 to 45 to execute the patch job and the user job according to the schedule determined by steps S42 to S44. The jobs are assigned to the nodes based on the number of nodes used and the start time specified by the schedule. The schedule is used until it is updated by any of the above circumstances.

[0203] At this point, the scheduler 100 may output the determined schedule. The scheduler 100 may store the determined schedule in a nonvolatile storage device, display it on the display device 111, or transmit it to another information processing apparatus.

[0204] As described above, the scheduler 100 of the second embodiment allows patch jobs to be executed on nodes at different start times, rather than being executed on all nodes at the same time. This allows the administrator to operate the information processing system without interruption, which improves the availability of the information processing system. In addition, the scheduler 100 distributes user jobs that use two or more nodes to nodes with the same version of OS. This mitigates errors and unexpected behaviors caused by version differences.

[0205] In addition, even if the patch job placed at the top of the waiting job list is executable and the subsequent user job is not yet executable, the scheduler 100 can determine to delay the patch job and wait until the user job becomes executable. This reduces the risk of significantly increasing the waiting time of the user job due to executing the patch job.

[0206] Furthermore, the scheduler 100 plans a schedule that minimizes the total waiting time of multiple user jobs and determines when to execute the patch job. Compared with the case of focusing only on the waiting time of the user job immediately after the patch job, the method achieves overall optimization and a reduction in the average waiting time of the user jobs. The method also reduces the risk that reducing the waiting time of at least one user job ultimately increases the waiting time of other user jobs, and thus improves the fairness of waiting time among multiple user jobs. In addition, the scheduler 100 comprehensively plans executable scheduling candidates by linking together the individual scheduling candidates created for the individual user jobs in the order of the user jobs on the waiting job list. This enables accurate determination of the schedule that minimizes the total waiting time.

[0207] According to one aspect, waiting time for a user's job is reduced.

Claims

1. A non-transitory computer-readable storage medium storing a computer program, the computer program causing a computer to perform a process, the process comprising: identifying, among a plurality of execution waiting jobs, an update job that updates control software of a target node among a plurality of nodes and two or more user jobs each having a specification of a number of nodes used and an expected execution time, the number of nodes used indicating how many nodes are used among the plurality of nodes; planning the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time in a manner that each of the two or more user jobs is assigned to one or more nodes among the plurality of nodes that are available and have the same version of the control software to reduce a total waiting time of the two or more user jobs; as well as An execution order of the update job and the two or more user jobs is controlled according to a planned schedule.

2. The non-transitory computer-readable storage medium of claim 1, wherein: The update job is placed at the top of an execution waiting queue containing the plurality of execution waiting jobs, and the two or more user jobs are placed after the update job in the execution waiting queue.

3. The non-transitory computer-readable storage medium of claim 1, wherein: The schedule is selected from a plurality of schedules including a first schedule for executing the update job earlier than executing the two or more user jobs and a second schedule for executing at least one of the two or more user jobs earlier than executing the update job.

4. The non-transitory computer-readable storage medium of claim 1, wherein: The plan includes: calculating a plurality of first patterns, each of the plurality of first patterns distributing a first user job among the two or more user jobs to as many nodes having the same version as the number of nodes used by the first user job; and A second pattern is calculated for each of the plurality of first patterns, the second pattern distributing a second user job among the two or more user jobs to as many nodes having the same version as the number of nodes used by the second user job.

5. A job scheduling method executed by a computer, the job scheduling method comprising: identifying, among a plurality of execution waiting jobs, an update job that updates control software of a target node among a plurality of nodes and two or more user jobs each having a specification of a number of nodes used and an expected execution time, the number of nodes used indicating how many nodes are used among the plurality of nodes; planning the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time in a manner that each of the two or more user jobs is assigned to one or more nodes among the plurality of nodes that are available and have the same version of the control software to reduce a total waiting time of the two or more user jobs; as well as An execution order of the update job and the two or more user jobs is controlled according to a planned schedule.

6. An information processing device, comprising: A storage device, the storage device being used to: store job information indicating a plurality of execution waiting jobs, the plurality of execution waiting jobs including an update job for updating control software of a target node among a plurality of nodes and two or more user jobs each having a provision for a number of nodes used and an expected execution time, the number of nodes used indicating how many nodes are used among the plurality of nodes; as well as A processing device, the processing device is used to: plan the scheduling of the update job and the two or more user jobs based on the number of nodes used and the expected execution time, in a way that each of the two or more user jobs is allocated to one or more nodes among the multiple nodes that are available and have the same version of the control software to reduce the total waiting time of the two or more user jobs, and control the execution order of the update job and the two or more user jobs according to the planned schedule.

Images