A memetic algorithm for the job-shop with time-lags

Computers & Operations Research 35 (2008) 2331 – 2356 www.elsevier.com/locate/cor

A memetic algorithm for the job-shop with time-lags夡 Anthony Caumonda , Philippe Lacommea,∗ , Nikolay Tcherneva, b a Laboratoire d’Informatique (LIMOS, UMR CNRS 6158), Campus des Cézeaux, 63177 Aubière Cedex, France b IUP, Université d’Auvergne, 26 Av. Léon Blum, 63008 Clermont Ferrand Cedex 1, France

Available online 1 March 2007

Abstract The job-shop with time-lags (JS|t) is defined as a job-shop problem with minimal and maximal delays between starting times of operations. In this article, time-lags between successive operations of the same job (JS|ti,si ) are studied. This problem is a generalization of the job-shop problem (null minimal time-lags and infinite maximal time-lags) and the no-wait job-shop problem (null minimal and maximal time-lags). This article introduced a framework based on a disjunctive graph to modelize the problem and on a memetic algorithm for job sequence generation on machines. Our aim is to provide also a framework to cover both job-shop and flow-shop problem and to encompass both no-wait and classical instances. A benchmark has been carried out on medium scale instances proving that high quality solutions can be obtained in short computational time. The framework we introduce competes with some methods dedicated to the no-wait job-shop instances and flow-shop instances in terms of quality of results. 䉷 2006 Elsevier Ltd. All rights reserved. Keywords: Scheduling; Job-shop problem; Time-lags

1. Introduction 1.1. Previous published works on scheduling problems with time-lags This paper addresses the job-shop scheduling problem with minimal and maximal time-lags. Time-lags are restrictions which enforce a minimal and/or a maximal delay between operations. Contrary to setup times, these restrictions do not consume any capacity of the machine. During a time-lag window, the machine remains idle and can perform operations of another job. Riezebos and Gaalman provide in [1] an illustration of scheduling problems in Flexible Manufacturing Systems which encompasses time-lags. They provide also a survey on flow-shop scheduling with time-lags. The job-shop problem consists in a set of n jobs which have to be sequenced on m machines. For each job, the sequence of operations which have to be processed is known. Each operation i has to be processed on a given machine i for an uninterrupted processing time period pi and no operation may be pre-empted. In the following, the successor 夡 This article is an extended version of a preliminary memetic algorithm provided in [12] which does not include system generation schedule for the initial population and which was limited to small scale instances resolution. ∗ Corresponding author. Tel.: +33 473 407 585. E-mail addresses: [email protected] (A. Caumond), [email protected] (P. Lacomme), [email protected] (N. Tchernev).

0305-0548/$ - see front matter 䉷 2006 Elsevier Ltd. All rights reserved. doi:10.1016/j.cor.2006.11.007

2332

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

of operation i in the jobs sequence is denoted si . Let denote ti the starting time of an operation i and ci its completion time. The job-shop problem consists in finding a feasible schedule that is, an allocation of the operations to machine time intervals, which has minimal length. According to the (||) notation, the job-shop problem with time-lags can be denoted as (Jm |tij |Cmax ) [2]. Since the time-lags concern only successive operations of the same job, we propose to denote this problem (Jm |ti,si |Cmax ) where (i, si ) is a pair of successive operations in the job sequence. Although the job-shop problem is addressed in a huge number of articles, very few articles are concerned with the time-lags constraints. Moreover, various terms are used to denote the time-lags: transportation times [3], generalized precedence constraints [4], precedence delays [5], limited waiting time [6]. As mentioned by Brucker in [2], scheduling problems with positive and negative time-lags have mainly been discussed in connection with project scheduling by [7,8]. Complexity results for scheduling problems with time-lags have been obtained by Wikum et al. in [4] and Finta and Liu in [5]. Wikum et al. in [4] investigate the complexity of single-machine problems with minimal and/or maximal distances between jobs. Their main results state that some particular single-machine problems with time-lags are polynomially solvable, even if the general case is NP-hard. Let us note that Brucker et al. in [2] state that many classical scheduling problems, including general shop problems, multi-processors tasks, multipurpose machines and problems with changeover times can be modelized to single-machine scheduling problems with time-lags. Most of the literature concerning time-lags is devoted to minimal time-lags constraints. This special case is quite different because all feasible schedules for the problem without time-lags can be turned into feasible ones. The addressed problems are: flow-shop, hybrid flow-shop (see [9] for a recent publication), one machine problem, job-shop problems. Let us note the recent publication of Fondrevelle et al. [10] devoted to permutation flow-shop scheduling problems including both minimal and maximal time-lags constraints. As stressed for the traditional job-shop problem, mathematical approaches are limited to small scale instances for the job-shop problem with time-lags. Thus, heuristics procedures are required to compute medium quality solutions in rather short computational time. In [11,12], two iterative procedures are introduced: a taboo search algorithm and a genetic one exploring feasible and infeasible schedules. Concerning the job-shop problem, most of the constructive heuristics are priority dispatching rules. A survey of priority dispatching rules is available in [13]. Recently, Deppner [14] proposed heuristics for a general scheduling problem which includes the job-shop problem. In his thesis, minimal and maximal time-lags between every pair of operations are tackled. A modified version of the Giffler and Thompson [15] algorithm and a modified version of the strict order algorithm are proposed. As stressed by the author, schedules proposed by the heuristic are not necessarily active (“a schedule is called active if it is not possible to schedule jobs earlier without violating some constraints” see [16, p. 7]) neither semi-active (“a schedule is called semi-active if no job can be processed earlier without changing the processing order or violating the constraints” see [16, p. 7]). The same author proposed also heuristics based on clusters of operations. In this approach, the set of operations is decomposed in clusters, each cluster is scheduled apart and the whole schedule is built using every partial schedule. In this work, no results are available for the job-shop problem. When considering maximal time-lags constraints, building non-trivial feasible schedules is not straightforward (however, note that scheduling all operations of a job after all operations of another one, conducts to feasible solutions: in Section 3.4. these solutions are denoted canonical schedules). This problem is studied in Mascis and Pacciarelli [17] for the special case of no-wait job-shop. In this work, partial schedules (disjunctive constraints have not been fully defined) are considered and the problem of finding a feasible solution given one partial schedule is addressed. Main results show that finding an extension is an NP-complete problem for the no-wait job-shop even in the case of three machines and all operations having unit processing time. 1.2. Linear description of the problem In this sub-section, the problem is formulated as a linear programming model by extending the Manne’s formulation [18]. The model uses one type of continuous decision variables ti and one type of binary variables aij . The continuous variables ti are related to the starting times of operations i and the binary variables aij are used to represent disjunction between two operations.

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2333

Notations: M set of machines O set of operations to schedule Z completion time of the last operation Ek set of operations processed on machine k ti starting time of operation i processing time of operation i pi si next operation of operation i depending on job min ti minimal time-lag between i and si timax  maximal time-lag between i and si  1 if operation j is processed before i aij = 0 otherwise H a large positive number minimize Z, subject to (H + pj )aij + (tj − ti ) pi

∀(i, j ) ∈ Ek , ∀k ∈ M,

(H + pj )(1 − aij ) + (ti − tj ) pj

∀(i, j ) ∈ Ek , ∀k ∈ M,

(1) (2)

ti + pi + timin tsi

∀i ∈ O,

(3)

tsi ti + pi + timax

∀i ∈ O,

(4)

Z ti + pi ti 0

∀i ∈ O,

∀i ∈ O,

aij ∈ {0; 1}

∀(i, j ) ∈ Ek , ∀k ∈ M.

(5) (6) (7)

The objective consists in minimizing Z the completion time of the last operation. Let us note that as regards Manne’s model, two extra constraints (constraints (3) and (4)) have been added. The remainder of the paper is organized as follows. Section 2 defines the framework we promote based on a memetic algorithm search scheme and on a disjunctive graph. This section includes a careful description of the disjunctive graph to modelize time-lags and numerous algorithms to obtain efficient evaluations of the oriented disjunctive graph. Section 3 describes the components of the memetic algorithm including but not limited to population definition, local search, clone detection and restarts. Section 4 deals with computational evaluation of the framework including benchmarks from flow-shop to job-shop, no-wait and time-lags instances. Section 5 concludes the paper and addresses promising directions for future research. 2. A memetic algorithm based framework The framework is based on a memetic algorithm (for job sequence generation on machines) coupled with a powerful local search procedure. The problem is modelized as a non-oriented disjunctive graph. Since a job sequence on machines is generated, it is possible to obtain an oriented disjunctive graph. A Bellman like longest path algorithm permits to compute the earliest completion time of the last operation: the makespan (Fig. 1). 2.1. Proposal for a non-oriented disjunctive graph and notations First introduced by Roy and Sussmann [19], the disjunctive graph modelizes each operation by a vertex and precedence constraints between operations of one job are represented by an arc. Disjunctive constraints between operations of two jobs which required the same machine are modelized by an edge. One arc has a total cost equal to the duration of the beginning operation. Table 1 stresses an instance of job-shop and Table 2 gives the maximal time-lags between operations.

