A scheduler for executing a set of task jobs using a set of machines, and in particular a computer-implemented method of machine scheduling.

Abstract

To provide a method of machine scheduling for performing a set of jobs of a task.SOLUTION: A method includes determining, in a first iteration, a first schedule that solves an optimization problem. The optimization problem is defined by a set of rules that assign a set of jobs to a set of machines. The first schedule maps each of the jobs to one machine, of the set of machines, that is capable of processing the job. Execution of jobs by one machine assigned thereto is scheduled to be finished in one machine span. The method further includes, in a second iteration, determining a constraint for at least one machine span, and determining a second schedule that solves the optimization problem about the set of jobs and the set of machines under the constraint, or determining a second schedule that solves the optimization problem about a sub-set of the set of jobs and a sub-set of the set of machines.SELECTED DRAWING: None

Description

[Technical Field]

[0001] background The present invention relates to a scheduler for executing a set of task jobs using a set of machines, and in particular to a computer-implemented method of machine scheduling. [Background technology]

[0002] Dimitrios Letsios, Miten Mistry, and Ruth Misener, “Exact lexicographic scheduling and approximate rescheduling”, European Journal of Operational Research Volume 290, Issue 2, April 16, 2021, pp. 469-478, discloses aspects of relevant scheduling approaches.

[0003] Further methods for machine scheduling are known from U.S. Patent Application Publication No. 2020 / 0320456, German Patent Invention No. 69513877 (translation), German Patent Application Publication No. 102016204392, and U.S. Patent No. 9798947. [Prior art documents] [Patent Documents]

[0004] [Patent Document 1] U.S. Patent Application Publication No. 2020 / 0320456 [Patent Document 2] German Patent No. 69513877 Specification Translation [Patent Document 3] German Patent Application Publication No. 102016204392 Specification [Patent Document 4] U.S. Patent No. 9798947 [Non-patent literature]

[0005] [Non-Patent Document 1] “Exact lexicographic scheduling and approximate rescheduling” by Dimitrios Letsios, Miten Mistry, Ruth Misener, European Journal of Operational Research Volume 290, Issue 2, April 16, 2021, pp. 469-478 [Overview of the project] [Problems that the invention aims to solve]

[0006] Disclosure of the invention The scheduler, computer program, and in particular a computer-implemented method for machine scheduling described in an independent claim further improve scheduling to make it directly usable for relatively complex scheduling problems involving machine allocation, sequence-dependent setup time, and release date, and to solve the problem of making it easier to maintain the specifications of the scheduling problem when requirements change. [Means for solving the problem]

[0007] A machine scheduling method, particularly computer-implemented, for executing a set of tasks or jobs using a set of machines, comprises, in a first iteration, determining a first schedule for solving an optimization problem, defined by a set of rules for assigning a set of jobs to a set of machines, the first schedule mapping each job in the set of jobs to one machine in the set of machines capable of handling the job, and scheduling the execution of a job assigned to a machine by the first schedule to be completed within one machine span, the method comprises, in a second iteration, determining constraints relating to at least one machine span, and determining a second schedule for solving an optimization problem relating to a set of jobs and a set of machines under those constraints, or determining a second schedule for solving an optimization problem relating to a subset of jobs and a subset of machines, wherein the subset of machines excludes the machines, and the subset of jobs excludes jobs assigned to machines according to the first schedule. This method can be directly applied to relatively complex scheduling problems involving machine allocation, sequence-dependent setup time, and release dates. Furthermore, another advantage is that it can be applied to prior art knowledge representations and inference solvers using their respective modeling languages, making it easier to maintain the specifications of the scheduling problem when requirements change.

[0008] The method may include selecting a machine from a set of machines that has a machine span that ends within a make span for performing a task according to a first schedule, and forming a subset of the set of machines that does not contain at least one machine. This reduces the complexity of the optimization problem concerning the machines.

[0009] The method may involve forming a subset of the job set that does not include at least one job assigned to the machine. This reduces the complexity of the job optimization problem.

