Job scheduling program, job scheduling method, and information processing apparatus

Abstract

To reduce waiting time of user jobs.SOLUTION: A computer identifies an update job of updating a control software and two or more user jobs with the number of used nodes and expected execution time which are designated respectively. The computer searches for a schedule of the update job and two or more user jobs so as to reduce the total waiting time of the two or more user jobs on the basis of the number of used nodes and expected execution time such that each of the two or more user jobs is assigned to nodes with the same version of the control software. The computer controls the order of execution of the update job and two or more user jobs on the basis of the searched schedule.SELECTED DRAWING: Figure 1

Description

[Technical field]

[0001] The present invention relates to a job scheduling program, a job scheduling method, and an information processing apparatus. [Background technology]

[0002] One type of information processing system is a parallel processing system that includes multiple nodes that can execute threads in parallel. The parallel processing system may accept a user job from a user with a specified number of nodes to be used, and execute the user job by allocating the specified number of free nodes to the user job. If the specified number of free nodes are not available, the parallel processing system registers the user job in an execution queue and waits until the specified number of free nodes can be secured. The parallel processing system allocates nodes to multiple user jobs according to an appropriate scheduling algorithm, taking into account factors such as the waiting time of the user job and the efficiency of node usage.

[0003] A patch application method has been proposed in which an OS (Operating System) patch is applied to each of a number of computers during a time period when the load on that computer is low and does not overlap with that of other computers.A software modification management device has also been proposed in which a certain number of free nodes, whose software has not been updated and which are not executing jobs, are selected from a number of nodes, and the software of the selected free nodes is updated.

[0004] A patch application method has also been proposed in which a thread running in kernel mode checks a patch flag when a certain function is called, and jumps to a patch module if the patch flag has a specific value.A dynamic patch application method has also been proposed in which kernel threads that use a function to be patched are detected, and when the function becomes free. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] JP 2003-15894 A [Patent Document 2] International Publication No. 2008 / 126221 [Patent Document 3] US Patent Application Publication No. 2015 / 0178071 [Patent Document 4] US Patent Application Publication No. 2017 / 0010879 Summary of the Invention [Problem to be solved by the invention]

[0006] A parallel processing system may execute an update job for updating control software such as an OS or middleware for each of a plurality of nodes. At this time, since the time at which an active user job ends differs depending on the node, the parallel processing system may allow update jobs to be started at different times depending on the node.

[0007] However, if the start times of update jobs differ depending on the nodes, the update jobs of some nodes may cause user jobs that are registered in the parallel processing system after the update jobs to wait for a long time. Therefore, in one aspect, the present invention aims to shorten the waiting time of user jobs. [Means for solving the problem]

[0008] In one aspect, a job scheduling program is provided that causes a computer to execute the following process: From a plurality of jobs waiting to be executed, an update job for updating control software of a target node among a plurality of nodes and two or more user jobs each specifying a number of nodes to be used indicating the number of nodes to be used among the plurality of nodes and a scheduled execution time are identified; A schedule for the update job and the two or more user jobs is searched for based on the number of nodes to be used and the scheduled execution time so as to reduce the total waiting time of the two or more user jobs, so that a node that is free among the plurality of nodes and has a common version of control software is assigned to each of the two or more user jobs; An execution order of the update job and the two or more user jobs is controlled based on the searched schedule.

[0009] According to another aspect, there is provided a job scheduling method executed by a computer, and an information processing device having a storage unit and a processing unit. Effect of the Invention

[0010] On the one hand, the waiting time for user jobs is reduced. [Brief description of the drawings]

[0011] [Figure 1] FIG. 1 is a diagram illustrating an information processing device according to a first embodiment. [Diagram 2] FIG. 11 illustrates an example of an information processing system according to a second embodiment. [Diagram 3] FIG. 2 is a block diagram showing an example of hardware of a scheduler. [Figure 4] FIG. 2 is a block diagram showing an example of the functions of a scheduler. [Diagram 5] 2 is a block diagram showing an example of functions of a patch processing server; [Figure 6] FIG. 11 is a diagram illustrating a first example of job scheduling. [Figure 7] FIG. 11 is a diagram illustrating a second example of job scheduling. [Figure 8] FIG. 4 illustrates an example of a job table. [Figure 9] FIG. 13 is a diagram illustrating an example of a node table. [Figure 10] FIG. 13 is a diagram illustrating an example of a schedule search table for a top job. [Figure 11] FIG. 13 is a diagram illustrating an example of a schedule search table for a subsequent job. [Figure 12] FIG. 11 is a diagram illustrating a third example of job scheduling. [Figure 13] FIG. 13 is a diagram illustrating a fourth example of job scheduling. [Figure 14] FIG. 13 is a diagram illustrating a fifth example of job scheduling. [Figure 15] FIG. 13 is a diagram illustrating a sixth example of job scheduling. [Figure 16] FIG. 13 is a diagram illustrating a seventh example of job scheduling. [Figure 17] FIG. 13 is a diagram illustrating an eighth example of job scheduling. [Figure 18] 10 is a flowchart illustrating an example of a procedure for generating a patch job. [Figure 19] 10 is a flowchart showing an example of a job reception procedure. [Figure 20] 13 is a flowchart illustrating an example of a job scheduling procedure. [Figure 21] 13 is a flowchart (continuation) illustrating an example of a procedure for job scheduling. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0012] Hereinafter, the present embodiment will be described with reference to the drawings. [First embodiment] A first embodiment will be described.

[0013] FIG. 1 is a diagram illustrating an information processing apparatus according to a first embodiment. An information processing device 10 according to the first embodiment performs job scheduling to allocate free nodes to jobs in a parallel processing system including multiple nodes. The information processing device 10 may be a client device or a server device. The information processing device 10 may be called a computer or a job scheduler.

[0014] The information processing device 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 may be a non-volatile storage such as a hard disk drive (HDD) or a flash memory.

[0015] The processing unit 12 is, for example, a processor such as a central processing unit (CPU), a graphics processing unit (GPU), or a digital signal processor (DSP). However, the processing unit 12 may include an electronic circuit such as an application specific integrated circuit (ASIC) or a field programmable gate array (FPGA). The processor executes a program stored in a memory such as a RAM (which may be the storage unit 11). A collection of processors may be called a multiprocessor or simply a "processor."

[0016] The storage unit 11 stores job information indicating a plurality of jobs waiting to be executed. The job information may be stored in a queue waiting to be executed. The plurality of jobs waiting to be executed 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 order in which the jobs are registered in the information processing device 10 is update job 13, update job 14, user job 15, and user job 16.

[0017] An update job updates the control software of a target node among multiple nodes. An update job is sometimes called a patch job. An update job may replace a program included in the control software. An update job may enhance the security of the control software and may expand the functions of the control software. Executing an update job upgrades the version of the control software held by the target node. Control software is infrastructure software used to run application software, and includes, for example, an operating system and middleware. "Version" is an attribute that identifies an improvement to the control software, and is sometimes called an edition number or revision.