2334

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Fig. 1. Description of the framework for job-shop with time-lags.

Table 1 One instance of job-shop Job 1 Job 2 Job 3

Machine 1 processing time: 10 Machine 2 processing time: 5 Machine 3 processing time: 8

Machine 2 processing time: 5 Machine 1 processing time: 3 Machine 2 processing time: 10

Machine 3 processing time: 8 Machine 3 processing time: 15 Machine 1 processing time: 8

Table 2 Time-lags between operations Job 1 Job 2 Job 3

t1min = 0, t1max = 1 t4min = 0, t4max = 2 t7min = 0, t7max = 4

t2min = 1, t2max = 12 t5min = 1, t5max = 10 t8min = 0, t8max = 10

Fig. 2 gives the non-oriented disjunctive graph of the job-shop and Fig. 3 gives the non-oriented disjunctive graph of the job-shop with maximal time-lags. Maximal time-lags constraints are represented by negative arc cost in the disjunctive graph from one operation to the previous one. The negative cost of the arc is equal to the duration of the previous operation plus the maximal time-lag value. The maximal time-lags between the first and the second operation of the job 1 are represented by one arc which values −11 in the non-oriented disjunctive graph. When no time-lags are specified (for example between one operation and the dummy operation of the graph), it is possible to assume, without lost of generality, to have null minimal time-lags and infinite maximal time-lags. Since there is no interest in considering infinite maximal time-lags, negative arc representing infinite maximal time-lags are ignored in graphs representation in the remainder of this article. Minimal time-lags constraints are included in processing time of conjunctive arc between successive operations of one job. The duration linked to such arc is equal to the processing time plus the minimal time-lags duration. Minimal time-lags are not included in disjunctive arcs: these arcs are weighted with the processing time of the operation at the beginning of the arc. In Fig. 4 the disjunctive arc from operation 5 to 9 values 3 which is the duration of operation 5. In Fig. 3 for example, the value of arc from operation 5 to operation 6 is 4 = 3 + 1 where 3 is the processing time of job 2 on machine 1 and 1 is the minimal time-lags from the second operation of job 2 to the third operation of job 2.

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Fig. 2. Non-oriented disjunctive graph of the job-shop.

Fig. 3. Non-oriented disjunctive graph of the job-shop with minimal and maximal time-lags.

Fig. 4. An oriented disjunctive graph (one solution).

2335

2336

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Table 3 Notations for graph description Data N 0 N +1 u b(u) e(u) w(u) s(i) r(i) d(i) v(i) l(i) P (i)

Number of operations (N + 2 vertices in the graph) Source vertex in the graph Final vertex in the graph An arc Begin vertex of arc u End vertex Arc cost Successor of vertex i according to job sequence of operations Predecessor of vertex i according to job sequence of operations Successor of vertex i according to disjunctions Successor of vertex i according to maximal time-lags Label of vertex i Father of vertex i in the critical path

The values of disjunctive arcs between machines are equal to the processing time of the source operation. Let us note that these arcs depend on the solution as stressed in the next section. Table 3 provides the notations for graphs description for the remainder of the paper. All related algorithms work in that graph for both problem representation and solution representation. 2.2. Solutions representation and solution feasibility A solution is an oriented disjunctive graph which encompassed arcs only. The arcs between operations of jobs which use the same machines define the operations sequence on machines. The graph of Fig. 4 represents a solution in which: on machine 1 the sequence is operation 1, operation 5 and operation 9; on machine 2 the sequence is operation 2, operation 4 and operation 8; on machine 3 the sequence is operation 3, operation 7 and operation 6. Since one operation is linked to one job only, a common notation consists in giving the sequence of jobs on machines. With such notation, the previous solution is denoted: machine 1: job 1, job 2, job 3; machine 2: job 1, job 2, job 3; machine 3: job 1, job 3, job 2. Bierwirth in 1995 [20] introduces an alternative representation as a sequence of job numbers. Based on his proposal, the solution of Fig. 4 is linked to: 1 1 2 1 2 3 2 3 3 (text in bold represents earliest starting times of operations). This kind of representation is called: sequence with repetition. Let us note, there exist several Bierwirth’s sequences which carry out to the same oriented disjunctive graph. Fig. 5 is a representation of the solution as a Gantt chart. Bierwirth’s sequences can be efficiently generated by any greedy algorithm or any iterative method. In this paper these sequences are managed by chromosomes in genetic search process (see Section 3). Unfortunately there exist inconsistent oriented disjunctive graphs which contain positive cycle length. The positive cycles in the graph are due to incorrect orientation of edges in arc but also due to negative arcs in the graph. The oriented disjunctive graph of Fig. 6 provides an example where a positive cycle exists with a length equal to 1. When no positive cycle exists in the graph, a Bellman like longest path algorithm permits to determine the starting date of each operation. The makespan denotes the completion time of the last operation. Using the well known heap data structure [21–24] it is possible to provide efficient implementation in O(n ln k) (except cycle detection) since minimal label vertices can be accessed in O(ln k) where k is the number of heap members. Positive cycle can be efficiently detected during the longest path algorithm run. Each time when a label is updated for

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2337

Minimal Time-lags 16

M3

24 J1

M2

J1

32

47

J3

J2

J2

J3 23 24

M1

J1

0

5

42

J2

10

15

20

25

30

40

J3

45

50

Fig. 5. Example of solution represented as a Gantt chart.

Fig. 6. An oriented disjunctive graph with positive cycle length.

Fig. 7. Example of Bierwirth’s sequence for graph of Fig. 4.

a vertex i, an array P is updated with the predecessor of vertex i. If the algorithm updates a label for a vertex which is the begin vertex of a negative arc, the array P can be used to cycle detection. Algorithm 1 provides a mainspring of a longest path algorithm with cycle detection. Assume that the algorithm for job-shop without time-lag is called Evaluate for convenience and the algorithm for the job-shop with time-lags is called Evaluate_with_TL. 2.3. Proposal for Bierwirth’s sequence evaluation As stressed in the previous section, the Bierwirth’s sequence permits to obtain an oriented disjunctive graph. Fig. 7 provides a Bierwirth’s sequence for graph of Fig. 4. Some Bierwirth’s sequences conduct to graph with positive cycle and it is necessary to affect a value to such Bierwirth’s sequence. Thanks to Bierwirth’s sequence, cycles are only due to maximal time-lags and not to incorrect operation sequence on machines. Incorrect disjunctions between operations on one machine are not possible.

2338

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Algorithm 1. Longest path algorithm with positive cycle detection Procedure name Evaluate_with_TL Additional procedures and functions required Push_Heap (x,v) : push x in the heap with value v Pop_Heap (x,v) : pop x with the minimal value v in the heap EmptyHeap : Boolean function to test if heap is empty Replace (x,y,v) : replace x by y which value v in heap Assumptions Labels l(i) are initialized for all vertex i P(i) are initialized with 0 (no father) Heap is initialized Local variables TestCycle : Boolean Begin TestCycle:=false // no cycle in graph Makespan:=∞ while (EmptyHeap = false) and (TestCycle = false) do Pop_Heap (i,v) // access to vertex with minimal label j := s(i) // j = successor 1 of vertex i k := d(i) // k = successor 2 of vertex i l := v(i) // l = successor 3 of vertex i If (j exist) and( l(i) + w(i, j ) < l(j )) then l(j ) := l(i) + w(i, j );Replace (j , j , l(j) );P(j) := i If (j = N + 1 )then Makespan:=l(j) ;End if End if If (k exist) and (l(i) + w(i , k) < l(k) ) then l(k) := l(i) + w(i , k) ;Replace(k , k , l(k)) ;P(k) := i End if If (l exist) and (time-lags of l is checked) and (l(i) + w(i , l) < l(j) ) then l(l) := l(i) + w(i , l) ;Replace (l , l , l[l] );P(l) := i t := P(l) // cycle detection from vertex l While (P(t) < > l )and (P(t) < > 0 )do t := P(t) // t = father of t End Do TestCycle := (P[t] = l ) Makespan := l(N + 1) ; End if End While End For each Bierwirth’s sequence x, a function f (x) = 1 .f1 (x) + 2 .f2 (x) defines a cost based on: f1 (x) : the number of time-lags which must be unchecked to obtain a graph without cycle; f2 (x) : the label of vertex *. If 1 and 2 are chosen such Min(1 .f1 (x)) > Max(2 .f2 (x)), f (x) is a strict hierarchic function which affects a value to Bierwirth’s sequence with the following extra properties: • a Bierwirth’s sequence without unchecked maximal time-lags has a lower cost than any Bierwirth’s sequence with unchecked maximal time-lags;

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2339