[0010] The method may include determining a plurality of machine spans for a plurality of machines scheduled to execute at least one job according to a first schedule among a set of machines. Therein, a machine span having a duration longer than at least one other machine span among the plurality of machine spans is selected as a constraint from the plurality of machine spans. Thereby, the solution of the optimization problem is constrained by the machine span having a duration longer than the other machine spans. Thereby, the solution is determined very efficiently.

[0011] The method may include determining a sequence in which jobs assigned to a machine are scheduled to be processed on the machine, and determining a machine span depending on the completion time of the last job in the sequence. Thereby, it becomes possible to determine a machine span for improving the robustness of the scheduling method.

[0012] The method may include determining the completion time of the last job depending on the sum of the start times of the first jobs in the sequence, the sum of the processing times of at least one job in the sequence scheduled to start earlier than the last job, and the duration of the last job. Thereby, the completion time of the last job is determined very accurately. Thereby, the robustness of the scheduling method is further improved.

[0013] The method may include determining a plurality of schedules in a plurality of iterations while limiting the number of iterations to be less than the number of machines in the plurality of machines. Thereby, the scheduling becomes much faster.

[0014] The method may include scheduling at least one machine among a set of machines to execute at least one job among a set of jobs according to a second schedule. By doing so, the machines are scheduled very efficiently.

[0015] A scheduler for using a set of machines to execute a set of jobs of a task within a makespan is configured to perform each step of the method.

[0016] A computer program includes computer-readable instructions for causing a computer to perform each step of the method when executed by the computer.

[0017] Further advantageous embodiments can be derived from the following description and the drawings.

Brief Description of the Drawings

[0018] [Figure 1] It is a diagram schematically showing at least a part of a scheduler for a set of machines. [Figure 2] It is a diagram schematically showing steps executed by a scheduler. [Figure 3] It is a diagram schematically showing steps in a first method. [Figure 4] It is a diagram schematically showing steps in a second method.

Modes for Carrying Out the Invention

[0019] Figure 1 schematically shows at least a portion of a scheduler 102 for a set of machines K. The scheduler 102 may include at least one processor and at least one memory, in particular for storing computer-readable instructions that, when executed by at least one processor of the scheduler 102, cause the scheduler 102 to execute a particularly computer-implemented scheduling method, as described below. The set of machines (hereinafter denoted by reference numeral K and not shown) represents a plurality of machines 104. In this example, the scheduler 102 and each of the plurality of machines 104 are connected at least temporarily via a data link 103. In this example, the scheduler 102 is configured to instruct at least some of the plurality of machines 104 to execute each job from a set of jobs (hereinafter denoted by reference numeral J and not shown).

[0020] This method solves the scheduling problem.

[0021] Given m machines k in a set K and n jobs j in a set J, each job j must be processed by a single machine k, and each machine k can process a maximum of one job j at a time. In other words, preemption is not permitted.

[0022] Some machines k can only handle specific jobs j. That is, cap(j) is the set of machines that can process job j.

[0023] Release date r for each job j and machine k j;k However, it is specified as a non-negative integer. The release date is machine-dependent because the time it takes to transport a job to the machine depends on the transport system and the location of the transport system. For any job j, the job release date r j;k It cannot be started earlier.

[0024] To change from one job j to the next job j, a time of a specified length may be required. Time s i;j;k is the time required to set up job j immediately after job i on machine k.

[0025] These times are referred to as sequence-dependent setup times. Each job j has a duration d j;k that depends on the machine k to which that job j is assigned.

[0026] A schedule for a problem instance is 1. An assignment a that maps each job j to a machine k ∈ cap(j) that can process that job j, 2. A total order for the set J of jobs j assigned to each machine k by the assignment a for that machine k

Number

[0027] Relationship

Number

[0028] If each job j can be processed by some machine k, then there exists at least one schedule for the problem instance.