[0018] 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. A user job specifies the number of nodes to be used and a scheduled execution time. The number of nodes to be used is the number of nodes that the user job uses in parallel. The scheduled execution time is an estimate of the time required from the start to the end of the user job. The number of nodes to be used and the scheduled execution time may be specified by the user. The scheduled execution time may also be estimated by the information processing device 10 from past similar user jobs.

[0019] Here, different running jobs may end at different times, and therefore different nodes may become free at different times. Therefore, the information processing device 10 does not force the update jobs of all nodes to be executed simultaneously, but allows the update jobs of different nodes to be executed at different times. On the other hand, different versions of control software may behave differently. Therefore, when a user job uses two or more nodes, the information processing device 10 assigns nodes with a common version of control software to the user job. The two or more nodes with a common version are nodes where no update jobs have been executed, or nodes where all update jobs have been executed.

[0020] The processing unit 12 searches for a schedule for the update job and the two or more user jobs based on the number of nodes used and the scheduled execution time of each of the two or more user jobs. At this time, the processing unit 12 searches for a schedule that satisfies a constraint that free nodes assigned to the same user job have a common version of control software at the start time of the user job.

[0021] The processing unit 12 may allocate free nodes preferentially to a user job that was registered in the information processing device 10 earlier than a user job, among two or more user jobs. Furthermore, even if an update job was registered in the information processing device 10 earlier than a user job, the processing unit 12 may reserve the update job and execute the user job preferentially. However, the processing unit 12 may execute the update job before the user job in order to secure nodes with a common version. Reserved update jobs may reduce the waiting time of two or more user jobs, and executing an update job first may ultimately reduce the waiting time of two or more user jobs.

[0022] For example, the processing unit 12 calculates a plurality of first patterns that can secure free nodes of a common version for the first user job by the number of nodes to be used. Each of the plurality of first patterns indicates nodes to be assigned 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 update job is put on hold and the first user job is executed first, or may include a pattern in which the update job is executed first and then the first user job is executed.

[0023] Next, the processing unit 12 calculates one or more second patterns for the second user job, which can secure free nodes of a common version in the number of nodes used. The one or more second patterns are calculated for each of the multiple first patterns. The processing unit 12 calculates a second pattern, which can allocate free nodes to the second user job as a schedule following a certain first pattern, taking into account the scheduled execution time of the first user job. Each of the one or more second patterns indicates nodes to be allocated to the second user job and a start time of the second job.

[0024] If the update job has not been executed in the first pattern, the one or more second patterns may include a pattern in which the update job is further reserved and the second user job is executed first, or a pattern in which the update job is executed first and the second user job is executed. In this way, for example, the processing unit 12 generates schedules such as schedules 17 and 18. Schedule 17 executes user job 15, executes update job 13 and user job 16 after user job 15, and 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 executes user job 16 after user job 15.

[0025] The processing unit 12 calculates the total waiting time of two or more user jobs for each schedule. The waiting time indicates the elapsed time from the current time or the reference time to the scheduled start time. The processing unit 12 may 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 so as to reduce the total waiting time. For example, the processing unit 12 selects a schedule with the shortest total waiting time or the shortest average waiting time from among the multiple schedules found. The processing unit 12 controls the execution order of the update job and two or more user jobs based on the searched schedule.

[0026] For example, the processing unit 12 determines when to execute an update job in the process of executing two or more user jobs. The processing unit 12 may instruct a plurality of nodes to execute an update job and two or more user jobs based on the selected schedule. The processing unit 12 may also store the selected schedule in a non-volatile storage, display it on a display device, or transmit it to another information processing device.

[0027] As described above, the information processing device 10 of the first embodiment identifies, from among jobs waiting to be executed, an update job for updating the control software of a target node and two or more user jobs each specifying the number of nodes to be used and the scheduled execution time. The information processing device 10 searches for a schedule for the update job and the two or more user jobs based on the number of nodes to be used and the scheduled execution time so that a node with a common version of the control software among the free nodes is assigned to each user job. At this time, a schedule is searched for so as 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 based on the searched schedule.

[0028] As a result, the information processing device 10 allows update jobs to be executed at different times depending on the node. This improves the availability of the parallel processing system compared to a case where the operation of the parallel processing system is temporarily stopped and update jobs of all nodes are executed simultaneously. In addition, nodes having a common version of control software are assigned to the same user job. This ensures the accuracy of the calculation results of each user job.

[0029] Furthermore, even if an update job is registered earlier than a user job, the update job may be put on hold and the user job may be executed first. Thus, compared to simply executing jobs in the order of registration, delays in user jobs following an update job are suppressed. Furthermore, the information processing device 10 selects a schedule that minimizes the total waiting time of two or more user jobs. Thus, compared to the case where only the waiting time of one user job immediately following an update job is considered, the average waiting time of user jobs is shortened and fairness between two or more user jobs waiting to be executed is improved. For example, the information processing device 10 can reduce the risk that the waiting time of the subsequent user jobs becomes longer by minimizing the waiting time of the user job immediately following an update job.

[0030] The update job may be the job at the top of the execution queue, and the two or more user jobs may be jobs behind the update job in the execution queue. This improves the inefficiency of simply executing jobs in the order of registration. The multiple schedules to be searched may include a schedule in which the update job is executed before the user job, and a schedule in which at least some of the user jobs are executed before the update job. This allows the information processing device 10 to select a schedule with the shortest total waiting time from among schedules with different execution timings of the update jobs.

[0031] Furthermore, the information processing device 10 may calculate a plurality of first patterns for allocating free nodes of a common version to a first user job by the number of nodes used. For each first pattern, the information processing device 10 may calculate a second pattern for allocating free nodes of a common version to a second user job by the number of nodes used. In this way, various schedules for allocating free nodes to two or more user jobs while respecting the priority order between the two or more user jobs are searched for.

[0032] [Second embodiment] Next, a second embodiment will be described. FIG. 2 illustrates an example of an information processing system according to the second embodiment.

[0033] 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 processing server 35, a plurality of nodes including nodes 41 to 45, and a scheduler 100.

[0034] The switch 31, the client device 32, and the patch distribution server 33 are connected to a network 30. The network 30 is, for example, a wide area data communication network such as the Internet. The login server 34, the patch processing 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 LAN (Local Area Network). The switch 31 transfers packets. The scheduler 100 corresponds to the information processing device 10 of the first embodiment.

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

[0036] The patch distribution server 33 is a server computer that distributes OS patches. A patch may be called a correction program or a correction module. The patch distribution server 33 receives access via the network 30. In response to the access, the patch distribution server 33 transmits the patch itself and specification information such as the patch version number and application conditions.

[0037] The login server 34 is a front-end server computer that accepts access from a user. The login server 34 authenticates the client device 32. If the authentication is successful, the login server 34 accepts specifications such as a user program, the number of nodes to be used, and the maximum execution time from the client device 32. The login server 34 generates a user job request based on these specifications and transmits it to the scheduler 100.

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

