On single machine scheduling with
processing time deterioration
Valery Gordon
United Institute of Informatics Problems of the NASB, Minsk, Belarus;
1
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
Plan of the talk
•
•
•
•
•
•
Introduction
Previous results
Scheduling with deterioration under precedence constraints
Priority functions and priority-generating functions
Priority functions for scheduling problems with processing time
deterioration
Conclusion
Introduction
Classical deterministic scheduling models:
- processing conditions are viewed as given constants
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
3
Processing time deterioration:
- the later a job starts, the longer it takes to process it
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)
Time deterioration:
• processing time grows depending on a start time of the job
( actual processing time of a job depends linearly on its start time in some
schedule)
4
Previous Results
Single machine scheduling problems with processing
time deterioration that can be solved in polynomial time
Recent state-of-art reviews:
Alidaee, Womer (JORS, 1999, 50); Cheng, Ding, Lin (EJOR, 2004, 152);
Biskup (EJOR, 2008, 188)
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
5
Positional deterioration
- cumulative: pj[r] = pj (1+ Σkr=-11 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)
6
Time deterioration
- simple linear time: pj(t) = aj t
Minimizing the weighted sum of the completion times
jobs in non-increasing order of -aj
Σ wj Cj
by sorting
/ (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 nondecreasing 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
7
Scheduling with deterioration under
precedence constraints
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.
8
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
9
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.
10
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)
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 .
11
Positional deterioration
cumulative: pj[r] = pj (1+ Σkr=-11 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 prioritygenerating 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 for12
any A1.
Positional deterioration
exponential: pj[r] = pj γr-1
( processing time of a job depends
exponentially on the position in which it is scheduled)
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.
13
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 NPhard (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)
14
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 prioritygenerating. 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.
15
16
Problem
Complexity
----------------------------------------------------------------------Positional deterioration
1
polinomial
| pj[r] = pj
r A , SP | Cmax
1
cumulative
| pj[r] = pj
(1+ Σkr=-11 p[k] ) A , prec | Cmax
O(nlogn) for A=1
O(n) for A=1
1 | pj[r] = pj (1+ Σkr=-11 p[k] ) A , SP | Cmax O(nlogn) for A=2
1 | pj[r] = pj (1+ Σkr=-11 p[k] ) A | Σ Cj
O(nlogn) for A1
1
1
exponential
| pj[r] = pj
| pj[r] = pj
γ r-1 , SP | Cmax
γ r-1 | Σ Cj
O(nlogn)
O(nlogn) for γ ≥ 2
17
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
1 | pj(t) = aj t , SP | ΣwjCj
1 | pj(t) = pj (1+at) , SP | ΣwjCj
O(n)
O(nlogn)
O(nlogn)
constant rate linear time
1 | pj(t) = a t , SP | Σ Cj
O(nlogn)
18
19
2. Single Machine Scheduling
and Due Date Assignment
under Positional Deterioration
Valery Gordon
United Institute of Information Problems,
Minsk, Belarus
Vitaly Strusevich
University of Greenwich, London, U.K.
This Part
•
•
•
•
•
Single Machine Scheduling
Jobs with Positional Deterioration Effect
Due Date Assignment (DDA)
Admission Control
Cost:
– Total Cost of Discarded Jobs
– Cost for DDA
– Possibly Total Earliness of Scheduled Jobs
Motivation
• The supply chain: a manufacturer and a customer.
• The manufacturer: wishes that all accepted orders are
completed in full and in time to satisfy the customer's
demand.
• The due dates are the subject of negotiation with the
customer
• For the mutually agreed due dates, the manufacturer can
discard some of the orders if they cannot be completed
in time; in this case a penalty for each discarded order is
paid
• The manufactures uses sensitive equipment, with its
production capability changing over time
Notation
N = {1,…, n} set of jobs to be processed on a single machine
pj
“normal” processing time of job j
If the jobs are processed in accordance with a certain
permutation π=(π(1), π(2),…, π(n)), then the
processing time of job j = π(r), i.e., the job
sequenced in the r-th position is given by
pj[r]=pjg(r),
g(r) is a function that specifies a positional deterioration effect
We assume that g(1)=1 and g(r) ≤ g(r+1) for each r, 1≤ r ≤ n-1.
Notation: Deterioration
Polynomial Deterioration:
The actual processing time of a job j that is sequenced in position
r is given by
pj[r]=pj rA,
where A > 0 is a given constant, common for all jobs.
Biskup (1999), Mosheiov (2001, 2005) , Gordon et al. (2008)
Exponential Deterioration:
The actual processing time of a job j that is sequenced in position
r is given by
pj[r]=pj γr-1,
where γ > 1 is a given constant representing a rate of
deterioration, common for all jobs
Wang (2005), Wang and Xia (2005) , Gordon et al. (2008)
Notation
Due Date Assignment (DDA): survey by Gordon et al. (2004)
Each job j Є N has to be assigned a due date dj
Given a schedule, let Cj denote the completion time of job j and, provided that Cj ≤ dj, define its
earliness as Ej = dj - Cj
In all problems under consideration: the jobs of set N have to be split into two subsets denoted by
NE and NT
The jobs of subset NT are essentially discarded, and a penalty αj is paid for a discarded job j Є NT.
Only the jobs of set NE are sequenced, and each of these jobs is completed no later than its
assigned due date.
The purpose is to select the due dates for the jobs and the sequence of the early jobs in such a
way that a certain penalty function is minimized.
Notation: Objective Functions
Sequence of
jobs
Vector of
due dates
F1 (d,  )   (d) 

jNT
j
Total cost of
discarded
jobs
Cost for DDA,
Depends on the chosen
model
F2 (d,  ) 
E
jN E
j
  (d) 

jNT
Total
earliness
j
Objective Functions
F1 (d,  )   (d) 
F2 (d,  ) 
E
jN E
j

jNT
  (d) 
j

jNT
j
• Due Date Assignment (DDA)
• Admission Control
• Scheduling of Deteriorating Accepted Jobs
Auxiliary Problem PdE
Find a permutation π that minimizes the function
n
f ( )   d ( )   E ( k ) ,
k 1
where β is a given positive constant,
d(π) is the completion time of the last job π(n) and is
treated as a due date common to all jobs
Auxiliary Problem PdE
Lemma
1
Auxiliary Problem PdE
Lemma
1
By pairwise interchange argument: Let π be an optimal
permutation for Problem PdE. Choose an arbitrary
position u, where 1 ≤ u ≤ n-1, and introduce a
permutation π′ that differs from π by swapping the jobs
π(u) and π(u+1). It follows that
Δ=f(π)-f(π′) =(pπ(u) - pπ(u+1))(g(u)(β+u-1)-g(u+1)(β+u))
Auxiliary Problem PdE
Lemma
1
For Problem PdE with positional deterioration an optimal
permutation can be found by LPT rule:
g(u+1)/g(u) ≥ 1 > (β+u-1)/(β+u)
Auxiliary Problem Pd
Find a permutation π that minimizes the function
f ( )  d ( )
where d(π) is the completion time of the last job π(n)
For Problem Pd with positional deterioration an optimal
permutation can be found by LPT rule
CON: Common Due Date
Assignment
F1 (d,  )   (d) 
F2 (d,  ) 
E
jN E
j

jNT
j

  (d) 
jNT
j
For the CON model, all due dates are equal, and we select
βd as the cost function φ(d), where β is a positive
constant. Thus we minimize the objective functions
F1 (d,  )  d 
F2 (d,  ) 
E
jN E
j

jNT
 d 
j

jNT
j
CON: Common Due Date
Assignment
F1 (d,  )  d 
F2 (d,  ) 
E
jN E
j

jNT
 d 
j

jNT
j
• To minimize the weighted number of discarded jobs with
fixed times with respect to a given common due date is
NP-hard in the ordinary sense [Karp 1972]
• CON DDA problems with fixed times admit polynomial
time algorithms [De et al. 1991, Kahlbacher and Cheng
1993]
• CON DDA problems with resource-dependent
processing times admit polynomial time algorithms
[Shabtay and Steiner (2007)]
CON: Common Due Date
Assignment
Function for
Problem Pd
F1 (d,  )  d 
F2 (d,  ) 
E
jN E
j

jNT
 d 
j

jNT
j
Function for
Problem
PdE
Idea:
• Fill the sequence from left to right so that the last scheduled
job completes exactly at time d
• Scan the jobs in LPT order
• Try either to discard the job (move to set NT) or schedule it
(to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute the
due date etc.). Accept the best option.
• Dynamic programming
CON: Illustartion
F1 (d,  )  d 

j
Idea:
jNT
• Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
• Scan the jobs in LPT order
• Try either to discard the job (move to set NT) or schedule
it (to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute
the due date etc.)
CON: Illustartion
F1 (d,  )  d 

j
Idea:
jNT
• Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
• Scan the jobs in SPT order
• Try either to discard the job (move to set NT) or schedule
it (to put it last among the scheduled jobs, compute its
processing time by the deterioration formula, recompute
the due date etc.)
CON: Illustartion
F1 (d,  )  d 

j
Idea:
jNT
• Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
• Scan the jobs in LPT order
• Try either to discard the job (move to set NT) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
CON: Illustartion
F1 (d,  )  d 

j
Idea:
jNT
• Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
• Scan the jobs in LPT order
• Try either to discard the job (move to set NT) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
CON: Illustartion
F1 (d,  )  d 

j
Idea:
jNT
• Fill the sequence from left to right so that the last
scheduled job completes exactly at time d
• Scan the jobs in LPT order
• Try either to discard the job (move to set NT) or schedule
it (to put it last among the scheduled jobs, compute its
processing time deterioration formula, recompute the
due date etc.)
CON: Dynamic Programming
F1 (d,  )  d 

jNT
j
The DP algorithm uses the states of the form (k, r), where
k - the number of jobs that have been considered
r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced
early
A state (k, r) is associated with f(k, r), the smallest value of the
objective function in the class of partial schedules for
processing k jobs, provided that r of these jobs have been
sequenced early, where f(0, 0) = 0
For each k from 1 to n
Answer: Optimal F1 = min{f(n, r}|0≤r≤n}
= O(n2)
CON: Dynamic Programming
F2 (d,  ) 
E
jN E
j
 d 

jNT
j
The DP algorithm uses the states of the form (k, r), where
k - the number of jobs that have been considered
r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced
early
A state (k, r) is associated with f(k, r), the smallest value of the
objective function in the class of partial schedules for
processing k jobs, provided that r of these jobs have been
sequenced early, where f(0, 0) = 0
For each k from 1 to n
1 ≤ r ≤ k-1
Answer: Optimal F2 = min{f(n, r}|0≤r≤n}
= O(n2)
SLK Due Date Assignment
F1 (d,  )   (d) 
F2 (d,  ) 
E
jN E
j

jNT
  (d) 
j

jNT
j
For the SLK model, for each job its due date is computed
by increasing its actual processing time by a slack q,
common to all jobs.
We select βq as the cost function φ(d), where β is a
positive constant. Thus we minimize the objective
functions
F (d,  )  q( )  

1
F2 (d,  ) 
jNT
E
jN E
j
 q( ) 
j

jNT
j
SLK Due Date Assignment

F (d,  )   E  q( )  
F1 (d,  )  q( ) 
2
jN E
j
jNT
j
jNT
j
SLK Due Date Assignment

F (d,  )   E  q( )  
F1 (d,  )  q( ) 
2
jN E
j
jNT
j
jNT
j
Idea:
• Try each job one by one as the on-time job
• Scan the remaining jobs in LPT order
• Try either to discard the job (move to set NT) or schedule it
(to put it right before the on-time job, compute its
processing time by the deterioration formula, recompute the
due date, the slack etc.). Accept the best option.
• Dynamic programming
SLK: Dynamic Programming
F1 (d,  )  q( ) 

jNT
j
The DP algorithm uses the states of the form (h, k, r), where
h – the fixed on-time job
k - the number of jobs that have been considered
r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced
early
A state (h, k, r) is associated with f(h, k, r), the smallest value of
the objective function in this class, where f(0, 0, 0) = 0
For each h, each k from 1 to n (without h)
1 ≤ r ≤ k-1
Answer: Optimal F1 = min{min{f(h, n, r)}, Σαj}
= O(n3)
SLK: Dynamic Programming
F2 (d,  ) 
E
jN E
j
 q( ) 

jNT
j
The DP algorithm uses the states of the form (h, k, r), where
h – the fixed on-time job
k - the number of jobs that have been considered
r, 0 ≤ r ≤ k, - how many of these jobs have been sequenced
early
A state (h, k, r) is associated with f(h, k, r), the smallest value of
the objective function in this class, where f(0, 0, 0) = 0
For each h, each k from 1 to n (without h)
Answer: Optimal F2 = min{min{f(h, n, r)}, Σαj}
= O(n3)
Conclusion
• Polynomial–time dynamic programming algorithms are
developed for single machine scheduling problems with
deteriorating jobs, admission control and two popular
policies of due date assignment (CON and SLK)
• The scheduled jobs follow the LPT order
• The results hold for any model of positional deterioration
• Can be extended to models with a positional learning effect,
but in this case extra conditions of the parameters are
required