[0029] j1, ···, j l Assume that is the processing sequence of job j assigned to machine k in a given schedule. Job j i The processing time p of ji is for this job j i the duration of this job j iThis is the sum of the setup time for the preceding job (if any), i.e., if i > 1, p j1 =d j1;k and p ji =s ji-1;ji;k +d ji;k Job J i Start time st ji When i=1, r ji;k And if i > 1, max(r ji;k ;st ji-1 +p ji-1 ) is. Job j i Completion time c ji , st ji +p ji The machine span(k) of machine k is the last job j on machine k. l This is the completion time.

[0030] The goal is to maximize throughput, which in this example is defined as the number of jobs j processed per unit of time. In principle, this is achieved by minimizing the make span, i.e., the maximum machine span of the schedule. However, when dealing with machines with high allocation rates, it is often observed that a large number of jobs can be processed by only a small number of machines. This means that the make span is determined by a small number of machines, with little regard for how jobs are scheduled on the remaining machines. This is undesirable, for example, when jobs need to be dynamically rescheduled due to sudden machine failures that can occur at any time. In such cases, domain experts have indicated the requirement that "all machines should complete as early as possible." This gives the scheduler the flexibility to reallocate and helps maintain high throughput.

[0031] To address this problem, this method uses an objective function that aims to capture the hope that all machines will be completed as early as possible. This objective function is referred to below as the lexicographical makesspan.

[0032] The lexicographical makespan of a schedule is defined as a tuple of all machine spans in non-ascending order. This method uses the lexicographical order of various schedule tuples for comparison, prioritizing schedules with smaller lexicographical makespans over schedules with larger ones. The resulting schedule is the one with the smallest lexicographical makespan. Therefore, the resulting schedule also has the smallest makespan, but ties are resolved by using machines that complete earlier.

[0033] To compute a schedule with the smallest lexicographical makespan, an exemplary exact algorithm and an exemplary approximate algorithm are described below. Both use solution set programming (ASP), a logic-based approach for declarative problem solving, as described in the following literature, for example.

[0034] Brewka, G., Eiter, T., Truszczy´nski, M., “Answer set programming at a glance. Communications of the ACM 54(12)”, pp. 92-103 (2011). El-Kholany, M., Gebser, M., “Job shop scheduling with multi-shot asp”, http: / / www.kr.tuwien.ac.at / events / taasp20 / accepted.html (2020), Workshop on Trends and Applications of Answer Set Programming (TAASP 2020).

[0035] The objective function called lexicographic makespan formulates the requirement that all machines should finish as early as possible.

[0036] When a schedule S containing m machines is given, the lexicographic makespan of S is the tuple ms(S) = (c_1, ···, c_m) of all machine spans c_i of S in non-increasing order.

[0037] In this definition, c_1 is the maximum machine span and thus corresponds to the makespan according to schedule S. For schedules S and S’ each containing m machines, if ms(S) is smaller than ms(S’) under the lexicographic order, S has a smaller lexicographic makespan than S’. This means that c_i < c’_i for the smallest index i, where ms(S) = (c_1, ···, c_m) and ms(S’) = (c’_1, ···, c’_m) do not match.

[0038] For a set S of schedules, if ms(S) is the smallest over all schedules in the set S, then S ∈ S is optimal.

[0039] The dynamics of a schedule S are described as the number of machines M(S; t) that finish at or before time t.

[0040] If S and S’ are two, particularly different, schedules for some problem instances, then if there exists a time point t such that M(S; t) > M(S’; t) and M(S; t’) ≥ M(S’; t’) for all t’ > t, then ms(S) < ms(S’).

[0041] In problems involving multiple machines, if the entire makespan is dominated by only a few machines, hierarchically minimizing all machine spans may be excessive. However, by comparing lexicographical makespans, parameterization becomes possible using an integer l that defines the number of components to consider in the comparison.

[0042] For schedules S and S', each containing m machines and having an integer l such that 1 ≤ l ≤ m, the makespan ms(S) = (c_1,···,c_m) corresponding to schedule S is smaller than the makespan ms(S') = (c'_1···,c'_m) corresponding to schedule S' under parameterized lexicographical order. For schedules with m machines, the makespan is obtained when l=1, and the complete lexicographical makespan is obtained when l=m.