[0039] The patch processing server 35 periodically accesses the patch distribution server 33 to determine whether a new patch has been distributed. If a new patch has been distributed, the patch processing server 35 determines whether the nodes 41 to 45 satisfy the application conditions for the new patch. The patch processing server 35 generates a patch job request for applying a patch to the nodes that satisfy the application conditions, and transmits it to the scheduler 100. A patch job request is generated for each node.

[0040] The nodes 41 to 45 are server computers that execute a specified program. The nodes 41 to 45 are sometimes called computation nodes. An OS is installed in the nodes 41 to 45. The nodes 41 to 45 may be assigned to the same or different user jobs. Each node is not assigned to two or more user jobs at the same time. In addition, the nodes 41 to 45 may be assigned to a patch job. A node that is executing a patch job is not assigned to a user job until the patch job is finished.

[0041] The scheduler 100 is a server computer that performs job scheduling to allocate multiple jobs to nodes 41 to 45. The scheduler 100 accepts 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 accepts a patch job request from the patch processing server 35 and registers the patch job at the end of the waiting job list.

[0042] The scheduler 100 monitors the execution status of jobs in the nodes 41 to 45. In principle, the scheduler 100 assigns one or more nodes to a job, preferentially from the top of the waiting job list, that is, in principle, in the order of arrival. If the top job is a user job, when there are free nodes equal to or greater than the specified number of nodes to be used, the scheduler 100 assigns free nodes to the user job as many as the number of nodes to be used. However, nodes with different OS versions are not assigned to the same user job. Therefore, all nodes assigned to a user job are either before patches have been applied or after patches have been applied.

[0043] Furthermore, if the leading job is a patch job, when the node to which the patch is to be applied becomes an available node, the scheduler 100 causes the node to which the patch is to be applied to execute the patch job. However, as described below, the scheduler 100 may temporarily hold the patch job and cause a user job that arrives after the patch job to be executed first.

[0044] FIG. 3 is a block diagram illustrating an example of hardware of a scheduler. The scheduler 100 has 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, all connected to a bus. The CPU 101 corresponds to the processing unit 12 in the first embodiment. The RAM 102 or the HDD 103 corresponds to the storage unit 11 in the first embodiment. The client device 32, the patch distribution server 33, the login server 34, the patch processing server 35, and the nodes 41 to 45 may each have hardware similar to that of the scheduler 100.

[0045] The CPU 101 is a processor that executes instructions of a program. The CPU 101 loads the program and data stored in the HDD 103 into the RAM 102, and executes the program. The scheduler 100 may have multiple processors.

[0046] The RAM 102 is a volatile semiconductor memory that temporarily stores programs executed by the CPU 101 and data used in calculations by the CPU 101. The scheduler 100 may have a type of volatile memory other than a RAM.

[0047] The HDD 103 is a non-volatile storage that stores software programs and other data. The software includes an OS, middleware, application software, etc. The scheduler 100 may have other types of non-volatile storage, such as a flash memory or an SSD (Solid State Drive).

[0048] The GPU 104 performs image processing in cooperation with the CPU 101, and outputs images to a display device 111 connected to the scheduler 100. The display device 111 is, for example, a CRT (Cathode Ray Tube) display, a liquid crystal display, an organic EL (Electro Luminescence) display, or a projector. Other types of output devices, such as a printer, may be connected to the scheduler 100.

[0049] Furthermore, the GPU 104 may be used as a general purpose computing on graphics processing unit (GPGPU). The GPU 104 may execute a program in response to an instruction from the CPU 101. The scheduler 100 may include a volatile semiconductor memory other than the RAM 102 as a GPU memory.

[0050] The input interface 105 receives an input signal from an input device 112 connected to the scheduler 100. The input device 112 is, for example, a mouse, a touch panel, or a keyboard. A plurality of input devices may be connected to the scheduler 100.

[0051] The medium reader 106 is a reading device that reads the program and data recorded on the recording medium 113. The recording medium 113 is, for example, a magnetic disk, an optical disk, or a semiconductor memory. The magnetic disk includes a flexible disk (FD) and a HDD. The optical disk includes a compact disc (CD) and a digital versatile disc (DVD). The medium reader 106 copies the program and data read from the recording medium 113 to another recording medium such as the RAM 102 or the HDD 103. The read program may be executed by the CPU 101.

[0052] The recording medium 113 may be a portable recording medium. The recording medium 113 may be used for distributing programs and data. The recording medium 113 and the HDD 103 may be called computer-readable recording media.

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

[0054] FIG. 4 is a block diagram illustrating an example of the functions of the scheduler. The scheduler 100 has 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 implemented using, for example, a RAM 102 or a HDD 103. The scheduler 100 also has a job reception unit 131, a job management unit 132, a node management unit 133, a job execution unit 134, an execution feasibility determination unit 135, a schedule search unit 136, an end time determination unit 137, and a patch time determination unit 138. These processing units are implemented using, for example, a CPU 101, a communication interface 107, and a program.

[0055] The job information storage unit 121 stores information on jobs waiting to be executed and jobs currently being executed. The information on jobs waiting to be executed includes the job type, the number of nodes used, and the required time. The job type is a patch job or a user job. The information on jobs currently being executed includes the job type, the nodes used, the required time, and the start time.

[0056] The node information storage unit 122 stores information indicating the current state of the nodes 41 to 45. The information on the current state includes the version number of the current OS. The information on the current state also includes a flag indicating whether the node is free or not, and if the node is not free, includes the job name of the job being executed.

[0057] The job history storage unit 123 stores the execution history of user jobs. The execution history includes job characteristic information such as the job name and program size. The execution history also includes the measured execution time of the user job. The patch history storage unit 124 stores the execution history of patch jobs. The execution history includes patch characteristic information such as the version number and patch type. The patch type is, for example, the patch purpose such as function addition, security response, bug fix, etc. The execution conditions also include the measured execution time of the patch job.

[0058] The job receiving unit 131 receives a user job request from the login server 34. The job receiving unit 131 also receives a patch job request from the patch processing server 35. The job receiving unit 131 outputs the received job request to the job management unit 132.

[0059] The job management unit 132 manages information on jobs waiting to be executed and jobs currently being executed. The job management unit 132 acquires a job request from the job receiving unit 131, and registers a job that meets the conditions specified by the job request at the end of the waiting job list. When a job is determined to be executable by the execution feasibility determination unit 135, the job management unit 132 assigns a free node to the job. The job management unit 132 deletes the job from the waiting job list and manages it as a currently being executed job, and instructs the job execution unit 134 to execute the job.

[0060] The node management unit 133 collects and manages information on the current state from the nodes 41 to 45. The node management unit 133 may actively collect information by periodically accessing the nodes 41 to 45. Alternatively, the node management unit 133 may passively receive information from the nodes 41 to 45 when the nodes 41 to 45 start a new job or finish an existing job.

