Parallel machine scheduling with precedence constraints and setup times

ARTICLE IN PRESS

Computers & Operations Research 37 (2010) 2141–2151

Contents lists available at ScienceDirect

Computers & Operations Research

0305-05

doi:10.1

� Corr

Toulous

E-m

lopez@l

journal homepage: www.elsevier.com/locate/caor

Parallel machine scheduling with precedence constraints and setup times

Bernat Gacias a,b, Christian Artigues a,b, Pierre Lopez a,b,�

a CNRS; LAAS; 7 avenue du Colonel Roche, F-31077 Toulouse, Franceb Universite de Toulouse; UPS, INSA, INP, ISAE; LAAS; F-31077 Toulouse, France

a r t i c l e i n f o

Available online 7 March 2010

Keywords:

Parallel machine scheduling

Setup times

Precedence constraints

Dominance conditions

Branch-and-bound

Limited discrepancy search

Local search

48/$ - see front matter & 2010 Elsevier Ltd. A

016/j.cor.2010.03.003

esponding author at: CNRS; LAAS; 7 avenu

e, France.

ail addresses: [email protected] (B. Gacias), a

aas.fr (P. Lopez).

a b s t r a c t

This paper presents different methods for solving parallel machine scheduling problems with

precedence constraints and setup times between the jobs. These problems are strongly NP-hard and

it is even conjectured that no list scheduling algorithm can be defined without explicitly considering

jointly scheduling and resource allocation. We propose dominance conditions based on the analysis of

the problem structure and an extension to setup times of the energetic reasoning constraint

propagation algorithm. An exact branch-and-bound procedure and a climbing discrepancy search

(CDS) heuristic based on these components are defined. We show how the proposed dominance rules

can still be valid in the CDS scheme. The proposed methods are evaluated on a set of randomly

generated instances and compared with previous results from the literature and those obtained with an

efficient commercial solver. We conclude that our propositions are quite competitive and our results

even outperform other approaches in most cases.

& 2010 Elsevier Ltd. All rights reserved.

1. Introduction

This paper deals with parallel machine scheduling withprecedence constraints and setup times between the executionof jobs. We consider the optimization of two different criteria: theminimization of the sum of completion times and the minimiza-tion of maximum lateness. These two criteria are of great interestin production scheduling. The sum of completion times is acriterion that maximizes the production flow and minimizes thework-in-process inventories. Due dates of jobs can be associatedto the delivery dates of products. Therefore, the minimization ofmaximum lateness is a goal of due date satisfaction in order todisturb as less as possible the customer who is delivered with thelongest delay. These problems are strongly NP-hard [1].

The parallel machine scheduling problem has been widelystudied [2], specially because it appears as a relaxation of morecomplex problems like the hybrid flow shop scheduling problemor the RCPSP (resource-constrained project scheduling problem).Several methods have been proposed to solve this problem. InChen and Powell [3], a column generation strategy is proposed.Pearn et al. [4] propose a linear program and an efficient heuristicfor large-size instances for the resolution of priority constraintsand family setup times problem. Salem et al. [5] solve the problemwith a tree search method. More recently, Neron et al. [6] compare

ll rights reserved.

e du Colonel Roche, F-31077

[email protected] (C. Artigues),

two different branching schemes and several tree search strategiesfor the problem with release dates and tails for the makespanminimization case.

However, the literature on parallel machine scheduling withprecedence constraints and setup times is quite limited. Baev et al.[7] and van den Akker et al. [8] deal with the problem withprecedence constraints for the minimization of the sum ofcompletion times and maximum lateness, respectively. The setuptimes case is considered in Schutten and Leussink [9] and inOvacik and Uzsoy [10] for the minimization of maximum lateness.Uzsoy and Velasquez [11] deal with the same criterion on a singlemachine with family-dependent setup times. Finally, Nessah et al.[12] propose a lower bound and a branch-and-bound method forthe minimization of the sum of completion times.

Problems that have either precedence constraints or setuptimes, but not both, can be solved by list scheduling algorithms. Itmeans there exists a total ordering of the jobs (i.e., a list) that,when a given machine assignment rule is applied, reaches theoptimal solution [13]. For a regular criterion, this rule is calledearliest completion time (ECT). It consists in allocating every job tothe machine that allows it to be completed at the earliest. Thisreasoning unfortunately does not work when precedence con-straints and setup times are considered together, as shown inHurink and Knust [14]. We have then to modify the way to solvethe problem and consider both scheduling and resource allocationdecisions.

In this paper we propose to solve these problems throughbranch-and-bound for small-sized instances and local search forlarge-scale instances. To compensate search tree explosion due tomachine assignment enumeration, we propose new constraint

www.elsevier.com/locate/caor

dx.doi.org/10.1016/j.cor.2010.03.003

mailto:[email protected]



ARTICLE IN PRESS

B. Gacias et al. / Computers & Operations Research 37 (2010) 2141–21512142

propagation and dominance rules. For the local search method, weretain the principle of neighborhood exploration using a treesearch structure in order to discard dominated solutions as soon aspossible and we propose variants of the climbing discrepancysearch method (CDS) proposed by Milano and Roli [15]. Inparticular we propose adapted dominance rules to avoid discard-ing solutions that do not have a dominant counterpart in theexplored neighborhood.

In Section 2, we define formally the parallel machine schedul-ing problem with setup times and precedence constraints betweenjobs. The solution properties and the implications on branch-and-bound and local search are presented in Section 3. In Section 4 wepresent the branch-and-bound method and its components: treestructure, lower bounds, and dominance rules. Discrepancy-basedtree search methods are described in Section 5. Section 6 isdedicated to computational experiments.

2. Problem definition

We consider a set J of n jobs to be processed on m parallelmachines. The precedence relations between the jobs and thesetup times, considered when different jobs are sequenced on thesame machine, must be satisfied. The preemption is not allowed,so each job is continually processed during pi time units on thesame machine. The machine can process no more than one job at atime. The decision variables of the problem are the start times ofevery job i¼1yn, Si, and let us define Ci as the completion time ofjob i, where Ci¼Si+pi. Let ri and di be the release date and the duedate of job i, respectively. Due dates are only considered for joblateness computation. We denote by E the set of precedenceconstraints between jobs. The relation ði,jÞAE, with i,jA J, meansthat job i is performed before job j ði!jÞ such that job j can startonly after the end of job i ðSjZCiÞ. Finally, we define sij as the setuptime needed when job j is processed immediately after job i on thesame machine. Thus, for two jobs i and j processed successively onthe same machine, we have either SjZCiþsij if i precedes j, orSiZCjþsji if j precedes i. Using the notation of Graham et al. [1],the problems under consideration are denoted: Pmjprec,sij,rij

PCi

for the minimization of the sum of completion times andPmjprec,sij,rijLmax for the minimization of the maximum lateness.

Example

