On single machine scheduling with processing time deterioration and precedence constraints

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
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
4
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)
5
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 pjr 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)
• pjr is the actual processing time of a job
  j scheduled in the position r Agt0 .
• Introduced by Biscup (EJOR, 1999, 115)
• Mosheiov (EJOR, 2001, 132 Math.Comput.
  Modelling, 2005, 41) LPT rule for minimizing the
  makespan

6

• Positional deterioration
• - cumulative pjr pj (1 Skr-11 pk ) A
• (processing time of a job depends polynomially on
  the total normal processing time of jobs that
  have been sequenced before)
• pk 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 S wj Cj by sorting jobs in
non-increasing order of -aj / (wj (1aj))
Mosheiov (Comput.Oper.Res, 1994, 21) -
constant rate linear time pj(t) a t
pj Minimizing the sum of the completion times S
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
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.
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 paß(p'aßp'') and pßa (p'ßap'')
be two permutations of n jobs that differ only in
the order of the subsequences a and ß. For a
function F(p) that depends on a permutation,
suppose that there exists a function ?(p) such
that for any two permutations paß and pßa the
inequality ?(a)gt?(ß) implies that F(paß) F(pßa),
while the equality ?(a)?(ß) implies that F(paß)
F(pßa). 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
Priority functions for scheduling problems with
processing time deterioration
Positional deterioration polynomial pjr 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 A1. Its priority function
is ?(p) (Sjp1 pp(j) )/p, where p(k) is a
job in the k-th position of permutation p. It
is unlikely that a priority function exists for A
other than 1 no priority function exists for A2
. No priority function exists for the problem of
minimizing SCj .
12
Positional deterioration cumulative pjr pj
(1 Skr-11 pk ) 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 A1. The
objective function is priority-generating if A2.
Its priority function is ?(p) Sjp1 pp(j) /
Sjp1 p2p(j) , where p(j) is a job in the j-th
position of permutation p. Corollary. For
independent jobs, SPT is an optimal index
policy. It is unlikely that a priority function
exists for Agt2 no priority function exists for
A3. No priority function exists for the problem
of minimizing SCj (for A 1, 2 or 3). For this
problem, optimal index policy for independent
jobs is SPT for any A?1.
13
Positional deterioration exponential pjr 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
?(p) (Sjp1 pp(j)? j-1) / (?p-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 ?, 1lt ? lt 2 . No priority function
exists for the problem of minimizing the sum of
completion times.
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
?(p) (?jp1 (1ap(j)) - 1) /
(Sjp1pp(j)?ipj1(1ap(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 (1a 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 ?(p) (Skp1 (1a) k)
/ (Skp1 pp(k) (1a) p - 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
(No Transcript)
17
Problem
Complexity ---------------------------------
--------------------------------------
Positional deterioration polinomial 1
pjr pj r A , SP Cmax
O(nlogn) for A1
cumulative 1 pjr pj (1 Skr-11 pk ) A ,
prec Cmax O(n) for A1 1 pjr
pj (1 Skr-11 pk ) A , SP Cmax O(nlogn)
for A2 1 pjr pj (1 Skr-11 pk ) A S
Cj O(nlogn) for A?1
exponential 1 pjr pj ? r-1 , SP Cmax
O(nlogn) 1
pjr pj ? r-1 S 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 SwjCj
  O(nlogn)
• 1 pj(t) pj (1at) , SP SwjCj
  O(nlogn)
• constant rate linear time
• 1 pj(t) a t , SP S Cj
  O(nlogn)

19
(No Transcript)