[0061] Job execution unit 134 causes nodes 41 to 45 to execute jobs in response to instructions from job management unit 132. Job execution unit 134 notifies the node assigned by job management unit 132 of the job name, the program to be executed, and the maximum execution time. The assigned node starts the notified program. The assigned node ends the job when the program stops or the maximum execution time has elapsed.

[0062] The execution possibility determination unit 135 determines whether a waiting job registered in the waiting job list can be executed. For a user job, the execution possibility determination unit 135 determines that the user job is executable if there are free nodes with the same OS version number equal to or greater than the number of nodes in use. For a patch job, the execution possibility determination unit 135 determines that the patch job is executable if the node to which the patch is to be applied is a free node. However, the execution possibility determination unit 135 may temporarily suspend an executable patch job, as described below.

[0063] The schedule search unit 136 comprehensively generates multiple schedule candidates by assigning use nodes and start times to all jobs waiting to be executed. At this time, the schedule search unit 136 allows a previous patch job to be put on hold and a later user job to be executed first. However, in the second embodiment, the schedule search unit 136 does not perform backfilling, which causes a later user job to be executed first, overtaking a previous user job. In addition, the schedule search unit 136 requires that free nodes assigned to the same user job have the same OS version at the start time of the user job.

[0064] The schedule search unit 136 selects a schedule that minimizes the total waiting time of the user jobs from among the multiple schedule candidates. The total waiting time is the sum of the remaining waiting times from the current time to the start time of each user job. In this way, the schedule search unit 136 determines when to execute the waiting patch job in the process of executing the waiting user jobs. The waiting patch job may be executed before all user jobs, may be executed after some user jobs are executed, or may be held until all user jobs are executed.

[0065] The end time determination unit 137 determines the end time of a user job that is being executed. In principle, the end time determination unit 137 calculates the end time by adding the maximum execution time to the start time. However, the end time determination unit 137 may estimate the execution time by referring to the execution history of past user jobs. For example, the end time determination unit 137 estimates the execution time of the user job from the average execution time of past user jobs with similar job names.

[0066] Also, for example, the end time determination unit 137 estimates the execution time from the size of the user program. Also, the end time determination unit 137 may estimate the execution time by acquiring the progress of the user job from the node assigned to the user job. Examples of the information on the progress include the amount of the executed program and the amount of processed data.

[0067] The patch time determination unit 138 determines the required time for a patch job waiting to be executed. When a patch of a certain version has not been applied to any node, the patch time determination unit 138 estimates the required time by referring to the execution history of past patch jobs. For example, the patch time determination unit 138 estimates the required time for the patch job from the average execution time of past patch jobs of the same patch type. When a patch of a certain version has been applied to at least one node, the patch time determination unit 138 uses the execution time of past patch jobs of the same version.

[0068] FIG. 5 is a block diagram illustrating an example of the functions of the patch processing server. The patch processing server 35 includes a patch monitoring unit 141, a patch information receiving unit 142, a patch job generating unit 143, and a patch job requesting unit 144. These processing units are implemented using, for example, a CPU, a communication interface, and a program.

[0069] 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. When a new patch is detected by the patch monitoring unit 141, 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 satisfies the application conditions. The application conditions include a hardware condition indicating that specific hardware is included, and a software condition indicating that a specific version of software is included.

[0070] The patch job generator 143 generates a patch job request for applying a new patch to each node that satisfies the application conditions. The patch job request specifies the node to which the patch is to be applied and the patch body. The patch body may be received by the patch processing server 35 or by each individual node.

[0071] The patch job request unit 144 transmits the patch job request generated by the patch job generating unit 143 to the scheduler 100 . Next, job scheduling will be described.

[0072] When patch jobs and user jobs are mixed in the waiting job list, the following three scheduling methods are possible. The first scheduling method does not distinguish between patch jobs and user jobs, and executes the jobs in the order they are registered in the waiting job list. The second scheduling method decides whether to execute or put on hold the patch job so that the waiting time of the user job following the patch job is short. The third scheduling method decides how long to delay the patch job so that the total waiting time of all user jobs currently waiting to be executed is short.

[0073] In the first scheduling method, a patch job may cause the waiting time of a user job registered after the patch job to become significantly longer. In the second scheduling method, shortening the waiting time of the user job following the patch job may actually increase the waiting time of subsequent user jobs, resulting in a longer average waiting time for user jobs waiting to be executed. Therefore, the scheduler 100 of the second embodiment performs job scheduling using the third scheduling method.

[0074] FIG. 6 is a diagram illustrating a first example of job scheduling. Graph 161 shows a schedule when the second scheduling method described above is executed for waiting job list 171. The current time is time t3. At time t3, node 41 is executing job b, node 42 is an available node, nodes 43 and 44 are executing job d, and node 45 is executing job e. Job b ends at time t5, job d ends at time t6, and job e ends at time t7. Nodes 41 and 45 have already been patched, and nodes 42 to 44 have not yet been patched.

[0075] The waiting job list 171 includes jobs p#2, p#3, p#4, f, g, h, and i, in that order. Job p#2 is a patch job for node 42 and has a required time of 4. Job p#3 is a patch job for node 43 and has a required time of 4. Job p#4 is a patch job for node 44 and has a required time of 4. Job f is a user job that uses 3 nodes and has a maximum execution time of 2. Job g is a user job that uses 4 nodes and has a maximum execution time of 2. Job h is a user job that uses 3 nodes and has a maximum execution time of 1. Job i is a user job that uses 5 nodes and has a maximum execution time of 3.

[0076] In the second scheduling method, the scheduler 100 minimizes the waiting time of job f. Therefore, the scheduler 100 suspends job p#2 and waits for job d to finish, and assigns nodes 42 to 44 to job f at time t6. When job f finishes at time t8, the scheduler 100 considers minimizing the waiting time of job g. At this time, there are no four nodes with the same OS version. Therefore, the scheduler 100 executes jobs p#2, p#3, and p#4.

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

[0078] According to this schedule, with respect to time t3 as the reference point, the waiting time of job f is 3, the waiting time of job g is 9, the waiting time of job h is 11, and the waiting time of job i is 12. Therefore, the total waiting time of jobs f, g, h, and i waiting to be executed is 35, and the average waiting time is 35 / 4 = approximately 8.8.

[0079] FIG. 7 is a diagram illustrating a second example of job scheduling. Graph 162 shows a schedule when the above-mentioned third scheduling method is applied to waiting job list 171. Scheduler 100 executes job p#2 at time t3. When job d is completed at time t6, scheduler 100 executes jobs p#3 and p#4. When jobs p#2 and e are completed at time t7, scheduler 100 assigns nodes 41, 42, and 45 to job f.