[0043] In this example, the problem statement is modeled using a model that includes rules for assigning a set of jobs J to a set of machines K. The schedule maps each job j from the set of jobs to one machine k ∈ cap(j) from the set of machines K that can handle that job j. The execution of a job j assigned by the schedule to a machine k is scheduled to complete within the machine span c_i of that machine k.

[0044] The above-mentioned model and objective function can be modeled by an extension of ASP using differential logic, as described, for example, in "Clingo goes linear constraints over reals and integers" by Janhunen, T., Kaminski, R., Ostrowski, M., Schellhorn, S., Wanko, P., and Schaub, T., Theory and Practice of Logic Programming 17(5-6), pp. 872-888 (2017).

[0045] Multi-shot solving can be used to implement resource-friendly multiple calls to an ASP solver in order to solve an optimization problem defined by a model and objective function using an exact algorithm. This is described, for example, in Gebser, M., Kaminski, R., Kaufmann, B., and Schaub, T., “Multi-shot asp solving with clingo,” Theory and Practice of Logic Programming 19(1), pp. 27-82 (2019).

[0046] To solve optimization problems using approximation algorithms, a portion of the solution can be fixed after the solver call, which makes it possible to find the near-optimal solution in a short amount of time.

[0047] The scheduler and scheduling method are applicable to semiconductor manufacturing. In this embodiment, a set of machines K is used to manufacture semiconductors. The scheduler and scheduling method are also applicable to distributed computing systems. In this embodiment, a machine may be a processor, or a computing core of a processor, or dedicated hardware for performing computational operations. Jobs are assigned to machines under certain constraints for calculating an executable schedule. One of the requirements is that the schedule should be constructed so that all machines complete as early as possible. To address this requirement and calculate the desired schedule, an optimization function called the lexicographical makespan and the algorithm for minimizing this optimization function, as described below, can be used. The machines can be instructed according to the schedule that solves the optimization problem.

[0048] ASP is essentially a propositional, compact relational form in which variables in the input language are replaced with certain symbols in a preprocessing step called foundationalization. An ASP program can take the following forms: p1|···|pk:-q1,···,qm,not r1,···,not rn This is a set of rules where all pi, qj, and rl are atoms. The head is all atoms before the implication sign :-, and the body is all atoms and negations after it. The intuitive meaning of this rule is that if all atoms q1,...,qm can be derived, and there is no evidence for any of atoms r1,...,rn (i.e., the rule is firing), then at least one of p1,...,pk must be true. Interpretation I is a set of atoms. Interpretation I is the solution set of the program if all the rules of the program are satisfied minimally and consistently. I must be the ⊆minimal model of all firing rules. This aspect is described, for example, in Gelfond, M., and Lifschitz, V., “Classical negation in logic programs and disjunctive databases,” New generation computing 9(3-4), pp. 365-385 (1991).

[0049] Rules with an empty body are called facts, and the colon is usually omitted. Facts are used to represent knowledge that is unconditionally true. Rules with an empty head are constraints. The body of a constraint cannot be satisfied by any solution set and is used to prune undesirable solution candidates.

[0050] Common syntactic extensions take the following forms: i{p1,...,pk}j:-q1,...,qm,not r1,...,not rn This is the selection rule.

[0051] This means that if the rule is triggered, then some subset S of p1, ..., pk such that i ≤ |S| ≤ j must also be true.

[0052] In one example, an ASP solver that uses differential logic can be used to solve an optimization problem. An example of an ASP solver is clingo-dl (https: / / github.com / potassco / clingo-dl).

[0053] Difference logic can be used to solve optimization problems under constraints, especially under difference constraints. In this example, the difference constraint is an expression of the form uv ≤ d, where u and v are integer variables and d is an integer constant.

