WO2008040563A1 - Procédé, système et programme informatique permettant de répartir l'exécution de travaux indépendants - Google Patents
Procédé, système et programme informatique permettant de répartir l'exécution de travaux indépendants Download PDFInfo
- Publication number
- WO2008040563A1 WO2008040563A1 PCT/EP2007/052719 EP2007052719W WO2008040563A1 WO 2008040563 A1 WO2008040563 A1 WO 2008040563A1 EP 2007052719 W EP2007052719 W EP 2007052719W WO 2008040563 A1 WO2008040563 A1 WO 2008040563A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- cumulative
- sequence
- execution
- ranges
- random number
- Prior art date
Links
- 238000000034 method Methods 0.000 title claims description 44
- 238000004590 computer program Methods 0.000 title claims description 5
- 230000001186 cumulative effect Effects 0.000 claims abstract description 102
- 230000003247 decreasing effect Effects 0.000 claims abstract description 5
- 238000012545 processing Methods 0.000 claims description 11
- 238000009826 distribution Methods 0.000 claims description 9
- 230000004044 response Effects 0.000 claims description 4
- 230000000875 corresponding effect Effects 0.000 description 29
- 230000000694 effects Effects 0.000 description 15
- 238000004519 manufacturing process Methods 0.000 description 10
- 230000009471 action Effects 0.000 description 8
- 230000008569 process Effects 0.000 description 6
- 230000015654 memory Effects 0.000 description 5
- 238000010586 diagram Methods 0.000 description 3
- 230000006870 function Effects 0.000 description 3
- 230000009467 reduction Effects 0.000 description 3
- 239000003795 chemical substances by application Substances 0.000 description 2
- 230000002452 interceptive effect Effects 0.000 description 2
- 239000004065 semiconductor Substances 0.000 description 2
- 238000003860 storage Methods 0.000 description 2
- 238000012360 testing method Methods 0.000 description 2
- 230000003936 working memory Effects 0.000 description 2
- 241001672018 Cercomela melanura Species 0.000 description 1
- 230000004075 alteration Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000001143 conditioned effect Effects 0.000 description 1
- 230000001276 controlling effect Effects 0.000 description 1
- 238000012937 correction Methods 0.000 description 1
- 238000007728 cost analysis Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000001627 detrimental effect Effects 0.000 description 1
- 230000009977 dual effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000007613 environmental effect Effects 0.000 description 1
- 230000003203 everyday effect Effects 0.000 description 1
- 230000007717 exclusion Effects 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 239000000463 material Substances 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/505—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the load
Definitions
- the present invention relates to the information technology field. More specifically, the invention relates to the distribution of the execution of work units in a data processing system.
- Data processing systems based on multiple computers are commonplace in several environments (such as in server farms) .
- This architecture allows implementing systems to be very powerful and easily scaleable; moreover, the same structure ensures high reliability (since operation of the system can be recovered even in case of failure of one or more computers) .
- a problem of the above-described systems is that of distributing the required activities correctly among the different computers.
- load-balancing applications or load-balancers
- the load-balancers submit the activities for their execution on the computers according to predefined algorithms, which are aimed at optimizing the overall performance of the system.
- a conventional approach consists of assigning the activities to the computers according to a round-robin policy; more sophisticated techniques select the computers for processing the activities according to their measured workloads.
- a typical example is that of a scheduling application (or scheduler) , which is commonly used to control the execution of different work units - such as batch jobs - according to a specific plan (for example, based on constraints defined by the completion of other jobs).
- the scheduler may interface with a workload manager to get recommendations of ways to distribute the execution of the jobs on the available computers.
- the workload manager periodically provides information about the workload of each computer to the scheduler. In this way, the scheduler can select the computer with the lowest workload for executing each job.
- the scheduler can easily achieve any distribution suggested by the workload manager.
- the selection is generally performed individually for each job; therefore, there is the risk of overloading the same computer (since the effects of the execution of the other jobs are not apparent until the next collection of the workload information from the load-balancer) .
- each job must be executed as soon the plan allows doing so, and it is not possible to wait for a significant number of jobs ready to be executed (which should then be distributed among the computers according to the corresponding workloads) .
- a further problem is caused by the fact that each job has specific requirements, which limit the computers on which the job can be executed. Therefore, the scheduler can select the computer for executing each job only among the ones satisfying the corresponding requirements. As a result, the distribution of the frequency of execution of the jobs on the computers in any case cannot reflect the corresponding workloads.
- the present invention suggests the use of a probabilistic method for distributing the execution of the work units.
- the present invention provides a solution as set out in the independent claims.
- Advantageous embodiments of the invention are described in the dependent claims.
- an aspect of the invention provides a method for distributing execution of work units on a plurality of data processing entities; each entity is associated with a corresponding target frequency (for the distribution of the work units on the entity) .
- the method includes the following steps. At first, a sequence of cumulative ranges associated with the entities is created; the cumulative range associated with each entity has a size corresponding to the target frequency of the entity. The method continues by generating a substantially random number. One of the cumulative ranges of the sequence is selected according to the random number. The entity associated with the selected cumulative range of the sequence is then elected for executing the work unit.
- the cumulative range of each entity is obtained by summing its target frequency with the preceding ones.
- the cumulative ranges are shifted forwards or backwards when the selected cumulative range is in the first half or in the second half, respectively, of the sequence.
- the random number - from 0 to 1 - is corrected according to a global range of the cumulative ranges.
- each random number is uniformly distributed.
- the target frequencies are calculated by normalizing corresponding performance weights of the entities.
- the proposed solution finds application in a scheduler .
- Another aspect of the invention proposes a computer program for performing the method.
- a further aspect of the invention proposes a corresponding system.
- Figure 1 is a schematic block diagram of a data processing system in which the solution according to an embodiment of the invention is applicable;
- Figure 2 is a collaboration diagram representing the roles of different software modules implementing the solution according to an embodiment of the invention
- Figures 3a-3g illustrate an exemplary application of the solution according to an embodiment of the invention
- Figure 4 provides experimental results of an exemplary application of the solution according to an embodiment of the invention.
- Figures 5a-5b show a diagram describing the flow of activities relating to an implementation of the solution according to an embodiment of the invention.
- the system 100 includes a central scheduling server 105, which is used to automate, monitor and control the execution of work units in the system 100.
- the work units consist of non-interactive tasks (for example, payroll programs, cost analysis applications, and the like) , which are to be executed on a set of execution servers 110.
- the scheduling server 105 and the execution servers 110 communicate through a network 115 - such as a Local Area Network (LAN) .
- LAN Local Area Network
- the scheduling server 105 is formed by several units that are connected in parallel to a system bus 120.
- multiple microprocessors ( ⁇ P) 125 control operation of the scheduling server 105;
- a RAM 130 is directly used as a working memory by the microprocessors 125, and
- a ROM 135 stores basic code for a bootstrap of the scheduling server 105.
- peripheral units are clustered around a local bus 140 (by means of respective interfaces) .
- a mass storage consists of one or more hard-disks 145 and drives 150 for reading CD-ROMs 155.
- the scheduling server 105 includes input units 160 (for example, a keyboard and a mouse), and output units 165 (for example, a monitor and a printer) .
- An adapter 170 is used to connect the scheduling server 105 to the network 115.
- a bridge unit 175 interfaces the system bus 120 with the local bus 140.
- Each microprocessor 125 and the bridge unit 175 can operate as master agents requesting an access to the system bus 120 for transmitting information.
- An arbiter 180 manages the granting of the access with mutual exclusion to the system bus 120.
- the main software modules that run on the scheduling server are denoted as a whole with the reference 200.
- the information is typically stored on the hard-disk and loaded (at least partially) into the working memory of the scheduling server when the programs are running.
- the programs are initially installed onto the hard disk, for example, from CD-ROM.
- the figure describes the static structure of the system (by means of the corresponding modules) and its dynamic behavior (by means of a series of exchanged messages, each one representing a corresponding action denoted with sequence numbers preceded by the symbol "A”) .
- the scheduling server runs a scheduler 205 for example, consisting of the "IBM Tivoli Workload Scheduler (TWS)" by IBM Corporation.
- the scheduler 205 includes a controller 210 (such as the “Composer” program in the case of the "TWS") , which is used to maintain a workload database 215 (action "Al .Maintain”) .
- the workload database 215 contains the definition of the whole scheduling environment. Particularly, the workload database 215 stores a representation of the topology of the system (i.e., the execution servers with their connections) and of the hardware/software resources that are available for executing the jobs.
- the workload database 215 also includes a descriptor of each job, which defines rules controlling its execution (written in a suitable control language, for example, XML-based). More specifically, the job descriptor specifies the programs to be invoked, their arguments and environmental variables.
- the execution of the job is typically conditioned by a set of dependencies (which must be satisfied before the job can be submitted); exemplary dependencies are time constraints (such as its run-cycle - like every day, week or month) , sequence constraints (such as the successful completion of other jobs), or enabling constraints (such as the entering of a response to a prompt by an operator) .
- the job descriptor also specifies the resources that are required by the job; those resources can be seen as further dependencies, which condition the execution of the job to their availability.
- the job descriptor includes statistics information relating to the job; for example, the statistics information provides a log of an actual duration of previous executions of the job, from which an estimated duration for its next executions may be inferred.
- a planner 220 (such as the "Master Domain Manager” of the "TWS") creates a workload plan; the plan consists of a batch of jobs - together with their dependencies - scheduled for execution on a specific production period (typically, one day) .
- a new plan is generally created automatically before every production period.
- the planner 220 processes the information available in the workload database 215 so as to select the jobs to be run and to arrange them in the desired sequence (according to their dependencies and expected duration) .
- the planner 220 creates the plan by adding the jobs to be executed (for the next production period) and by removing the preexisting jobs (of the previous production period) that have been completed; in addition, the jobs of the previous production period that did not complete successfully or that are still running or waiting to be run can be maintained in the plan (for their execution during the next production period) .
- the plan so obtained is then stored into a corresponding control file 225 - such as the "Symphony" of the "TWS" (action "A2. Create”) .
- a handler 230 (such as the "Batchman” process of the "TWS") starts the plan at the beginning of every production period (action “A3. Start”).
- the handler 230 interfaces with a workload manager 235 - for example, consisting of the "Enterprise Workload Manager (EWLM)" by IBM Corporation; the "EWLM” allows defining business-oriented performance goals for an entire domain of execution servers, so as to provide an end-to-end view of actual performance relating to those goals.
- the workload manager 235 provides information about the workload of each execution server to the scheduler 205. Typically, this workload information consists of a numerical weight for each execution server.
- the weight measures the performance of the execution server - for example, ranging from 0 (when the execution server is completely busy) to 100 (when the execution server is substantially idle) .
- This performance weight is commonly obtained by combining key metrics of the execution server (such as its processing power usage, memory usage, network activity, amount of input/output operations, job execution details, and the like) .
- the handler 230 saves the performance weights of all the execution servers into a corresponding table 240 (action "A4.Weights”) .
- the handler 230 submits the jobs of the plan for execution as soon as possible - according to their dependencies.
- an analyzer 245 selects one or more of the execution servers that are eligible to execute the job (i.e., satisfying its resource dependencies) ; preferably, the analyzer 245 creates a list that orders the (eligible) execution servers (or a part of them) in decreasing order of preference.
- the creation of this preference list for each job is described in detail further in the text.
- the preference list so obtained is then provided to the handler 230 (action "A5.List").
- the handler 230 selects the first execution server of the preference list that is available for submitting the execution of the job (Action "A6. Submit”) .
- the actual execution of the job is managed by a corresponding module 250 (such as the "Jobman" process of the "TWS") .
- the executor 250 directly launches and tracks the job, by interfacing with an agent (not shown in the Figure) running on the selected execution server.
- the executor 250 returns feedback information about the execution of the job to the handler 230 (for example, whether the job has been completed successfully, its actual duration, and the like) ; the handler 230 enters this feedback information into the control file 225, so as to have a real-time picture of the current state of all the jobs of the plan (action "A7. Feedback”) .
- the planner 220 extracts the feedback information of the completed jobs from the control file 225.
- the planner 220 revises the statistics information relating to the completed jobs accordingly, and updates it in the workload database 215 (action "A8. Statistics”) .
- the performance weights Wi are not normalized (i.e., their sum is different from 100); this is due to the fact that the execution servers are generally only a part of the computers controlled by the workload manager and/or to an intrinsic limitation of the workload manager.
- the target frequencies Fj indicate how the jobs should be distributed for execution on the execution servers Sj in the ideal situation (so as to distribute the workload according to their performance) .
- the sequence of target frequencies Fj so obtained is then converted into a cumulative form - defined by a sequence of disjoint ranges of values being adjacent to one another. Particularly, for each execution server Sj a selection cumulative range Cj is calculated.
- HCj Fj + HCj-I for j>0
- the cumulative range Cj of each execution server Sj has a size (from the lower limit LCj to the upper limit HCj) that is equal to its target frequency Fj .
- the cumulative ranges Cj will span a global range GR from 0 to 1.
- a uniformly distributed random number RN is generated; the random number RN spans the same global range GR of the cumulative ranges Cj (i.e., from 0 to 1) .
- This random number RN selects one of the cumulative ranges Cj including it (differentiated with a prime notation, i.e., Cj'); for example, this result may be achieved by applying a binary search on the sequence of cumulative ranges Cj .
- the execution server corresponding to the selected cumulative range Cj ' (differentiated with the same prime notation, i.e., Sj') is then selected for executing the job.
- the proposed solution allows preventing any risk of overloading single execution servers Si.
- the devised technique is also less sensitive to the fact that the selection of the execution servers Si on which each job must be submitted is limited to a part of them only (i.e., to the corresponding eligible execution servers Sj).
- next execution servers - wherein the job may be executed in decreasing order of preference - are selected by reiterating the same operations described above on a reduced sequence of execution servers - obtained by removing the information relating to the selected execution server Sj ' .
- each shifted cumulative range Cj is increased by the target frequency of the selected execution server Sj' (differentiated by the same prime notation, i.e., Fj'):
- the cumulative range Cj of each execution server Sj has again a size (from the lower limit LCj to the upper limit HCj) that is equal to its target frequency Fj.
- the cumulative ranges Cj will span a different global range (differentiated by adding an apex A , i.e., GR A ); particularly, the global range GR A is now from the lower limit of the first cumulative range Cj in the sequence - denoted with LCfirst - to 1.
- a further random number (again from 0 to 1) is generated - differentiated by adding the same apex A , i.e., RN A ; the random number RN A is then updated so as to span the global range GR A of the cumulative ranges Cj (now from LCfirst to 1) :
- RN ⁇ LCfirst+RN ⁇ *GE ⁇ .
- this random number RN A selects one of the cumulative ranges Cj including it; the execution server corresponding to the selected cumulative range is then selected as a second choice for executing the job.
- the global range GR A of the cumulative ranges Cj is now from 0 to the upper limit HCj of the last cumulative range Cj in the sequence - denoted with HClast.
- the two reduction algorithms described above are combined together.
- the cumulative ranges Cj are shifted forwards when the selected cumulative range Cj' is in a first half of the sequence, whereas they are shifted backwards when the selected cumulative range Cj' is in a second half of the sequence (with the choice that is indifferent when the selected cumulative range Cj' is exactly in the middle of the sequence) .
- the global range GR A will be from the first lower limit LCfirst to last upper limit HClast.
- the random numbers are obtained from a pseudo-random generator.
- a pseudo-random generator For example, it is possible to use the object "Random" of the Java language, which object exposes the method “nextDouble ( ) " returning all 2 53 possible float values of the form m*2 ⁇ 53 , where m is a positive integer less than 2 53 , with approximately equal probability.
- the values of the random numbers generated for a particular choice in the preference lists for different jobs may exhibit a lack of correlation to the given weights. This is because the values of the random numbers already generated are no longer available for the other jobs (making the random number generator no longer uniform) . This might cause the creation of preference lists that do not reflect the distribution of the desired target frequencies accurately. Care should then be taken to make sure a new random number generator is available to use for each choice iteration to ensure the uniformity of the random numbers generated.
- the method begins at the black start circle 503 in the swim-lane of the load-balancer. Whenever a predefined time-out expires at block 506 (for example, every 20-4Os), the workload manager at block 509 transmits the performance weights of all the execution servers to the scheduler. In response thereto, the scheduler at block 512 stores these performance weights in the corresponding table (replacing their previous values) .
- the desired plan is started at the beginning of every production period; every job of the plan is submitted for execution at block 515 as soon as possible (according to its dependencies).
- the method passes to block 518, wherein the eligible execution servers for the job are selected (among all the execution servers, by discarding the ones that do not satisfy its resource dependencies).
- the execution servers are arranged in a sequence (for example, according to their names) .
- the target frequency of each execution server is then calculated at block 524 (by normalizing its performance weight) .
- the flow of activity passes to block 527, wherein the target frequencies are converted into the corresponding cumulative ranges.
- the method then enters a loop for building the preference list (of the execution servers) for the job.
- the loop begins at block 530 with the generation of a new random number (from 0 to 1) .
- the random number is then updated at block 533 so as to span the current global range of the cumulative ranges (when it is necessary, i.e., starting from the second iteration of the loop - for the selection of the execution servers following the first choice) .
- the cumulative range including the random number is identified.
- the execution server corresponding to this cumulative range is then selected and added to the preference list (starting from the beginning) at block 536.
- the method branches at block 539 according to the configuration of the scheduler. If a single execution server must be selected, the flow of activity descends into block 542 (described in the following) . Conversely, a test is made at block 543 to verify whether the desired preference list is complete (for example, when all the execution servers have been added or a predefined maximum length has been reached) . If so, the method likewise descends into block 542. On the contrary, the flow of activity branches again at block 545 according to the position of the previously selected cumulative range in the corresponding sequence. Particularly, if the position falls in the first half of the sequence the blocks 548-551 are executed, whereas if the position falls in the second half of the sequence the blocks 554-557 are executed; in both cases, the method merges at block 560.
- the cumulative ranges preceding the selected one in the sequence are shifted forwards.
- the shifted cumulative ranges are then corrected at block 551 by adding the target frequency of the selected execution server (so as to compensate the removal of the selected cumulative range) .
- the cumulative ranges following the selected one in the sequence are shifted backwards.
- the shifted cumulative ranges are then corrected at block 557 by subtracting the target frequency of the selected execution server.
- the global range is updated accordingly at block 560 - so as to span from the first lower limit to the last upper limit of the cumulative ranges.
- the method then returns to block 530 to repeat the operations described above (for the selection of next execution servers representing secondary choices for executing the job) .
- the job is submitted for execution.
- the first execution server in the preference list is extracted at block 566.
- a test is made at block 569 to verify whether the (current) execution server is available for executing the job. If so, the job is launched on this execution server at block 572. The flow of activity then passes to block 575 (described in the following) . Conversely, the method verifies at block 578 the residual content of the preference list. If the preference list is not empty, a further execution server is extracted therefrom at block 581. The method then returns to block 569 to reiterate the same operations.
- the statistics information relating to the completed jobs is updated in the workload database at block 593 according to the corresponding feedback information.
- the method then ends at the concentric white/black stop circles 596.
- each computer may have another structure or may include similar elements (such as cache memories temporarily storing the programs or parts thereof to reduce the accesses to the mass memory during execution) ; in any case, it is possible to replace the computer with any code execution entity (such as a PDA, a mobile phone, and the like) .
- code execution entity such as a PDA, a mobile phone, and the like
- job as used herein may include other work units (such as interactive tasks) , or more generally whatever activities to be distributed for their execution on multiple computers.
- the execution servers may be ordered in a different way, the cumulative ranges may be calculated with other formulas (with their sizes that may also not depend linearly on the corresponding target frequencies) , or the random numbers may be generated with equivalent functions.
- the proposed algorithm for selecting the first execution server is not to be interpreted in a limitative manner. For example, nothing prevents assigning the cumulative ranges to the execution servers in a different way (for example, calculating them starting from the end of the sequence) .
- the random numbers may be generated with equivalent functions (for example, with the random numbers that span the current global range of the cumulative ranges directly) .
- any other generator of (substantially) random number may be used.
- the workload manager (or any equivalent component) may provide different performance information (such as already normalized) , or the selection may always be performed on all the execution servers for every job.
- the proposed technique has equal applicability to equivalent schedulers.
- the same solution may also be implemented in any other data processing system (such as in a server farm) .
- the program may take any form suitable to be used by or in connection with any data processing system, such as external or resident software, firmware, or microcode (either in object code or in source code) .
- the medium can be any element suitable to contain, store, communicate, propagate, or transfer the program.
- the medium may be of the electronic, magnetic, optical, electromagnetic, infrared, or semiconductor type; examples of such medium are fixed disks
- the solution according to the present invention lends itself to be implemented with a hardware structure (for example, integrated in a chip of semiconductor material), or with a combination of software and hardware.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Multi Processors (AREA)
Abstract
La solution (500) proposée permet de répartir l'exécution de travaux dans un ordonnanceur. Les travaux doivent être soumis individuellement à une exécution (515) sur une série de serveurs d'exécution avec des fréquences cibles de sélection qui correspondent à leur poids de performance (donnés, par exemple, par un gestionnaire de charge de travail). À cette fin, les serveurs d'exécution sont ordonnés (521) selon une séquence définie; la séquence correspondante des fréquences cibles est ensuite convertie (527) sous forme cumulative - en attribuant une plage cumulative de sélections à chaque serveur d'exécution (avec une taille égale à la fréquence cible correspondante). Un chiffre aléatoire (allant de 0 à 1) est utilisé (530 à 535) pour sélectionner la plage cumulative qui l'inclut. Le travail est alors soumis (536) au serveur d'exécution qui correspond à la plage cumulative sélectionnée. Les mêmes opérations peuvent également être réitérées (543 à 560) pour obtenir une liste de serveurs d'exécution dans l'ordre de préférence décroissant pour exécuter le travail.
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
EP06121689 | 2006-10-03 | ||
EP06121689.1 | 2006-10-03 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2008040563A1 true WO2008040563A1 (fr) | 2008-04-10 |
Family
ID=38117060
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/EP2007/052719 WO2008040563A1 (fr) | 2006-10-03 | 2007-03-22 | Procédé, système et programme informatique permettant de répartir l'exécution de travaux indépendants |
Country Status (1)
Country | Link |
---|---|
WO (1) | WO2008040563A1 (fr) |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8185902B2 (en) | 2007-10-31 | 2012-05-22 | International Business Machines Corporation | Method, system and computer program for distributing a plurality of jobs to a plurality of computers |
US20240020597A1 (en) * | 2022-07-15 | 2024-01-18 | Ukg Inc. | Systems and methods for extended horizon time-sequences |
Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5951694A (en) * | 1995-06-07 | 1999-09-14 | Microsoft Corporation | Method of redirecting a client service session to a second application server without interrupting the session by forwarding service-specific information to the second server |
US6070191A (en) * | 1997-10-17 | 2000-05-30 | Lucent Technologies Inc. | Data distribution techniques for load-balanced fault-tolerant web access |
WO2000045263A2 (fr) * | 1999-02-01 | 2000-08-03 | Mpath Interactive, Inc. | Gestionnaire adaptatif de fils |
WO2001063403A2 (fr) * | 2000-02-25 | 2001-08-30 | Sun Microsystems, Inc. | Procede et appareil de repartition de la charge dans un environnement informatique |
US6859834B1 (en) * | 1999-08-13 | 2005-02-22 | Sun Microsystems, Inc. | System and method for enabling application server request failover |
-
2007
- 2007-03-22 WO PCT/EP2007/052719 patent/WO2008040563A1/fr active Application Filing
Patent Citations (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5951694A (en) * | 1995-06-07 | 1999-09-14 | Microsoft Corporation | Method of redirecting a client service session to a second application server without interrupting the session by forwarding service-specific information to the second server |
US6070191A (en) * | 1997-10-17 | 2000-05-30 | Lucent Technologies Inc. | Data distribution techniques for load-balanced fault-tolerant web access |
WO2000045263A2 (fr) * | 1999-02-01 | 2000-08-03 | Mpath Interactive, Inc. | Gestionnaire adaptatif de fils |
US6859834B1 (en) * | 1999-08-13 | 2005-02-22 | Sun Microsystems, Inc. | System and method for enabling application server request failover |
WO2001063403A2 (fr) * | 2000-02-25 | 2001-08-30 | Sun Microsystems, Inc. | Procede et appareil de repartition de la charge dans un environnement informatique |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8185902B2 (en) | 2007-10-31 | 2012-05-22 | International Business Machines Corporation | Method, system and computer program for distributing a plurality of jobs to a plurality of computers |
US20240020597A1 (en) * | 2022-07-15 | 2024-01-18 | Ukg Inc. | Systems and methods for extended horizon time-sequences |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US11226848B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager with snapshot and resume functionality | |
US10956222B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager with dynamic workload termination based on cost-benefit analysis | |
US11237865B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager that identifies and consumes global virtual resources | |
US11243807B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager with workload re-execution functionality for bad execution runs | |
US20220300334A1 (en) | System and Method for a Self-Optimizing Reservation in Time of Compute Resources | |
US11243818B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager that identifies and optimizes horizontally scalable workloads | |
Peng et al. | Optimus: an efficient dynamic resource scheduler for deep learning clusters | |
US11237866B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager with scheduling redundancy and site fault isolation | |
Yan et al. | Tr-spark: Transient computing for big data analytics | |
US10810043B2 (en) | Systems, methods, and apparatuses for implementing a scheduler and workload manager with cyclical service level target (SLT) optimization | |
Huedo et al. | A framework for adaptive execution in grids | |
Yu et al. | An adaptive rescheduling strategy for grid workflow applications | |
US8140523B2 (en) | Decision based system for managing distributed resources and modeling the global optimization problem | |
US9262216B2 (en) | Computing cluster with latency control | |
US8230426B2 (en) | Multicore distributed processing system using selection of available workunits based on the comparison of concurrency attributes with the parallel processing characteristics | |
US20070016907A1 (en) | Method, system and computer program for automatic provisioning of resources to scheduled jobs | |
US8631412B2 (en) | Job scheduling with optimization of power consumption | |
US20090007132A1 (en) | Managing processing resources in a distributed computing environment | |
Di et al. | Adaptive algorithm for minimizing cloud task length with prediction errors | |
CN107038070A (zh) | 一种云环境下执行可靠性感知的并行任务调度方法 | |
US20090158286A1 (en) | Facility for scheduling the execution of jobs based on logic predicates | |
US20080221857A1 (en) | Method and apparatus for simulating the workload of a compute farm | |
Roy et al. | Condor and preemptive resume scheduling | |
US20090089772A1 (en) | Arrangement for scheduling jobs with rules and events | |
Rood et al. | Grid resource availability prediction-based scheduling and task replication |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 07727195 Country of ref document: EP Kind code of ref document: A1 |
|
NENP | Non-entry into the national phase |
Ref country code: DE |
|
122 | Ep: pct application non-entry in european phase |
Ref document number: 07727195 Country of ref document: EP Kind code of ref document: A1 |