[0080] At time t10, jobs p#3 and p#4 are completed. As a result, the OS versions of nodes 41 to 45 become the same. Scheduler 100 assigns nodes 41 to 44 to job g. When job g is completed at time t12, scheduler 100 assigns nodes 41 to 43 to job h. When job h is completed at time t13, scheduler 100 assigns nodes 41 to 45 to job i.

[0081] According to this schedule, with respect to time t3 as the base point, the waiting time of job f is 4, the waiting time of job g is 7, the waiting time of job h is 9, and the waiting time of job i is 10. Therefore, the total waiting time of jobs f, g, h, and i waiting to be executed is 30, and the average waiting time is 30 / 4=7.5. Compared to graph 161, although the waiting time of job f is longer, the waiting times of jobs g, h, and i are shorter because the OS versions of nodes 41 to 45 are earlier and the same, and the average waiting time of jobs f, g, h, and i is shorter.

[0082] Next, a method for searching the schedule shown in graph 162 will be described. FIG. 8 is a diagram illustrating an example of a job table. The scheduler 100 stores a job table 151. The job table 151 includes a number of records, each of which includes a job name, a job type, the number of nodes used, a required time, and a job status. One record corresponds to one job. The job name identifies the job. Patch jobs that are applied to different target nodes are treated as different jobs. The job type is a patch job or a user job.

[0083] 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 required time for a user job is the maximum execution time specified by the user or the execution time estimated by the scheduler 100. The required time for a patch job is the execution time measured on the first node for the same patch, or the execution time measured in the past for other similar patches. The end time is predicted by adding the required time to the start time of each job. The job state is waiting to be executed, running, or finished.

[0084] FIG. 9 is a diagram illustrating an example of a node table. The scheduler 100 stores a node table 152. The node table 152 includes a number of records corresponding to the nodes 41 to 45. Each record includes a node number and an OS version. The node number identifies the node. The OS version indicates the version of the OS. By applying a patch, the OS version becomes higher. Therefore, the OS version of a node to which a patch has been applied is higher than that of a node to which a patch has not been applied.

[0085] FIG. 10 is a diagram showing an example of a schedule search table for a top job. First, the scheduler 100 schedules job f, which is the top user job. In this way, the scheduler 100 comprehensively generates individual schedule candidates for job f. An individual schedule is a schedule for one job that forms part of a schedule for all jobs waiting to be executed. Note that for jobs p#2, p#3, and p#4, which are patch jobs, the scheduler 100 only needs to determine appropriate execution timing through the scheduling of jobs f, g, h, and i, which are user jobs, and does not need to schedule them independently.

[0086] The scheduler 100 generates a schedule search table 153. The schedule search table 153 comprehensively includes individual schedule candidates that can execute job f. Since the number of nodes used by job f is three, ten individual schedule candidates are possible, in which three nodes are selected from nodes 41 to 45. The three selected nodes do not necessarily have the same OS version. If the OS versions are not the same and a patch job for matching the OS version has not been executed, the scheduler 100 generates an individual schedule candidate in which the patch job is executed before job f.

[0087] Each individual schedule candidate includes a number, a node, a node that needs patching, a patch time, a job time, and a wait time. The number identifies the individual schedule candidate. The node is a node that is assigned to the job of interest (here, job f). The node that needs patching is a node that is assigned to the node that needs to execute the patch job first.

[0088] The patch time is the time from the current time to the scheduled end time of the patch job of the node that needs to be patched. If there are two or more nodes that need to be patched, the patch time is calculated based on the latest scheduled end time. The job time is the time from the current time to the scheduled end time of the running job. If some of the assigned nodes are running different jobs, the job time is calculated based on the latest scheduled end time. The wait time is the time from the current time to the time the job in question can start, and is the larger of the patch time or the job time.

[0089] When the schedule search table 153 is generated, the scheduler 100 comprehensively generates individual schedule candidates for the next job g, based on each of the ten individual schedule candidates included in the schedule search table 153.

[0090] Here, we focus on the third individual schedule candidate and the seventh individual schedule candidate. The third individual schedule candidate has node 42 execute job p#2, and assigns nodes 41, 42, and 45 to job f. In this case, the waiting time for job f is 4. The seventh individual schedule candidate assigns nodes 42 to 44 to job f. Jobs p#2, p#3, and p#4 are not executed before job f. In this case, the waiting time for job f is 3, which is shorter than the third individual schedule candidate.

[0091] FIG. 11 is a diagram showing an example of a schedule search table for a subsequent job. The scheduler 100 generates a schedule search table 154. The schedule search table 154 exhaustively includes individual schedule candidates in which job g can be executed, on the assumption that job f is executed according to the seventh individual schedule candidate.

[0092] Since the number of nodes used by job g is four, five individual schedule candidates are possible, which select four nodes from nodes 41 to 45. Here, nodes 41 and 45 have already been patched, and nodes 42 to 44 have not been patched, so there are nodes that require patching in all five individual schedule candidates. As a result, the patch time and wait time are 9 for each individual schedule candidate.

[0093] In addition, the scheduler 100 generates a schedule search table 155. The schedule search table 155 comprehensively includes individual schedule candidates capable of executing job g, on the assumption that job f is executed according to the third individual schedule candidate. Here, since nodes 41, 42, and 45 have been patched and nodes 43 and 44 have not been patched, there are nodes requiring patching in all five individual schedule candidates. However, in each individual schedule candidate, the patch time is 7, and the wait time is 7.

[0094] In this way, with regard to the waiting time of job f, the seventh individual schedule candidate is more advantageous than the third individual schedule candidate. On the other hand, with regard to the waiting time of job g, it is more advantageous for job f to select the third individual schedule candidate than it is to select the seventh individual schedule candidate. Therefore, from the perspective of all user jobs waiting to be executed, it is not necessarily better for job f to select the seventh individual schedule candidate.

[0095] Similarly, the scheduler 100 comprehensively generates individual schedule candidates for job h based on each of the individual schedule candidates for job g. Because the number of nodes used by job h is 3, ten individual schedule candidates are considered, in which three nodes are selected from nodes 41 to 45. Furthermore, the scheduler 100 comprehensively generates individual schedule candidates for job i based on each of the individual schedule candidates for job h. Because the number of nodes used by job i is 5, one individual schedule candidate is considered, in which five nodes are selected from nodes 41 to 45.

[0096] The scheduler 100 calculates the total waiting time of jobs f, g, h, and i for each schedule candidate that combines the individual schedule candidates of jobs f, g, h, and i. Such multiple schedule candidates can be searched for in a tree structure. The scheduler 100 selects a schedule with the smallest total waiting time from the multiple schedule candidates. If a patch job with an undetermined start time remains, the scheduler 100 may place the patch job after job i. Furthermore, the scheduler 100 may place the patch job in the gap time if the patch job is inserted in the gap between jobs f, g, h, and i and no inconsistency in the OS version occurs in subsequent jobs.