A set of five jobs (n¼5) must be executed on two parallelmachines (m¼2). For every job i, we give pi, ri, di, and sij (seeTable 1). Besides, for that example we have the precedenceconstraints: 1!4 and 2!5.

Table 1Example 1 data.

(a)

n pi ri di

1 4 1 7

2 3 0 5

3 4 3 8

4 3 3 10

5 2 1 5

(b)

sij 1 2 3 4 5

1 0 2 3 4 5

2 7 0 6 1 3

3 2 4 0 7 1

4 4 4 8 0 1

5 3 4 8 5 0

Fig. 1 displays a feasible solution for this problem. The set ofprecedence constraints is satisfied: S5 ¼ 13Z3¼ C2 andS4 ¼ 5Z5¼ C1. We stress that job 4 must postpone its start timeon M2 by one time unit because of the precedence constraint. Onthe other hand, we have to check that, for every job i, rirSi andthat setup times between two sequenced jobs on the samemachine are also respected. For the evaluation of the solution, weobserve that for the minimization of the sum of completion timesthe value of the function is z¼

PCi ¼ 43 and for the minimization

of maximum lateness z¼Lmax¼L5¼10.

3. Solution properties and impact on branch-and-bound andlocal search

3.1. Solution properties

In Schutten [13], the author proves that the parallel machinescheduling problem with either setup times between jobs orprecedence constraints can be solved to optimality by a listscheduling algorithm. He demonstrates that the schedules builtusing the list scheduling algorithm with earliest completion timeassignment rule are dominant schedules.

However, precedence constraints and setup times parallelmachine scheduling problems may not be efficiently solved by alist algorithm as conjectured by Hurink and Knust [14]. It meansthat there possibly does not exist a job assignment rule thatreaches an optimal solution when all the possible lists of jobs areenumerated. Let us consider the minimization of the sum ofcompletion times for four jobs scheduled on two parallelmachines. The data of the problem are displayed in Table 2.

If we consider the problem without precedence constraints, wefind two optimal solutions ð

PCi ¼ 9Þ when we allocate the jobs

following the earliest completion time rule for the lists {1,2,4,3}and {2,1,4,3} (see Fig. 2a). Now, let us consider the same problemwith the precedence constraint 3!4. In that case, there does notexist any allocation rule that reaches an optimal solution for anylist of jobs that respects the precedence constraint. The optimal

Fig. 1. Feasible schedule.

Table 2Example 2 data.

(a)

n pi ri

1 1 0

2 1 0

3 1 2

4 1 2

(b)

sij 1 2 3 4

1 0 10 2 10

2 10 0 1 1

3 10 10 0 10

4 10 10 10 0

ARTICLE IN PRESS

Fig. 2. Example of job assignment. (a) Optimal schedule without the precedence constraint, (b) optimal schedule with the precedence constraint.

1

1

1

1

1

2

1

1

1

1

1

S

4s

5s

2

1t

2t

3t

5t

0t

4t

1s

3s

0s

2s

T

Fig. 3. Network to determine the problem feasibility.

B. Gacias et al. / Computers & Operations Research 37 (2010) 2141–2151 2143

solution ðP

Ci ¼ 11Þ is reached when we consider the list {1,2,3,4}and job 3 is not allocated on the machine that allows it to finishfirst (see Fig. 2b).

In the same paper, the authors prove that even if a total order isimposed on the job start times, i.e., S1rS2r � � �rSn, the problemremain NP-hard. Thus, in our problems we have not only to findthe best list of jobs, but also to specify the best resource allocation.

However, in Neumann et al. [16] the authors prove that once wehave at our disposal a set of job start times we can check the feasibilityof the schedule in polynomial time (O(n3)). The idea is to convert theschedule into a graph and to verify using a max flow computation thatall jobs are executed and the resource constraint is satisfied.

To construct the network two vertices are considered for eachjob, the first one represents the start time it and the second one thecompletion time is of the job. One unit capacity arcs are definedbetween the vertices is� jt and they represent the transfer ofresource units between the jobs, we create a direct arc is� jt ifSjZSiþpiþsij, that means if job j can be executed on the samemachine than job i and after job i. Finally, we need four dummyvertices. Two vertices (0s, 0t), the source node S and the sink nodeT, flow origin and flow destination, respectively. Arcs S-0s and 0t-T

have m-unit capacity and represent the resource constraint. The1-unit capacity arcs between S-is and it-T ensure the job execution.

Let us consider the start times of the schedule of Section 2(S1¼1, S2¼0, S3¼8, S4¼5, S5¼13). Fig. 3 shows the networkcorresponding to the start times. The max flow computationdetermines the schedule feasibility and also proposes theassignment of jobs on machines that respect the start times. Weobserve that a max flow of m+p units is necessary to ensure all jobexecutions and to satisfy the resource constraints.

It follows from this analysis that, in a solving method, we caneither represent a solution by a couple (job list, job/machineassignment) or directly by a start time vector (from which afeasible machine assignment can be derived in polynomial time).

3.2. Semi-active schedules

The set of semi-active schedules are dominant schedules for theproblem. This means that there always exists an optimal schedulewhich is semi-active; therefore the search space can be reduced tothe set of semi-active schedules. A feasible schedule represented bya start time vector S is semi-active if no feasible schedule can beobtained from S by left-shifting by one time unit a single activity[17]. The dominant properties of semi-active schedules are used tointegrate new dominance rules in the branch-and-bound and localsearch schemes (see Sections 4.3 and 5.4).

The max flow computation proposed in Section 3.1 can be usedto check in polynomial time whether a schedule is semi-active ornot by checking n times the existence of a feasible flow in theresource-flow network (see Algorithm 1).

Algorithm 1. Semi-active checking for schedule S¼{S0,S1,y,Sn}.

Step 1: Build the resource-flow nework associated to S.for (i¼1yn) do

Step 2 : Set Si :¼ Si�1:

Step 3 : Update network by removing all arcs

js�it such that SioSjþpjþsji:

Step 4 :

If a feasible flow is found then the schedule

is not semi� active; return false:

Step 5 : Set Si :¼ Siþ1 and restore the removed arcs

on the network:

66666666666666664Step 6: The schedule is semi-active, return true.

3.3. Issues for branch-and-bound and local search

In this paper, we propose an exact method to solve small-sizeinstances and an efficient local search structure to solve the large-size instances of the problem. Our methods are based on solutionrepresentation through the job list/machine assignment repre-sentation. However, we propose to use the semi-active scheduleverification Algorithm 1 as a dominance rule to discard any joblist/machine assignment yielding a non-semi-active schedule. Wewill present in Section 4 a branch-and-bound method embeddingthis dominance rule together with lower bounds, and newconstraint propagation algorithms. For local search, instead ofusing directly the standard machine scheduling neighborhoods(pairwise interchange, reassignments, y), our proposal is tointegrate them in a tree search structure. This allows us to benefitfrom the lower bounds, constraint propagation and dominancerule components. The climbing discrepancy search methodproposed by Milano and Roli [15] appears as an appropriatesolving scheme to reach this goal. This raises, however, the issue ofhow to avoid discarding dominated solutions that have not their