• if two Bierwirth’s sequences have unchecked maximal time-lags, then the Bierwirth’s sequence with the lowest number of unchecked maximal time-lags has the lowest cost. The challenging problem consists in determining which maximal time-lags must be removed to obtain a graph without positive cycle. The mainspring of such an algorithm is: Evaluate the Bierwirth’s sequence without maximal time-lags in graph f1 (x) := 0 For i := 1 to N do Checked the maximal time-lags of operation i Evaluate the Bierwirth’s sequence with the maximal time-lags which have been checked f2 (x) := l(∗ ) If (there is positive cycle in the graph) then f1 (x) := f1 (x) + 1 Unchecked the maximal time-lag of operation i End if End do Because new checked maximal time-lags can only increase l(∗ ), the vertex labels and heap can be saved at each iteration where no positive cycle appears avoiding entire execution of the longest path algorithm. A full description of a Bierwirth’s sequence evaluation algorithm is provided in Algorithm 2 hereafter. This algorithm takes advantage of the previous remarks on vertex labels and heap data structure. Algorithm 2. Bierwirth’s sequence evaluation Procedure name Evaluate_A_Sequence Input data x : a Bierwirth’s sequence Begin l (0) := 0 // initial label of first vertex for i in 1..N + 1 do l(i) := ∞; End Do Unchecked all maximal time-lags f1 (x) := 0 Push_Heap (0,0) // push in heap the first vertex Call the Evaluate procedure for the job-shop without time-lag Save_label :=label // save the labels of vertices Save_heap :=heap For i := 1 to N + 1 do Check time-lag of operation i Call Evaluate_with_TL If (there is positive cycle in the graph) then f1 (x) := f1 (x) + 1; Label:=Save_label; Heap:=Save_Heap Else Save_label:=label; Save_heap :=heap End if End Do Return f (x) = 1 .f1 (x) + 2 .f2 (x) End

2340

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Fig. 8. Bierwirth’s sequence evaluation by Evaluate procedure for the job-shop without time-lag.

Fig. 9. Bierwirth’s sequence evaluation by Evaluate_with_TL at the first iteration.

An example of this algorithm execution is provided using the following Bierwirth’s sequence and the simple data of Tables 1 and 2: 1

3

3

m1

m3

m2

2

2

m2

2

1

m1 m3

m2

1

3

m3

m1

The procedure Evaluate_A_Sequence evaluates this sequence with all unchecked time-lags (classical job-shop evaluation) which conducts to the graph evaluation of Fig. 8. In Fig. 8 the underlined values in bold are label vertices. The maximal time-lag of operation 1 is checked and a new evaluation is performed. This evaluation conducts to an identical makespan but implies modification in the label of the first operation of job 1 due to the new maximal time-lags constraint added in the graph (Fig. 9). The process is iterated with the next operation in the sequence which conducts to add a new negative arc (representing a new maximal time-lags constraint) in the graph. And a new evaluation conducts to the graph presented below (Fig. 10). The process is iterated in a similar way until iteration 7 which concerns the second operation of job 1. By adding this constraint in the graph, a positive cycle is detected in updating label of operation 2 from 23 to 25 (Fig. 11). The Evaluate_with_TL procedure detects the cycle using P in which the following data are stored: P=

0

2

3

6

8

1

5

0

7

5

3

0

1

2

3

4

5

6

7

8

9

10

The positive cycle consist in: P (1) = 2, P (2) = 3, P (3) = 6, P (6) = 5, P (5) = 1. Since a positive cycle is detected, the last checked maximal time-lag is unchecked and the process iterates with the next operation in the Bierwith’s sequence.

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2341

Fig. 10. Bierwirth’s sequence evaluation by Evaluate_with_TL at the second iteration.

Fig. 11. Bierwirth’s sequence evaluation by Evaluate_with_TL at the seventh iteration.

To avoid time consuming label computation, the next iteration is based on heap data previously saved (before the call to the procedure Evaluate_with_TL) in the variable Save_heap. Let us note, the procedure Evaluate_A_Sequence is a heuristic one since, the cycle could be avoided by deleting any negative arc in the cycle. In the previous example, by deleting the negative arc from operation 2 to operation 1 it is possible to obtain an acyclic graph. The procedure Evaluate_A_Sequence is a greedy procedure because it unchecks the last checked maximal time-lags when cycle is detected. 3. Components for the memetic algorithm 3.1. Chromosome: representation, evaluation and generation Many genetic algorithms use quasi-direct representations of solutions.An idea for the job-shop with time-lags consists in considering Bierwirth’s sequence as a chromosome. Clearly, a chromosome C does not represent a solution but can be viewed as partial solution representation. Two properties hold in this case: (1) chromosomes can be efficiently evaluated with respect to their sequence; (2) two chromosomes can hold to the same oriented disjunctive graph. These properties hold for many GA dedicated to scheduling problems. For convenience, we note C.Seq the Bierwirth’s sequence linked to the chromosome, and C.Fitness the fitness of the chromosome. C.Fitness is defined by the Bierwirth’s sequence evaluation procedure provided in Algorithm 2. It is possible to denote “feasible chromosome”, any chromosome with f1 = 0 which corresponds to a chromosome with a sequence implying not unchecked maximal time-lags to obtain a graph with no cycle. Most of the time, chromosome uses list of operations because it is very complicated to design crossover that directly combines two schedules. An engine that build schedules from list of operations permits to obtain, depending on problems, non-delay schedules, semi-active or active ones. Since, the framework we promote is based on a longest path

2342

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

algorithm, only semi-actives schedules are generated. Semi-actives schedules generation is appropriate since it is well known that the set of semi-actives schedules contains at least one optimal solution. The initial population is created by random chromosome generation and by priority dispatching rules generation. The priority dispatching rules generation permits to obtain a set of solutions with all maximal time-lags checked. The random generation generates a high percent of solutions with a significant number of unchecked time-lags. The main reason to combine random chromosomes and heuristic chromosomes in the initial population is to obtain a great diversity. The priority dispatching rules generation is based on the framework fully described in [25]. At each successive step all the operations which are available to be scheduled are assigned a priority and the operation with the highest priority is chosen to be sequenced. For one instance of job-shop with time-lags, 14 different chromosomes with all checked maximal time-lags can be generated. The framework for priority dispatching rules heuristics is presented in Algorithm 3. The heuristic proposed in Algorithm 3 is a constructive algorithm which consists in scheduling of one operation per iteration. During the initialization phase (steps 1 and 2), the set of unscheduled operations (U ) is initialized to the set of all operations O and the set of scheduled operations S is initialized to the empty set. The main loop consists in scheduling of one operation and is ended when the set of unscheduled operations is empty. The scheduling of one operation is performed in six steps. First, due to precedence constraints, all operations cannot be scheduled. Eligible operations are operations for which all predecessors have been previously scheduled. This set depends on remaining operations U and currently scheduled operations. For each operation in E, its earliest starting time is computed (step 5). Then, the Restriction procedure is used to build F , a subset of E. Depending on the Restriction procedure, different properties can be given to the finally generated schedules (active, non-delay, semi-active). The routine Rule is used to choose one operation among operations in F. The routine Update adds operation o in the schedule under construction. Last step consists in removing operation o from U. Algorithm 3. Framework for priority dispatching rules heuristics Procedure name Evaluate_A_Sequence Input data O : set of operations to sequence Begin U := O // Unscheduled operations S := ∅ // Scheduled operations while U  = ∅ loop E := Eligible(U, S); // Eligible operations Evaluate ti , ∀i ∈ E // Evaluate starting times F := Restriction (E , U , S) // F subset of E i :=Rule(F) // Choose an operation S := Update (S, i) // Add operation i to S U := U − {i} // Remove operation i from U end loop end Due to time-lags constraints, a great number of solutions are infeasible and a reparation procedure is required to obtain feasible ones. Routines Evaluation, Rule and Update must be tuned to take into account the time-lags constraints. The Evaluation routine could not be as basic as the classical job-shop one. When dealing with time-lags, inserting an operation may require alteration of the starting times of previously scheduled operations. Thus, the evaluation of one partial schedule consists in a full run of the longest path algorithm in the disjunctive graph. During this evaluation, a positive length cycle may be detected and the evaluation procedure returns an infinite starting time. The Rule routine selects an operation in the set F of possible operations. All rules available for the job-shop can be used for the job-shop with time-lags. However, if an operation in E has an infinite starting time, it should be chosen

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2343

first: if another operation is inserted, the gap between the two operations concerned with the time-lags would increase. Thus, all dispatching rules are modified to select at first the operations which induce infeasible schedules. The Update routine inserts the selected operation at the last position in the machine sequence: the operation is processed last on its machine. If the evaluation of such a schedule leads to an infinite starting time (the associated disjunctive graph contains a positive length cycle), reparation is performed according to Algorithm 4 (a full description is available in [25]). The reparation procedure considers a current operation i and performs iteratively right shifts of i, until the schedule become feasible. If no right shift is possible, the current operation becomes r(i) i.e. the previous operation in the job sequence. Algorithm 4. Reparation procedure Input data i : operation responsible of schedule unfeasibility Local variables k : one operation Begin k := r(i) while (the schedule is unfeasible) loop Shift right k in the schedule; if shifting impossible then k = r(k); End if; End loop End

