Scheduler for performing set of jobs of task with set of machines and method of, in particular, computer implemented 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 a related scheduling approach.

[0003] Further methods for machine scheduling are known from US 2020 / 0320456 A1, DE 69513877 A1, DE 102016204392 A1 and US 9798947 B1. [Prior art documents] [Patent documents]

[0004] [Patent Document 1] US Patent Application Publication No. 2020 / 0320456 [Patent Document 2] German Patent No. 69513877 Specification Translation [Patent Document 3] German Patent Application Publication No. 102016204392 [Patent Document 4] U.S. Patent No. 9,798,947 [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 Summary of the Invention [Problem to be solved by the invention]

[0006] Disclosure of the Invention The scheduler, computer program and, in particular, computer-implemented method for machine scheduling according to the independent claims solve the problem of further improving scheduling to make it directly usable for relatively complex scheduling problems involving machine allocation, sequence-dependent setup times and release dates, and to make it easier to maintain the specification of the scheduling problem when requirements change. [Means for solving the problem]

[0007] A method, particularly a computer-implemented method, of machine scheduling for executing a set of jobs of a task using a set of machines includes, in a first iteration, determining a first schedule that solves an optimization problem defined by a set of rules that assign a set of jobs to the set of machines, the first schedule mapping each job of the set of jobs to one machine of the set of machines that can process the job, and scheduling execution by a machine of a job assigned to a machine by the first schedule to finish within a machine span, and, in a second iteration, determining a constraint on at least one machine span and determining a second schedule that solves the optimization problem for the set of jobs and the set of machines under the constraint, or determining a second schedule that solves the optimization problem for a subset of the set of jobs and the set of machines, the subset of the set of machines excluding the machines, and the subset of the set of jobs excluding jobs assigned to machines according to the first schedule. The method can be used directly for relatively complex scheduling problems involving machine allocation, sequence-dependent setup times, and release dates. Another advantage is that the method can be applied to prior art knowledge representations and inference solvers using the respective modeling languages, making it easier to maintain the specification of the scheduling problem as requirements change.

[0008] The method may include selecting, from the set of machines, machines having machine spans that end in makespans for performing tasks according to the first schedule, and forming a subset of the set of machines that does not include at least one machine, thereby reducing the complexity of the optimization problem for the machines.

[0009] The method may include forming a subset of the set of jobs that does not include at least one job assigned to a machine, thereby reducing the complexity of the optimization problem for the jobs.

[0010] The method may include determining a plurality of machine spans for a plurality of machines of the set of machines scheduled to execute at least one job according to the first schedule, wherein a machine span having a longer duration than at least one other machine span of the plurality of machine spans is selected as a constraint from the plurality of machine spans, such that a solution to the optimization problem is constrained by the machine span having a longer duration than the other machine spans, thereby providing a highly efficient solution determination.

[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 making it possible to determine the machine span to improve 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 that is scheduled to start earlier than the last job, and the duration of the last job, thereby determining the completion time of the last job very accurately, which further improves the robustness of the scheduling method.

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

[0014] The method may include scheduling at least one machine of the set of machines to perform at least one job of the set of jobs according to a second schedule, in such a way that the machines are scheduled very efficiently.

[0015] A scheduler for executing a set of jobs of tasks within a makespan using a set of machines is configured to perform the steps of the method.

[0016] The computer program comprises computer readable instructions that, when executed by a computer, cause the computer to perform the steps of the method.

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

[0018] [Figure 1] FIG. 1 illustrates a schematic diagram of at least a portion of a scheduler for a collection of machines. [Figure 2] FIG. 2 illustrates schematically the steps performed by a scheduler. [Figure 3] FIG. 2 shows a schematic diagram of steps in a first method. [Figure 4] FIG. 4 shows a schematic diagram of steps in a second method. DETAILED DESCRIPTION OF THE INVENTION

[0019] 1 schematically illustrates 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 a memory for storing computer-readable instructions that, when executed by at least one processor of the scheduler 102, cause the scheduler 102 to perform, in particular, a computer-implemented scheduling method, described below. The set of machines (hereinafter designated K and not shown) represents a plurality of machines 104. The scheduler 102 in this example and each machine of the plurality of machines 104 are at least temporarily connected via a data link 103. The scheduler 102 in this example is configured to instruct at least some of the plurality of machines 104 to execute each job of a set of jobs (hereinafter designated J and not shown).

[0020] The method solves a scheduling problem.

[0021] Given m machines k in a set of machines K and n jobs j in a set of jobs J, every job j must be processed by a single machine k, and every machine k can process at most one job j at a time, i.e., preemption is not allowed.

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

[0023] For each job j and machine k, the release date r j;k is specified as a non-negative integer. The release date is machine dependent because the transportation time of a job to a machine depends on the transportation system and its location. Any job j has a release date r j;k It cannot start earlier.

[0024] A specified amount of time may be required to change from one job j to the next. i;j;k is the time required to set up job j immediately after job i on machine k.

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

[0026] The schedule for the 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. For each machine k, the total ordering of the set J of jobs j assigned to that machine k by assignment a.

number

[0027] Relationships

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. i Processing time p ji is this job j i For the duration of this job j iplus the setup time for the predecessor jobs (if any) of p j1 =d j1;k and p ji =s ji-1;ji;k +d ji;k Job j i Start time st ji is r when i=1 ji;k and if i>1, then max(r ji;k ;st ji-1 +p ji-1 ) Job j i Completion time c ji is st ji +p ji The machine span(k) of machine k is the time it takes for the last job j on machine k to be l is the completion time.

[0030] The goal is to maximize throughput, defined in this example as the number of jobs j processed per unit time. In principle, this can be achieved by minimizing the makespan, i.e., the maximum machine span of the schedule. However, when dealing with machines with high allocation rates, it is often the case that many jobs can be processed by only a few machines. This means that the makespan is determined by a small number of machines, with little regard for how jobs are scheduled on the remaining machines. This is not ideal, 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 stipulate the requirement that "all machines should finish as early as possible." This gives the scheduler freedom for reassignment and helps maintain high throughput.

[0031] To address this issue, the method uses an objective function, referred to below as the lexicographical makespan, that aims to capture the desire for all machines to complete as soon as possible.

[0032] The lexicographic makespan of a schedule is defined as the tuple of all machine spans in non-ascending order. The method uses the lexicographic order of the tuples of different schedules for comparison and prioritizes schedules with smaller lexicographic makespans over schedules with larger lexicographic makespans. The resulting schedule is the one with the smallest lexicographic makespan. Thus, the resulting schedule also has the smallest makespan, but ties are broken by using earlier completing machines.

[0033] An exemplary exact algorithm and an exemplary approximate algorithm for computing a schedule with minimum lexicographic makespan are described below, both of which use answer set programming (ASP), a logic-based approach to declarative problem solving described, for example, in:

[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 the lexicographic makespan formulates the requirement that all machines should finish as early as possible.

[0036] Given a schedule S containing m machines, 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 less 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 of schedules S, if ms(S) is the minimum 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, and 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] For problems involving a large number of machines, hierarchically minimizing all machine spans may be excessive if the entire makespan is dominated by only a few machines. However, comparing lexicographic makespans allows for parameterization with 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 with an integer l, 1≦l≦m, the makespan ms(S)=(c_1, ,c_m) according to schedule S is smaller than the makespan ms(S')=(c'_1 ,c'_m) according to schedule S' under parameterized lexicographic ordering. For a schedule with m machines, when l=1 we obtain the makespan, and when l=m we obtain the full lexicographic makespan.

[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 in the set of jobs to one machine k∈cap(j) in the set of machines K that can process that job j. Job j assigned by the schedule to one machine k is scheduled to be completed by this machine k within the machine span c_i of this machine k.

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

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

[0046] To solve an optimization problem with an approximation algorithm, part of the solution can be fixed after the solver call, allowing a near-optimal solution to be found quickly.

[0047] The scheduler and scheduling method are applicable to semiconductor manufacturing. In this embodiment, a set K of machines is used to manufacture semiconductors. The scheduler and scheduling method are similarly applicable to distributed computing systems. The machines in this embodiment may be processors, or computing cores of a processor, or dedicated hardware for performing computational operations. Jobs are assigned to machines under certain constraints to compute a feasible 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 compute the desired schedule, an optimization function called lexicographic makespan and an algorithm described below for minimizing this optimization function can be used. The machines can be instructed according to a schedule that solves the optimization problem.

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

[0049] Rules with empty bodies are called facts, and the :- is usually omitted. Facts are used to express knowledge that is unconditionally true. Rules with empty heads are constraints. The body of a constraint cannot be satisfied by any solution set and is used to prune unwanted solution candidates.

[0050] Common syntax extensions are of the form i{p1,...,pk}j:-q1,...,qm,not r1,...,not rn This is the selection rule.

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

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

[0053] Differential logic can be used to solve optimization problems under constraints, specifically differential constraints, which in this example are expressions of the form u v ≦ d, where u and v are integer variables and d is an integer constant.

[0054] In contrast to unbounded integer constraints, systems with difference constraints can be solved in polynomial time. The latter can be expressed in clingo-dl using theoretical atoms, as described, for example, in Gebser, M., Kaminski, R., Kaufmann, B., Ostrowski, M., Schaub, T., Wanko, P., "Theory solving made easy with clingo 5", 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 contains problem instances described by ASP facts using some fixed predicate names.

[0056] In the following, we will explain an example with one machine m1 and two jobs j1 and j2. Machine m1 can process all jobs and all release dates are 0. The setup time in this example is 4 when changing from job j1 to job j2 and 2 when changing from job j2 to job j1. Both jobs have duration 5. The corresponding facts are as follows: [Table 1]

[0057] Below, we explain the ASP encoding for computing the minimum schedule, with reference to each line of the above program. For every problem instance I, the schedule of I with the minimum lexicographic makespan corresponds one-to-one to the solution set of the above rules augmented by the fact representation of I.

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

[0059] Lines 1-10 qualitatively model executable sequences of jobs on a machine.

[0060] The first line indicates that each job is assigned to a machine that can process it. The notation asg(J,M):cap(M,J) denotes the foundation step for each value j of global variable J as it 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 that jobs assigned to a machine be completely ordered, i.e., for any two distinct such jobs j1 and j2,

number

[0062] Line 5 defines the predicate first(J,M) that represents the first job on each machine. Line 6 defines the predicate last(J,M) that represents the last job on each machine. Line 7 contains the predicate next(J1,J2,M) representing the successor of each job except the last, and a constraint on the predicate next(J1,J2,M) that ensures that the selection by the predicate next(J1,J2,M) conforms to the ordering given by the predicate before(J1,J2,M). Line 8 contains the predicate next(J2,J1,M) that denotes the predecessor of each job except the first job, and a constraint on the predicate next(J2,J1,M) that ensures that the selection by the predicate next(J2,J1,M) conforms to the ordering given by the predicate before(J2,J1,M). Line 9 contains a constraint on the predicate first(J,M) that ensures that the selection by the predicate first(J,M) conforms to the ordering given by the predicate before(J2,J1,M). Line 10 contains a constraint on the predicate last(J,M) that ensures that the selection by the predicate last(J,M) conforms to the ordering given by the predicate before(J1,J2,M).

[0063] Lines 12 to 19 are the quantitative model completion times using differential logic.

[0064] Lines 12-16 model the scheduling problem described above. Line 17 defines c_max as an upper bound on any completion time. In this example, the ASP solver instantiates integer variables with the smallest possible values. Therefore, for any solution set the solver determines, c_max is the actual makespan. Line 19 defines an additional redundancy rule. In this example, the ASP solver searches for solutions in the search space. This rule helps the ASP solver to 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, where int(T) is assumed to provide a bounded range of integers. Line 22 forces the machine to complete no slower than the span defined for that machine. Line 23 defines the objective function.

[0067] In particular, every machine contributes its 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 ordered by priority.

[0069] In this example, differential logic is used to indicate that jobs are placed on machines 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 base.

[0070] The exact algorithm is referred to as lexicographic makespan optimization and is described below with reference to Figure 2, which illustrates in schematic form exemplary steps performed by scheduler 102.

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

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

number

number

number

[0073] In the following, we describe an exact algorithm for determining the lexicographic makespan optimization.

[0074] Input: A model M containing m machines with 1≦l≦m and a parameter l Output: A schedule R(c_1, ,c_m) for M with parameterized lexicographic makespan

[0075] solve(M) returns a non-empty solution R for M if none is found within fixed resource constraints, or

number

[0076] The bound(i°b),°∈{<≦} constraint enforces that c_i°b for a lexicographic makespan (c_1, ,c_m) is as follows: [Table 2]

[0077] This exact algorithm allows the use of multiple solver calls and incremental addition of constraints to compute a schedule with the minimum lexicographic makespan.

[0078] This represents a multi-objective minimization involving highest priority first hierarchical descent. Due to symmetries, proving that there is no solution is usually more costly than finding a solution for this problem; this makes alternative strategies with fewer expected 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 in lines 21-23 to implement solve(M). Using clingo-dl, which supports multi-shot solving where parts of the solver state are maintained across multiple runs, saves computational resources. In particular, solve(M) in an exact algorithm is not limited to using an ASP solver. Instead, any exact method that can generate a solution to model M in the input language of the respective system can be used instead.

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

[0081] The i-th component of the lexicographic makespan being less than or equal to b is equivalent to forcing at least m-i+1 machines to have spans at most b. In this example, the latter is achieved by non-deterministically selecting m-i+1 machines and forcing them to complete no slower than b. [Table 3] It is encoded as follows.

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

[0083] A first exemplary method of scheduling is described with reference to Figure 3. The first method includes step 302. In step 302, a schedule is determined that solves an optimization problem for a set K of machines and a set J of jobs.

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

[0085] The execution by a machine of a job assigned by the schedule is scheduled to be completed within one machine span.

[0086] Then, step 304 is executed, in which a constraint for at least one machine span is determined depending on the machine span.

[0087] Then, step 306 is performed. In step 306, a schedule is determined that solves an optimization problem for a set of jobs and a set of machines under the constraints. The execution of a job assigned to a machine by the schedule is scheduled by this machine so that it is completed within one machine span.

[0088] Then, 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. If not, the counter is incremented and step 304 is executed.

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

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

[0091] The approximation algorithm uses an optimizer, specifically an exact optimizer, designed 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 lexicographic makespans, as described below.

[0092] Input: A model M containing m machines with 1≦l≦m and a parameter l Output: A schedule S(c_1, ,c_l) for M with parameterized lexicographic makespan opt(M) returns the optimal solution to M found within fixed resource constraints. [Table 4]

[0093] This approximation algorithm uses an optimizer to iteratively calculate and improve parts 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. Therefore, the problem instance can be solved more easily.

[0094] The optimizer can be implemented by using multi-shot solving that reuses heuristic values ​​and learned clauses from previous solver runs.

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

[0096] A second exemplary method of scheduling is described below with reference to Figure 4. The second method includes step 402. In step 402, a schedule is determined that solves an optimization problem for a set of machines K and a set of jobs J.

[0097] Then, step 404 is executed. In step 404, at least one machine k is selected that has a machine span scheduled to finish at the makespan of the schedule.

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

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

[0100] Then, step 410 is performed, in which a schedule is determined that solves an optimization problem for a subset of the set of jobs J and a subset of the set of machines K.

[0101] Then, 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. If not, the counter is incremented and step 404 is executed.

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

Claims

1. 1. A method of machine scheduling, particularly computer-implemented, for executing a set of task jobs using a set of machines (104), comprising: In the first iteration, determining (302, 402) a first schedule for solving the optimization problem; 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 in the set of jobs to one machine in the set of machines that is capable of processing the job; execution of a job assigned to a machine by the first schedule is scheduled to be completed within one machine span; In the second iteration, Determining 304 a constraint for at least one machine span; determining (306) a second schedule that solves an optimization problem for the set of jobs and the set of machines (104) subject to the constraints; or determining (410) a second schedule that solves the optimization problem for 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 machine, and the subset of the set of jobs excludes jobs assigned to the machine according to the first schedule. A method comprising:

2. selecting a machine from the set of machines (104) having a machine span that ends in a makespan for performing the task according to the first schedule; forming (406) a subset of the set of machines (104) that does not include at least one machine; The method of claim 1.

3. forming (408) a subset of the set of jobs that does not include at least one job assigned to the machine; The method of claim 2.

4. determining a plurality of machine spans for a plurality of machines of the set of machines (104) that are scheduled to execute at least one job according to the first schedule; a machine span having a longer duration than at least one other machine span of the plurality of machine spans is selected as a constraint from the plurality of machine spans; The method of claim 1.

5. determining a sequence in which jobs assigned to said machines are scheduled to be processed on said machines; determining the machine span dependent on a completion time of a last job in the sequence; The method of claim 1.

6. determining a completion time of the last job depending on the sum of the start time of a first job in the sequence, the sum of the processing time 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 5.

7. determining a plurality of schedules over a plurality of iterations while limiting a number of iterations to be less than a number of machines in the plurality of machines; The method of claim 1.

8. scheduling at least one machine of the set of machines (104) to perform at least one job of the set of jobs according to the second schedule; The method of claim 1.

9. A scheduler (102) for executing a set of jobs of a task within a makespan using a set of machines (104), comprising: A scheduler (102) adapted to implement the steps of the method according to any one of the claims 1 to 8.

10. A computer program comprising computer readable instructions which, when executed by a computer, cause the computer to carry out each step of the method according to any one of claims 1 to 8.

Images