ARTICLE IN PRESS


dominant counterpart in the explored neighborhood. The variantsof the CDS method, addressing in particular this issue, arepresented in Section 5.

Fig. 4. Minimum energy consumed in a partial schedule.

4. Branch-and-bound components for Pmjprec,sij,rijP

Ci andPmjprec,sij,rijLmax

A tree structure with two levels of decisions (scheduling andresource allocation) is defined in Section 4.1. Lower bounds andconstraint propagation mechanisms are presented in Section 4.2.Dominance rules are introduced in Section 4.3.

4.1. Tree structure

The optimal solution can be reached by a two decision-leveltree search. We define a node as a partial schedule sðpÞ of p jobs.Every node entails at most m� (n�p) child nodes. The term n�p

corresponds to the choice of the next job to be scheduled (jobscheduling problem). Only the jobs with all the previous jobsalready executed are candidates to be scheduled. Once the nextjob to be scheduled is selected we have to consider the m possiblemachine allocations (machine allocation problem). For practicalpurposes, we have mixed both levels of decision: one branch isassociated with the choice of the next job to schedule and alsowith the choice of the machine. A solution is reached when thenode represents a complete schedule, i.e., when p¼n.

4.2. Node evaluation

Node evaluation differs depending on the studied criterion.First, we propose to compute a simple lower bound. For everynode (partial schedule), we update the earliest start times of theunscheduled jobs taking account of the branching decisionsthrough precedence constraints and we calculate the minimumcompletion time (for min

PCi criterion) and the minimum

lateness (for min Lmax criterion) for every not yet-scheduled job.Then we update the criterion and we compare the lower boundwith the best current solution.

We also propose to compute an upper bound. The upper boundis computed by a simple list scheduling heuristic selecting thecombination of job, between the not yet-scheduled jobs, andmachine with the earliest start time (EST). We take criterion ESTbecause it is intuitively compatible with the minimization of setuptimes which has globally a positive impact for minimization ofother regular criteria [18]. In case of tie between two jobs, weapply SPT (smallest processing time) rule for min

PCi and EDD

(earliest due date) for min Lmax.For criterion min

PCi, we also propose to compute the lower

bound presented in Nessah et al. [12] for the parallel machinescheduling problem, with sequence-dependent setup times andrelease dates ðPmjsij,rij

PCiÞ. This problem is a relaxation of the

problem with precedence constraints, so the lower bound is stillvalid for our problem. In this paper, we just present the lowerbound for the problem, that is based on job preemption relaxation,and we refer to Nessah et al. [12] for the proof.

Let S* be the schedule obtained with the SRPT (shortestremaining processing time) rule for the relaxed problem1jri,ðpi=mþs�i Þ,pmtnj

PmaxðC�i �s�i ,riþpiÞ, where si ¼minja isij and

s�i ¼ si=m. Let C*[i](S*) be the modified completion time of job i with

the processing time pi+s*i for each job i. Let ai¼pi+ri+s*

i and let(a[1],a[2],y,a[n]) be the series obtained by sorting (a1,a2,y,an) innon-decreasing order. Then LB¼

Pmax½C�

½i�ðS�Þ,a½i��P

s�i is alower bound for Pmjprec,sij,rij

PCi. The complexity of the lower

bound is O (n log n), the same complexity as SRPT.

For min Lmax, the evaluation consists in triggering a satisfia-bility test based on constraint propagation involving energeticreasoning [19]. We propose here a simple extension of thisconcept to setup times. The energy is produced by the resourcesand it is consumed by the jobs. We apply this feasibility test toverify whether the best solution reached from the current nodewill be at least as good as the best current solution. We determinethe minimum energy consumed by the jobs (Econsumed) over a timeinterval D¼ ½t1,t2� and we compare it with the available energyðEproduced ¼m� ðt2�t1ÞÞ. In our problem we also have to considerthe energy consumed by the setup times (Esetup). If Econsumedþ

Esetup4Eproduced we can prune the node.For an interval D where there is a set F of k jobs that may

consume energy, we can easily show that the minimum quantityof setups which occurs is a¼maxð0,k�mÞ. So, we have to take thea shortest setup times of the set fsijg,i,jAF, into account.

The energy consumed in an interval D is Econsumed ¼Pimaxð0,minðpi,t2�t1,r0iþpi�t1,t2�d0iþpiÞÞþ

Pal s½l� where s[l] are

the setup times of the set fsijg,i,jAF, sorted in non-decreasingorder, and a time window ½r0i ,d

0i� for every not yet-scheduled job i is

issued from precedence constraint propagation:

r0i ¼maxfri,rjþpj; 8jAG�i g and d0i ¼minfZbestþdi,d0j�pj; 8jAGþi g,

where G�i and Gþi are, respectively, the set of previous andsuccessor jobs for job i and Zbest is the minimum current valuefor Lmax.

In Fig. 4 we illustrate how to compute the energy consumed bythe not yet-scheduled jobs (1–5 in the example) for a 3-machineproblem. For every job, we determine a time window and theminimum energy consumed (in grey) over the selected intervalD¼ ½t1,t2�. For Esetup we have to take the a shortest setup times, inthe example k¼4 (there is no consumption for job 1) and m¼3, sowe have to sum only the shortest setup time between theconsuming jobs, in our case we add two energy units (value of s35).

The time interval D¼ ½t1,t2� considered to compute the energyconsumed is t1 ¼min r0i ,8iAF and t2 ¼ d0j, where j is the job withthe shortest time window minðd0j�r0jÞ,8jAF. The restriction to asingle interval, although yielding an incomplete algorithm, allowsto an O(n2) time complexity of the energetic test.

4.3. Dominance rule

We also propose a dominance rule to restrict the search space.It consists in trying to find whether there exists a dominant nodeallowing us to prune the evaluated node. The proposed rule is

ARTICLE IN PRESS


based on the dominance properties of the set of semi-activeschedules (see Section 3). Let JðsðpÞÞ denote the set of jobsincluded in the partial schedule sðpÞ. Let us define the frontFðsðpÞÞD JðsðpÞÞ of a partial schedule sðpÞ as the set of the lastscheduled jobs on the machines (the ones with the largest starttimes). In Fig. 5, FðsðpÞÞ ¼ f4,5g.

Dominance Rule 1. A partial schedule sðpÞ is dominated if there

exists another partial schedule s0ðpÞ such that JðsðpÞÞ ¼ Jðs0ðpÞÞ,FðsðpÞ ¼ Fðs0ðpÞÞ ¼ F and S0irSi, 8iAF.

To check if a partial schedule sðpÞ is dominated we useAlgorithm 1 (semi-active checking) with the following changes:

�
At Step 1, where the resource-flow network associated to sðpÞis built as proposed in Section 3.1, we do not create any arcissued from jobs of F in order to keep the front unchanged.Indeed in Fig. 5, job 5 (S5¼18) could be scheduled after job 4, ifarc 4s�5t would be created, with a shortest start time (S5¼17).However, the new schedule sðpÞ is not dominant (see counter-example presented in Section 3). � At Step 2 only jobs in F are selected for the left-shift feasibility
test.

If a negative answer is return by the modified Algorithm 1, thenode is pruned.

Note similar dominance rules have already been used for theRCPSP (which can be defined as an extension of the parallelmachine scheduling problem with precedence constraints, butwithout setup times) under the name ‘‘cutset dominancerules’’ [20]. However, in Demeulemeester and Herroelen [20], allthe cutsets are kept in memory yielding important memoryrequirements.

Fig. 5. Partial schedule of the evaluated node.

Fig. 6. Limited discrepancy

5. Discrepancy-based tree search methods

5.1. Limited discrepancy search

To tackle the combinatorial explosion of the standard branch-and-bound methods for large problem instances, we use a methodbased on the discrepancies regarding a reference branchingheuristic. Such a method is based on the assumed goodperformance of this reference heuristic, thus making an orderedlocal search around the solution given by the heuristic. First, itexplores the solutions with few discrepancies from the heuristicsolution and then it moves away from this solution until it hascovered the whole search space. In this context, the principle ofLDS (limited discrepancy search) [21] is to explore first the solutionswith discrepancies on top of the tree, since it assumes that theearly mistakes, where very few decisions have been taken, are themost important.

Fig. 6 shows LDS behavior for a binary tree search with thenumber of discrepancies for every node. Let us consider the leftbranch as the reference heuristic decision. At iteration 0 weexplore the heuristic solution, then at iteration 1 we explore allthe solutions that differ at most once from the heuristic solution,and we continue until all the leaves have been explored.

LDS can be used as an exact method, for small-size instances,when the maximum number of discrepancies is authorized. Wecan also use it as an approximate method if we limit the number ofauthorized discrepancies.

Several methods based on LDS have been proposed to improveits efficiency. ILDS (improved LDS) [22] has been devised to avoidthe redundancy (observed in Fig. 6) where the solutions with nodiscrepancies are also visited at iteration 1. DDS (depth-bounded

discrepancy search) [23] or DBDFS (discrepancy-bounded depth first

search) [24] propose to change the order of the search. DDS limitsthe depth where the discrepancies are considered, in the sensethat at the k th iteration we only authorize the discrepancies at thefirst k levels of the tree. It stresses the principle that the earlymistakes are the most important. DBDFS consists in a classical DFS

where the nodes explored are limited by the discrepancies.Recently, in the YIELDS method [25], learning process notionsare integrated. In what follows, we propose several versions of LDSadapted to the considered parallel machine scheduling context.

5.2. Exploration strategy

As a branching heuristic, we use as job selection heuristic thelist of jobs obtained by EST (earliest start time) rule. In case of tie

search for a binary tree.

ARTICLE IN PRESS


between two jobs, we apply SPT (smallest processing time) rule formin

PCi and EDD (earliest due date) for min Lmax. We use a fixed

heuristic for the job selection heuristic and a dynamic one for theallocation heuristic (the job is allocated to the earliest completionmachine).

Because of the existence of two types of decisions, we considerhere two types of discrepancies: discrepancy on job selection anddiscrepancy on resource allocation. In the case of non-binary searchtrees, we have two different ways to count the discrepancies (seeFig. 7). In the first mode (binary), we consider that choosing theheuristic decision corresponds to 0 discrepancy, while any othervalue corresponds to 1 discrepancy. The other mode (non-binary)consists in considering that the further we are from the heuristicchoice the more discrepancies we have to count. We suggest toexperimentally evaluate both modes for the heuristic for jobselection. Owing to setup times the list of jobs obtained by EST

(earliest start time) after some discrepancies may become a badchoice. For that reason we propose to use the binary mode in orderto improve the branching strategy. On the other hand, for the choiceof the machine, we use the non-binary mode since we assume thatthe allocation heuristic only makes a few errors. As we will see inSection 6, selecting the machine which allows the earliestcompletion of the job is a high performance heuristic.

We propose to test three different branching schemes. The firstone, called DBDFS [24], is a classical depth-first search where thesolutions obtained are limited by the allowed discrepancies (seeSection 5.1). We propose two other strategies, LDS-top and LDS-

low, which consider the number of discrepancies for the order inwhich the solutions are reached. The node to explore is the node

0 1 1discrepancies 1

Heuristic list of jobs

discrepancies11110

1 2 3 5

1−2−3−4−5

1−2 1−3 1−4 1−5

4

Fig. 7. Example of discrepancies counting mode

Fig. 8. Order of explored leaves

with the smallest number of discrepancies, and with the smallestdepth for the strategy called LDS-top, and with the largest depthfor the strategy called LDS-low. As Fig. 8 shows (case of twoauthorized discrepancies) all three methods explore the samesolutions but in different orders.

5.3. Large neighborhood search based on LDS

We have presented LDS as an exact or a truncated tree searchmethod. In this section, we propose to use it as part of local search.In a local search method, we define a solution neighborhood Nk (x) (kdefines the acceptable variations of solution x). If we find a solutionx0 better than x in Nk(x) then we explore the neighborhood Nkðx

0Þ ofthis new best solution. In the case of large-scale neighborhoodsproblems, the neighborhood becomes so huge that we can considerthe search for the best solution in Nk (x) as an optimization sub-problem [26]. In that context, we consider a neighborhood definedby an LDS search tree. The advantages of the LDS search tree methodis that the neighborhood search is guided following a strict orderthat normally favors the search of better solutions and that we canuse the tree search pruning methods in order to discard notinteresting solutions as soon as possible as discussed in Section 3.

CDS (climbing discrepancy search) [15] is the first largeneighborhood search method based on LDS (see Algorithm 2). Ateach iteration it carries out a k-discrepancy search around the bestcurrent solution. If a better solution is found, then CDS explores itsneighborhood. In the case of no better solution is found, then k isincreased by one.

0discrepancies

Heuristic list of jobs

discrepancies 10

1 2 3 5

1−2−3−4−5

1−2 1−3 1−4 1−5

4

2 3 4

1 2 3

s on job selection. (a) Binary, (b) non-binary.

for different branching rules.

ARTICLE IN PRESS


Algorithm 2. Climbing discrepancy search

Step 0: Initialize discrepancy counter ðk :¼ 1Þ and the

maximum number of discrepancy ðkmax :¼ nÞ.Step 1: Get the Solref by the initial_heuristic( ).

while krkmax doStep 2 : Generate the set of solutions

S of k discrepancies from Solref :