[0054] In contrast to unrestricted integer constraints, difference-constrained systems are solvable in polynomial time. The latter can be represented in clingo-dl using theoretical atoms. Theoretical atoms are described, for example, in "Theory solving made easy with clingo 5" by Gebsser, M., Kaminski, R., Kaufmann, B., Ostrowski, M., Schaub, T., and Wanko, P., in: Technical Communications of the 32nd International Conference on Logic Programming (ICLP 2016), Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik (2016).

[0055] The model in this example includes problem instances described by ASP facts using several fixed predicate names.

[0056] The following example describes the use of one machine m1 and two jobs j1 and j2. Machine m1 is capable of processing all jobs, and all release dates are 0. In this example, the setup time is 4 when changing from job j1 to job j2, and 2 when changing from job j2 to job j1. Both jobs have a duration of 5. The corresponding facts are as follows: [Table 1]

[0057] In the following, the ASP encoding for calculating the minimum schedule will be explained with reference to each line of the program above. For all problem instances I, the schedule of I with the smallest lexicographical makespan corresponds one-to-one with the solution set of the above rules, augmented by the fact representation of I.

[0058] The encoding in this example consists of the following three parts:

[0059] Lines 1 through 10 qualitatively model the executable sequence of a job on the machine.

[0060] The first line indicates that each job is assigned to a machine capable of processing that job. The notation asg(J,M):cap(M,J) represents a foundational step for each value j of the global variable J, as occurs in the body. This means that asg(J,M) is replaced by all atoms asg(j,m) from which cap(j,m) can be derived.

[0061] The third line represents a rule that requires jobs assigned to a single machine to be perfectly ordered. That is, for any two separate such jobs j1 and j2,

number

[0062] The fifth line defines the predicate first(J,M) which represents the first job on each machine. The sixth line defines the predicate last(J,M) which represents the last job on each machine. The seventh line includes a predicate next(J1,J2,M) representing the subsequent jobs for each job except the last job, and a constraint on the predicate next(J1,J2,M) that ensures the selection made by the predicate next(J1,J2,M) conforms to the order given by the predicate before(J1,J2,M). The eighth row includes a predicate next(J2,J1,M) representing the preceding jobs for each job except the first job, and a constraint on the predicate next(J2,J1,M) that ensures the selection by the predicate next(J2,J1,M) conforms to the order given by the predicate before(J2,J1,M). The ninth line includes a constraint on the predicate first(J,M) that ensures the selection made by the predicate first(J,M) conforms to the order given by the predicate before(J2,J1,M). The tenth line includes a constraint on the predicate last(J,M) that ensures the selection made by the predicate last(J,M) conforms to the order given by the predicate before(J1,J2,M).

[0063] Lines 12 through 19 show the quantitative model completion time using differential logic.

[0064] Lines 12-16 model the scheduling problem described above. Line 17 defines c_max as an upper limit on the arbitrary completion time. In this example, the ASP solver instantiates an integer variable with the smallest possible value. Therefore, in every solution set determined by the solver, c_max is the actual make span. Line 19 defines an additional, redundant rule. In this example, the ASP solver searches for a solution within the search space. This rule helps the ASP solver further prune the search space.

[0065] Lines 21-23 define how to solve the optimization problem.

[0066] Line 21 defines the span for each machine. Here, it is assumed that int(T) provides a bounded range of integers. Line 22 compels the machine to complete the task no later than the span defined for that machine. Line 23 defines the objective function.

[0067] In particular, each machine assigns its own span c to the cost function at priority level c.

[0068] The cost function accumulates the contributing values, and the solver minimizes the solution set by lexicographically comparing the cost tuples, which are ordered by priority.

[0069] In this example, differential logic is used to represent that jobs are placed on the machine in the order defined by an arbitrary predicate `next`. The use of differential logic has the advantage of avoiding integer arithmetic in Boolean ASP constraints, which can increase the size of the underlying structure.

[0070] The exact algorithm, referred to as lexicographical makespan optimization, will be described below with reference to Figure 2. Figure 2 schematically shows exemplary steps performed by scheduler 102.

[0071] In this example, the schedule is determined as the solution to the optimization problem by iteratively solving the optimization problem. Model M is supplied to the ASP solver 204 as input 202. The schedule is output 206 of the ASP fact generator 208.