3.2. Crossover The crossover is based on the GOX crossover first introduced by Bierwirth. This crossover stems from the OX crossover dedicated to the TSP. The main characteristic of this crossover is to preserve the relative order of operations. Note, that a child obtained after crossover of two feasible parents, may be not feasible. 3.3. Mutation by local search The local search is an iterative search process based which exploits the special structure of the problem as much as possible. The neighborhoods are obtained using the machine-block. A machine-block is a sequence of operations of the same job processed consecutively. Enlarge this subsequence by one operation leads to a subsequence which does not fulfill the previous property. Theoretical considerations prove that interchanging neighborhood operations on a critical path (see [26]) in the inner part of machine-block cannot result in improving solutions makespan. The neighborhoods are solutions obtained by exchanging one operation at the end of one block with another one at the beginning of the next block. Fig. 12 provides an example including one chromosome, the oriented disjunctive graph, the critical path obtained after evaluation and the machines-blocks. In Fig. 12, the permutation is represented and includes permutation of the third operation of job 1 with the first operation of job 3. The local search mainspring is given in Algorithm 5. It is based on a main loop which iterates along the vertices of the critical path from the last operation to the first one. The algorithm stops when the initial vertex is reached or when the maximal number of iterations (nm) is achieved. At each iteration, a neighborhood is generated by permutation of two operations of two blocks. When a lowest cost neighborhood solution (the final vertex label of the graph has a lower cost) is obtained, the father vertex is stored in P (N + 1) (see Algorithm 1). The formula i := P (i) permits to attain the father vertex along the critical path. The beginning and the end of two blocks are identified by two operations of different jobs on the critical path. The swap of these operations permits to generate a neighborhood chromosome which is evaluated by used of the Evaluate_A_Sequence procedure. Two situations must be considered: • first, the new solution is better than the current one: the new solution become the current one (C := T ) and the index i is assigned to the last operation of the new critical path (i := P (N + 1));

2344

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Fig. 12. A chromosome, the oriented disjunctive graph and the machine-block on one critical path.

• second, the new solution is worst and the index i is updated (i := P (i)) to access to i father operation on the critical path. Algorithm 5. Local search Procedure name Local_Search Input parameter C : a chromosome nm : maximal number of iterations Local variables g : integer Begin Call Evaluate_A_Sequence(C.Seq) to have the fitness of C i := P(N + 1) // last vertex of the critical path g := 0 While (i < > 0 ) and (g < = nm) do j := P(i) // j is the father of i on the critical path If (job of operation i < > job of operation j ) then T :=C; T.Seq :=C.Seq with Swap (i,j) Call Evaluate_A_Sequence(T.Seq) If (T.Fitness < = C.Fitness) then C:=T; // new best current solution i := P(N + 1) //last vertex of the new critical path Else i := P(i) // father vertex on the critical path Endif Else i := P [i] // next vertex on the critical path End if; g := g + 1 End Do End

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2345

3.4. Population structure and initialization The initial population is composed of nc chromosomes in an array Pop sorted by decreasing fitness order. The initial population is composed of n1 = 14 chromosomes obtained by priority dispatching rules and of (nc-n1) canonical chromosomes randomly generated. A canonical chromosome is chromosome with a sequence where job numbers are consecutive in the sequence. For example if p is the total number of jobs then 1, 1, 1, . . . , 1, 2, 2, 2, . . . , 2, 3, 3, 3, . . . , 3, . . . , p, p, p, . . . , p is a sequence of a canonical chromosome. There is p! canonical chromosomes which conduct in feasible solutions. The initial population encompasses: (i) first two canonical chromosomes by ordering jobs in decreasing and increasing number of each job; (ii) second randomly generated canonical chromosomes. In traditional GAs, identical solutions or clones appear, introducing a premature converge to local minima. The local search reduces cost interval in population and increases the converge rate of the algorithm. One solution to avoid this phenomenon consists in forbidden clones. Because exact clone detection can be time consuming, hashing techniques have been promoted for example by Cormen et al. [27]. We adopt an approximate but fast system in which all chromosomes have a distinct mark and we define a mark according to the disjunctive oriented graph linked to the chromosomesequence. If ti is the earliest date of operation i in the disjunctive graph linked to the chromosome C, mark(C) = i ti2 (mod K) where K is a great integer value, for example K = 49999. Each mark of chromosomes can be stored in an array Clone such as Clone[x] gives the number of chromosomes which mark values x. Thanks to the array Clone, clone detection is possible in O(1). 3.5. Incremental memetic algorithm The incremental memetic algorithm selects two chromosomes to undergo crossover and mutation. The resulting child replaces one existing chromosome in population. The selection consists in selecting (see [28]) the rank i of parent P 1 with probability 2i/nc(nc + 1). The rank of parent P 2 is drawn uniformly with a probability 1/nc. Algorithm 6. Memetic algorithm Procedure name Memetic_Algorithm Parameters of the algorithm mni : maximal number of iterations np : maximal number of unproductive iteration before a restart nc : number of chromosomes in population pm : local search probability LB : lower bound of the problem nm : maximal number of iteratons during local search pr : percent of population begin Generate the initial population Pop npi:=0; // current iteration number ni :=0; // number of successive unproductive iteration Repeat Select P1 and P2 Applied GOX crossover to P1 and P2 : the children is called C k :=integer number in [1,int(nc/2)] If(random < pm) Then Applied local search to C. The chromosome after local search is called S If S is not a clone Then C := S; End If If C is not a clone Then if C.Fitness < Pop[nc].Fitness Then npi := 0 else npi : = npi + 1;

2346

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

End if; Pop[k] : = C; Resort population Pop EndIf if (npi = np) then Do a restart; npi : = 0; End if; ni : = ni + 1 Until (ni = mni) or (Pop[nc].Fitness = LB). end

The GOX crossover is applied to (P1, P2) and one child is selected at random. The child undergoes a local search with a probability pm. Depending on duplicated fitness or not, the child mutated enters or not enter in the population. If the child enters, a productive iteration is counted. If not, the child is rejected and the iteration is an unproductive one. When the maximal number of unproductive iterations is reached, the algorithm experienced a restart by replacing pr percent of the population by random generated chromosomes. Note that the best chromosome Pop[nc] cannot be mutated during a restart and so the best chromosome is preserved. The memetic algorithm stop when the maximal number of iterations is reached either the lower bound is reached.

4. Computational evaluation 4.1. Implementation and benchmarks used All procedures are implemented under Delphi 6.0 package and experiments were carried out on a 1.8 GHz computer under Windows XP with 512 MO of memory. The benchmark is concerned with instances based on the OR-library1 which instances concern classical shop problems (job-shop, flow-shop, no-wait flow-shop and no-wait job-shop). To include time-lag constraints, each instance N is completed with two parameters x and y. These parameters are coefficients used to compute minimal and maximal time-lags. Minimal time-lags of operations in job j are equal to xm, where m is the average value of the processing time over the operations of the job. Maximal time-lags are computed in the same manner using the parameter y. An instance N from the OR-library with parameters x and y is denoted N _x_y. In the next sections, the memetic algorithm is benchmarked on various instances with different values of maximal time-lags. Because feasibility considerations arise for non-infinite maximal time-lags, all the results concern null minimal time-lags. The instances with time-lags can be downloaded at: http://www.isima.fr/lacomme/Job_Shop_TL.html. Because the framework we propose is a random search method, each instance is studied over four runs of the framework. The set of parameters used is stated in each section: these sets have been obtained after basic experimentations. The framework has been tuned for each set of instances. This approach has been chosen since all heuristics and meta-heuristics methods (including the variable neighborhood search (VNS) and genetic algorithms and simulated annealing (GASA) methods mentioned below) have been carefully tuned for the problem of interest. The framework performance is studied over experiments including both flow-shop and job-shop instances and nowait and time-lags instances. For each set of instances, the objective is to underlines, the capabilities of the framework to provide new solutions for time-lags instances. Note, a fair comparison between the resolution of non-time lags instances and time-lags instances should required the same set of parameters to highlight the difficulty of resolution linked to time-lags.

1 http://people.brunel.ac.uk/∼mastjjb/jeb/info.html

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2347

Table 4 Class of problems concerning in the computational evaluation of the framework ∀i, timin

∀i, timax

Studied problems

=0 =0 =0a =0 =0 =0a

=∞ =0  = 0 and = ∞ =∞ =0  = 0 and = ∞

Flow-shop No-wait flow-shop Flow-shop with time-lags Job-shop No-wait job-shop Job-shop with time-lags

a For time-lags instances, the minimal time-lags are stated to zero without lost of generality since minimal time-lags can be included in processing time of jobs.

Table 5 Analysis of the small scale instance ft06 Instance

