Upload
wes
View
26
Download
4
Embed Size (px)
DESCRIPTION
On single machine scheduling with processing time deterioration and precedence constraints. V. Gordon 1 , C. Potts 2 , V.Strusevich 3 , J.D. Whitehead 2. 1 United Institute of Informatics Problems of the NASB, Minsk, Belarus; - PowerPoint PPT Presentation
Citation preview
1
On single machine scheduling with processing time deterioration and
precedence constraints
V. Gordon 1, C. Potts
2 , V.Strusevich 3,
J.D. Whitehead 2
1 United Institute of Informatics Problems of the NASB, Minsk, Belarus;
2 University of Southampton, School of Mathematics, Southampton, UK
3 University of Greenwich, School of Computer and Mathematical Sciences, London, UK
Workshop, 12 -16 May 2008, Marseille-Luminy
2
Plan of the talk
1. Introduction
2. Previous results
3. Scheduling with deterioration under precedence constraints
4. Priority functions and priority-generating functions
5. Priority functions for scheduling problems with processing time deterioration
6. Conclusion
3
Classical deterministic scheduling models:
- processing conditions are viewed as given constants
Introduction
Real-life situations:
- processing conditions may vary in time
Models with processing time deterioration or with learning: actual processing time of a job depends on the place of
the job in a schedule
Deterioration: - machine is served by a human operator who gets tired;- machine loses the processing quality of its tools if it works long
Learning: - the skills of the workers continuously improve by processing one job after the other
4
Processing time deterioration:
- the later a job starts, the longer it takes to process it
Time deterioration:
• processing time grows depending on a start time of the job
Positional deterioration:
• processing time grows depending on a position of the job in the processing sequence ( either on the number of jobs that have been sequenced before, or on the total processing time of these jobs)
( actual processing time of a job depends linearly on its start time in some schedule)
5
Previous ResultsSingle machine scheduling problems with processing
time deterioration that can be solved in polynomial time
Positional deterioration
- polynomial: pj[r] = pj r A
(processing time of a job depends polynomially on the position in which it is scheduled or, equivalently, on the number of jobs that have been scheduled before)
pj[r] is the actual processing time of a job j scheduled in the position r ; A>0 .
Introduced by Biscup (EJOR, 1999, 115)
Mosheiov (EJOR, 2001, 132; Math.Comput. Modelling, 2005, 41): LPT rule for minimizing the makespan
Recent state-of-art reviews: Alidaee, Womer (JORS, 1999, 50); Cheng, Ding, Lin (EJOR, 2004, 152); Biskup (EJOR, 2008, 188)
6
Positional deterioration- cumulative: pj
[r] = pj (1+ Σkr=
-1
1 p[k] ) A (processing time of a job depends polynomially on the total ‘normal’ processing time of jobs that have been sequenced before)
p[k] is the ‘normal’ processing time of a job sequenced in position k; A ≥ 1
Introduced (for learning effect) by Kuo, Yang (Inform.Processing Lett. 2006, 97)
Problem of minimizing the makespan can be solved in O(nlogn) time by SPT
Time deterioration(actual processing time of a job depends linearly on its start time in some schedule)
- linear time: pj(t) = aj t + pj
Minimizing makespan by sorting jobs in non-increasing order of aj / pj :
Melnikov, Shafransky (Cybernetics, 1980, 15), Browne, Yechiali (OR, 1990, 38), Gawiejnowicz, Pankovska (Inform. Proc. Lett., 1995, 54)
7
Time deterioration
- simple linear time: pj(t) = aj t
Minimizing the weighted sum of the completion times Σ wj Cj by sorting
jobs in non-increasing order of -aj / (wj (1+aj)) :
Mosheiov (Comput.Oper.Res, 1994, 21)
- constant rate linear time: pj(t) = a t + pj
Minimizing the sum of the completion times Σ Cj by sorting jobs in non-
decreasing order of pj (SPT rule):
Ng, Cheng, Bachman, Janiak (Inform.Processing Lett., 2002, 81)
All these results are obtained for optimal sequencing of independent jobs
8
In practice, products are manufactured in a certain order implied, for example, by technological, marketing or assembly requirements.
Thus, not all sequences of jobs are feasible or make sense. This can be modelled by imposing the precedence constraints over set of jobs to describe possible sequences of jobs.
Our aim is to identify single machine scheduling problems with processing time deterioration that can be solved in polynomial time, provided that the set of jobs is partially ordered.
Scheduling with deterioration under precedence constraints
9
Priority functions and priority-generating functions
We consider single machine scheduling problems in which schedules can be specified by permutations of jobs.
Index policy or priority rule for independent jobs:
• an optimal permutation can be found by assigning certain priorities to jobs and then sorting the jobs in the order of these priorities
The most commonly used index policies: SPT, LPT rules (Smith, 1956;
Tanaev, 1965; Rothkopf, 1966 and other) Priority functions and priority-generating functions:
• to handle scheduling problems under precedence constraints (Lawler, Ann.Discrete Math. 1978, 2; Gordon, Shafransky, Proc. Academy of Sci. of Belarus, 1978, 22; Monma, Sidney, Math.Oper.Res. 1979,4)
For systematic exposition of related issues: Chapter 3 in Tanaev, Gordon, Shafransky Scheduling Theory. Single-Stage Systems, Kluwer, 1994
10
Definition. Let παβ=(π'αβπ'') and πβα =(π'βαπ'') be two
permutations of n jobs that differ only in the order of the
subsequences α and β. For a function F(π) that depends on a
permutation, suppose that there exists a function ω(π) such
that for any two permutations παβ and πβα the inequality
ω(α)>ω(β) implies that F(παβ)≤ F(πβα), while the equality
ω(α)=ω(β) implies that F(παβ)= F(πβα). In this case, function F
is called a priority-generating function, while function ω is called its priority function.
The concept of priority-generating function has been independently introduced by Gordon, Shafransky, Proc. Academy of Sci. of Belarus, 1978, 22;
Monma, Sidney, Math.Oper.Res. 1979,4. Any priority-generating function can be minimized in O(nlogn) time if the reduction graph of the precedence constraints is series-parallel and is given by its decomposition tree.
11
Theorem 1. For the single machine problem to minimize the makespan, the objective function is priority-generating if A=1. Its priority function is
ω(π) = (Σj|π|
=1 pπ(j) )/|π|,
where π(k) is a job in the k-th position of permutation π.
It is unlikely that a priority function exists for A other than 1: no priority
function exists for A=2 .
No priority function exists for the problem of minimizing ΣCj .
Priority functions for scheduling problems with processing time deterioration
Positional deterioration polynomial: pj
[r] = pj r A ( processing time of a job depends
polynomially on the position in which it is scheduled)
12
Positional deterioration cumulative: pj
[r] = pj (1+ Σkr=
-1
1 p[k] ) A (processing time of a job
depends polynomially on the total ‘normal’ processing time of jobs that have been sequenced before)
Theorem 2. For the single machine problem to minimize the makespan, any (feasible) permutation of jobs defines an optimal schedule if A=1. The objective function is priority-
generating if A=2. Its priority function is
ω(π) = Σj|π|
=1 pπ(j) / Σj|π|
=1 p2π(j) ,
where π(j) is a job in the j-th position of permutation π.
Corollary. For independent jobs, SPT is an optimal index policy.
It is unlikely that a priority function exists for A>2 : no priority function
exists for A=3.
No priority function exists for the problem of minimizing ΣCj (for A =1, 2 or
3). For this problem, optimal index policy for independent jobs is SPT for any A1.
13
Theorem 3. For the single machine problem to minimize the makespan, the objective function is priority-generating. Its priority function is ω(π) = (Σj
|π|=1 pπ(j)γ j-1) / (γ|π|-1)
For the problem with independent jobs, LPT is an optimal index policy:
ω(j) = pj (1-priority function)
Theorem 4. For the single machine problem to minimize the sum of completion times of independent jobs, the function ω(j) = pj is a 1-priority function for each γ ≥ 2 .
No 1-priority function exists for any γ, 1< γ < 2 . No priority function exists for the problem of minimizing the sum of completion times.
Positional deterioration exponential: pj
[r] = pj γr-1 ( processing time of a job depends
exponentially on the position in which it is scheduled)
14
Time deterioration linear time: pj
(t) = aj t + pj ( processing time of a job depends
linearly on its start time in some schedule)
Theorem 5. For the single machine problem to minimize the makespan, the objective function is priority-generating. Its priority function is
ω(π) = (Πj|π|
=1 (1+aπ(j)) - 1) / (Σj|π|
=1pπ(j)Πi|π|
=j+1(1+aπ(i)))
The problem of minimizing the weighted sum of completion times is NP-hard (Bachman, Janiak, Kovalyov, Inform.Proc.Lett. 2002)
We show that even for unit processing times a 1-priority function does not exist for this problem
simple linear time: pj(t) = pj (1+a t )
For the single machine problem to minimize the weighted sum of completion times, the objective function is priority-generating (Wang, Ng, Cheng, Comp.Oper.Res. 2008)
15
Time deterioration constant rate linear time: pj
(t) = a t + pj ( processing time of
a job depends linearly on its start time in some schedule)
Theorem 6. For the single machine problem to minimize the sum of completion times, the objective function is priority-generating. Its priority function is
ω(π) = (Σk|π|
=1 (1+a) k) / (Σk|π|
=1 pπ(k) (1+a) |π| - k)
For independent jobs, the problem admits SPT optimal index policy (Ng, Cheng, Bachman, Janiak, Inform.Proc.Lett. 2002).
This is follows as a Corollary: If the priority function is
calculated for a single job, ω(j) = 1 / pj is a 1-priority function.
16
17
Problem Complexity-----------------------------------------------------------------------
Positional deterioration polinomial
1 | pj[r] = pj r A , SP | Cmax O(nlogn) for A=1
cumulative
1 | pj[r] = pj (1+ Σk
r=
-1
1 p[k] ) A , prec | Cmax O(n) for A=1
1 | pj[r] = pj (1+ Σk
r=
-1
1 p[k] ) A , SP | Cmax O(nlogn) for A=21 | pj
[r] = pj (1+ Σkr=
-1
1 p[k] ) A | Σ Cj O(nlogn) for A1 exponential
1 | pj[r] = pj γ r-1 , SP | Cmax O(nlogn)
1 | pj[r] = pj γ r-1 | Σ Cj O(nlogn) for γ ≥ 2
18
Problem Complexity-------------------------------------------------------------------
Time deterioration linear time
1 | pj(t) = aj t + pj , SP | Cmax O(nlogn)
simple linear time
1 | pj(t) = aj t , prec | Cmax O(n)
1 | pj(t) = aj t , SP | ΣwjCj O(nlogn)
1 | pj(t) = pj (1+at) , SP | ΣwjCj O(nlogn)
constant rate linear time
1 | pj(t) = a t , SP | Σ Cj O(nlogn)
19