Step 3 : Find the best solution ðSolÞ of the set S:

if Sol is better than Solref then

Step 4 : Replace Solref for Sol

and re�initialize discrepancy counter ðk :¼ 1Þ:

��else

Step 5 : Increase discrepancy counter by one unit

ðk :¼ kþ1Þ:

$

666666666666666666664

The drawback of CDS is that for large-size instances theneighborhood quickly explodes. Hmida et al. [27] propose CDDS

(climbing depth-bounded discrepancy search) that mixes principlesof CDS and of DDS. The neighborhood of the best solution islimited not only by the number of discrepancies, but also by thedepth in the tree. In that case, the neighborhood explosion isavoided and the idea that the most important heuristic mistakesare early ones is stressed.

In this work, we propose two variants of CDS and CDDS for theproblems at hand. They are closely related with VNS (variable

neighborhood search) [28] concept, since we modify the size andthe structure of the neighborhood explored. HD-CDDS (hybrid

discrepancy CDDS) (see Algorithm 3) consists in a mix of CDS andCDDS. We start with a CDS search, but if for a defined number ofdiscrepancies klimit we cannot find a better solution, then weauthorize a bigger number of discrepancies only between somelevels [dmin,dmax] (see Step 6 of Algortihm 3). Once we havefinished the search for klimit+1, we propose either to increase thenumber of authorized discrepancies and to keep the same numberof levels where the discrepancies are authorized (x¼dmax�dmin),which is the case of the Step 8 in Algorithm 3, or to increase thenumber of levels and to keep the number of discrepancies. Thismethod solves the problem of neighborhood explosion and offersmore jobs mobility than CDDS (which is particularly interestingfor setup times problems) but we need to parameterize the valuesof the search (klimit, x). Another advantage is that the levelsbetween the discrepancies are authorized can be selecteddepending of the solution structure. For example for the min Lmax

problem we propose to begin with levels [dmin,dmax] around acritical job in order to quickly improve the solution.

Fig. 9. Example of dominant schedule. (a)

Algorithm 3. Algorithm HD-CDDS

Step 0: Initialize discrepancy counter ðk :¼ 1Þ, the maximumnumber of discrepancy (klimit) and the levels limits

ðdmin :¼ 0,dmax :¼ nÞ.Step 1: Get the Solref by the initial_heuristic( ).while termination conditions not met do

Step 2 : Generate the set of solutions S of k

discrepancies between ½dmin,dmax�

from Solref :

Step 3 : Find the best solution ðSolÞ of the set S:

if Sol is better than Solref then

Step 4 : Replace Solref for Sol, re�initialize discrepancy

counterðk :¼ 1Þ and the levels limits ðdmin :¼ 0,dmax :¼ nÞ:

��else

if koklimit then


ðk :¼ kþ1Þ:

��else

if dmax�dmin ¼ n then

Step 6 : Re�initialize the levels limits

ðdmin :¼ 0,dmax :¼ xÞ:

��else

Step 7 : Update the levels limits

ðdmin :¼ dmax,dmax :¼ dminþxÞ:

if dmin4n then


ðk :¼ kþ1Þand re�initialize the levels limits

ðdmin :¼ 0,dmax :¼ xÞ:

66664

66666666666664

6666666666666666666666664

666666666666666666666666666666666664

6666666666666666666666666666666666666666666666666666666664

The second proposed variant, MC-CDS (mix counting CDS), is anapplication of CDS but with a modification in the way to count thediscrepancies for the job selection rule only. We consider a binarycounting for the discrepancies at the top level of the tree and anon-binary counting way for the rest of levels. This variant acceptsdiscrepancies for all depth levels because the non-binary countingrestricts the explored neighborhood.

5.4. Discrepancy-adapted dominance rule

In this section we propose to adapt the dominance rulepresented in Section 4.3 to the principle of local search. We arguethat it can be very inefficient to use the dominance rule as

Evaluated node, (b) dominant schedule.

ARTICLE IN PRESS

Table 3

Results of ECT and dominance rules efficiency for minP

Ci problem.

60 instances

n¼10, m¼3 NbBest AvgNodes AvgTCPU

BB-no rule 60 (100.0%) 484 925 10.6

BB-front rule 60 (100.0%) 480 444 12.3


presented in Section 4.3 with the proposed local search methods.Indeed, the best solutions of the neighborhood could not beexplored because we have found a dominant partial schedule thatallows us to prune them. Even if it is true that there exists asolution better than the evaluated node, it may not belong to theexplored neighborhood.

For that reason, we propose a discrepancy-adapted dominancerule. Once we know the criterion that defines the neighborhood(for example, k authorized discrepancies from the job list L), weonly have to verify that the new list of jobs L0 that reaches thedominant partial schedule is part of the explored nodes in the localsearch (L0AG, where G is the set of k-discrepancies lists from L).

We can see that the max flow computation rule presented inSection 4.3 is not discrepancy adaptable. It is not possible to verifythat the dominant partial schedule s0ðpÞ is part of the exploredspace because the rule indicates the existence of s0ðpÞ but not thecorresponding schedule.

We propose a new dominance rule based on the position of thefront jobs in the priority list.

Dominance Rule 2. For a given partial schedule sðpÞ associated with

a job list L, if there exists a permutation of the jobs in FðsðpÞÞ such that

the resulting schedule s0ðpÞ and its list L0 are such that L0AG and

S0irSi, 8iAFðsðpÞÞ, the partial scheduled is dominated and the

associated node can be fathomed.

In Fig. 9, we see that the dominant partial schedule keeps thesame front ðFðs0ðpÞÞ ¼ f1,2,3gÞ than the one of the evaluated node,one of the jobs starts earlier ðS01oS1Þ and for the rest of front jobsthe start times are not delayed (S2 ¼ S02 and S3 ¼ S03). If the order ofscheduled front jobs is 1–2–3, we test all the possiblepermutations, satisfying precedence constraints and respectingthe authorized discrepancies, in order to find a dominant partialschedule which allows to prune the evaluated node.

This rule can be computed with time complexity O(m!). Asshown in Section 6, despite its exponential worst-case complexity,this dominance rule has interesting properties when used inconjunction with discrepancy-based tree search and remainsefficient for a small number of machines. If m becomes very large,a partial enumeration can be carried out to limit the computa-tional requirement, yielding as a counterpart weaker dominanceconditions.

Table 4Results of ECT and dominance rules efficiency for min Lmax problem.

60 instances


Optimal 60 (100.0%) 281 896 5.6

Front rule 60 (100.0%) 263 474 7.9

Max flow 60 (100.0%) 219 557 19.7

ECT 52 (86.7%) 69 141 0.07

60 instances


Optimal 60 (100.0%) 11 936 385 884.8

Front rule 60 (100.0%) 10 503 767 778.7

Max flow 60 (100.0%) 8 945 948 628.4