[0097] The scheduler 100 controls the execution of jobs p#2, p#3, p#4, f, g, h, and i based on the selected schedule. For example, at time t3, the scheduler 100 causes node 42 to execute job p#2. The selected schedule is used until the scheduling is re-executed. For example, the scheduler 100 re-executes the above scheduling when a new job is registered in the waiting job list 171 or when any of the currently executing jobs is completed.

[0098] Next, a description will be given of an example of scheduling that is different from those in Figs. 6 and 7. Here, the description will be given while comparing the results of the first scheduling method, the second scheduling method, and the third scheduling method described above.

[0099] FIG. 12 is a diagram illustrating a third example of job scheduling. Graph 163 shows a schedule when the above-mentioned first scheduling method is executed for queued job list 172. The current time is time t1. At time t1, nodes 41 to 45 are free nodes. Patches have been applied to nodes 41 and 45, and patches have not been applied to nodes 42 to 44.

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

[0101] Job b is a user job that uses 1 node and has a maximum execution time of 4. Job c is a user job that uses 1 node and has a maximum execution time of 2. Job d is a user job that uses 2 nodes and has a maximum execution time of 5. Job e is a user job that uses 1 node and has a maximum execution time of 6. Job f is a user job that uses 3 nodes and has a maximum execution time of 2. Job g is a user job that uses 4 nodes and has a maximum execution time of 2. Job h is a user job that uses 3 nodes and has a maximum execution time of 1. Job i is a user job that uses 5 nodes and has a maximum execution time of 3.

[0102] In the first scheduling method, the scheduler 100 does not distinguish between patch jobs and user jobs, and executes jobs p#2, p#3, p#4, b, c, d, e, f, g, h, and i in the order in which they were registered. At time t1, the scheduler 100 causes nodes 42 to 44 to execute jobs p#2, p#3, and p#4. The scheduler 100 also assigns node 41 to job b, and node 45 to job c.

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

[0104] According to this schedule, with time t1 as the base, the waiting time of jobs b and c is 0. In addition, the waiting time of job d is 4, the waiting time of job e is 4, the waiting time of job f is 9, the waiting time of job g is 11, the waiting time of job h is 13, and the waiting time of job i is 14. Therefore, the total waiting time of jobs b, c, d, e, f, g, h, and i waiting to be executed is 55, and the average waiting time is 55 / 8 = approximately 6.9.

[0105] FIG. 13 is a diagram illustrating a fourth example of job scheduling. Graph 164 shows a schedule when the second scheduling method described above is executed for waiting job list 172. At time t1, scheduler 100 assigns node 41 to job b, node 42 to job c, nodes 43 and 44 to job d, and node 45 to job e. Since jobs b, c, d, and e can be executed immediately, jobs p#2, p#3, and p#4 are put on hold.

[0106] When job d ends at time t6, scheduler 100 assigns nodes 42 to 44 to job f. When job f ends at time t8, scheduler 100 has nodes 42 to 44 execute jobs p#2, p#3, and p#4 because there are only three nodes with the same OS version. When jobs p#2, p#3, and p#4 end at time t12, scheduler 100 assigns nodes 41 to 44 to job g.

[0107] When job g ends at time t14, scheduler 100 assigns nodes 41 to 43 to job h. When job h ends at time t15, scheduler 100 assigns nodes 41 to 45 to job i. Note that graph 164 corresponds to the schedule of graph 161 in FIG. 6 as viewed at time t1.

[0108] According to this schedule, with respect to time t1, the waiting time of jobs b, c, d, and e is 0. In addition, the waiting time of job f is 5, the waiting time of job g is 11, the waiting time of job h is 13, and the waiting time of job i is 14. Therefore, the total waiting time of jobs b, c, d, e, f, g, h, and i waiting to be executed is 43, and the average waiting time is 43 / 8 = approximately 5.4.

[0109] FIG. 14 is a diagram illustrating a fifth example of job scheduling. Graph 165 shows a schedule when the third scheduling method described above is executed for waiting job list 172. At time t1, scheduler 100 assigns node 41 to job b, node 42 to job c, nodes 43 and 44 to job d, and node 45 to job e.

[0110] When job c ends at time t3, scheduler 100 has node 42 execute job p#2. When job d ends at time t6, scheduler 100 has nodes 43 and 44 execute jobs p#3 and p#4. When jobs p#2 and e end at time t7, scheduler 100 assigns nodes 41, 42, and 45 to job f.

[0111] When jobs p#3 and p#4 are completed at time t10, scheduler 100 assigns nodes 41 to 44 to job g. When job g is completed at time t12, scheduler 100 assigns nodes 41 to 43 to job h. When job h is completed at time t13, scheduler 100 assigns nodes 41 to 45 to job i. Note that graph 165 corresponds to the schedule of graph 162 in FIG. 7 viewed at time t1.

[0112] According to this schedule, the waiting time of jobs b, c, d, and e is 0, based on time t1. In addition, the waiting time of job f is 6, the waiting time of job g is 9, the waiting time of job h is 11, and the waiting time of job i is 12. Therefore, the total waiting time of jobs b, c, d, e, f, g, h, and i waiting to be executed is 38, and the average waiting time is 38 / 8=approximately 4.8. Thus, according to the schedule of graph 165, the average waiting time is shorter than those of graphs 163 and 164.

[0113] FIG. 15 is a diagram illustrating a sixth example of job scheduling. Graph 166 shows a schedule when the first scheduling method is executed for queued job list 173. The current time is time t3. 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 an available node. Jobs b, p#2, p#3, and p#4 end at time t5. Nodes 41 and 45 have already been patched, and nodes 42 to 44 are currently applying patches.

[0114] The waiting job list 173 includes jobs d, e, f, g, h, and i, in that order. Job d is a user job using 2 nodes and with a maximum execution time of 5. Job e is a user job using 1 node and with a maximum execution time of 6. Job f is a user job using 3 nodes and with a maximum execution time of 2. Job g is a user job using 3 nodes and with a maximum execution time of 2. Job h is a user job using 1 node and with a maximum execution time of 3. Job i is a user job using 4 nodes and with a maximum execution time of 3.

[0115] At time t3, there are not enough free nodes to execute job d. When jobs b, p#2, p#3, and p#4 are completed at time t5, scheduler 100 assigns nodes 41 and 42 to job d, and node 43 to job e. When job d is completed at time t10, scheduler 100 assigns nodes 41, 42, and 44 to job f. When job f is completed at time t12, scheduler 100 assigns nodes 41, 42, and 44 to job g, and node 45 to job h. When job g is completed at time t14, scheduler 100 assigns nodes 41 to 44 to job i.

[0116] According to this schedule, with respect to time t3 as the base point, the waiting time of job d is 2, the waiting time of job e is 2, the waiting time of job f is 7, the waiting time of job g is 9, the waiting time of job h is 9, and the waiting time of job i is 11. Therefore, the total waiting time of jobs d, e, f, g, h, and i waiting to be executed is 40, and the average waiting time is 40 / 6 = approximately 6.7.