[0072] The ASP solver 204 searches for a solution (solve(M)) to an optimization problem and outputs a non-empty set R that solves the optimization problem for M, or, if nothing is found within a fixed resource limit,

number

number

number

[0073] The following describes an exact algorithm for determining lexicographical makespan optimization.

[0074] Input: Model M containing m machines such that 1 ≤ l ≤ m and parameter l. Output: Schedule R(c_1,···,c_m) for M with parameterized lexicographical makespan.

[0075] solve(M) is a non-empty solution R for M if nothing is found within the fixed resource limit, or

number

[0076] The constraint bound(i°b),°∈{<≦} compels that c_i°b for the lexicographical makespan(c_1,···,c_m) be as follows: [Table 2]

[0077] This exact algorithm allows us to compute a schedule with the smallest lexicographical makespan using multiple solver calls and incremental addition of constraints.

[0078] This represents a multi-objective minimization that includes a first hierarchical descent with the highest priority. Due to symmetry, showing that there is no solution is usually more costly than finding a solution for this problem. That is, this makes alternative strategies with relatively few solver calls, such as binary search or exponentially increasing search steps, less attractive.

[0079] In this example, clingo-dl and the above coding are used without the optimization statements on lines 21-23 for performing solve(M). Computational resources are saved by using clingo-dl, which supports multishot solving where part of the solver state is maintained over multiple runs. In particular, solve(M) in the exact algorithm is not limited to using the ASP solver. Instead, any exact method that can generate a solution for model M in the input language of each system can be used.

[0080] The constraint on bound(i≦b) can be expressed, for example, in ASP.

[0081] The i-th component of a lexicographical makespan less than or equal to b is equivalent to forcing at least m-i+1 machines to have a span of at most b. In this example, the latter is achieved by nondeterministically selecting m-i+1 machines and forcing these machines to complete without being slower than b. [Table 3] It will be encoded like this.

[0082] The exact algorithm is guaranteed to return a schedule with the smallest lexicographical makespan, provided that resources for solve(M) are not limited.

[0083] A first exemplary scheduling method will be described with reference to Figure 3. The first method includes step 302, in which a schedule is determined for solving the optimization problem for the set of machines K and the set of jobs J.

[0084] An optimization problem is defined by a set of rules that assign a set of jobs to a set of machines. The schedule maps each job in the set of jobs to one machine in the set of machines that is capable of handling that job.

[0085] The schedule assigns a job to a particular machine, and its execution by that machine is scheduled to be completed within a single machine span.

[0086] Subsequently, step 304 is performed. In step 304, a constraint relating to at least one machine span is determined depending on that machine span.

[0087] Subsequently, step 306 is executed. In step 306, a schedule is determined that solves the optimization problem for the set of jobs and the set of machines under constraints. The schedule is arranged so that the execution of jobs assigned to a particular machine by that machine is completed within a single machine span.

[0088] Next, step 308 is executed. In step 308, it is determined whether the iteration counter i exceeds the parameter l. If the iteration counter i exceeds the parameter l, step 310 is executed. Otherwise, the counter is incremented and step 304 is executed.

[0089] In step 310, the schedule is output as the solution to the optimization problem.

[0090] In practice, the time spent searching for a solution to an optimization problem can be limited by an appropriate time constraint.

[0091] In the approximation algorithm, an optimizer, particularly an exact optimizer, is used that is configured to find schedules with small makespans. This optimizer can use any procedure that is good at finding schedules with small makespans. In this example, this optimizer is employed to compute schedules with small lexicographical makespans, as described below.

[0092] Input: Model M containing m machines such that 1 ≤ l ≤ m and parameter l. Output: Schedule S(c_1,···,c_l) for M with parameterized lexicographical makespan. opt(M) returns the best solution for M found within fixed resource constraints. [Table 4]

[0093] This approximation algorithm uses an optimizer to iteratively compute and improve a portion of the solution provided by the optimizer. This requires multiple solver calls to the optimizer. The number of solver calls is limited by the number of machines. After each solver call, the problem instance is significantly simplified, making it easier to solve.

