Transcript Document
Parallel-Machine Models
Chapter 7
Elements of Sequencing and Scheduling
by Kenneth R. Baker
Byung-Hyun Ha
R1
Outline
Introduction
Minimizing the makespan
Nonpreemptable jobs
Dependent nonpreemptable jobs
Preemptable jobs
Minimizing total flowtime
Summary
1
Introduction
Beyond single machine
Some types
• Parallel systems, serial systems (flow shop), hybrid systems (job shop)
Sequencing + resource allocation
Parallel machines
Basic model (Pm)
•
•
•
•
n jobs independent and simultaneously available at time zero
m identical parallel machines
A job can be processed by at most one machine at a time
e.g., Pm || Cj
More general models
• Parallel machines with different speeds, or uniform machines (Qm)
• Speed of machine i -- vi
• Processing time of job j on machine i -- pij = pj /vi
• Unrelated machines in parallel (Rm)
• Speed of machine i on job j -- vij
• pij = pj / vij
2
Minimizing the Makespan
Makespan problem for parallel machines
Resource allocation problem
Sequence is not important
Preemptable jobs -- Pm | prmp | Cmax
Optimal makespan (McNaughton, 1959)
• M* = max[j=1..n pj /m, max{pj}]
ALGORITHM 1 -- Minimizing M with m parallel, identical machines
1. Select some job to begin on machine 1 at time zero.
2. Choose any unscheduled job and schedule it as early as possible on the
same machine. Repeat this step until the machine is occupied beyond time
M* (or until all jobs are scheduled).
3. Reassign the processing scheduled beyond M* to the next machine instead,
starting at time zero. Return to Step 2.
Exercise
• Three machines, jobs with processing times of 1, 2, 3, 4, 5, 6, 7, 8
• M* ? Optimal schedule?
3
Minimizing the Makespan
Nonpreemptable jobs -- Pm || Cmax
NP-hard
• PARTITION reduces to Pm || Cmax
PARTITION -- NP-hard in ordinary sense
» Given positive integers a1, ..., at , is there a subset X {1, ..., t}
such that 2iX ai = a1 + ... + at ?
• Branch and bound? Not easy to obtain good lower bound
• Dynamic programming? Extremely large number of states, commonly
List scheduling -- a plausible way
• Procedure
1. Construct a list of jobs.
2. Remove the first job from the list and place it in the schedule as early as
possible.
3. Repeat Step 2 without changing the existing partial schedule.
• Dispatching mechanism for real-time decision, possibly
• Optimal schedule can always be produced by some list scheduling! (why?)
• Search space reduction to n!
4
Minimizing the Makespan
Nonpreemptable jobs (cont’d)
Performance guarantee
• A (worst-case) bound on the performance of a particular solution procedure
• General form with error bound r
• z rz*
» where z -- objective from heuristic, z* -- that of optimal solution
Theorem 1
• List scheduling for independent, nonpreemptable jobs yields a makespan
satisfying M /M* 2 – 1/m.
Proof of Theorem 1
•
•
•
•
Consider a schedule by a list scheduling with makespan M.
Let k be a job that finishes at time M (start time of the job: M – pk).
At time (M – pk), all m machines must have been occupied since time zero.
Hence, m(M – pk) j=1..n pj – pk M j=1..n pj /m + pk(m – 1)/m.
• j=1..n pj /m M* (from results on preemptable case)
• pk M*
• Therefore, M j=1..n pj /m + pk(m – 1)/m M* /m + M*(m – 1)/m.
5
Minimizing the Makespan
Nonpreemptable jobs (cont’d)
LPT list scheduling
• List scheduling by longest processing time (LPT)
Theorem 2 (Graham, 1969)
• LPT list scheduling for independent, nonpreemptable jobs yields a makespan
satisfying M /M* 4/3 – 1/3m.
Proof of Theorem 2 (adopted from Pinedo, 2008)
Suppose there exist counterexamples such that 4/3 – 1/3m M /M*.
Then, there must exist an example with the smallest number of jobs.
Consider this smallest one and assume it has n jobs and job 1 is shortest.
Then, C1 = M. Otherwise, a counterexample with fewer jobs exists. (why?)
Since all other machines are busy at start of job 1, C1 – p1 = M – p1 j=2..n pj /m.
Hence, M p1 + j=2..n pj /m = p1(1 – 1/m) + j=1..n pj /m.
Since M* j=1..n pj /m,
4/3 – 1/3m M /M* p1(1 – 1/m)/M* + j=1..n pj /mM* p1(1 – 1/m)/M* + 1.
• It leads to M* 3p1 , which implies that the optimal schedule may results in at
most two jobs on each machine. (why?)
• However, LPT scheduling is optimal in that case (why?), which is a contradiction.
•
•
•
•
•
•
•
6
Minimizing the Makespan
Nonpreemptable jobs (cont’d)
First-fit decreasing (FFD)
• To check whether makespan M is possible or not
• Procedure
1. Order the jobs according to LPT
2. Attempt to assign the first job on the list to the first machine on which
the job will fit (i.e., it completes on or before M). If no such machine
exists, report FAIL.
3. Repeat Step 2 until all jobs have been scheduled.
• Sometimes it fails, when a feasible schedule actually exists.
Determining whether M is valid is no easier than solving the makespan
problem itself
It is from bin packing problem
Best-fit decreasing LPT list scheduling
• Exercise
• 2 parallel machines, jobs with processing times 3, 3, 2, 2, 2, 2
» M by LPT list scheduling? Result of FFD using that M?
7
Minimizing the Makespan
Nonpreemptable jobs (cont’d)
Multifit algorithm
• Determining schedule by searching for the smallest feasible value of M,
using FFD
• Min. trial M -- LB from preemptable case
• Max. trial M -- max[2j=1..n pj /m, max{pj}], or makespan of any feasible
schedule
Theorem 3
• The multifit algorithm for independent, nonpreemptable jobs yields a
makespan satisfying M /M* 72/61, or about 1.18.
8
Minimizing the Makespan
Dependent nonpreemptable jobs -- Pm | prec | Cmax
Complexity
• Strongly NP-hard, generally
Special cases
• P1 | prec | Cmax
• Easy (why?)
• P | prec | Cmax
• Project scheduling, polynomially solvable by CPM (critical path method)
• Pm | pj=1, intree | Cmax , Pm | pj=1, outtree | Cmax
• P2 | pj=1, prec | Cmax
intree (assembly tree)
outtree
9
Minimizing the Makespan
Dependent nonpreemptable jobs (cont’d)
Intree and unit-length jobs -- Pm | pj=1, intree | Cmax
• Critical path (CP) rule gives optimal schedule
• To give highest priority to the job at the head of the longest string of jobs
in the precedence graph (ties may be broken arbitrarily)
• A.k.a. highest level first rule
Equivalent to ALGORITHM 2 + scheduling phase
» Proof of optimality -- see p. 120 of Pinedo (2008)
Analogous to LPT list scheduling
• Exercise
• Three parallel machines, following intree jobs with unit processing time
12
17
13
14
15
8
5
2
9
6
3
7
4
10
16
1
11
10
Minimizing the Makespan
Dependent nonpreemptable jobs (cont’d)
Arbitrary precedence with two machines -- P2 | pj=1, prec | Cmax
• Critical path (CP) rule using labels of direct successors
• To give priority to the job with the lexicographically smallest sequence of
direct successors’ labels in nonincreasing order
Equivalent to ALGORITHM 3 + scheduling phase
• Exercise
• Three parallel machines, unit-length jobs with following precedence
6
5
3
4
0
7
2
1
11
Minimizing the Makespan
Preemptable jobs
Arbitrary precedence with two machines -- P2 | prmp, prec | Cmax
• A possible approach
• Transforming to P2 | pj=1, prec | Cmax with chains
• Example
2
2
2
5
6
7
1
1
5
1
6
1
7
1
5
1
6
1
7
1
4
4
1
2
3
1
2
3
1
1
1
1
1
1
• Guarantee optimal?
» No! The jobs must be divided into half-unit-length jobs.
12
Minimizing Total Flowtime
Minimizing F -- Pm || Cj
Notation
• pi[j] -- processing time of the jth job in sequence on the ith machine
• Fi[j] -- flowtime of the jth job in sequence on the ith machine
• nj -- number of jobs processed by the ith machine
Objective function
• F = i=1..m j=1..ni Fi[j] = i=1..m j=1..ni (ni – j + 1)pi[j]
Solution approach
• F as scalar product of two vectors
• Matching integer coefficients (ni – j + 1) with processing times pi[j]
• F cannot be minimized unless ni differ by at most one. (why?)
• SPT list scheduling
• Dispatching procedure and adaptable dynamic job arrivals
Exercise
• Two parallel machines and six jobs with processing times of 1, 2, 3, 4, 5, 6
Minimizing Fw -- Pm || wjCj
NP-hard
13
Summary
More than one machine
Allocation and sequencing
• In case of makespan problems, allocation may be enough
Two-phase method, commonly, because of complexity
• Allocation first, sequencing next considering as single machine
LPT list scheduling
Applicable to some situations
• No precedence, intree, critical path
Flowtime measures
Total tardiness problems
Very limited optimization approaches
14