[0117] FIG. 16 is a diagram illustrating a seventh example of job scheduling. Graph 167 shows a schedule when the second scheduling method is executed for the waiting job list 174. The current time is time t3. Due to the difference in the scheduling method, the states of nodes 41 to 45 at time t3 differ from those of graph 166.

[0118] At time t3, node 41 is executing job b, node 42 is an empty node, nodes 43 and 44 are executing job d, and node 45 is executing job e. Job b ends at time t5, job d ends at time t6, and job e ends at time t7. Nodes 41 and 45 have already been patched, and nodes 42 to 44 have not yet been patched. The waiting job list 174 includes jobs p#2, p#3, p#4, f, g, h, and i, in that order. The contents of jobs b, c, d, e, f, g, h, and i are the same as those in FIG. 15.

[0119] At time t3, scheduler 100 puts job p#2 on hold in order to execute job f sooner. When job d ends at time t6, scheduler 100 assigns nodes 42-44 to job f. When job f ends at time t8, scheduler 100 assigns nodes 42-44 to job g and node 45 to job h.

[0120] When job g ends at time t10, the scheduler 100 causes nodes 42 to 44 to execute jobs p#2, p#3, and p#4. When jobs p#2, p#3, and p#4 end at time t14, the scheduler 100 assigns nodes 41 to 44 to job i.

[0121] According to this schedule, with respect to time t3 as the reference point, the waiting time of job f is 3, the waiting time of job g is 5, the waiting time of job h is 5, and the waiting time of job i is 11. Therefore, the total waiting time of jobs f, g, h, and i waiting to be executed is 24, and the average waiting time is 24 / 6=4.

[0122] FIG. 17 is a diagram illustrating an eighth example of job scheduling. Graph 168 shows a schedule when the third scheduling method is executed for waiting job list 174. At time t3, scheduler 100 causes node 42 to execute job p#2. When job d is completed at time t6, scheduler 100 causes node 43 to execute job p#3.

[0123] When jobs p#2 and e are completed at time t7, scheduler 100 assigns nodes 41, 42, and 45 to job f. When job f is completed at time t9, scheduler 100 assigns nodes 41, 42, and 45 to job g, and assigns node 44 to job h. When job g is completed at time t11, scheduler 100 assigns nodes 41 to 43, and 45 to job i. When job h is completed at time t12, scheduler 100 has node 44 execute job p#4.

[0124] According to this schedule, with respect to time t3, the waiting time of job f is 4, the waiting time of job g is 6, the waiting time of job h is 6, and the waiting time of job i is 8. Therefore, the total waiting time of jobs f, g, h, and i waiting to be executed is 24, and the average waiting time is 24 / 6=4. Thus, according to the schedule of graph 168, the average waiting time is shorter than that of graph 166 and is equivalent to that of graph 167. Also, the end time of job i, the last user job, is earlier than that of graph 167.

[0125] Next, the processing procedure of the information processing system will be described. FIG. 18 is a flowchart showing an example of a procedure for generating a patch job. (S10) The patch monitoring unit 141 accesses the patch distribution server 33 and checks whether the patch distribution server 33 has started distributing a new patch.

[0126] (S11) The patch monitoring unit 141 determines whether or not there is a new patch. If there is a new patch, the process proceeds to step S12, and if there is no new patch, the process ends. (S12) The patch information receiving unit 142 receives specification information of a new patch. The patch information receiving unit 142 selects one node. The patch information receiving unit 142 determines whether the selected node is a target for patch application. If the selected node is a target for patch application, the process proceeds to step S13; if the selected node is not a target for patch application, the process proceeds to step S17.

[0127] (S13) The patch job generating unit 143 determines the urgency of the patch from the specification information. (S14) The patch job generating unit 143 generates a patch job request for updating the OS of the node selected in step S12. The patch job request specifies the node to which the patch is to be applied and the modification program to be executed.

[0128] (S15) The patch job generation unit 143 assigns a priority to the patch job request according to the urgency determined in step S13. For example, if the urgency of the patch is high, the patch job generation unit 143 assigns a priority indicating the urgency level to the patch job request, and if the urgency of the patch is medium or low, the patch job generation unit 143 assigns a priority indicating the normal level to the patch job request.

[0129] (S16) The patch job request unit 144 transmits the patch job request generated in steps S13 to S15 to the scheduler 100. (S17) The patch information receiving unit 142 determines whether all nodes have been confirmed in step S12. If all nodes have been confirmed, the process ends. If there are unconfirmed nodes, the process returns to step S12, and another node is selected.

[0130] FIG. 19 is a flowchart showing an example of a job reception procedure. (S20) The job receiving unit 131 receives a job request. The received job request is the above-mentioned patch job request or a user job request from the login server 34. The user job request specifies a user program, the number of nodes to be used, and the maximum execution time.