ft06_0_0 ft06_0_0.5 ft06_0_1 ft06_0_2

OPT

73 63 58 55

Canonical chromosomes

Randomly generated chromosomes

Best canonical chromosomes value

Best dev. (%)

Best randomly generated chromosomes value

Best dev. (%)

83 109 63 60

13.7 73.7 8.6 9.1

– – – –

– – – –

– : no feasible chromosomes found.

Table 4 sumps up the experiments carried out trying to prove that the framework encompass a wide range of problems: • with some merits in no-wait instances, flow-shop and job-shop instances; • with new results in time-lags instances. In the next section, the following notations are used: OPT BKS S* Dev.% Avg. I* T* TT

denotes the optimal solution Best Known Solution (asterisk denotes optimal solution) the best solution found by the framework deviation in percentage from S* to OPT or BKS average iteration number where S* has been found computational time (in seconds) to found S* total computational time (in seconds)

4.2. Experimental analysis of search space This section focuses first on analysis of the small scale instance ft06 under different values of the maximal time-lags and second on priority dispatching rules efficiency. Table 5 gives an analysis of this instance using canonical chromosomes and randomly generated chromosomes. First 1000 canonical chromosomes are generated and the best canonical chromosomes values are reported in Table 5. The second test consists in generating 1000 random chromosomes. Let us note that over 1000 randomly generated chromosomes, no feasible chromosomes have been found and depending on the instances the best canonical chromosomes found (over 1000 attempts) have values from 8% to 73% of the optimal solution. These results seem to prove first that canonical chromosomes do not give high quality solutions and second that the number of feasible chromosomes is rather low as regard the total number of chromosomes.

2348

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Table 6 Priority dispatching rules efficiency provided by [25] Instance

OPT/BKS Best rule Rules dev. (%) FIFO SPT LPT LWKR MWKR FOPNR GOPNR TWORK EDD WINK SRMPT LRMPT SPT TWORK FCFS

la01_0_0 la02_0_0 la03_0_0 la04_0_0 la05_0_0

971* 937* 820* 887* 777*

54.9 51.1 45.4 51.7 57.5

1880 1416 1661 1416 1224

2270 1655 1338 1752 1543

1837 1683 1417 1767 1671

1672 1638 1240 1346 1574

1618 1511 1429 2007 1548

1993 1618 1192 1787 1444

1880 1454 1584 1938 1423

1882 1604 1337 1946 1339

1762 1835 1305 1593 1286

1624 1445 1364 1735 1333

2020 1822 1361 1774 1464

2020 1822 1361 1774 1464

1504 1652 1328 1602 1583

1752 1416 1248 1709 1457

Average: la01_0_0,5 758* la02_0_0,5 742* la03_0_0,5 679* la04_0_0,5 703* la05_0_0,5 622*

52.1 94.5 62.7 59.8 64.4 94.2

1824 1239 1328 1223 1266

1642 1710 1569 1365 1296

1737 1428 1147 1795 1554

1494 1358 1374 1308 1475

1823 1734 1460 1623 1208

1665 1358 1085 1156 1229

1824 1503 1435 1296 1348

2163 1823 1441 1558 1505

1486 1207 1113 1196 1353

1474 1538 1380 1391 1249

1620 1386 1285 1156 1217

1620 1386 1285 1156 1217

1846 1436 1280 1511 1274

1489 1368 1328 1203 1404

Average: la01_0_1 la02_0_1 la03_0_1 la04_0_1 la05_0_1

683* 686* 640* 646* 593*

75.1 63.1 65.6 45.5 32.7 62.6

1606 1252 1355 1397 1309

1483 1267 1294 1027 1113

1600 1391 1508 1592 1134

1114 1350 1002 1016 1027

1615 1579 1424 1282 1297

1146 1530 1005 955 964

1606 1210 1161 1374 1156

1583 1764 1224 1410 1558

1322 1178 1039 1102 973

1543 1130 1544 1505 931 1091 1217 857 1426 982

1130 1505 1091 857 982

1404 1233 1014 1506 1158

1277 1136 1355 972 1061

Average: la01_0_2 la02_0_2 la03_0_2 la04_0_2 la05_0_2

666* 655* 597* 590* 593*

53.9 42.3 36.6 31.8 42.0 15.2

1542 1321 1240 1012 929

1033 907 974 1098 1103

957 1256 1403 910 1336

1117 1038 929 1004 907

1137 1412 1217 996 1171

1227 1100 979 1069 861

1545 1436 1098 1292 1067

1882 1469 1494 939 786

1130 993 864 1020 683

948 1046 895 978 991 886 899 939 734 921

1046 978 886 939 921

1182 1104 1101 1263 1142

1452 906 787 838 1146

Average: Average:

33.6 53.7

The results provided in [25] about priority dispatching rules efficiency confirm that generation of high quality solutions based on priority dispatching rules is a challenging problem which has not been solved to the best of our knowledge. Table 6 proves that over 14 priority dispatching rules and over 20 instances the solutions are about 50% of the best knows solution. 4.3. Computational evaluation on flow-shop instances The experiments we conduct consist in evaluating the framework on flow-shop instances. The results show that for this special case high quality results can be obtained. The following set of parameters is used for all instances of Table 7 . These instances are small scale instances with less than 60 operations to schedule. Each instance is experienced four times to provide representative values of framework performances: nc = 50 np = 10 000 pm = 2.5% mni = 1 000 000 nm = 10

// 50 chromosomes in the population // 10 000 unproductive iterations before a restart // probability of applying a local search // maximal number of iterations // maximal number of iterations during local search

On average in 90 s of computational time, the framework provides results close to 0.07% of the optimal solution whatever the time-lags included in the instances. Note also that all no-wait instances are optimally solved. The optimal

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2349

Table 7 Framework performances on flow-shop instances with time-lags Instances

OPT

S*

Dev. (%)

I*

car5_0_0 car5_0_0 car5_0_0 car5_0_0 car6_0_0 car6_0_0 car6_0_0 car6_0_0 car7_0_0 car7_0_0 car7_0_0 car7_0_0 car8_0_0 car8_0_0 car8_0_0 car8_0_0 car5_0_0,5 car5_0_0,5 car5_0_0,5 car5_0_0,5 car6_0_0,5 car6_0_0,5 car6_0_0,5 car6_0_0,5 car7_0_0,5 car7_0_0,5 car7_0_0,5 car7_0_0,5 car8_0_0,5 car8_0_0,5 car8_0_0,5 car8_0_0,5 car5_0_1 car5_0_1 car5_0_1 car5_0_1 car6_0_1 car6_0_1 car6_0_1 car6_0_1 car7_0_1 car7_0_1 car7_0_1 car7_0_1 car8_0_1 car8_0_1 car8_0_1 car8_0_1 car5_0_2 car5_0_2 car5_0_2 car5_0_2 car6_0_2 car6_0_2 car6_0_2 car6_0_2 car7_0_2

9159 9159 9159 9159 9690 9690 9690 9690 7705 7705 7705 7705 9372 9372 9372 9372 7768 7768 7768 7768 8648 8648 8648 8648 6645 6645 6645 6645 8452 8452 8452 8452 7750 7750 7750 7750 8313 8313 8313 8313 6573 6573 6573 6573 8279 8279 8279 8279 7702 7702 7702 7702 8313 8313 8313 8313 6558

9159 9159 9159 9159 9690 9690 9690 9690 7705 7705 7705 7705 9372 9372 9372 9372 7788 7788 7788 7788 8648 8648 8648 8648 6645 6645 6645 6645 8452 8452 8452 8452 7750 7768 7750 7750 8323 8323 8330 8323 6573 6573 6573 6573 8279 8279 8279 8279 7702 7702 7731 7732 8313 8505 8313 8697 6558

0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.26 0.26 0.26 0.26 0.00 0.00 0.00 0.00 0,00 0,00 0,00 0,00 0.00 0.00 0.00 0.00 0.00 0.23 0.00 0.00 0.12 0.12 0.20 0.12 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.38 0.39 0.00 2.31 0.00 4.62 0.00

14 22 5 119 3 3 3 2 2 3 3 3 25 8 2 18 3 96 104 5 30 137 37 25 6 5 5 4 75 8 4 110 508 603 18 2 468 277 148 247 83 29 6 117 9 55 9 35 12 591 984 961 910 360 3 477 31

438 520 387 196 575 269 132 862 649 281 879 642 199 072 992 570 589 927 542 574 837 765 918 831 414 106 433 281 301 452 424 749 081 072 738 160 459 112 851 113 376 752 055 647 772 162 565 758 499 937 143 980 496 226 580 190 657

T*

TT

14 21 6 124 4 4 4 4 1 1 2 1 22 6 2 16 2 63 72 4 26 118 33 20 3 2 3 2 44 5 2 63 304 355 10 1 351 197 114 181 31 10 2 45 5 27 4 19 5 292 537 492 657 210 3 363 12

