dominance rules for the parallel machine total weighted tardiness scheduling problem with release...
TRANSCRIPT
Computers & Operations Research 38 (2011) 1259–1266
Contents lists available at ScienceDirect
Computers & Operations Research
0305-05
doi:10.1
� Corr
E-m
savoure
journal homepage: www.elsevier.com/locate/caor
Dominance rules for the parallel machine total weighted tardiness schedulingproblem with release dates
Antoine Jouglet a,�, David Savourey b
a Heudiasyc, UMR CNRS 6599, Universite de Technologie de Compi�egne, BP 20529, 60205 Compi�egne, Franceb Ecole Polytechnique, CNRS LIX, F-91128 Palaiseau, France
a r t i c l e i n f o
Available online 16 December 2010
Keywords:
Scheduling
Parallel machines
Total weighted tardiness
Dominance rules
Possible machines
48/$ - see front matter & 2010 Elsevier Ltd. A
016/j.cor.2010.12.006
esponding author. Tel.: +33 3 44 23 79 39; fa
ail addresses: [email protected] (A. Jo
[email protected] (D. Savourey).
a b s t r a c t
We address the parallel machine total weighted tardiness scheduling problem with release dates. We
describe dominance rules and filtering methods for this problem. Most of them are adaptations of
dominance rules based on solution methods for the single-machine problem. We show how it is possible
to deduce whether or not certain jobs can be processed by a particular machine in a particular context and
we describe techniques that use this information to improve the dominance rules. On the basis of these
techniques we describe an enumeration procedure and we provide experimental results to determine the
effectiveness of the dominance rules.
& 2010 Elsevier Ltd. All rights reserved.
1. Introduction
In this paper we consider the situation where a set of n jobsJ¼{1,y,n} has to be processed on a set of m identical parallelmachines M¼{1,y,m} and where the objective is to minimize thetotal weighted tardiness. Associated with each job i is a release dateri, a processing time pi, a due date di and a weight wi. A job cannotstart before its release date and preemption is not allowed.Machines cannot execute more than one job simultaneously. Thetardiness of job i is defined as Ti¼max(0, Ci�di), where Ci is thecompletion time of job i. The problem is to find a feasible schedulewith minimum total weighted tardiness. This problem, denoted asPmjrij
PwiTi, is strongly NP-hard [25].
The single machine problem has been intensively addressedover the last two decades. For the 1jrij
PTi problem, Chu and
Portmann [17] and Chu [15] introduced dominance rules, heur-istics, a lower bound and branch-and-bound procedures. Baptisteet al. [7] also proposed a lower bound and a branch-and-boundmethod using efficient dominance rules. For the 1jrij
PwiTi
problem, Akturk and Ozdemir [2] proposed dominance rules usedin a branch-and-bound algorithm [1,2]. Finally, Jouglet et al. [22]studied these two criteria and generalized and improved the abovedominance rules which were used in a branch-and-bound method.More recently Jouglet et al. [23] described dominance-basedheuristic methods for these problems.
ll rights reserved.
x: +33 3 44 23 44 77.
uglet),
As regards parallel machine problems, several exact methodshave been described. Yalaoui and Chu [32,33] described dominancerules, lower bounds and branch-and-bound methods for thegeneral Pmjrij
PCi problem. More recently Nessah et al. [28]
described dominance rules and a branch-and-bound method forthe weighted case Pmjrij
PwiCi. Less attention has been given to
the tardiness criteria. Nevertheless, Azizoglu and Kirca [3], Yalaouiand Chu [32] and Shim and Kim [30] solved the problem with equalrelease dates Pmjj
PTi using a branch-and-bound algorithm and
dominance rules. Moreover, Liaw et al. [26] also proposed a branch-and-bound algorithm using dominance properties for the weightedcase considering unrelated parallel machines. Finally, Baptiste [6]showed that the special case Pmjpi ¼ p,rij
PTi of the total tardiness
problem with release dates for which the processing times of jobsare equal can be polynomially solved. More recently Baptiste et al.[8] proposed several lower bounds for the case with release dates.
Unfortunately, dominance rules from the literature [3,26,30,32]cannot be used to solve the Pmjrij
PwiTi problem. Indeed, these
dominance rules no longer holds when release dates are considered.In this paper we describe new dominance rules for Pmjrij
PwiTi
based on solution methods for one-machine problems. We describein Section 2 the enumeration procedure that was used to solve theproblem. In Section 3 we introduce the notion of ‘‘possiblemachines’’ on which a job can be scheduled, and from this wederive some dominance rules. In addition, we use this notion of‘‘possible machines’’ to improve most of the dominance rules thatwe shall describe. In Section 4 we generalize a local dominance rulefrom the literature concerning the one-machine problem. In Section5 we recall the one-machine dominance rule based on the notion ofpartial ‘‘dominated sequences’’ of scheduled jobs, and show howthis rule can be used and generalized for the parallel machine case.
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–12661260
Finally, in Section 6 we present some experimental results whichshow the interest of the described techniques.
Fig. 1. A nearly active schedule and its associated sequence.
2. Enumeration procedure
Among the most commonly used methods for solving combi-natorial problems for which there is no known way of avoiding thehuge size of their solution space are so-called enumerative tech-niques [31]. The idea is to find a way of organizing an enumeratedlist of solutions, using as much information as possible, so as toeliminate intelligently dominated parts of the solution space as thecomputation progresses, without having to enumerate these domi-nated parts [24] explicitly. The utility of the method comes from thefact that only a small part of the solution space actually needs to beenumerated [27]. The remaining solutions are eliminated fromconsideration through the application of dominance rules thatestablish that such solutions cannot be optimal or better than thebest solution already known.
In this section we describe an enumeration procedure forsolving the problem exactly. First we present the notion of a nearlyactive schedule. We show that the subset of nearly active schedulesis dominant for the problem. Then we show that there exists abijection between the set of nearly active schedules and the set ofpermutations of (1,y,n). This enables us to represent a solution as apermutation and to search for an optimal sequence of jobs insteadof searching for the start times of jobs in an optimal schedule.
Building a schedule means allocating resources to jobs over timewhile respecting any constraints that might be imposed. Clearly, inorder to find an optimal schedule, given that the total weightedtardiness is non-decreasing, it is sufficient to visit the set of semi-active schedules, i.e. schedules in which no job can be scheduledearlier without changing the execution sequence of jobs on one ofthe machines [12]. Because this set contains a lot of obviously non-optimal schedules (for example, schedules where all jobs arescheduled on the same machine even though more than onemachine is available), we define the subset of ‘‘nearly activeschedules’’ which is dominant for the studied problem. Moreover,we are able to build a bijection between the set of permutations ofjobs and the set of nearly active schedules. Thus, enumerating allpermutations allows us to find an optimal schedule.
We now introduce the notion of nearly active schedule:
Definition 2.1. A schedule is said to be nearly active if it is semi-active and if no job can be scheduled earlier by processing it as thelast job on another machine.
Proposition 2.1. The set of nearly active schedules is dominant for the
total weighted tardiness parallel machines problem.
Proof. Any active schedule is nearly active and the set of activeschedules is dominant for the studied problem [5,18]. &
From here onwards we denote by mSi the index of the machine
on which job i is processed in schedule S, and by DSi the date of
availability of machine mSi before the execution of job i in S.
Proposition 2.2. There exists a bijection between the set S of
permutations of (1,y,n) and the set of nearly active schedules.
Proof. Let S be a nearly active schedule. We define the followingorder relation on the set of jobs in S: i!j if and only if DS
i oDSj or
(DSi ¼DS
j and mSi omS
j ). This defines clearly a total order on jobs of S
which can be represented by a permutation on jobs in S.
Conversely, given a permutations of jobs, a schedule S is associated
to s using the following scheme: jobs are considered in the order
given by s and are scheduled one by one as soon as possible on the
machine available the earliest. Where several machines are available
at the same earliest time, choose the one with the smallest index
number. The obtained schedule is such that no job can be scheduled
earlier without changing some sequence order, because jobs are
scheduled as soon as possible. Moreover, suppose there exists a job j
that can be processed earlier by placing it after the last job scheduled
on some other machine. Then, at the step involving job j, this other
machine would have been chosen to process j. Thus, there is no job
that can be processed earlier by placing it after the last job schedule on
another machine and the schedule is nearly active.
Finally, there is a bijection between nearly active schedules and
permutations of jobs. &
An illustration from a nearly active schedule and its associatedsequence is provided in Fig. 1. In this example, r1 ¼ r2 ¼ r3 ¼ r5 ¼
r6 ¼ r7 ¼ 0 and r4¼3. Jobs are scheduled in the order of thesequence s following the procedure described in the proof ofProposition 2.2. Thus, there is an idle time before job 4 which is dueto its release date.
The nearly active property is stronger than the semi-activeproperty. In fact, this property also ensures that the load is ‘‘wellbalanced’’ between machines. A schedule in which all jobs arescheduled on the same machine despite there being severalmachines available can be semi-active but cannot be nearly active.
From now on, the solution to any given problem will be soughtonly among the set of nearly active schedules. We use the one-to-one mapping between the set of nearly active schedules and the setof permutations of the jobs’ index numbers to enumerate solutions.Rather than searching for the starting times of jobs, we look for asequence of jobs. To build such a sequence, we use the edge-findingbranching scheme (see for instance Carlier [13]) when constructinga solution. This involves ordering jobs (‘‘edges’’ in a graph repre-senting the possible orderings of jobs): at each node a set of jobs isselected and, for each job i belonging to this set, a new branch iscreated where job i is constrained to be first in the sequence amongthe jobs in this set. Thus, at each node of the search tree a partialsequence s associated with a partial nearly active schedule isconsidered. By partial solution, we mean that only a subset of jobs ofN has been sequenced to be scheduled as soon as possible followingthe procedure described in the proof of Proposition 2.2. In fact, apartial solution s represents the subset of schedules whoseassociated sequence starts with subsequence s. Hereafter wedenote as mðsÞ the earliest available machine in the partial nearlyactive schedule associated with s. At each node of the search tree,an unsequenced job i is then sequenced at the end of s correspond-ing to the schedule of i on machine mðsÞ as soon as possible. Thesequence is built by using a depth-first strategy.
Throughout the search tree we dynamically maintain severalsets of jobs that represent the current state of a partial solution s:
�
FðsÞ is the sum of the weighted tardiness of the jobs in the partialschedule associated with s; � s ¼ fjAN=i=2sg is the set of jobs which are not sequenced in s(that need to be sequenced after sÞ;
� PFðsÞDs (possible first) is the set of jobs which it is possible toattempt to sequence first immediately after s.
Some basic filtering methods are used in this enumerationprocedure at each node of the search tree. First, since the subset of
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–1266 1261
active schedules is dominant [5] for the problem, we eliminatefrom PFðsÞ any job that would give rise to a non-active schedule if itwere to be scheduled first. Second, a simple rule based on the starttimes of jobs is also used (see for instance [33]): we only look atsequences that impose an order on scheduled jobs such that theirstart times are non-decreasing.
Other dominance rules are described in the following sections tofilter the set PFðsÞ at each node of the search tree, thus enhancingthe performance of the branch-and-bound procedure.
The following notation is also used in the remainder of thepaper:
�
Startsi is the start time of job i in the partial schedule associatedwith sequence s; � Csi is the completion time of job i in the partial scheduleassociated with sequence s;
� Fsi is the cost of job i in the partial schedule associated withsequence s;
� Asj is the availability time of machine j in the partial scheduleassociated with sequence s;
� Ci(t) is the completion time of job i if it is scheduled from date ti.e. Ci(t)¼max(ri,t)+pi;
� Fi(t) is the cost of job i if it is scheduled from date t i.e. Fi(t)¼wimax(Ci(t)�di,0);
� sjr represents the sequence resulting from the concatenation ofsequences s and r.
Note that since a nearly active (partial) schedule S is associatedwith each (partial) sequence s, the terms S and s are usedinterchangeably below.
3. Machines on which a job can be scheduled
In this section we introduce the notion of machines on which ajob can be scheduled (referred to as ‘‘possible machines’’) and weshow how this notion can be used to improve the behavior of theenumeration method.
Given a partial solution s and a job i, let msi be the set ofmachines which can process job i in any (partial) schedule whoseassociated sequence begins with s. At the root of the search tree, mi
is set to M. If iAs thenmsi is a singleton containing only the machinems
i which processes i in the schedule associated with s. If iAs thenmsi DM. Note that the definition of mi implies that for two partialsolutions s and su such that su begins with s, we have msui Dmsi .
We now show how mi can be filtered throughout the searchaccording to the jobs already scheduled. In [22], Jouglet et al.described a dominance rule on unscheduled jobs for the one-machine problems. Letsbe a partial solution. Let j and k be two jobssuch that jAs and kAPFðsÞ. Jouglet et al. described conditions inwhich j dominates k in the first position. By ‘‘dominance in the firstposition’’, they mean that if k is scheduled immediately aftersequences, and if the sequencesjk is completed by any sequencerof jobs belonging to s=fkg including job j, then it will always be‘‘better’’ to interchange j and k, i.e. the sequence sjkjr is dominatedwhatever sequence r is, and job k can be removed from the setPFðsÞ of possible first jobs. While this one-machine dominance rulecannot be used to filter the set PFðsÞ from a partial solution s ifm41, it can, however, be used directly to filter the possiblemachines of unscheduled jobs in the following way. Let s be asolution of a given parallel machines problem with m41. Let job k
be the last sequenced job in s. Let j be a job such that jAs. Supposethat before job k was processed, job j dominated job k in the firstposition, according to the single-machine dominance rule of [22].We may deduce that from now on, if j is scheduled on the machinems
k , then we will obtain a strictly better schedule by interchanging j
and k or by inserting j before k. Therefore, we should not schedulejob j on machine ms
k , and msj may be set to msj ¼ msj \fm
sk g.
Note that this possibility of filtering the sets of possiblemachines is not exhaustive, and we believe that new deductionmethods might be found that improve performance. The informa-tion can be used in different ways:
�
If there exists an unscheduled job iAs such that msi ¼ | then thenode associated with the partial schedule s can be pruned fromthe search tree since any solution which can be derived from thisnode is strictly dominated. � Suppose that x=2msi with iAs. Then we also have x=2msjri , where rrepresents any sequence of a subset ofs=fig. Consequently, eachtime we encounter a partial solution where the next job toschedule is to be processed by machine x, i.e. a sequence sjr forwhich mðsjrÞ ¼ x, then job i can be removed from PFðsjrÞ.
� The fact that some unscheduled jobs can be processed by only asubset of M can be used to improve some dominance rules. Suchan improvement is proposed in Section 5.
4. Local dominance rule
In this section we show how we can extend to the parallelmachine case the notion of a ‘‘LOWS-Active’’ schedule, used insolving one-machine problems.
Jouglet et al. [22,23] described a dominant subset of schedulestermed LOWS-active (LOcally Well Sorted active) schedules. This isan improved generalization of a local dominance rule described byChu [15,16] and Chu and Portmann [17] for non-weighted criteria,and it involves building schedules such that no exchanges of twoadjacent jobs can improve the schedule.
The dominance rule described above may be applied simply tothe parallel machine problem in a branch-and-bound procedure asfollows:
Theorem 4.1 (Jouglet et al. [22,23]). Consider a partial solution
associated with sequence s. Let j be the last job on the machine
mðsÞ and let kAPFðsÞ. If CkðDsj ÞrCs
j and FkðDsj ÞþFjðCkðD
sj ÞÞrFsj þ
FkðCsj Þ (with at least one strict inequality), then the schedule associated
with sequence sjk is dominated and k is removed from PFðsÞ, since it is
better to schedule k before j.
We now propose an adaptation of the LOWS-active property forthe parallel machine case. We introduce the notion of ‘‘adjacentfront’’, which allows us to define which jobs are the neighbors of aparticular job. Then, we can check whether or not swapping twoneighbor jobs is advantageous. Recall that ms
i is equal to themachine which processes i in the schedule associated with s.
Definition 4.1. Consider a solution associated with sequences. LetPredsi be the set of jobs preceding i in sequence s. The adjacentfront of i in s, is defined by: Adjsi ¼ fjAPredsi =8kAPredsi ,ðms
j ¼msk Þ
) ðStartsj 4Startsk Þg.
Informally speaking, Adjsi is equal to the set of jobs scheduled inthe final slot on each machine according to the partial scheduleobtained just before scheduling i. Now we can introduce thedominant subset of the LOWS-active schedules for the parallelmachine case.
Definition 4.2. An active schedule associated with sequence s issaid to be LOWS-active if
8iAs and 8jAAdjsi
1.
if msj amsi , at least one of the following conditions holds:(a) FsþFsoFjðD
si ÞþFiðD
sj Þ;
j i
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–12661262
(b) minðCsj ,Cs
i ÞominðCjðDsi Þ,CiðD
sj ÞÞ or maxðCs
j ,Csi ÞomaxðCj
ðDsi Þ,CiðD
sj ÞÞ;
(c) Fsj þFsi ¼ FjðDsi ÞþFiðD
sj Þ and minðCs
j , Csi Þ ¼minðCjðD
si Þ,Cj
ðDsi ÞÞ and maxðCs
j ,Csi Þ ¼maxðCjðD
si Þ,CiðD
sj ÞÞ.
2.
if msj ¼msi , at least one of the following conditions holds:(a) Fsj þFsi oFiðD
sj ÞþFjðCiðD
sj ÞÞ;
(b) Csi oCs
j ðCiðDsj ÞÞ;
(c) FsþFs ¼ FiðDsj ÞþFjðCiðD
sj ÞÞ and Cs ¼ CjðCiðD
sj ÞÞ.
j i iA schedule associated withs is said to be LOWS-active if none ofthe jobs i in the schedule can be exchanged with another job j in i’sadjacent front so as to create a better schedule. Conditions areestablished so that any such exchange of jobs either increases thecost locally or delays jobs scheduled after j. This definition meansthat a schedule can be discarded where none of the conditions (a),(b) and (c) are met. In such schedules, exchanging jobs i and j leadsto a schedule at least as good as the original one. Indeed, asconditions (a) are not fulfilled, the swap does not increase the sumof costs of jobs i and j. As conditions (b) do not hold either, jobsscheduled after i and j are not delayed by this interchange and theircost does not increase. As conditions (c) are also not fulfilled, itensures that the interchange either strictly decreases the sum ofcosts of i and j or let the machines available strictly earlier after theschedule of i and j.
Note that the case msj ¼ms
i corresponds exactly to the condi-tions established by Jouglet et al. [22,23] for obtaining a LOWS-active schedule on one machine. As for the one-machine problem,we can now propose the following theorem, proved by consideringthe different possible interchange cases:
Theorem 4.2. The subset of the LOWS-active schedules is dominant
for the parallel machine total weighted tardiness problem.
Proof. We have to prove that there always exists an optimalschedule that is also LOWS-active. At first, it is well known that theset of active schedules is dominant, i.e. there is at least an optimalschedule which is active [5]. Consider an active schedule associatedwith sequence s which is not LOWS-active. There exist two jobs i
and j for which the condition of LOWS-active property is not met.First, suppose that i and j are scheduled on different machines.None of the corresponding conditions (a), (b) and (c) holds. Thismeans that jobs i and j can be exchanged without delaying anyother job and without increasing the cost (see above). Moreover,because condition (c) does not hold before the swap, we know thatat least one of these conditions holds after swapping i and j. Now, ifjobs i and j are scheduled on the same machine, in the same way thetwo jobs can be exchanged without delaying any other job andwithout increasing the cost [23]. This procedure can be applied onthe schedule each time a couple of jobs i and j that do not have theLOWS-active property is found. During these swaps, the cost neverincreases. This means that the resulting schedule is both optimaland LOWS-active. &
The dominance rule is used in the branch-and-bound procedureas follows: if the schedule corresponding tosjk is not LOWS-active,then the sequence sjk is dominated and k is removed from PFðsÞ.Note that the adjacent front of k for the test corresponds exactly tothe set of jobs last scheduled on each machine. Since there are atmost m jobs to consider in this adjacent front, testing ifsjk is LOWS-active runs in O(m) time.
5. Dominated sequences
In this section we extend the notion of ‘‘dominated sequences’’defined for the one-machine problem. Then we show how thisnotion can be used within the enumeration procedure to reduce the
search space. Here we shall focus on sequences, but recall that thesesequences are associated with nearly active schedules (see Section 2)and that we might just as easily talk about schedules as sequences.
For some flow-shop scheduling problems, Ignall and Schrage[21] showed how to compare two nodes of the search tree whichsequence the same set of jobs. In fact, this kind of dominancerelation can be adapted to the Pmjrij
PwiTi problem.
Thus, it is possible to compare two partial sequences s and sufrom the same set of jobs (i.e. su is a permutation of s). Informallyspeaking, a sequencesu dominates a sequences ifsmay be replacedadvantageously by su in any sequence starting with sequence s. It isclearly a dominance relation between the set of solutions beginningwith sequences and the set of solutions beginning with sequencesu.Now, suppose that, when enumerating solutions, we encounter apartial solutions. If we can find such a sequencesuwhich dominatess then the implicit enumeration of solutions derived from s can bestopped if one of the two following conditions is satisfied (see forexample [24]):
1.
su dominates strictly s and thus s cannot lead to an optimalsolution;2.
su is only at least as good as s but we are sure that the bestsolution of su was or will be enumerated during the search.Several methods exist for finding better permutations su of s (see[22]). For this problem we use a set of sequences already encoun-tered during the search as explained below. In the following, recallthat s is the set of jobs not belonging to sequence s, i.e.
s ¼ flANjl=2sg. Note that if su is a permutation of s, we have su¼ s.Now, consider any schedule and a subset X of jobs in this
schedule. Suppose that we delay the jobs belonging to X by d timeunits. Let us define LXðdÞ as any nondecreasing upper bound of thedifference between the total cost of jobs belonging to X before andafter delaying these jobs by d time units, whatever their positions inthe schedule. For the total weighted tardiness the evaluationfunction LXðdÞ ¼ d
PiAXfwig is valid. This function considers the
worst case in which all jobs are all already late before delayingthem from d. Thus, for each job iAX, a cost dwi is added.
For the special case with m¼1, Jouglet et al. [22] identified thefollowing conditions in which a partial sequence of jobs s isdominated by another sequencesu from the same set of jobs. Ifs is aone-machine sequence, we denote by As the availability time of themachine, i.e. the completion time of the last job in s.
Proposition 5.1 (Jouglet et al. [22]). Consider a partial schedule on a
single machine associated with a sequence s. Consider a sequence susuch thatsu is a permutation ofs. If one of the following two conditions
holds:
1.
AsurmaxðAs,minjAs frjgÞ and FðsuÞrFðsÞ; 2. FðsuÞþLs ðdÞrFðsÞ, where d¼maxð0,Asu�maxðAs,minjAs frjgÞÞthen s is dominated.
Recall that FðsÞ is the total weighted tardiness of the jobs in theschedule associated with s. The first condition concerns the casewhere no delay is entailed for the jobs ins whens is replaced bysu,and the second condition concerns the case where jobs in s will bedelayed by d units of time. Such a delay occurs when, reschedulingjobs according to su, new idle times are added. Thus, Ls ðdÞevaluates the maximum cost of this delay.
We shall now show how this dominance rule can be adapted andgeneralized to the parallel machine case.
First, since there is a subsequence of jobs associated with eachmachine in a schedule of the parallel machine problem, theprevious one-machine dominance rule can be used. Consider a
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–1266 1263
partial solution associated with sequence s. We now denote by si
the subsequence of jobs on machine i. If one of the subsequences si
is strictly dominated (in terms of cost) by a sequence su of the sameset of jobs according to the previous dominance rule, then thewhole partial solution cannot lead to an optimal solution. Note thatfor the second condition, we do not need to consider all the jobsbelonging to s in the evaluation of the additional cost due to thedelay of certain jobs. Indeed, when considering subsequence si, wecan take the subset s i ¼ fjAs=iAmsj g instead of s since only thesejobs will possibly be scheduled after si on machine i. This is one ofthe benefits of the notion of ‘‘possible machines’’ (see Section 3).Applying to the parallel machine problem, the dominance rule isthen expressed as:
Proposition 5.2. Consider a partial schedule on m machines asso-
ciated with a sequences. If one of the subsequencesi,iAM is such that
there exists a schedule on a single machine associated with one-
machine sequence su of the set of jobs belonging to si for which one of
the following two conditions holds:
1.
AsurmaxðAsi ,minjAs ifrjgÞ and FðsuÞoFðsÞ;
2. FðsuÞþLjAs iðdÞoFðsÞ, where d¼maxð0,Asu�maxðAsi ,minjAs i
frjgÞÞ;
then s cannot lead to an optimal solution.
Computing the sum of weights and the minimum release datesof jobs belonging to s i takes OðjsjÞ time. Thus, given sequences si
and su, it takes OðjsjÞ time to know if si is strictly dominated by su,given that it has already been established thatsu is a permutation ofsi and that the set of values fðFðsiÞ,A
si Þ,ðFðsuÞ,A
suÞg is known.We shall now extend the previous dominance rule by consider-
ing the whole sequence s of jobs instead of each subsequence si.The difficulty now comes from the fact that the completion time As
i
of each machine i has to be taken into account in the conditions ofthe dominance rule.
Given a sequence s, we now define the following strict totalorder relation v s over the index of machines: i v sj if and only ifAs
i oAsj or (As
i ¼ Asj and io j). Then, we denote by ½i�s the ith value in
the sorted vector of the machine indexes according to v s.The extension of the dominance rule to the parallel machine
case can then be expressed as:
Proposition 5.3. Consider a partial schedule associated with
sequence s. Consider a sequence su such that su is a permutation of
s. If one of the following two conditions holds:
1.
8iAM, Asu½i�surmaxðminjAs ½i�s frjg,As½i�s Þ4FðsuÞrFðsÞ
2.
FðsuÞþPjAsLjðdjÞrFðsÞ,where dj ¼max½i�sAms
jmax 0,Asu
½i�su�max minjAs ½i�s frjg,A
s½i�s
� �� �� �
then s is dominated.
Proof. Once again, the first condition concerns the case where,after reconfiguring, replacing s by su entails no delay for the jobs ins, while the second condition is where some jobs in s are delayed.
Consider two sequences s and su of the same set of jobs with
FðsuÞrFðsÞ. Let S be any schedule whose associated sequence starts
withs. Let ti be the sequence of jobs which completes sequencesi on
machine i in S, i.e. the complete subsequence of jobs on machine i in S
issijti. Note that each job j belonging to ti is such that iAmsj . Thus, in S
sequence ti cannot start earlier than ti ¼maxðAsk ,min
jAs i frjgÞ.
Let Sube the schedule obtained from S,s andsu in the following way.
The first part of Su is built by scheduling jobs belonging to s by
following sequence su using the procedure described in the proof of
Proposition 2.2. Then, on each machine ½i�su, jobs belonging to t½i�s are
scheduled in Su as soon as possible from time maxðt½i�s ,Asu½i�suÞ following
sequence t½i�s . Note that each job jAs scheduled on machine ½i�s in S is
delayed of at most maxf0,Asu½i�su�maxfminjAs ½i�s frjg,A
s½i�s gg. Note also
that we have FðSÞ�FðSuÞ ¼ FðsÞ�FðsuÞþP
jAs ðFSj �FSu
j Þ and thus FðSuÞ ¼
FðSÞ�FðsÞþFðsuÞ�P
jAs ðFSj �FSu
j Þ.
First, suppose that condition (1) holds. Then 8iAM, we have
Asu½i�su
rmaxfminjAs ½i�s frjg,As½i�s g. Thus, each job jAs is scheduled at
the same time in S and Su and we have FSj ¼ FSu
j . It follows that
FðSuÞrFðSÞ.
Now, suppose that condition (2) holds. In Su, a job jAs is processed
by a machine ½i�s belonging to msj . Thus, job j has been delayed by at
most dj ¼max½i�sAmsjðmaxð0,Asu
½i�su�maxfminjAs ½i�s frjg,A
s½i�s ÞgÞ and FSu
j rFS
j þL jðdjÞ. It follows that FðsÞ�FðsuÞ�P
jAs ðFSj �FSu
j ÞZ0 and FðuSÞ
rFðSÞ. &
During the construction of Su the subsequence su½i� could havebeen completed with a subsequence other than t½i�. However,the chosen matching is the one that minimizes the longestpossible delay among jobs. In this evaluation, it could have alsobeen assumed that in the worst case the cost of all jobs belonging tos will be increased, due to the longest delay over the jobs which canappear on one of the machines if a schedule beginning by s isreplaced bysu. Nevertheless, like for the single-machine dominancerule applied to the parallel machine case, we make use of the notionof possible machines to improve this evaluation, by consideringthe longest possible delay dj for each job j considering the set ofmachines which can potentially process it. Given two sequences sand su, it takes OðmðlogmþjsjÞ time to know ifs is dominated bysu,by considering we already know thatsu is a permutation ofs and theset of values fðFðsÞ,As
½1�s , . . . ,As½m�s Þ, ðFðsuÞ,A
su½1�su
, . . . ,Asu½m�suÞg.
We remark that Proposition 5.3 may be used with only a subsetof the m machines. In fact, in an m-machine schedule, if asubsequence associated with a schedule considering only k
machines over m is dominated, it is obvious that the entire scheduleis dominated. However, it is not easy to test this rule in practice,because every possible subset of machines needs to be investi-gated. After some fruitless attempts, we abandoned this possibility.
To apply these dominance rules to a current partial solution sassociated with a node of the search tree, we need to find sequences(or subsequences)suwhich allow us to establish thats is dominated.Of course, enumerating all such possible sequences is not feasible inpractice. During the search with our enumerative method, we onlyconsider sequences recorded from previously encountered solu-tions. Using suitable data structures, relevant recorded sequencescan be found in an effective way.
Consider a partial solutions associated with a particular node of thesearch tree. As soon as all solutions which can be derived from this nodehave been (implicitly) enumerated, i.e. as soon as the best solutionwhich can be built froms is known, the characteristic ofs are stored intwo sets V1 and Vm. To this end, only the following data are saved:
�
the set of jobs belonging to sequence s associated with the pairof values ðFðsÞ,As½1�s , . . . ,As½m�s Þ is recorded in Vm;
�
for each machine i, the set of jobs belonging to sequence siassociated with the pair of values ðFðsiÞ,Asi Þ is recorded in V1.
During the search, the previously recorded solutions are used inthe following way at each node of the search tree. Let s be thepartial solution associated with the examined node. The set ofpossible first jobs PFðsÞ is filtered. For all jAPFðsÞ, we seek a state inVm whose characteristics meet the condition of Proposition 5.3 todeduce that sequence sjj is dominated. If such a state is found thenscheduling a job j immediately after s yields a partial solution
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–12661264
which is dominated, i.e. no solution better than those previouslyencountered can be built from sjj. Thus, job j can be removed fromset PFðsÞ. If it is not the case, job j could be sequenced immediatelyafter s, i.e. scheduled as soon as possible on machine mðsÞ. Thesubsequence smðsÞjj is then tested by searching a state in V1 whosecharacteristics meet the condition of Proposition 5.2. If it is the case,job j can also be removed from set PFðsÞ. Note that it is required inProposition 5.2 that the state obtained from V1 is strictly better thansmðsÞjj (according to the cost) to eliminate j from set PFðsÞ. Anequivalence is not sufficient to deduce that no better solution thanpreviously encountered ones can be built from sjj, given thatsubsequences other than smðsÞ are not considered.
Hash tables combined with height-balanced binary search treesmake for an efficient use of sets V1 and Vm. This generally allows usto obtain a pertinent state of one of the sets in O(n log n). A state of aset consists of a list of jobs sorted in lexicographic order coded in avector, and a list of couples (F, A) corresponding to the differentstates of the nodes which have been visited within this set of jobs.Note that only non-comparable couples can be retained. Supposethat we search a state with the same set of jobs belonging to asequences in one of set V1 or Vm. Sorting jobs in lexicographic orderruns in O(n log n) time. Computing an index in the hash table of thisset of jobs runs in O(n) time. Since jobs are sorted in lexicographicorder, a comparison of two sets of jobs runs in O(n) time. Thus, ifthere is no collision with another state at the same index in the hashtable, seeking the set of relevant sequences su encountered frompreviously encountered solution in the search runs in O(n log n)time. In case of collision with k states at the same index in the hashtable, a height-balanced binary search tree is used with anadditional search running in O(n log k) time. Once a relevant statehas been found with the same set of jobs, it simply needs to bedetermined whether a couple (F,A) of the state satisfies thesufficient condition of Proposition 5.3 or 5.2 according to the case.Experimental tests revealed that the amount of such (non-compar-able) couples is very low.
6. Experimental results
In this section we provide experimental results to compare theeffectiveness of the described dominance rules. All the computations
Table 1Testing the effectiveness of the techniques, n¼15.
m % Basic LOWS
cpu nodes opt. cpu nodes opt
2 81.67 27523 229133 95 1931 23945 100
3 74.17 10874 85484 86 2562 28074 100
5 75.00 132 1369 79 105 1163 83
m % DR1 DRm
cpu nodes opt. cpu nodes opt
2 81.67 7906 26780 98 3112 8135 100
3 74.17 20478 34175 83 3939 9517 100
5 75.00 304 1268 75 267 900 100
m % LOWS, DR1, DRm LOWS, DRm
cpu nodes opt. cpu nodes opt
2 81.67 711 1878 100 574 1961 100
3 74.17 1013 2237 100 744 2272 100
5 75.00 177 426 100 138 427 100
were performed on a 1.6 GHz Pentium-M running MS-Windows XP.Instances were generated from schemes used in the literature.
We used a classical branch-and-bound procedure given inAlgorithm 1. A depth first strategy is used within this enumerationmethod using a stack STACK of nodes. In the search tree, a nodecorresponds to a partial sequence s. STACK is initialized with theempty sequence. A variable UB is used to store the value of the bestfound sequence BestSequence. A lower bound function LB (seebelow) is used to evaluate the minimal cost of a given solution.Dominance rules are applied to each generated node s, leadingpossibly to eliminating some children of this node in the tree byfiltering PFðsÞ. When all the possible children of s have beenenumerated, the sequence s is recorded in V1 and Vm as explainedin Section 5.
Algorithm 1. The branch-and-bound algorithm
Push the empty sequence on STACK;
V1’|, Vm’|, UB’1;while STACK is not empty do
Let s be the sequence on the top of STACK;
if PFðsÞa| then
Let jAPFðsÞ;PFðsÞ’PFðsÞ=fjg;su’sjj;if LBðsuÞoUB then
Filter PFðsuÞ according to Definition 4:2 as explained
in Section 4;
Filter PFðsuÞ according to Propositions 5:3and 5:2
as explained in Section 5;
Push su in STACK;
������������
����������������������elseRemove the sequence s which is on the top of STACK;
Add s to Vm and each subsequence si,iAM to V1;
if all jobs belonging to N belong to s and FðsÞoUB then
UB’FðsÞ;BestSequence’s;
�����
�������������
��������������������������������������������
To generate instances, we adapted the schemes from Chu [15]and Akturk and Ozdemir [1] for the single machine problem. Foreach n, m, we generate m sets of bn=mc jobs and one set ofn�m�bn=mc jobs. This method is controlled by two parameters aand b. Values ri, pi, di and wi are generated from uniform distribu-tions: pi are uniformly distributed in [1, 100], wi in [1, 10]. Then, ri
are distributed in ½0,aP
pi� and di�ri+pi in ½0,bP
pi�. Parameter atakes values {0,0.5,1,1.5} and b takes values in {0.05,0.25,0.5}.When n, m, a and b are fixed, 10 instances are created. Finally, thereare 120 instances for each couple (n,m).
Tests were done on instances of different sizes in terms of thenumber of jobs. For each size there were three sets of instances,depending on the number of machines: 2, 3 or 5. A time limit of1800 s was fixed.
In Table 1 we compare the effectiveness of the differenttechniques described in this paper. Below, ‘‘LOWS’’ refers to theuse of the technique based on local dominance rule described inSection 4 while ‘‘DR1’’ and ‘‘DRm’’ respectively mean the use oftechniques based on Propositions 5.2 and 5.3 described in Section 5.The enumeration procedure is run with instances of n¼15 jobs andm¼{2,3,5} machines. For these tests we use a trivial lower bound ateach node of the search tree. For each partial schedule, the lowerbound is obtained by computing the total cost, assuming that alljobs will be scheduled as early as possible at the end of the partial
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–1266 1265
schedule. The method only uses the dominance rule of the activeschedule and the start-times-based dominance rule (see Section 2).The results are reported in the column ‘‘basic’’. Techniques are firsttested one by one (‘‘LOWS’’, ‘‘DR1’’, ‘‘DRm’’). Then, we report theresults obtained when all techniques are used (‘‘LOWS, DR1, DRm’’).Finally, we present the results for the configuration of techniquesthat appears to be the best tradeoff between the size of the searchspace and the computation time efficiency, i.e. ‘‘LOWS, DRm’’. Notethat for the two last cases, we also used another dominance rulebased on not scheduled jobs (see [29]) whose contribution addsvirtually nothing to the results.
For the different numbers of machines we report the averagecomputing times in milliseconds (‘‘cpu’’) and the average number ofgenerated nodes (‘‘nodes’’) over the 120 generated instances. Notethat some instances are not solved within the time limit. This iswhy we provide these statistics only over the instances which havebeen solved for all versions. The percentage of concerned instancesis shown in the ‘‘%’’ column. However, we provide the percentage ofinstances which were solved for each version (columns ‘‘opt.’’).
We can see that all the rules are effective in reducing the searchspace, and especially the rule DRm, which succeeds in reducing itquite dramatically. Nevertheless, the rate of improvement decreasesas the number of machines grows. We can see that although DR1
reduces the search space, computing times are higher than for thebasic version where m¼3. In the light of our numerical experimentswe decided not to use DR1 when the other dominance rules were
Table 2Computational results.
n a b m¼2 m
cpu nodes c
10 0 0.05 105 360 2
0 0.25 120 400 2
0 0.5 109 380 1
0.5 0.05 25 79 3
0.5 0.25 28 113 2
0.5 0.5 41 140 4
1 0.05 12 31 1
1 0.25 6 24 1
1 0.5 8 25 6
1.5 0.05 6 21 5
1.5 0.25 6 9 5
1.5 0.5 2 6 3
15 0 0.05 2273 4659 1
0 0.25 2924 5614 2
0 0.5 4608 9532 7
0.5 0.05 1264 2614 1
0.5 0.25 1406 3158 5
0.5 0.5 2044 4842 1
1 0.05 117 293 1
1 0.25 56 142 3
1 0.5 69 155 3
1.5 0.05 42 90 2
1.5 0.25 9 29 1
1.5 0.5 6 12 3
20 0 0.05 30 106 40 407 4
0 0.25 78 533 89 729 5
0 0.5 245 462 337 232 1
0.5 0.05 50 830 71 230 1
0.5 0.25 66 991 92 108 3
0.5 0.5 42 016 62 340 1
1 0.05 881 1611 4
1 0.25 1425 2698 3
1 0.5 25 41 5
1.5 0.05 1176 1776 5
1.5 0.25 3 9 3
1.5 0.5 2 0 6
activated. In fact, the size of the search space was very similar with orwithout DR1, but the computation time was substantially higher.
Results of the branch-and-bound method using the best com-bination of the techniques (LOWS, DRm) are shown in Table 2. Thelower bound lb[]combo of Baptiste et al. [8] is used.
For the different combinations of parameters (a,b) and fordifferent sizes of instances the average computing times in milli-seconds (cpu) are shown, as well as the average number ofgenerated nodes (nodes) over the 10 generated instances. Note thatsome instances are not solved within the time limit, and in thesecases we provide in brackets the number of instances over 10 whichare not solved. The cpu and nodes statistics are then provided onlyfor the solved instances. As we can see, the hardest instances tosolve are the ones with all release dates equal to 0 (a¼ 0). Thissuggests that a specific method for the instances without releasedates should be used. In the case of different release dates (a40)the hardest instances are those with (a¼ 0:5,b¼ 0:25) or(a¼ 0:5,b¼ 0:5), as in the case of the 1jrij
PwiTi problem [22].
Above n¼20 jobs the instances become very hard to solve by thisbranch-and-bound method if the number of machines is greaterthan 3. This is hardly surprising, since to our knowledge even themost effective methods for the one-machine problem are able tosolve all instances only as long as the number of jobs is less than 30[22]. In both the one-machine and parallel machine cases, this canbe explained by the fact that the best-known lower bounds for theseproblems are not particularly satisfactory. Both the one-machine
¼3 m¼5
pu nodes cpu nodes
86 908 394 922
53 801 337 783
69 540 122 248
6 121 22 91
8 100 33 120
2 156 8 28
0 35 9 33
6 47 3 14
19 3 6
25 6 19
15 2 0
13 2 1
3 884 26 868 79 984 78 104
5 551 47 681 228 389 166 394
2 542 118 595 155 381 85 746
477 3180 702 1483
955 9921 3964 6853
388 3308 134 324
09 267 88 207
1 78 37 70
9 90 8 9
05 453 5 12
1 27 6 2
3 5 0
73 142 489 333 1 494 446 (10) 913 122
84 889 (2) 569 814 – _
224 438 (3) 1 082 238 1 730 781 (9) 576 345
17 463 153 602 137 261 109 252
11 556 358 236 163 428 (2) 124 420
99 344 (1) 221 334 85 912 (2) 62 731
334 6698 12 626 10 738
227 4936 106 176
94 974 192 334
3 104 30 44
4 64 60 105
5 13 16
A. Jouglet, D. Savourey / Computers & Operations Research 38 (2011) 1259–12661266
and the parallel machine total weighted tardiness problem appearvery hard to solve in practice.
7. Conclusion
This paper describes dominance rules for the parallel totalweighted tardiness scheduling problem. We have shown how it ispossible to deduce whether or not some jobs can be processed by aparticular machine in a particular context. This idea is used in non-trivial adaptations of one-machine dominance rules from theliterature. A numerical validation of the described technique ispresented. Experimental results show that the dominance rules areeffective in reducing the search space and the computing times of abranch-and-bound method. The absence of a satisfactory lowerbound for this problem means that if the number of machines is toohigh, then it is possible to solve all instances only as long as thenumber of jobs does not exceed n¼20. Nevertheless, consideringthat the best methods for the one-machine version of the problemare only able (to our knowledge) to solve instances up to n¼30 jobs,and considering that the hardness of the problems dramaticallyincreases with the number of machines, the obtained results wouldappear to be reasonably good. Moreover, note that without the useof the dominance rules described in this paper, a lot of instances of15 jobs cannot be solved, which demonstrates the interest of thedescribed techniques. To our knowledge, ours is the first attempt tosolve this problem exactly.
Acknowledgments
The authors would like to thank Jacques Carlier for enlighteningdiscussions on this problem. They also would like to thank thereviewers, whose remarks helped to improve this paper.
References
[1] Akturk MS, Ozdemir D. An exact approach to minimizing total weightedtardiness with release dates. IIE Transactions 2000;32:1091–101.
[2] Akturk MS, Ozdemir D. A new dominance rule to minimize total weightedtardiness with unequal release dates. European Journal of OperationalResearch 2001;135:394–412.
[3] Azizoglu M, Kirca O. Tardiness minimization on parallel machines. Interna-tional Journal of Production Economics 1998;55:163–8.
[5] Baker KR. Introduction to sequencing and scheduling. John Wiley and Sons; 1974.[6] Baptiste Ph. Scheduling equal-length jobs on identical parallel machines.
Discrete Applied Mathematics 2000;13:21–32.[7] Baptiste Ph, Carlier J, Jouglet A. A branch-and-bound procedure to minimize
total tardiness on one machine with arbitrary release dates. European Journal
of Operational Research 2004;158(3):595–608.[8] Baptiste Ph, Jouglet A, Savourey D. Lower bounds for parallel machine
scheduling problems. International Journal of Operational Research 2008;3(6):661–82.
[12] Brucker P. Scheduling algorithms. Springer Lehrbuch; 1995.[13] Carlier J. Ordonnancements �a contraintes disjonctives. RAIRO 1978;12:
333–351.[15] Chu C. A branch and bound algorithm to minimize total flow time with unequal
release dates. Naval Research Logistics 1992;39:859–75.[16] Chu C. A branch and bound algorithm to minimize total tardiness with different
release dates. Naval Research Logistics 1992;39:265–83.[17] Chu C, Portmann M-C. Some new efficients methods to solve the nj1jrij
PTi .
European Journal of Operational Research 1991;58:404–13.[18] Conway RW, Maxwell WL, Miller LW. Theory of scheduling. Reading: Addison-
Wesley; 1967.[21] Ignall E, Schrage L. Applications of the branch-and-bound technique to some
flow-shop scheduling problems. Operations Research 1965;13:400–12.[22] Jouglet A, Baptiste Ph, Carlier J. Branch-and-bound algorithms for total
weighted tardiness. In: Leung JY-T, editor. Handbook of scheduling: algorithms
models and performance analysis, vol. 13. Chapman & Hall/CRC edition; 2004.p. 1–21.
[23] Jouglet A, Savourey D, Carlier J, Baptiste Ph. Dominance-based heuristics forone-machine total cost scheduling problems. European Journal of OperationalResearch 2008;184(3):879–99.
[24] Kohler WH, Steiglitz K. Enumerative and iterative computational approaches.In: Coffman EG, editor. Computer and job-shop scheduling theory, vol. 6. John
Wiley & Sons; 1976. p. 229–87.[25] Lenstra J, Kan AR, Brucker P. Complexity of machine scheduling problems.
Annals of Discrete Mathematics 1977;1:343–62.[26] Liaw C-F, Lin Y-K, Cheng C-Y, Chen M. Scheduling unrelated parallel machines
to minimize total weighted tardiness. Computers & Operations Research2003:1777–89.
[27] Mitten L. Branch-and-bound methods: general formulation and properties.Operations Research 1970;18(1):24–34.
[28] Nessah R, Yalaoui F, Chu C. A branch-and-bound algorithm to minimize totalweighted completion time on identical parallel machines with job releasedates. Computers & Operations Research 2008;35(4):1176–90.
[29] Savourey D. Ordonnancement sur machines parall�eles: minimiser la sommedes couts. PhD thesis, Universite de Technologie de Compi�egne, France; 2006.
[30] Shim S-O, Kim Y-D. Scheduling on parallel identical machines to minimize totaltardiness. European Journal of Operational Research 2007:135–46.
[31] Walker R. An enumerative technique for a class of combinatorial problems.American Mathematical Society Symposia in Applied Mathematics 1960;10:
91–4.[32] Yalaoui F, Chu C. Parallel machine scheduling to minimize total tardiness.
International Journal of Production Economics 2002;76:265–79.[33] Yalaoui F, Chu C. New exact method to solve the Pmjrij
PCi problem.
International Journal of Production Economics 2006;100(1):168–79.