[0131] (S21) The job management unit 132 registers the job indicated by the job request received in step S20 at the end of the waiting job list. (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, urgent level jobs are lined up before normal level jobs. Jobs of the same priority are lined up in the order of earliest registration time.

[0132] FIG. 20 is a flowchart showing an example of a job scheduling procedure. This job scheduling is performed, for example, when a new job is added to the waiting job list or when any job currently being executed is completed.

[0133] (S30) The schedule search unit 136 checks the waiting job list. (S31) The schedule search unit 136 determines whether the waiting job list includes a patch job. If the waiting job list includes a patch job, the process proceeds to step S32. If the waiting job list does not include a patch job, the process proceeds to step S35.

[0134] (S32) The schedule search unit 136 selects all patch jobs from the waiting job list. The following steps S33 and S34 are executed for each patch job. (S33) The schedule search unit 136 determines whether the priority of the patch job is at an emergency level. If the priority is at an emergency level, the process proceeds to step S34, and if the priority is at a normal level, the process proceeds to step S35.

[0135] (S34) The schedule search unit 136 determines an individual schedule for the patch job with an urgent priority level before the user job and other patch jobs. This individual schedule specifies, as a start time, the time when the node to which the patch is to be applied next becomes available. This allows the patch job to be executed as early as possible.

[0136] (S35) The schedule search unit 136 determines whether the waiting job list includes a user job. If the waiting job list includes a user job, the process proceeds to step S36. If the waiting job list does not include a user job, the process proceeds to step S43.

[0137] (S36) The schedule search unit 136 selects the top user job from the waiting job list. The top user job is the user job that is closest to the top of the waiting job list among the user jobs and is the user job that was registered in the waiting job list earliest.

[0138] (S37) The schedule search unit 136 generates individual schedule candidates for the selected user job. Here, the schedule search unit 136 exhaustively generates patterns for selecting nodes equal to the number of nodes to be used, using the method described in FIG. 10. These individual schedule candidates specify the nodes and start times to be assigned to the user job. If an individual schedule for the patch job is determined first in step S34, individual schedule candidates for the user job are generated to avoid the determined individual schedule. The individual schedule candidates may indicate that the patch job is to be executed first in order to align the OS versions.

[0139] (S38) The schedule search unit 136 determines whether the waiting job list includes a subsequent user job of the currently selected user job. If the waiting job list includes a subsequent user job, the process proceeds to step S39. If the waiting job list does not include a subsequent user job, the process proceeds to step S41. The latter is the case when the currently selected user job is the last user job.

[0140] (S39) The schedule search unit 136 selects the next user job from the waiting job list. The next user job is the user job that is registered in the waiting job list one job after the currently selected user job.

[0141] (S40) The schedule search unit 136 generates individual schedule candidates for the user job selected in step S39. Here, the schedule search unit 136 exhaustively generates patterns for selecting nodes for the number of nodes to be used following each individual schedule candidate for the previous user job, using the method described in Fig. 11. The individual schedule candidates may indicate that a patch job is to be executed first in order to align the OS version. Then, the process returns to step S38.

[0142] FIG. 21 is a flowchart (continuation) illustrating an example of a job scheduling procedure. (S41) By generating individual schedule candidates in order from the first user job to the last user job, a schedule candidate that combines the individual schedule candidates of all user jobs is generated. The schedule search unit 136 calculates the total waiting time of the user jobs for each of the multiple schedule candidates.

[0143] (S42) The schedule search unit 136 selects the schedule with the smallest total waiting time from among multiple schedule candidates. (S43) The schedule search unit 136 determines whether the individual schedules of all patch jobs included in the waiting job list have been determined among the schedules adopted in step S42. The individual schedules of the patch jobs may be determined in step S34, or may be determined in steps S37 and S40. If the individual schedules of all patch jobs have been determined, the process proceeds to step S45. If there is a patch job for which the individual schedule has not been determined, the process proceeds to step S44.

[0144] (S44) The schedule search unit 136 determines individual schedules for the remaining patch jobs whose individual schedules have not been determined. At this time, the schedule search unit 136 determines whether there is a gap time between the user jobs in which the remaining patch jobs can be executed. If there is a gap time and executing the patch job in that gap time will not cause an OS version inconsistency in the subsequent user job, the schedule search unit 136 places the patch job in that gap time. Otherwise, the schedule search unit 136 places the patch job after the last user job executed on the node to which the patch is to be applied.

[0145] (S45) The execution possibility determination unit 135 causes the nodes 41 to 45 to execute the patch job and the user job according to the schedule determined in steps S42 to S44. The allocation of nodes to jobs follows the nodes to be used and the start times defined in the schedule. This schedule is used until it is updated at the aforementioned opportunity.

[0146] The scheduler 100 may output the determined schedule. The scheduler 100 may store the determined schedule in a non-volatile storage, may display the determined schedule on the display device 111, or may transmit the determined schedule to another information processing device.

[0147] As described above, the scheduler 100 of the second embodiment does not execute patch jobs for all nodes at the same time, but allows patch jobs to be executed at different start times depending on the node. This eliminates the need for an administrator to stop the operation of the information processing system, improving the availability of the information processing system. In addition, the scheduler 100 assigns nodes having the same version of the OS to a user job that uses two or more nodes. This reduces errors and unexpected behavior caused by differences in version numbers.

[0148] Furthermore, even if the patch job at the top of the waiting job list is executable and the subsequent user job is not yet executable, the scheduler 100 may suspend the patch job and wait for the user job to become executable, thereby reducing the risk that the waiting time of the user job will increase significantly due to the effect of the patch job.

[0149] The scheduler 100 also searches for a schedule that minimizes the total waiting time of multiple user jobs and determines when to execute a patch job. This reduces the average waiting time of user jobs through overall optimization compared to when only focusing on the waiting time of the user job immediately following the patch job. In addition, shortening the waiting time of some user jobs reduces the risk of increasing the waiting time of other user jobs, improving the fairness of waiting times among multiple user jobs. The scheduler 100 also stacks individual schedule candidates for each user job according to the order on the waiting job list to comprehensively search for executable schedule candidates. This allows a schedule that minimizes the total waiting time to be determined with high accuracy. [Explanation of symbols]

[0150] 10. Information processing device 11 Storage section 12 Processing section 13,14 Update Jobs 15,16 User Jobs 17,18 Schedule

Claims

1. A process of identifying, from among a plurality of waiting jobs, an update job for updating control software of a target node among a plurality of nodes, and two or more user jobs each specifying a number of nodes to be used, which indicates the number of nodes to be used among the plurality of nodes, and a scheduled execution time; a process of searching for a schedule for the update job and the two or more user jobs based on the number of nodes to be used and the scheduled execution time so that a free node among the plurality of nodes and a node having a common version of the control software is assigned to each of the two or more user jobs, thereby reducing a total waiting time of the two or more user jobs; a process of controlling an execution order of the update job and the two or more user jobs based on the searched schedule; A scheduling program that causes a computer to execute the above.

2. the update job is a job at the top of a queue of waiting jobs including the plurality of waiting jobs, and the two or more user jobs are jobs at a rear of the update job in the queue of waiting jobs; The scheduling program according to claim 1.

3. the schedule is searched from among a plurality of schedules including a first schedule in which the update job is executed prior to the two or more user jobs, and a second schedule in which at least a part of the two or more user jobs is executed prior to the update job; The scheduling program according to claim 1.

4. the searching process includes a process of calculating a plurality of first patterns for allocating the number of nodes having the common version to a first user job of the two or more user jobs, and a process of calculating a second pattern for allocating the number of nodes having the common version to a second user job of the two or more user jobs, for each of the plurality of first patterns. The scheduling program according to claim 1.

5. A process of identifying, from among a plurality of waiting jobs, an update job for updating control software of a target node among a plurality of nodes, and two or more user jobs each specifying a number of nodes to be used, which indicates the number of nodes to be used among the plurality of nodes, and a scheduled execution time; a process of searching for a schedule for the update job and the two or more user jobs based on the number of nodes to be used and the scheduled execution time so that a free node among the plurality of nodes and a node having a common version of the control software is assigned to each of the two or more user jobs, thereby reducing a total waiting time of the two or more user jobs; a process of controlling an execution order of the update job and the two or more user jobs based on the searched schedule; A job scheduling method executed by a computer.

6. a storage unit that stores job information indicating a plurality of jobs waiting to be executed, including an update job for updating control software of a target node among a plurality of nodes, and two or more user jobs each specifying a number of nodes to be used among the plurality of nodes and a scheduled execution time; a processing unit that searches for a schedule for the update job and the two or more user jobs based on the number of nodes to be used and the scheduled execution time so as to reduce a total waiting time of the two or more user jobs, so that a node that is a free node among the plurality of nodes and has a common version of the control software is assigned to each of the two or more user jobs, and controls an execution order of the update job and the two or more user jobs based on the searched schedule; An information processing device having the above configuration.

Images