14 21 6 124 4 4 4 4 1 1 2 1 22 6 2 16 705 698 705 686 26 118 33 20 512 509 517 512 44 5 2 63 304 626 10 1 831 851 806 808 31 10 2 45 5 27 4 19 5 292 547 513 657 742 3 859 12

No-wait instance Avg. Dev. 0.0%

Time-lags instances

2350

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Table 7 (Continued) Instances

OPT

S*

Dev. (%)

I*

car7_0_2 car7_0_2 car7_0_2 Car8_0_2 Car8_0_2 Car8_0_2 Car8_0_2

6558 6558 6558 8264 8264 8264 8264

6558 6558 6558 8264 8407 8264 8264

0.00 0.00 0.00 0.00 1.73 0.00 0.00

8 278 5 607 152 7 187

Avg. %

158 314 573 948 204 795 272

0.07

T*

TT

2 103 2 334 73 4 103

2 103 2 334 575 4 103

86.59

226.88

Table 8 Framework performances on flow-shop instances Instances

OPT

S*

Dev. (%)

I*

car5 car5 car5 car5 car6 car6 car6 car6 car7 car7 car7 car7 car8 car8 car8 car8

7702 7702 7702 7702 8313 8313 8313 8313 6558 6558 6558 6558 8264 8264 8264 8264

7821 7821 7821 7720 8313 8330 8313 8505 6558 6558 6558 6558 8407 8407 8264 8279

1.55 1.55 1.55 0.23 0.00 0.20 0.00 2.31 0.00 0.00 0.00 0.00 1.73 1.73 0.00 0.18

178 33 90 223 367 12 465 37 16 25 9 20 3 125 12 81

Avg. (%)

0.69

787 295 385 179 617 962 352 050 807 656 415 457 322 040 537 805

T*

TT

77 15 39 89 293 8 338 22 6 9 3 6 2 69 7 44

220 220 209 231 293 392 338 342 6 9 3 6 285 304 7 323

61.18

199.25

solutions are provided by [29] from instances car5_0_0 to car8_0_0 and by [12] from instances car5_0_0,5 to car8_0_2. The optimal solutions reported in [12] have been obtained by linear resolution. The flow-shop is a special case of flow-shop with time-lags for which results are detailed in Table 8. The framework provides an average deviation of 0.69% from the optimal solutions. The computational time closed to 60 s is rather short for a method which is not dedicated to the flow-shop: nc = 250 np = 10 000 pm = 2.5% mni = 500 000 nm = 10

// chromosomes in the population // unproductive iterations before a restart // probability of applying a local search // maximal number of iterations // maximal number of iterations during local search

4.4. Computational evaluation on job-shop instances 4.4.1. Computational evaluation on no-wait job-shop The no-wait job-shop is a special case of job-shop with time including null minimal time-lags and null maximal time-lags. The results are evaluated as regards the recent publication of Schuster and Framinan in 2003 [29].

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2351

They proposed two different local search algorithms for determining solutions to the no-wait job-shop problem. The first one is VNS algorithm designed to exploit the special structure of the problem. The second one is a nondeterministic hybrid algorithm denoted GASA. In Table 9 , BKS column refers to the best value reported by Schuster and Framinan in [29]. Values with asterisk denote optimal values computed by the branch and bound of [17]. For larger instances, the column reports values obtained by applying the heuristics described in [29]. The aim is to provide a table similar to Tables 2 and 3 in the publication of [29]. The following sets of parameters are used including a great number of iterations which is required to solve these very hard no-wait job-shop instances: nc = 50 np = 10 000 pm = 5% mni = 1 500 000 nm = 10

// chromosomes in the population // unproductive iterations before a restart // probability of applying a local search // maximal number of iterations // maximal number of iterations during local search

The results reported in Table 9 are to −7% of the BKS values in 2700 s on average. Let us note, the framework competes with the VNS (in terms of quality of results) which is dedicated to the no-wait problem. The framework cannot compete with the high performances of the dedicated GASA algorithm but on some instances, it provides better results than GASA. For the instance la12_0_0, GASA provides a value of 1631 and the framework found 1594. Similar comments remain true for the la03_0_0 instance. The number of experiments reporting best results than Schuster and Framinan’s methods is not significant but induces us to accept that the framework has some merits in no-wait job-shop problems. Although the framework competes with the VNS method of [29] in term of quality of results, Schuster and Framinan’s methods outperform the framework we propose in terms of computational time. It is quite not surprising since the framework we introduce in this paper is not dedicated to the no-wait job-shop. 4.4.2. Computational evaluation on job-shop With the following set of parameters, the framework we propose permits to obtain the optimal solution for all instances from la06 to la15 in 15.92 s in average. This experiment seems to show the framework capability to efficiently solve medium scale instances of job-shop (Table 10): nc = 150 np = 20 000 pm = 5% mni = 500 000 nm = 10

// chromosomes in the population // unproductive iterations before a restart // probability of applying a local search // maximal number of iterations // maximal number of iterations during local search

The framework proposes optimal solutions for all instances in 16 s of computational time (on average). 4.5. Computational evaluation on job-shop with time-lags The experiments concern Laurence’s instances. Because, the difficulty to solve instances with time-lags highly depends on the maximal time-lags, the experiments consist in varying the maximal parameter time-lags from 0.5 to 10. Each maximal time-lag value defines a special case of instances for which we propose a numerical analysis of results (Table 11). For the Laurence’s instances (whatever the maximal time-lags value), the following set of parameters have been used: nc = 50 np = 20 000 pm = 5% mni = 1 000 000 nm = 10

// chromosomes in the population // unproductive iterations before a restart // probability of applying a local search // maximal number of iterations // maximal number of iterations during local search

2352

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Table 9 Laurence’s job-shop no-wait instances Instances

BKS

VNS

Dev. (%)

GASA

Dev. (%)

S*

Dev. (%)

I*

T*

la01_0_0 la01_0_0 la01_0_0 la01_0_0 la02_0_0 la02_0_0 la02_0_0 la02_0_0 la03_0_0 la03_0_0 la03_0_0 la03_0_0 la04_0_0 la04_0_0 la04_0_0 la04_0_0 la05_0_0 la05_0_0 la05_0_0 la05_0_0 la06_0_0 la06_0_0 la06_0_0 la06_0_0 la07_0_0 la07_0_0 la07_0_0 la07_0_0 la08_0_0 la08_0_0 la08_0_0 la08_0_0 la09_0_0 la09_0_0 la09_0_0 la09_0_0 la10_0_0 la10_0_0 la10_0_0 la10_0_0 la11_0_0 la11_0_0 la11_0_0 la11_0_0 la12_0_0 la12_0_0 la12_0_0 la12_0_0 la13_0_0 la13_0_0 la13_0_0 la13_0_0 la14_0_0 la14_0_0 la14_0_0 la14_0_0 la15_0_0 la15_0_0

971* 971* 971* 971* 937* 937* 937* 937* 820* 820* 820* 820* 887* 887* 887* 887* 777* 777* 777* 777* 1863 1863 1863 1863 1965 1965 1965 1965 1910 1910 1910 1910 2189 2189 2189 2189 2045 2045 2045 2045 2821 2821 2821 2821 2434 2434 2434 2434 2650 2650 2650 2650 2662 2662 2662 2662 2765 2765

1064 1064 1064 1064 1011 1011 1011 1011 973 973 973 973 1020 1020 1020 1020 861 861 861 861 1431 1431 1431 1431 1366 1366 1366 1366 1390 1390 1390 1390 1586 1586 1586 1586 1527 1527 1527 1527 1915 1915 1915 1915 1694 1694 1694 1694 1907 1907 1907 1907 2313 2313 2313 2313 1898 1898

9.58 9.58 9.58 9.58 7.90 7.90 7.90 7.90 18.66 18.66 18.66 18.66 14.99 14.99 14.99 14.99 10.81 10.81 10.81 10.81 −23.19 −23.19 −23.19 −23.19 −30.48 −30.48 −30.48 −30.48 −27.23 −27.23 −27.23 −27.23 −27.55 −27.55 −27.55 −27.55 −25.33 −25.33 −25.33 −25.33 −32.12 −32.12 −32.12 −32.12 −30.40 −30.40 −30.40 −30.40 −28.04 −28.04 −28.04 −28.04 −13.11 −13.11 −13.11 −13.11 −31.36 −31.36

1037 1037 1037 1037 990 990 990 990 832 832 832 832 889 889 889 889 817 817 817 817 1339 1339 1339 1339 1240 1240 1240 1240 1296 1296 1296 1296 1447 1447 1447 1447 1338 1338 1338 1338 1825 1825 1825 1825 1631 1631 1631 1631 1766 1766 1766 1766 1805 1805 1805 1805 1829 1829