ECT 54 (90.0%) 4 681 104 7.27

BB-max flow 60 (100.0%) 339 541 27.7

BB-ECT 53 (88.3%) 61 684 0.07

60 instances


BB-no rule 60 (100.0%) 10 126 793 641.9

BB-front rule 60 (100.0%) 9 480 313 626.4

BB-max flow 60 (100.0%) 7 530 154 454.6

BB-ECT 54 (90.0%) 1 747 416 2.5

6. Computational experiments

In this section we present the main results obtained from theimplementation of our work. In the literature we have not foundinstances for parallel machines including both setup times andprecedence constraints. Therefore, we propose to test the methodson a set of randomly generated instances. The algorithms areimplemented in C++ and were run on a 2 GHz personal computerwith 2 Go of RAM under the Linux Fedora 8 operating system.

We generate a set of 120 (60 for each criterion) small-sizeinstances (n¼10, m¼3, and n¼15, m¼2) for the evaluation of thedominance rules and for the ECT rule efficiency. Then, we test on aset of 120 middle-size instances (n¼40, mA ½2,4�) the differentbranching rules (LDS-top, LDS-low, and DBDFS), the different waysto count the discrepancies (binary and non-binary) to determinethe best methods for being included inside the LDS structure of thelocal search methods. The efficiency of the lower bounds, thedominance rules and the energetic reasoning proposed in Section4 are tested on middle and large-size instances (n¼100, mA ½2,4�).We also compare the CDS and the HD-CDDS methods with theresults obtained in Neron et al. [6] for the hard instances of thePmjri,qijCmax problem (without precedence constraints and setuptimes). And finally, we evaluate and compare the proposed

methods on a set of 120 large-size instances with the resultsobtained with IBM ILOG CP Optimizer 6.0, a commercial constraintprogramming solver embedding an efficient self-adapting largeneighborhood search method dedicated to scheduling problems[29,30].

We use the RanGen software [31] in order to generate theprecedence graph between the jobs. Setup times and timewindows [ri, di] cannot be generated by RanGen. Setup times aregenerated from the uniform distributions U[1,10] and U[20,40].Moreover they must respect the weak triangle inequality:sijrsikþpkþskj,8 i,j,k. The values of pi are generated from theuniform distribution U[1,5]. Time windows are generated as inSourd [32]. The values of di are generated from the uniformdistribution U½maxð0,P � ð1�t�r=2ÞÞ,P � ð1�tþr=2Þ�, whereP¼

PðpiþminjðsijÞÞ, tA ½0,1�, rA ½0,1�. The ri are generated from

di, ri ¼ di�ðpi � ð2þaÞÞ where aA ½�0:5,þ1:5�.We solve to optimality all the small-size instances and we

compare in Table 3 for theP

Ci problem and in Table 4 for the Lmax

problem, the results of the branch-and-bound method with theproposed lower bounds and constraint propagation method butwithout the dominance conditions (BB-no rule) with the onesobtained using the dominance rule based on the permutation offront jobs (BB-front rule), and the ones obtained with the resultsusing the dominance rule based on max flow computation (BB-

max flow). The last row (BB-ECT) displays the result of a restrictionof the branch-and-bound allocating systematically the jobs usingthe earliest completion time rule, i.e., to the machine which allowsto complete it at the earliest.

We observe in Tables 3 and 4 that ECT rule is very efficient forboth problems. The optimal solution is reached over almost 90% ofthe instances and the average CPU time (AvgTCPU) is clearlyreduced when we use the ECT rule. These results let us consider,for local search methods, only the job permutation allocating the

ARTICLE IN PRESS

Table 8Results of lower bound, energetic reasoning and dominance rule efficiency for min

Lmax problem.

60 instances

n¼ 40,mA ½2,4� NbBest AvgNodes TBest

Table 7

Results of lower bounds and dominance rule efficiency for minP

Ci problem.

60 instances


LBCP 36 (60.0%) 62 007 4.52

LBNCY 38 (63.3%) 61 742 4.47

DaDR 35 (58.3%) 53 373 1.69

60 instances


LBCP 26 (43.3%) 9259 17.55

LBNCY 34 (56.7%) 7813 15.63

DaDR 38 (63.3%) 7606 8.71


jobs on the machines following the ECT rule. The dominance frontrule is also effective, the average number of explored nodes(AvgNodes) and the average CPU time usually decrease when weuse it. We observe that the max flow rule largely reduces thenumber of explored nodes and the CPU time, except for the verysmall-size instances. We deduce that it is a very efficient rule tosolve to optimality instances with a larger number of jobs.

We now evaluate the two different ways to count thediscrepancies, binary and non-binary (only for job selection rules).We have evaluated on the middle-size instances the number oftimes each mode has found the best solution (NbBest) in astandard LDS scheme. The CPU time is limited to 100 s. Note thatno discrepancy is allowed on the ECT machine selection rule.

We also compare three different strategies for discrepancies asexplained in Section 5: depth-bounded depth first search, LDS-topand LDS-low. Table 5 presents that the binary mode has a higherperformance than the non-binary one. Out of a set of 120 instances(60 instances with the Lmax criterion and 60 instances with theP

Ci criterion), the binary mode has found the best solution over75% of the instances, independently of the branching strategy. Wefind very similar results for both criteria. In the following, thebinary counting is kept for the LDS structure of the local search.

In Table 6, we can see the results for the comparison betweenthe exploration strategies. In addition to previous notations, weintroduce the average mean deviation from the best solution(AvgDev). The CPU time is limited to 100 s.

We find that LDS-low is the most efficient strategy, since itreaches the best solution for a larger number of instances and itpresents the less important average mean deviation when the bestsolution is found by another strategy. LDS-low finds the bestsolution for all instances except for one corresponding to themaximum lateness minimization and for 50 over a set of 60instances for completion times sum minimization. We use thisstrategy for the remaining computational experiments.

The lower bounds, the energetic reasoning, and the discre-pancy-adapted dominance rule are compared in Tables 7 and 8.We run a 30 s LDS search for the middle and large-size instancesfor different versions of the node evaluation. First, we onlyconsider the lower bound computed using precedence constraintpropagation (LBCP), then we add the lower bound (LBNCY)proposed in Nessah et al. [12] for min

PCi problem and the

energetic reasoning (ENERGY) for min Lmax problem; finally weadd the discrepancy-adapted dominance rule (DaDR). We comparethe number of times each version finds the best solution (NbBest),

Table 5Results of the comparison between discrepancies counting modes.

120 instances NbBest

n¼ 40,mA ½2,4� Binary mode Non-binary mode

DBDFS 90 (75.0%) 48 (40.0%)

LDS-top 93 (77.5%) 49 (40.8%)

LDS-low 98 (81.7%) 31 (25.8%)

Table 6Results for the comparison of different branching strategies.

Binary mode minP

Ci (60 instances) min Lmax (60 instances)