[0094] The optimizer can be implemented by using multishot solving, which reuses heuristic values ​​and learned nodes from the previous solver run.

[0095] In this example, the ASP fact generator 208 can be configured to remove all machines k that complete in c_i from model M and to remove all jobs assigned to k from M in the first iteration. In this example, the ASP solver 204 is configured to call the optimizer to resolve the modified model M.

[0096] In the following, a second example of scheduling will be described with reference to Figure 4. The second method includes step 402, in which a schedule is determined for solving the optimization problem for the set of machines K and the set of jobs J.

[0097] Subsequently, step 404 is performed. In step 404, at least one machine k is selected that has a machine span scheduled to end within the schedule's make span.

[0098] Subsequently, step 406 is performed. In step 406, a subset of the set of machines K that does not contain machine k is formed.

[0099] Subsequently, step 408 is executed. In step 408, a subset of the set of jobs J is formed that does not include job j assigned to machine k according to the schedule.

[0100] Subsequently, step 410 is performed. In step 410, a schedule is determined for solving the optimization problem relating to a subset of the set of jobs J and a subset of the set of machines K.

[0101] Next, step 412 is executed. In step 412, it is determined whether the iteration counter i exceeds the parameter l. If the iteration counter i exceeds the parameter l, step 414 is executed. Otherwise, the counter is incremented and step 404 is executed.

[0102] In step 414, the schedule is output as the solution to the optimization problem.

Claims

1. A machine scheduling method, particularly computer-implemented, for executing a set of task jobs using a set of machines (104), In the first iteration, Determine the first schedule for solving the optimization problem (302, 402), The optimization problem is defined by a set of rules for assigning the set of jobs to the set of machines (104), The first schedule maps each job from the set of jobs to one machine from the set of machines that is capable of processing that job. The execution of a job assigned to a machine by the first schedule described above is scheduled to be completed within one machine span. In the second iteration, Determine constraints on at least one machine span (304), A second schedule (306) is determined (306) to solve the optimization problem relating to the set of jobs and the set of machines (104) under the aforementioned constraints, or A second schedule is determined (410) to solve the optimization problem relating to a subset of the set of jobs and a subset of the set of machines (104). The subset of the set of machines (104) excludes the machines, and the subset of the set of jobs excludes the jobs assigned to the machines according to the first schedule. Determine a plurality of machine spans for a plurality of machines in the set of machines (104) that are scheduled to perform at least one job according to the first schedule, A machine span having a longer duration than at least one of the plurality of machine spans is selected as a constraint from the plurality of machine spans. A method characterized by the following:

2. From the set of machines (104), select a machine having a machine span that ends in a make span for performing the task according to the first schedule, A subset (406) of the set of machines (104) that does not include at least one machine, The method according to claim 1.

3. A subset of the set of jobs is formed (408) that does not include at least one job assigned to the machine. The method according to claim 2.

4. Determine the sequence in which the jobs assigned to the machine are scheduled to be processed on the machine. The machine span is determined depending on the completion time of the last job in the sequence. The method according to claim 1.

5. The completion time of the last job is determined depending on the sum of the start times of the first jobs in the sequence, the sum of the processing times of at least one job in the sequence that is scheduled to start earlier than the last job, and the duration of the last job. The method according to claim 4.

6. The number of iterations is limited to less than the number of machines in the aforementioned multiple machines, and multiple schedules are determined in multiple iterations. The method according to claim 1.

7. Schedule at least one machine from the set of machines (104) to execute at least one job from the set of jobs according to the second schedule. The method according to claim 1.

8. A scheduler (102) for executing a set of task jobs within a makespan using a set of machines (104), A scheduler (102) characterized by being configured to carry out each step of the method according to any one of claims 1 to 7.

9. A computer program characterized by including computer-readable instructions that, when executed by a computer, cause the computer to perform each step of the method according to any one of claims 1 to 7.

Images