6.80 6.80 6.80 6.80 5.66 5.66 5.66 5.66 1.46 1.46 1.46 1.46 0.23 0.23 0.23 0.23 5.15 5.15 5.15 5.15 −28.13 −28.13 −28.13 −28.13 −36.90 −36.90 −36.90 −36.90 −32.15 −32.15 −32.15 −32.15 −33.90 −33.90 −33.90 −33.90 −34.57 −34.57 −34.57 −34.57 −35.31 −35.31 −35.31 −35.31 −32.99 −32.99 −32.99 −32.99 −33.36 −33.36 −33.36 −33.36 −32.19 −32.19 −32.19 −32.19 −33.85 −33.85

975 1045 996 1045 937 963 995 978 870 900 900 820 921 911 938 923 833 869 851 818 1424 1433 1305 1435 1340 1383 1324 1282 1391 1312 1460 1368 1569 1608 1573 1547 1460 1435 1333 1491 1959 1875 1896 2019 1614 1594 1691 1745 1870 1926 1799 1811 2015 1999 2114 1960 2073 1948

0.41 7.62 2.57 7.62 0.00 2.77 6.19 4.38 6.10 9.76 9.76 0.00 3.83 2.71 5.75 4.06 7.21 11.84 9.52 5.28 −23.56 −23.08 −29.95 −22.97 −31.81 −29.62 −32.62 −34.76 −27.17 −31.31 −23.56 −28.38 −28.32 −26.54 −28.14 −29.33 −28.61 −29.83 −34.82 −27.09 −30.56 −33.53 −32.79 −28.43 −33.69 −34.51 −30.53 −28.31 −29.43 −27.32 −32.11 −31.66 −24.31 −24.91 −20.59 −26.37 −25.03 −29.55

1 069 616 1 311 031 1 097 425 360 712 278 291 1 126 967 440 189 1 028 166 1 141 353 225 387 757 825 356 270 361 420 1 253 266 1 424 290 959 167 240 659 549 412 246 858 379 854 342 792 1 079 239 1 049 100 677 188 830 332 1 039 274 1 327 036 767 836 243 964 1 272 344 1 329 181 893 713 1 468 495 614 963 1 227 658 465 048 339 620 594 267 478 853 767 799 657 738 1 309 247 1 094 367 424 376 1 260 576 1 397 796 728 909 491 294 1 454 067 658 615 1 382 061 1 317 558 1 140 917 344 883 445 485 1 085 575 935 063 883 531

631 829 706 240 165 735 309 696 755 156 475 234 254 856 986 609 156 371 155 258 1 004 2 405 2 111 1 749 1 713 2 927 3 191 2 546 653 3 371 3 456 1 996 3 570 1 655 2 563 936 746 1 633 1 386 1 778 5 129 9 879 6 446 3 284 6 512 8 474 5 206 3 042 9 904 5 005 10 387 10 255 8 323 2 283 3 631 6 879 6 853 6 934

TT

1 1 1

1 1 1 1 1 1 1 1 4 3 3 3 3 3 3 5 4 4 4 3 3 3 3 3 4 4 3 3 10 11 8 9 7 9 10 9 10 11 11 11 10 10 13 9 11 11

903 929 913 027 047 010 968 969 980 053 922 028 035 019 037 052 960 026 964 018 186 250 332 970 187 953 604 124 437 116 000 416 652 909 283 151 148 152 906 401 770 154 697 897 700 122 477 099 216 089 377 620 964 000 284 807 540 471

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2353

Table 9 (Continued) Instances

BKS

VNS

Dev. (%)

GASA

Dev. (%)

S*

Dev. (%)

I*

la15_0_0 la15_0_0 la16_0_0 la16_0_0 la16_0_0 la16_0_0 la17_0_0 la17_0_0 la17_0_0 la17_0_0 la18_0_0 la18_0_0 la18_0_0 la18_0_0 la19_0_0 la19_0_0 la19_0_0 la19_0_0 la20_0_0 la20_0_0 la20_0_0 la20_0_0

2765 2765 1575* 1575* 1575* 1575* 1371* 1371* 1371* 1371* 1417* 1417* 1417* 1417* 1482* 1482* 1482* 1482* 1526* 1526* 1526* 1526*

1898 1898 1673 1673 1673 1673 1556 1556 1556 1556 1713 1713 1713 1713 1786 1786 1786 1786 1795 1795 1795 1795

−31.36 −31.36 6.22 6.22 6.22 6.22 13.49 13.49 13.49 13.49 20.89 20.89 20.89 20.89 20.51 20.51 20.51 20.51 17.63 17.63 17.63 17.63

1829 1829 1637 1637 1637 1637 1430 1430 1430 1430 1555 1555 1555 1555 1610 1610 1610 1610 1693 1693 1693 1693

−33.85 −33.85 3.94 3.94 3.94 3.94 4.30 4.30 4.30 4.30 9.74 9.74 9.74 9.74 8.64 8.64 8.64 8.64 10.94 10.94 10.94 10.94

1928 2097 1992 1879 1969 1833 1591 1724 1669 1647 1797 1840 1790 1800 1863 1831 1897 1997 1892 1885 1828 1864

−30.27 −24.16 26.48 19.30 25.02 16.38 16.05 25.75 21.74 20.13 26.82 29.85 26.32 27.03 25.71 23.55 28.00 34.75 23.98 23.53 19.79 22.15

977 1 365 957 739 716 782 1 428 1 332 769 400 1 479 779 1 139 1 328 339 1 160 369 1 200 157 1 107 1 368 1 019

Dev.

−6.40

−13.82

−7.00

T* 540 730 888 457 668 034 073 122 932 702 962 046 707 030 150 562 202 145 066 897 287 056

866 840

6 10 1 1 1 1 2 2 1 2 1 1 1 1 1 1 3 1

TT 551 551 588 268 431 725 101 213 219 625 005 165 799 870 418 522 584 751 290 693 385 586

2709.14

10 11 2 2 2 3 2 2 2 2 2 2 2 2 2 1 2 2 3 2 3 2

296 494 387 812 902 293 191 471 095 533 034 222 438 112 286 995 125 142 143 396 746 302

4446.70

One can note that the BKS column reports the best known solution of the classical job-shop problem since to the best of our knowledge no optimal solutions are available for the instances of interest. Since the deviation is computed using the best known solution of the job-shop, it is possible (from a theoretical point of view) to obtain, for the job-shop with time-lags, better solutions than the best known solution of the job-shop. However, due to the considerable amount of attention received by the job-shop from many years, one can reasonably assume that these best known solutions are high quality ones and are very closed to the optimal solutions. Another solution is to provide a readable table to present the results on job-shop with time-lags could be to use a tight lower bound of the job-shop as a second column of Table 11. An important remark concerns the last set of instances for which the best solution found S* has a makespan identical than the best known solution of the job-shop. It is not surprising since the job-shop is a special case of job-shop with time-lags having infinite maximal time-lags and null minimal time-lags. For instances with tight maximal time-lags, a feasible solution is found for all the instances in less than 30 min of computational time. The framework proves its capacity of optimizing job-shop instances whatever the maximal time-lags value, but it is difficult to evaluate the gap from the optimal solution since the optimal solutions are unknown. 5. Concluding remarks This article addresses the problem of scheduling in job-shop with time-lags. A framework based on a modelization of the problem as a disjunctive graph and on a memetic algorithm is proposed. This framework encompasses features including initial solutions generation by priority dispatching rules and a powerful local search. Due to maximal time-lags in problem definition and to favor search space exploration, the memetic algorithm investigates infeasible solutions during process. This feature is based on the definition of a fitness based both on makespan and on the number of unchecked maximal time-lags to obtain a feasible solution. The proposed framework permits to address a wide range of job-shop problems including but not limited to no-wait instances. The numerical experiment proves that our framework

2354

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Table 10 Laurence’s job-shop instances Instances

OPT

S*

Dev. (%)

I*

T*

TT

la06 la06 la06 la06 la07 la07 la07 la07 la08 la08 la08 la08 la09 la09 la09 la09 la10 la10 la10 la10 la11 la11 la11 la11 la12 la12 la12 la12 la13 la13 la13 la13 la14 la14 la14 la14 la15 la15 la15 la15

926 926 926 926 890 890 890 890 863 863 863 863 951 951 951 951 958 958 958 958 1222 1222 1222 1222 1039 1039 1039 1039 1150 1150 1150 1150 1292 1292 1292 1292 1207 1207 1207 1207

926 926 926 926 890 890 890 890 863 863 863 863 951 951 951 951 958 958 958 958 1222 1222 1222 1222 1039 1039 1039 1039 1150 1150 1150 1150 1292 1292 1292 1292 1207 1207 1207 1207

0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

3 430 3 271 4 045 3 933 13 536 25 250 6 538 11 405 7 574 6 873 8 455 6 165 5 746 5 151 4 731 4 829 4 663 4 211 3 928 3 428 6 087 5 252 6 312 8 182 3 730 5 554 3 847 4 199 4 633 4 737 5 173 6 792 3 521 3 273 3 535 3 128 247 158 81 718 280 785 84 057