n¼ 40,mA ½2,4� NbBest AvgDev (%) NbBest AvgDev (%)

DBDFS 43 (71.7%) 0.91 47 (78.3%) 1.86

LDS-top 29 (48.3%) 0.43 17 (28.3%) 2.33

LDS-low 50 (83.3%) 0.71 59 (98.3%) 0.75

the explored nodes average (AvgNodes), and the average CPU timeneeded to reach the best solution (TBest), only for the cases that allversions have found it.

Tables 7 and 8 present the efficiency of the specific lowerbound LBLCY and energetic reasoning with the computation ofsetup times consumption. Moreover, we find that the discrepancy-adapted dominance rule is very efficient, especially for large-sizeinstances and the

PCi criterion. Furthermore, the time consumed

to reach the best solution is reduced when we use the dominancerule for most of cases.

We now compare CDS and the proposed HD-CDDS methodagainst other tree search methods presented in Neron et al. [6]. InNeron et al. [6], the authors test two different branching schemes,time windows (tw) and chronological (chr), and several incom-plete tree search techniques (truncated branch-and-bound, LDS,beam search and branch-and-greed) for the Pmjri,qijCmax problem.We adapt the proposed methods for this problem and we use theheuristic for the initial solution and the upper bounds proposed intheir paper. In Table 9, we compare LDS (z is the number ofauthorized discrepancies) and beam search (BS, o is the number ofexplored child nodes) results, which obtained the best results intheir study, with the proposed CDS and HD-CDDS methods. We

LBCP 47 (78.3%) 93 737 4.81

ENERGY 48 (80.0%) 99 856 4.24

DaDR 44 (73.3%) 71 737 4.59

60 instances


LBCP 44 (73.3%) 11 474 4.29

ENERGY 48 (80.0%) 12 961 3.58

DaDR 55 (91.7%) 9462 3.17

Table 9Results for the comparison with other truncated tree search techniques.

50 instances NbBest NbBestStrict

LDStwz¼1 1 (2.0%) 0

LDSchrz¼2 7 (14.0%) 0

BStwo ¼ 3

25 (50.0%) 3

BSchro ¼ 4

22 (44.0%) 0

CDS 35 (70.0%) 6

HD-CDDS 38 (76.0%) 9

ARTICLE IN PRESS


have evaluated the number of times each method has found thebest solution (NbBest) and for how many of them the method isthe only one to reach the best solution (NbBestStrict) for a set of 50hard instances (n¼100 and m¼10). The CPU time is limited to 30 sas in Neron et al. [6].

Although precedence constraints and setup times are notconsidered in the problem, we can observe that our results arevery good. Out of a set of 50 instances, CDS and HD-CDDS find thebest solution for most of the cases and they find a new bestsolution for six and nine instances, respectively. We underline thatrather than contradicting the statement of relative LDS ineffi-ciency for parallel machine problem experienced by Neron et al.[6], this result demonstrates, at least for this problem, theefficiency of large neighborhood search based on LDS.

Finally, we compare the local search methods with the resultsobtained by IBM ILOG CP Optimizer 6.0 on the Pmjri,prec,sijjLmax

and Pmjri,prec,sijjP

Ci problems. The four variants of the hybridtree local search methods (CDS, CDDS, HD-CDDS, MC-CDS)are implemented with LDS-low, discrepancy-adapted dominancerule and binary counting (except for MC-CDS which supposesa mix counting). No discrepancy is allowed from the ECTmachine assignment rule. We solve the large-size instancesðn¼ 100,mA ½2,4�Þ for two different CPU time limits, 30 and

Table 10Results for the comparison of different variants of hybrid tree local search methods

for minP

Ci problem.

30 instances TCPU¼30 s TCPU¼300 s

p�U½1,5�,sij �U½1,10� NbBest AvgDev (%) NbBest AvgDev (%)

CDS 17 (56.6%) 0.64 7 (23.3%) 0.51

CDDS 7 (23.3%) 0.75 7 (23.3%) 0.82

HD-CDDS 16 (53.3%) 0.60 14 (46.7%) 0.43

MC-CDS 17 (56.6%) 0.64 10 (33.3%) 0.45

ILOG OPL 4 (13.3%) 1.51 2 (6.7%) 1.47



CDS 9 (30.0%) 0.23 6 (20.0%) 0.18

CDDS 7 (23.3%) 0.35 6 (20.0%) 0.38

HD-CDDS 12 (40.0%) 0.26 11 (36.6%) 0.1

MC-CDS 11 (36.7%) 0.25 13 (43.3%) 0.26

ILOG OPL 10 (33.3%) 0.70 5 (16.6%) 0.63

Table 11Results for the comparison of different variants of hybrid tree local search methods

for min Lmax problem.



CDS 10 (33.3%) 2.75 7 (23.3%) 3.06

CDDS 9 (30.0%) 2.65 8 (26.7%) 3.28

HD-CDDS 13 (43.3%) 1.92 10 (33.3%) 2.56

MC-CDS 13 (43.3%) 1.75 11 (30.0%) 2.29

ILOG OPL 15 (50.0%) 2.07 18 (60.0%) 1.55



CDS 3 (10.0%) 2.76 2 (6.0%) 2.89

CDDS 3 (10.0%) 2.71 2 (6.0%) 2.88

HD-CDDS 13 (43.3%) 2.12 7 (23.3%) 1.55

MC-CDS 12 (40.0%) 2.08 8 (26.7%) 1.83

ILOG OPL 15 (50.0%) 0.91 19 (63.3%) 0.90

300 s, then we compare the number of times when the bestsolution has been found by each method and the average deviationfrom the best solution.

In Table 10, we observe that the proposed hybrid local searchmethods improve the best solutions found by CP Optimizer. Allmethods, except CDDS, find the best solution for a larger numberof instances and the mean deviation from the best solution is lessimportant than CP Optimizer solutions. We observe thatcomputing an upper bound highly increases the efficiency of thetruncated search.

Table 11 presents the results for the minimization of maximumlateness. For this case, we observe CP Optimizer has the bestresults. However, we can argue that the proposed methods are stillcompetitive. The mean deviation is acceptable and the bestsolution is found by the hybrid methods over 50% and 37% ofinstances, for 30 and 300 s, respectively.

7. Conclusion

In this paper we have proposed a branch-and-bound methodand heuristics based on limited discrepancy-based search meth-ods for the parallel machine scheduling problem with precedenceconstraints and setup times. We have compared and tested someof the existing options for different LDS components, such asdiscrepancy counting modes and branching.

New local search methods based on LDS have been proposedand compared with similar existing methods. The computationalexperiments showed that these methods are efficient to solveparallel machine scheduling problems in general and demon-strates the interest, at least for the studied problem, of incorpor-ating LDS into a large neighborhood search scheme as firstsuggested by Milano and Roli [15]. We improved upon the resultsof Neron et al. [6] for the standard parallel machine problem andwe obtained results competitive with the efficient self-adaptinglarge neighborhood search heuristic embedded in the IBM-ILOG CPOptimizer commercial solver [29], especially for the

PCi criterion.

We have suggested an energetic reasoning scheme integratingsetup times and we have proposed new dominance rules adaptedto local search. As the results show, these evaluation techniquesallow to significantly reduce the number of explored nodes andthe time of the search.

As a direction for further research, the proposed methods couldbe extended to solve more complex problems involving setuptimes, like the hybrid flow shop or the RCPSP. The concept of ‘‘localsearch compatible’’ dominance rules could also be generalized fordiscrete optimization and constraint satisfaction.

References

[1] Graham RL, Lawler EL, Lenstra JK, Rinnooy Kan A. Optimization andapproximation in deterministic sequencing and scheduling: a survey. Annalsof Discrete Mathematics 1979:287–326.

[2] Cheng T, Sin C. A state-of-the-art review of parallel-machine schedulingresearch. European Journal of Operational Research 1990;47:271–92.

[3] Chen Z-L, Powell WB. Solving parallel machine scheduling problems bycolumn generation. INFORMS Journal on Computing 1999;11(1):78–94.

[4] Pearn WL, Chung SH, Lai CM. Scheduling integrated circuit assemblyoperations on die bonder. IEEE Transactions on Electronics PackagingManufacturing 2007;30(2).

[5] Salem A, Anagnostopoulos GC, Rabadi G. A branch-and-bound algorithm forparallel machine scheduling problems. In: Society for computer simulationinternational (SCS). Portofino, Italy; 2000.

[6] Neron E, Tercinet F, Sourd F. Search tree based approaches for parallel machinescheduling. Computers and Operations Research 2008;35(4):1127–37.

[7] Baev ID, Meleis WM, Eichenberger A. An experimental study of algorithms forweighted completion time scheduling. Algorithmica 2002;22:34–51.

[8] van den Akker M, Hoogeven J, Kempen J. Parallel machine scheduling throughcolumn generation: minimax objective functions, release dates, deadlines

ARTICLE IN PRESS


and/or generalized precedence constraints. Technical Report, Utrech uni-versity; 2005.

[9] Schutten JMJ, Leussink RAM. Parallel machine scheduling with release dates,due dates and family setup times. International Journal of ProductionEconomics 1996;46–47(1):119–26.

[10] Ovacik IM, Uzsoy R. Rolling horizon procedures for dynamic parallel machinescheduling with sequence-dependent setup times. International Journal ofProduction Research 1995;33(11):3173–92.

[11] Uzsoy R, Velasquez JD. Heuristics for minimizing maximum lateness on asingle machine with family-dependent set-up times. Computers and Opera-tions Research 2008;35:2018–33.

[12] Nessah R, Chu Ch, Yalaoui F. An exact method for Pmjsds,rijP

Ci problem.Computers and Operations Research 2005;34:2840–8.

[13] Schutten JMJ. List scheduling revisited. Operations Research Letters1994;18:167–70.

[14] Hurink J, Knust S. List scheduling in a parallel machine environment withprecedence constraints and setup times. Operations Research Letters2001;29:231–9.

[15] Milano M, Roli A. On the relation between complete and incomplete search: aninformal discussion. In: Proceedings of CP-AI-OR’02. Le Croisic, France; 2002.

[16] Neumann K, Schwindt C, Zimmermann J. Project scheduling with timewindows and scarce resources. Springer-Verlag, Berlin, Heidelberg; 2003.

[17] Sprecher A, Kolisch R, Drexl A. Semi-active, active, and non-delay schedulesfor the resource-constrained project scheduling problem. European Journal ofOperational Research 1995;80(1):94–102.

[18] Artigues C, Lopez P, Ayache P-D. Schedule generation schemes and priorityrules for the job-shop problem with sequence-dependent setup times:dominance properties and computational analysis. Annals of OperationsResearch 2005;138(1):21–52.

[19] Lopez P, Esquirol P. Consistency enforcing in scheduling: a general formulationbased on energetic reasoning. In: Proceedings of fifth international workshopon project management and scheduling (PMS’96). Poznan, Poland; 1996.

[20] Demeulemeester EL, Herroelen WS. New benchmark results for the resource-constrained project scheduling problem. Management Science 1997;43(11):1485–92.

[21] Harvey WD, Ginsberg ML. Limited discrepancy search. In: Proceedings of 14thIJCAI, 1995.

[22] Korf R. Improved limited discrepancy search. In: Proceedings of 13th AAAI, 1996.[23] Walsh T. Depth-bounded discrepancy search. APES Group, Department of

Computer Science; 1997.[24] Beck JC, Perron L. Discrepancy-bounded depth first search. In: Second

international workshop on integration of AI and OR technologies for combina-torial optimization problems (CP-AI-OR’00). Paderborn, Germany; 2000.

[25] Karoui W, Huguet M-J, Lopez P, Naanaa W. YIELDS: a yet improved limiteddiscrepancy search for CSPs. In: Proceedings of fourth international con-ference on integration of AI and OR techniques in constraint programming forcombinatorial optimization problems (CP-AI-OR’07). Brussels, Belgium; 2007.

[26] Shaw P. Using constraint programming and local search methods to solve vehiclerouting problems. In: Principles and practice of constraint programming-CP 98, 1998.

[27] Ben Hmida A, Huguet MJ, Lopez P, Haouari M. Climbing depth-boundeddiscrepancy search for solving hybrid flow shop scheduling problems.European Journal of Industrial Engineering 2007;1(2):223–43.

[28] Hansen P, Mladenovic N. Variable neighborhood search: principles andapplications. European Journal of Operational Research 2001;130:449–67.

[29] Laborie P, Godard D. Self-adapting large neighborhood search: application tosingle-mode scheduling problems. In: Baptiste P, Kendall G, Munier-Kordon A,Sourd F, editors. Proceedings of the third multidisciplinary internationalconference on scheduling: theory and applications (MISTA’07). Paris, France;2007. p. 276–284.

[30] Laborie P. Ibm ilog cp optimizer for detailed scheduling illustrated on threeproblems. In: van Hoeve WJ, Hooker JN, editors. Proceedings of the sixthinternational conference on integration of AI and OR techniques in constraintprogramming for combinatorial optimization problems (CP-AI-OR’09). Lec-ture notes in computer science, vol. 5547. Pittsburgh, USA; 2009. p. 148–62.

[31] Demeulemeester E, Vanhoucke M, Herroelen W. Rangen: a random networkgenerator for activity-on-the-node networks. Journal of Scheduling2003;6:17–38.

[32] Sourd F. Earliness-tardiness scheduling with setup considerations. Computersand Operations Research 2005;32(7):1849–65.

Documents

Parallel machine scheduling with precedence constraints and setup times