3 2 3 2 8 11 5 6 6 5 6 5 5 5 5 5 5 5 5 3 11 9 11 11 8 8 8 6 9 9 8 8 9 8 8 6 124 54 177 50

3 2 3 2 8 11 5 6 6 5 6 5 5 5 5 5 5 5 5 3 11 9 11 11 8 8 8 6 9 9 8 8 9 8 8 6 124 54 177 50

Avg.

0.00

22 720.88

15.92

15.92

competes with recent framework dedicated to no-wait job-shop problem and permits to obtain solutions closed to the optimal ones in rather short computational time. Note also that the proposed framework is more time consuming than dedicated methods for the no-wait job-shop. This work is a step forward definition of wide-ranging methods for shop problem. Future useful extensions could include: • • • •

tight lower bound taking advantages of time-lags; exact solutions procedures for large scale instances; stochastic maximal time-lags with the objective to determine robust solutions; transportation time from machines.

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

2355

Table 11 Laurences’s job-shop instances with time-lags Instances

BKS of the job-shop

S*

Dev. (%)

I*

T*

TT

la06_0_0.5 la06_0_0.5 la06_0_0.5 la06_0_0.5 la07_0_0.5 la07_0_0.5 la07_0_0.5 la07_0_0.5 la08_0_0.5 la08_0_0.5 la08_0_0.5 la08_0_0.5

926 926 926 926 890 890 890 890 863 863 863 863

1233 1218 1256 1231 1186 1194 1225 1179 1249 1124 1197 1224 Avg.

33.15 31.53 35.64 32.94 33.26 34.16 37.64 32.47 44.73 30.24 38.70 41.83 35.52

832 349 936 076 704 373 691 004 794 156 467 415 780 243 971 270 397 994 876 007 665 338 766 154 740 198.25

1 892 2 312 1 736 1 692 1 979 1 116 1 938 2 230 829 2 132 1 578 1 574 1 750.67

2 258 2 465 2 566 2 473 2 486 2 328 2 538 2 299 1 996 2 420 2 397 2 086 2 359.33

la06_0_1 la06_0_1 la06_0_1 la06_0_1 la07_0_1 la07_0_1 la07_0_1 la07_0_1 la08_0_1 la08_0_1 la08_0_1 la08_0_1

926 926 926 926 890 890 890 890 863 863 863 863

1087 1138 1086 1139 1093 1055 1054 1032 1170 1104 1068 1048

17.39 22.89 17.28 23.00 22.81 18.54 18.43 15.96 35.57 27.93 23.75 21.44

970 657 424 352 709 295 252 949 343 260 987 508 299 222 867 730 520 195 905 300 805 315 391 025

1 932 747 1 298 491 610 1 852 625 1 671 904 1 677 1 380 742

1 991 1 790 1 839 1 883 1 861 1 873 1 946 1 914 1 919 1 870 1 732 1 833

la06_0_2 la06_0_2 la06_0_2 la06_0_2 la07_0_2 la07_0_2 la07_0_2 la07_0_2 la08_0_2 la08_0_2 la08_0_2 la08_0_2

926 926 926 926 890 890 890 890 863 863 863 863

Avg. 1087 1138 1086 1139 1062 1086 1059 1061 1170 1104 1068 1048

22.08 17.39 22.89 17.28 23.00 19.33 22.02 18.99 19.21 35.57 27.93 23.75 21.44

623 067.33 970 657 424 352 709 295 252 949 522 260 326 718 748 502 470 823 520 195 905 300 805 315 391 025

1 160.75 1 967 752 1 321 485 990 620 1 346 840 891 1 707 1 360 758

1 870.92 2 027 1 802 1 872 1 859 1 874 1 926 1 788 1 729 1 889 1 903 1 708 1 867

la06_0_10 la06_0_10 la06_0_10 la06_0_10 la07_0_10 la07_0_10 la07_0_10 la07_0_10 la08_0_10 la08_0_10 la08_0_10 la08_0_10

926 926 926 926 890 890 890 890 863 863 863 863

Avg. 926 926 926 926 890 890 890 890 863 863 863 863

22.40 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

587 282.58 0 0 0 0 106 526 149 397 313 573 70 306 11 128 43 013 5 081 6 851

1 086.42 758 758 758 758 35 50 121 25 3 13 2 2

1 853.67 1 0 0 0 35 50 121 25 3 13 2 2

Avg.

0.00

58 822.92

273.58

21.00

2356

A. Caumond et al. / Computers & Operations Research 35 (2008) 2331 – 2356

Acknowledgments The authors are grateful to the anonymous referees for their helpful comments on an earlier draft of the paper. References [1] Riezebos J, Gaalman GJC. Time lag size in multiple operations flow shop scheduling heuristics. European Journal of Operational Research 1998;105(1):72–90. [2] Brucker P, Hilbig T, Hurink J. A branch and bound algorithm for a single machine scheduling with positive and negative time-lags. Discrete Applied Mathematics 1999;94:77–99. [3] Rebaine D, Strusevich VA. Two-machine open shop scheduling with special transportation times. Journal of the Operational Research Society 1999;50:756–64. [4] Wikum ED, Llewellynn DC, Nemhauser GL. One-machine generalized precedence constrained scheduling problem. Operations Research Letters 1994;16:87–99. [5] Finta L, Liu Z. Single machine scheduling subject to precedence delays. Discrete Applied Mathematics 1996;70:247–66. [6] Yang DL, Chern MS. A two-machine flowshop sequencing problem with limited waiting time constraints. Computers and Industrial Engineering 1995;28(1):63–70. [7] Bartusch M, Mohring RH, Rademacher FJ. Scheduling project networks with resource constraints and time windows. Annals of Operations Research 1988;I6:201–40. [8] Brinkmann K, Neumann K. Heuristic procedures for resource-constrained project scheduling with minima1 and maxima1 time lags: the minimum project-duration and resource-levelling problems. Journal of Decision Systems 1996;5:129–56. [9] Botta-Genoulaz V. Hybrid flow shop scheduling with precedence constraints and time lags to minimize maximum lateness. International Journal of Production Economics 2000;64(1–3):101–11. [10] Fondrevelle J, Oulamara A, Portmann MC. Permutation flowshop scheduling problems with maximal and minimal time lags. Computers and Operations Research 2006;33(6):1540–56. [11] Caumond A, Gourgand M, Lacomme P, Tchernev N. Métaheuristiques pour le problème du job-shop avec time-lags. Actes de MOSIM’04. Nantes 2004;2:939–46. [12] Caumond A, Lacomme P, Tchernev N. Proposition d’un algorithme génétique pour le job-shop avec time-lags. ROADEF’05, Tours, 2005, p. 183-200. [13] Haupt R. A survey of Priority Rule-Based Scheduling. OR Spektrum 1989;11:3–16. [14] Deppner F. Ordonnancement d’atelier avec contraintes temporelles entre opérations. PhD thesis in French, LORIA Nancy, France, 2004. [15] Giffler B, Thompson JL. Algorithms for solving production scheduling problems. Operations Research 1960;8:487–503. [16] Brucker P. Scheduling Algorithms. 3rd ed, Berlin: Springer; 2001. [17] Mascis A, Pacciarelli D. Job-shop scheduling with blocking and no-wait constraints. European Journal of Operational Research 2002;143: 498–517. [18] Manne AS. On the job–shop scheduling problem. Operations Research 1960;8(2):219–23. [19] Roy B, Sussmann B. Les problèmes d’ordonnancement avec contraintes disjonctives, Note DS no. 9 bis, SEMA, Paris, 1964. [20] Bierwirth C. A generalized permutation approach to jobshop scheduling with genetic algorithms. OR Spektrum 1995;17:87–92. [21] Wirth N. Algorithms + data structures = Programs. Prentice Hall Series in Automatic Computation, 1976. [22] Levy G. Algorithmique Combinatoire: methodes constructuves. Paris: Dunod; 1994. [23] Kaplan, Haim, Tarjan, Robert E. New heap data structures. Technical Report TR-597-99, Princeton University. http://www.cs. princeton.edu/research/techreps/TR-597-99 ; 1999. [24] Reddy US, Yang H. Correctness of data representations involving heap data structures. Proceedings of ESOP 223–37, 2003. [25] Caumond A, Lacomme P, Tchernev N. Feasible schedules generation with an extension of the Giffler and Thomson algorithm for the jobshop with timelags. In: International conference on industrial engineering and system management, Marrakech-Morocco, 2005. [26] Van Laarhoven PJM, Aarts EHL, Lenstra JK. Job-shop scheduling by simulated annealing. Operations Research 1992;40(1):113–25. [27] Cormen TH, Leiserson CL, Rivest ML. Introduction to algorithms. Cambridge, MA: MIT Press; 1990. [28] Reeves CR. A genetic algorithm for flowshop sequencing. Computers and Operations Research 1995;22(1):5–13. [29] Schuster CJ, Framinan JM. Approximative procedures for no-wait job shop scheduling. Operations Research Letters 2003;31:308–18.