Heuristics for minimizing total weighted tardiness in flexible flow shops

*Correspondence to: Michael Pinedo, The Stern School of Business, New York University, New York, NY 10012, U.S.A.sE-mail: mpinedo@stern. nyu.edutYa Yang's research was conducted while she was a Ph.D. student at Columbia University and a visiting AssistantProfessor at Duke University. Ya Yang passed away in November 1999, at the age of 27, due to injuries caused by a fatalcar accident.

Contract/grant sponsor: DAAD (HSP II)

Copyright ( 2000 John Wiley & Sons, Ltd.

JOURNAL OF SCHEDULINGJ. Sched. 2000; 3:89}108

Heuristics for minimizing total weighted tardinessin #exible #ow shops

Ya Yangt, Stephan Kreipl1 and Michael Pinedo2,*,s

1Universitaet Passau, Lehrstuhl fuer Fertigungswirtschaft, 94032 Passau, Germany2The Stern School of Business, New York University, New York, NY 10012, U.S.A.

SUMMARY

Consider a #exible #ow shop with s stages in series and at each stage a number of identical machines inparallel. There are n jobs to be processed and each job has to go through the stages following the same route.Job j has release date r

j, due date d

j, weight w

jand a processing time p

jlat stage l, l"1,2, s. The objective is

to minimize the total weighted tardiness of the n jobs. In this paper we describe and analyse three heuristics.The "rst one is a decomposition algorithm that solves the problem by decomposing the #exible #ow shopproblem into a series of single-stage scheduling subproblems. The second one is an algorithm based on localsearch. The third heuristic is a hybrid algorithm that combines the "rst two. We conclude with a compara-tive study of the three heuristics. Copyright ( 2000 John Wiley & Sons, Ltd.

KEY WORDS: decomposition methods; local search

1. INTRODUCTION

A #exible #ow shop is a machine con"guration that is a generalization of the traditional #owshop. There are s stages in series. At each stage there is, instead of a single machine, a bank ofparallel machines. Stage l has m

lidentical machines in parallel. There is unlimited storage

between any two successive stages. A set of n jobs has to be processed and all jobs have to go "rstthrough stage 1, then through stage 2, and so on. At any stage, a job has to be processed on oneand only one of the parallel machines, any one can do. Job j becomes available at stage 1 at itsrelease date r

jand has to be completed at the last stage by its due date d

j. Its processing time at

stage l is pjl. Job j has a weight w

jwhich is an indication of its priority level. If job j "nishes at the

last stage at time Cj, then its tardiness is de"ned as

¹j"maxMC

j!d

j, 0N

The objective function to be minimized is +nj/1

wj¹

j. Using the standard notation in the

scheduling literature, this problem is denoted by FFs DrjD+ w

j¹

j.

This particular problem is of importance in practice since the #exible #ow shop is a machineenvironment that is quite common and the total weighted tardiness is an objective that relates tocustomers' satisfaction.

This problem is obviously NP-hard since 1E+wj¹

jis already known to be NP-hard. In this

paper we present three heuristic methods for this problem. The "rst one is an approach based ona decomposition method. The second one is a method based on local search and the third one isa combination of the "rst two.

The decomposition heuristic decomposes the #exible #ow shop problem into a number ofparallel machine subproblems, each subproblem corresponding to one of the stages. The sub-problems are solved separately, one after another. The local search method "rst considers theassignment of jobs to machines and then does the sequencing of the jobs on each machine. Thuseach iteration in this method consists of two steps, namely, (i) machine loading and (ii) scheduling.The combined version of the two heuristics uses the solution of the decomposition heuristic asa starting point for the local search heuristic, and then iterates between the two until a givenstopping criterion is met.

This paper is organized as follows. We "rst describe a disjunctive graph representation of ourscheduling model. We then discuss the three heuristics in detail. We proceed with computationalresults that are based on extensive testing and we conclude with a discussion section.

2. THE DISJUNCTIVE GRAPH REPRESENTATION

We "rst present a graphical representation of our problem which makes the subsequent analysisclearer. Our problem can be represented by a disjunctive graph. The disjunctive graph representa-tion was "rst used by Balas [1] for the job shop scheduling problem. Certain modi"cations haveto be made to the original disjunctive graph representation of the job shop model in order toaccommodate our speci"c model.

In the disjunctive graph, a node ( j, l ) corresponds to the event of job j starting its processing ona machine at stage l. The source node; denotes the beginning of the process, i.e. t"0, while thesink node <

j, denotes the completion time of job j at the last stage. There is a conjunctive arc

going from node ( j, l ) to node ( j, m) if and only if stage l is the stage that is immediately precedingstage m. There are also conjunctive arcs from the source node; to the "rst operation of each joband conjunctive arcs that go from the nodes that represent the "nal operations of the jobs to thecorresponding sink nodes. In each stage, there is between each pair of operations that belong todi!erent jobs two disjunctive arcs that go in opposite directions. The scheduling process requiresthe selection of at most one disjunctive arc from each pair. This selection process is at times alsoreferred to as the ,xing process. If job j is scheduled immediately before job k on the samemachine at stage k, then the disjunctive arc going from node ( j, l ) to node (k, l ) is selected ("xed). Ifjobs j and k are scheduled on di!erent machines, then both disjunctive arcs are discarded, becausethen there are no precedence constraints between these two operations.

Each arc in the disjunctive graph has a length. The length of a conjunctive arc from node ( j, l)to node ( j, m) is p

jl. The length of the conjunctive arc that goes from the source node ; to node

( j, 1) is rj, while the length of the conjunctive arc from node ( j, s) to the sink node <

jis p

js. The

length of a disjunctive arc pointing from node ( j, l) to node (k, l ) is pjl. In terms of the disjunctive

90 Y. YANG, S. KREIPL AND M. PINEDO

Copyright ( 2000 John Wiley & Sons, Ltd. J. Sched. 2000; 3:89}108

Figure 1. Initial disjunctive graph for a 4 stage, 3 job instance.

graph representation, our problem is to "nd a selection of disjunctive arcs such that the resultinggraph is acyclic and the total weighted tardiness is minimized.

Consider the following example with four stages in series. The four stages have 2, 2, 1and 1 machine respectively. There are three jobs and the information regarding these jobs ispresented in table below:

job wj

rj

dj

pjl

1 3 0 25 10, 3, 6, 42 2 7 25 7, 3, 5, 23 1 8 26 8, 2, 4, 3

The initial disjunctive graph, before the selection of any disjunctive arc, is depicted in Figure 1.Consider the following "nal schedule:

Stage 1: Machine 1: job 1#job 3; Machine 2: job 2Stage 2: Machine 1: job 1#job 3; Machine 2: job 2Stage 3: Machine 1: job 1#job 2#job 3Stage 4: Machine 1: job 1#job 2#job 3

The disjunctive graph corresponding to this schedule is presented in Figure 2.

3. THE STAGE-BASED DECOMPOSITION HEURISTIC

This stage-based decomposition heuristic decomposes the #exible #ow shop according to itsstages. It treats each stage as a separate parallel machine problem and schedules the stages one by

HEURISTICS FOR MINIMIZING TOTAL WEIGHTED TARDINESS 91


Figure 2. Final disjunctive graph for a 4 stage, 3 job instance.

one. It consists of four basic modules, namely:

(i) bottleneck detection,(ii) subproblem formulation,(iii) solution of the subproblems and(iv) reoptimization.

In the remaining part of this section we discuss each of these modules in detail.We "rst discuss the bottleneck detection module. As in most decomposition methods for shop

scheduling problems, the bottleneck concept is critical in the design of the algorithm. In an actualproduction line, a bottleneck is the unit (machine, workcentre or bank of parallel machines) thatplays the most critical role in determining the completion times of the jobs. So the quality of theschedule for the bottleneck unit has a signi"cant e!ect on the performance of the overall schedulefor the entire machine environment. In the design of an algorithm, one tries to have an estimate ofthe impact of the bottleneck in the given machine environment on the objective function. Itprovides information that is useful for the design of the scheduling mechanism. In the well-knownshifting bottleneck procedure for JmEC

.!9proposed by Adams et al. [2], a bottleneck is the

machine with the maximum objective value when each machine is analysed as a separate1 Dr

jD¸

.!9problem. In our model, a bottleneck is the stage that is the most critical in the

minimization of the total weighted tardiness in the #exible #ow shop. Before the schedulingprocess starts, we order the stages according to their criticality.

The "rst measure of criticality is the average workload per machine at each stage. This capturesthe degree of congestion at a stage. It is de"ned as the sum of the processing times of the jobs ata stage divided by the number of machines at that stage, i.e.

=l"

+nj/1

pjl

ml

, l"1, . . . , s (1)

Intuitively, a higher average workload at a stage is more likely to cause longer delays for the jobsat that stage. So obtaining a good schedule at such a stage is critical in the search for a goodoverall schedule.



If two or more stages are very close to one another with respect to their average workload permachine, we consider the stage with the smallest number of machines as the more critical one.This is because with fewer machines one has less #exibility with regard to the scheduling of thejobs and it is natural to deal with the least #exible subproblem "rst.

We prioritize the s stages according to these two criteria. A more critical stage has a higherpriority than a less critical stage. We proceed with the scheduling of the stages in decreasing orderof their criticality.

The second module is the subproblem formulation module. When we consider, after decompo-sing the #exible #ow shop, a speci"c stage, we basically have a parallel machine schedulingproblem with jobs that arrive at di!erent points in time. Finding a good schedule for each one ofthese subproblems is important since the quality of the overall schedule for the entire #ow shopdepends on the solutions of the single-stage subproblems. We have to formulate the subproblemsin such a way that their solutions facilitate the search for a good overall schedule for the entire#exible #ow shop. The choice of the objective function of the subproblem does not have to beunique, but it should be a function of the completion times of the jobs at the corresponding stage.Without loss of generality, we illustrate the subproblem formulation by considering an arbitrarystage l. Assume that the overall scheduling problem corresponds to a disjunctive graph G; thecurrent state of the scheduling process can be represented by a directed graph G@ that is obtainedby ignoring all the un"xed disjunctive arcs. Given graph G@, a lower bound on the starting time ofoperation ( j, l ) is the length of the longest path from the source node ; to node ( j, l ), sinceoperation ( j, l ) cannot start its processing at stage l before all preceding operations have beencompleted. We denote the length of this longest path by ¸[;, ( j, l)]. We set the local release dateof job j at stage l equal to this value, i.e.

rjl"¸[;, ( j, l )] (2)

We solve the longest path problems using the subroutine described in Reference [2].Similarly, a type of due date for operation ( j, l ) can be determined by computing the length of

the longest path from node ( j, l) to the sink node <k, k"1, . . . , n. Note that node ( j, l), i.e. the

start of operation ( j, l ), may be connected to the sink node of any one of the n jobs, which impliesthat the completion time of operation ( j, l) may have an e!ect on the completion times of alln jobs at the "nal stage, which all contribute to the total weighted tardiness objective. So, anoperation at stage l may, therefore, have n local due dates. The local due date of job j at stage lwith respect to job k, say dk

jl, is de"ned as follows:

dkjl"G

maxMCk, d

kN!¸[( j, l ), <

k]#p

jlR

if ¸[( j, l ), <k)] exists

otherwise(3)

In this computation, the dkis the due date of job k and C

kis a lower bound on the completion time

of job k at the last stage. This lower bound is equal to the length of the longest path from thesource node ; to the sink node <

kin the current disjunctive graph G@. The tardiness of job j at

stage l with respect to job k can then be de"ned as

¹kjl"maxM0, C

jl!dk

jlN (4)



where

Cjl"¸[;, ( j, l )]#p

jl(5)

One option for a local objective function would be the aggregated total weighted tardiness atthe stage under consideration, i.e.

n+j/1

n+k/1

wk¹k

jl(6)

This function tries to capture the e!ect of the completion time of each operation at stage l on thecompletion times of all n jobs at the last stage. An alternative for the local objective function is

n+k/1

wk¹

kl(7)

where ¹kl

is de"ned as

¹kl"max

j¹k

jl(8)

This objective function is a lower bound for the increment of the total weighted tardiness of the#exible #ow shop due to the scheduling of stage l [3], just as in the original shifting bottleneckprocedure for JmEC

.!9, the ¸

.!9objective of the subproblem is a lower bound for the increment

of the makespan of the job shop due to the scheduling of one machine. The justi"cation forminimizing this function is similar to the rationale behind a greedy algorithm in which each steptries to achieve what is locally best in the current situation. However, in trying to minimize (6), wesearch for a schedule that takes into consideration the contribution to the total weightedtardiness from each job separately. We therefore need a procedure for solving the parallelmachine subproblem at a stage that takes into consideration the local release date and themultiple local due dates of the jobs and the multiple objective functions at this stage.

The third module involves the solution of the parallel machine subproblem formulated in thesecond module. The description of the methodology for solving the parallel machine subproblemis rather lengthy. The type of method to use for solving the subproblems is a delicate choice. It isnot hard to realize that the selection of the method depends on a tradeo! between time andquality. We could use branch and bound and "nd an optimal schedule for the subproblem, butthat is computationally expensive for a subroutine that is called many times and often applied toa subproblem of fairly large size. Also, it is not clear to what extent the quality of the solution ofthe subproblems a!ects the quality of the overall schedule. In a decomposition algorithm like thisone, other elements, such as bottleneck detection, subproblem formulation and especially, thereoptimization strategy (also referred to as the control structure), also have a signi"cant impacton the quality of the overall schedule, and possibly to a greater extent.

We therefore make an e!ort to "nd a reasonable solution for the subproblem in an e$cientway. We apply a dispatching rule and improve on this solution with a neighbourhood search.One of the better known dispatching rules for total weighted tardiness problems is the apparenttardiness cost "rst (ATC) rule. This rule, "rst proposed by Vepsalainen and Morton [4], is



a composite dispatching rule that combines the weighted shortest processing time "rst (WSPT)rule with the minimum slack "rst (MS) rule. However, we have to make modi"cations in this rulein order to make it suitable to our problem. Firstly, the ATC rule is usually applied tosingle-machine problems and here we have parallel machines. Secondly, the ATC rule is speci"-cally designed for the scheduling of jobs that have a single due date. In our case each operationhas multiple due dates and the objective is more complicated than the total weighted tardinessobjective in the regular sense. Lastly, the ATC rule typically assumes that all jobs are available attime 0 and here we have operations with di!erent release dates.

Without loss of generality, we describe how to apply a modi"ed version of the ATC rule toobtain an initial schedule for the subproblem at stage l. The procedure starts at time 0, when all m

lmachines are idle and all n operations are yet to be scheduled. The current decision moment ateach one of the machines is equal to 0. We break ties arbitrarily by choosing any one of themachines and we call it machine m

c. We compute the priority index I

jl(0) for each operation ( j, l ).

The operation that results in the highest index value is selected as the "rst one to be processed onmachine m

c. The decision moment on machine m

cis then changed to the time when the machine

"nishes the current operation and is free again, while the decision moments on all other machinesremain 0. At a typical iteration of the procedure, the decision moment t is set equal to the timea machine becomes idle; an idle machine is chosen (ties are broken arbitrarily) and a priorityindex is computed for each operation ( j, l) that is not yet scheduled and the one with the highestindex value I

jl(t) is selected to be processed next on the chosen machine. The priority index for

operation ( j, l) at time t is computed as

Ijl(t)"

n+k/1

wk

pjl

expA!maxM0, dk

jl!p

jl!maxMt, r

jlNN

KpNl

B (9)

The pNlis the average processing time of all unscheduled operations at stage l. To compute this

index, the scaling parameter K has to be determined. Lee and Pinedo [5] address the issue ofselecting scaling parameters for the ATC rule experimentally. Using a similar approach, wedetermine the best K value for our computation of the priority index empirically.

As in most schedules generated with dispatching rules, there is room for improvement in theschedule obtained. In what follows, we present an improvement routine for the parallel machinesubproblem that is based on a local search. The local search routine consists of two subroutines.The "rst subroutine focuses on minimizing function (6) while the second focuses on minimizingfunction (7). The idea is that when the local search in the "rst subroutine has reached its stoppingcriterion and further improvement is hard to come by, we switch to the second subroutine andperform a local search with regard to a second objective function until that subroutine reaches itsstopping criterion. We iterate between these two subroutines seeking improvement in bothobjectives. We stop the improvement routine after a certain number of iterations and choose theschedule with the best of function (7) as the "nal schedule for this stage.

In the "rst subroutine we compute for machine i at stage l the value

n+k/1

+j|pil

wk¹k

jl, i"1, . . . ,m

l

assuming sequence pilwas generated originally with the priority rule described above. Among the

machines, we select the one with the highest value and the one with the lowest value, m.!9

and



m.*/

, respectively. From the schedule on machine m.!9

we randomly select an operation amongthose with a positive tardiness, and move it to machine m

.*/. With this move, we try to achieve

a better balance between the machines. Because the machines at any given stage are all assumedto be identical, we expect them to contribute more or less the same amount to the objective value.It therefore makes sense to aim for a more balanced distribution of +

k+jwk¹k

jlamong the

machines. Now on machine m.!9

, there is one less job, and the remaining jobs remain in theoriginal sequence and we keep this sequence. But at machine m

.*/, there is one additional job that

has to be inserted. We insert this job in the position that results in the lowest cost increase andthen perform adjacent swaps on this machine in order to obtain further improvements. Whetheror not to accept a move is based on a Metropolis test [6] that may be regarded as a simulatedannealing procedure with constant temperature. More speci"cally, if a move in iteration k yieldsan improvement in the objective, we accept the move and the swaps performed so far. If there isno improvement, we still accept the move with probability

P (k)"exp(!(cL k!ck)/¹) (10)

where ck is the value of the objective before iteration k and cL k is the value after. Unlike the usualsimulated annealing procedures that apply a cooling scheme for controlling the temperature, wekeep the parameter ¹ constant, the reason being that we only make relatively few iterations.More speci"cally, we determine ¹ in the following way: we set an acceptance probability p forworse neighbors, e.g. p"0.25 implies that on average every one in four deteriorations is accepted.With p "xed, we calculate a corresponding temperature¹ for each instance [7]. The fact that witha certain probability we accept a move which includes swaps that results in a worse solutionenables us to get out of local minima.

The second subroutine is similar to the "rst except for the cost function. For each job k,k"1, . . . , n, we identify from the n jobs the one that determines the maximum tardiness ¹

kl.

Similarly, we call the machine that contributes the most to

n+k/1

wk¹

kl

machine m@.!9

. We select from this machine one of the jobs that causes the maximum tardinessand move this job to one of the machines that contribute the minimum amount to

n+k/1

wk¹

kl

The remaining steps are similar to those in the "rst subroutine described above.The number of iterations of the improvement routine depends on the number of machines at

the stage. Typically, this improvement routine results in a better schedule with regard to the localobjectives.

It is not hard to realize that among the set of feasible schedules, there may be more than oneschedule that achieve the same objective value. More speci"cally, in our solution of the subprob-lem, we may encounter in the local search multiple schedules with the same +n

k/1w

k¹

klvalue.

This phenomenon happens more frequently in the earlier iterations of the scheduling process for



the #exible #ow shop, the reason being that with few stages scheduled, the local release date andlocal due dates are loosely approximated and result in local tardinesses that are zero or close tozero. In light of this, the selection of the "nal solution for the subproblem becomes a signi"cantissue. In other words, in case of ties in the primary objective, it may be advantageous to havea secondary objective according to which ties can be broken. This may result in better solutionsthat when breaking ties arbitrarily.

The objective for our #exible #ow shop problem is the total weighted tardiness, which impliesthat no matter how much ahead of time a job "nishes, as long as it is earlier than its due date, itcontributes zero to the objective value. However, when we are scheduling a particular stage, wewould prefer the jobs to be completed earlier even though they would not result in any tardinessat this point in the scheduling process. This insight determines our selection of the secondaryobjective, which is

n+j/1

n+k/1

wk¸k

jl(11)

In this computation, ¸kjl

is de"ned as

¸kjl"G

Cjl!dk

jl0

if dkjlOR

otherwise(12)

The fourth module of the decomposition heuristic does the reoptimization. Reoptimization isan essential element of decomposition algorithms and is sometimes also referred to as the controlstructure. Everytime a new stage has been scheduled, we reschedule all the stages that have beenscheduled previously in the order of their criticality indices. This type of reoptimization is knownto be very e!ective in improving the solution quality, see References [3, 8, 9]. More speci"cally,for each stage previously scheduled, we discard the schedule obtained before and treat it as a newstage with no disjunctive arcs "xed yet, and apply the same method for solving a single-stagesubproblem as described before in order to obtain a new schedule for this stage. This may leadnow to a better schedule because more information has become available with regard to the otherstages since this stage was scheduled last. Usually, better schedules are found with this type ofreoptimization.

The structure of the decomposition heuristic can be described using a simple #ow chartconsisting of the four modules. This #ow chart is presented in Figure 3.

4. THE LOCAL SEARCH HEURISTIC

In this section we describe our second heuristic for the problem. Assume we have in handa feasible schedule for the entire #exible #ow shop. We discuss a local search heuristic thatimproves upon a given schedule. Each iteration of the local search heuristic consists of twophases. In the "rst phase of an iteration we search at every stage for a good assignment ofoperations to machines and we generate an initial sequence for each machine. The second phaseattempts to "nd better schedules for each one of the machines at each stage. In subsequentiterations we modify the machine loading that corresponds to the schedule generated for each



Figure 3. The structure of the decomposition heuristic.

machine in the scheduling phase of the previous iteration and then reschedule all the machines.The procedure stops after a given number of iterations.

The "rst phase modi"es the machine loading and generates new machine sequences. It is donebasically by applying the "rst subroutine of the improvement routine in the third moduledescribed in Section 3. It is carried out for each stage in the order speci"ed by the same criticalityindices that are utilized in the decomposition heuristic. Based on the same rationale as that for thedecomposition heuristic, the order in which the stages are handled is a factor in the e!ectivenessof the algorithm. At each stage, we apply the "rst subroutine of the improvement routine since itattempts to balance the machines; this appears to be advantageous from the machine loadingpoint of view. During the procedure, we save the assignment and the corresponding sequencesevery time a better objective value is achieved. If we make a change at one stage, we update thelocal release dates and due dates for the jobs at all other stages before we move on to the machineloading of the next stage. The machine loading phase results in an assignment of the jobs as wellas an initial sequence for each machine as a starting point for the second phase.

The second phase, i.e. the improvement of the sequences of jobs on all machines, is done usingthe large step optimization (LSO) method. It is a type of local search method that was introducedby Martin et al. [10] to solve travelling salesman problems. It has also been applied to job shopscheduling problems [11]. LSO methods consist of consecutive phases of diversi,cation andintensi,cation. Lourenco [11] calls diversi"cation the large step and intensi"cation the small step.The large step tries to guide the search to new regions of the solution space that appear to bepromising. The small step intensi"es the search in a particular region trying to "nd a goodsolution within that region. Similar to simulated annealing, LSO methods do accept during thesearch worse solutions with given probabilities and are able to escape from local minima.

The large step of the algorithm perturbs the solution in a major way in order to lead the searchaway from the last solution obtained in the small step. This perturbation is not completelyrandom, since it still tries to stay near a local minimum, which most likely is a reasonably goodsolution. For a large step we use the metropolis algorithm with the following stopping criterion:Let S* denote the best solution found so far, and S the "nal solution of the previous small step. Ifc(S)"c(S*), then we do x iterations of the metropolis algorithm, with x randomly selectedbetween 5 and 20. If c(S))1.1c(S*) or c(S))c (S*)#20, we do y iterations with y randomly



selected between 10 and 40. Otherwise we do z iterations, with z randomly selected between 10and 100. With this stopping criterion we perturb the solution S generated by the small step onlya little if it seems to be a promising solution, otherwise S undergoes a bigger change.

The small step of the algorithm performs an intensi"ed search starting from the solutionobtained in the previous large step. In the small step, we use iterative improvement in such a waythat the next large step starts from a local minimum. Iterative improvement can be done in twoways. One way is to check the entire neighbourhood in order to "nd the best neighbour (steepestdescent), the other way is to take the "rst neighbour that is better than the current solution(random descent). We choose the random descent method for two reasons. The "rst reason is thegain in computing time, since we do not have to inspect all the neighbours and the size ofa neighbourhood is typically large. The second reason is that the behaviour of the randomdescent method reduces the probability that after several consecutive large steps and small stepsthe same local minimum is reached. We implemented random descent in the following way toassure that the small step ends up in a local minimum: we keep all the neighbours of a solution ina list, take the "rst element of the list and compare it to the current solution. If it is better itbecomes the new current solution. Otherwise we check the second element of the list, and so on,until we "nd a better solution. If we do not "nd a better solution and we have checked the entirelist, we have a local minimum.

As in any local search algorithm for a combinatorial optimization problem, we have to de"ne

(i) the set of feasible solutions F,(ii) the cost function c :FPR and(iii) a neighbourhood structure N.

The neighbourhood N de"nes for each solution S3F the set of solutions that can be reached ina single step. These solutions are called the neighbours of S.

Our neighbourhood structure is based on the longest paths of the jobs in the disjunctive graph.The longest path of job j is the longest path from the source node ; to the sink node <

jand the

length of this longest path determines the completion time of job j in the current schedule. Also,we call an arc (i, l)P( j, l) on a longest path critical if operations (i, l ) and ( j, l) are adjacent to oneanother on the same machine at stage l.

We use two types of neighbourhood structures in our algorithm, dependent upon whether thealgorithm performs a large step or a small step. In a large step we consider all the critical arcs inthe longest path that belong to the job with the largest weighted tardiness. In a small step weconsider all the critical arcs on all longest paths that belong to all the tardy jobs. The reason fordesigning a larger neighbourhood in a small step is that the search in such a step has to beintensi"ed. Once we have identi"ed all the critical arcs, we choose one randomly (in bothsituations). Many types of neighbourhoods for this kind of scheduling problem are based on thereversal of the critical arc selected. Even though this neighbourhood structure has some niceproperties [12, 13], several extensions have been introduced [14, 15]. With the total weightedtardiness objective we obtained the best results with the neighbourhood proposed by Matsuoet al. [16]. Instead of a large perturbation on one machine, this neighbourhood consists of smallmodi"cations on di!erent machines. These machines are related to one another by the twooperations that are connected by the selected critical arc.

The structure of the local search heuristic can be represented by the #ow chart depicted inFigure 4.



Figure 4. The structure of the local search heuristic.

5. CONTROL STRUCTURE OF THE HYBRID ALGORITHM

In the fourth module in Section 3, we have described a control structure that is embedded in thedecomposition heuristic. It serves as a reoptimization module that improves the quality of theschedule obtained with the decomposition heuristic by rescheduling the previously scheduledstages every time a new stage is scheduled. Reoptimization can actually also be carried out ata higher level than that of the rescheduling process in the decomposition heuristic. In this section,we describe a control structure that is the basis for our third algorithm*the hybrid heuristic.

Suppose we have for the #exible #ow shop a complete schedule in hand that is obtained by thedecomposition heuristic. There is most likely room for improvement since it has been obtainedvia a heuristic. But it is di$cult to "nd a better solution by continuing with the decompositionapproach since, when we terminate the decomposition heuristic, we have reached a point whereno improvement can be obtained by doing more iterations. However, if we apply a di!erent kindof improvement method to this solution, it may be possible to obtain a better schedule. The localsearch procedure described above is an ideal candidate for this purpose. So, by applying thedecomposition procedure and the local search procedure iteratively, we obtain our third heuristicwhich we refer to as the hybrid heuristic. More precisely, we apply the decomposition heuristic tothe #exible #ow shop until no further improvement can be achieved; we then switch to the localsearch heuristic to improve the current schedule until a certain stopping criterion is reached. Wego back to the decomposition heuristic after having reached the solution obtained with the localsearch, we take out each stage in the order of its criticality, discard the "xed disjunctive arcs andreschedule it. Since decomposition and local search lead to di!erent types of local minima,iterating between the two has the e!ect of complementing one another. Clearly, the hybridheuristic is expected to outperform the decomposition heuristic as well as the local search



heuristic. With the same rationale behind our hybrid algorithm, we can implement a slightvariation of it by taking out two or more stages at a time for rescheduling (instead of a single stageat a time). It makes the search go into a broader area of the solution space, and presumably canresult in an even better solution than the version we experimented with.

6. EXPERIMENTAL DESIGN AND COMPUTATIONAL RESULTS

The objectives of our computational experiments are two-fold. First, we want to test the e$ciencyof the three algorithms developed. Second, we are interested in reaching some empirical con-clusions with regard to certain characteristic factors of #exible #ow shops.

We "rst describe how the instances are generated. The weights are assigned in a deterministicfashion: 20 per cent of the jobs have weight 1, 60 per cent have weight 2 and 20 per cent weight 4.The processing times are basically generated from a discrete uniform distribution over theinterval [1, 40]. For certain instances, some adjustments of the processing times are made in orderto meet some speci"c constraints which are described in the next paragraph. The release dates areintegers which are uniformly distributed between 0 and 10. The due date of job j is set equal to itsrelease date plus its total processing times multiplied by a &tightness' factor g

1, that is

dj"r

j# g

1 *s+l/1

pjl, j"1, . . . , n (13)

The most important characteristics of a #exible #ow shop concern the bottleneck(s). Recall thatthe bottleneck is the stage with the largest average workload=

.!9. The bottleneck location factor

g2

indicates where the bottleneck stage is located in the #exible #ow shop. It may be at thebeginning, in the middle or at the end of the #exible #ow shop. We de"ne the bottleneck criticalityfactor g

3as a measure of how much higher the workload on a machine at the bottleneck stage is

relative to the machines at non-bottleneck stages. We are interested in testing how the bottlenecklocation factor (g

2) and the bottleneck criticality factor (g

3) a!ect the performance of the

algorithms. We refer to the stage with the smallest average workload per machine =.*/

as thebasic stage. The workload decreases linearly from the bottleneck stage to the basic stage. In otherwords, if we normalize the workload at the basic stage and set it equal to one unit, then theworkload at any other stage should be a value determined by the position of the stage and thevalue of g

2. We call this value the target workload ratio of that stage and denote that of stage l as

Rl, l"1, . . . , s. It is computed as follows. For the scenario where the bottleneck stage is stage

1 and the basic stage is stage s

Rl"g

3 * (s!l)#1, l"1, . . . , s!1 (14)

Likewise, for the scenario where the bottleneck stage is stage s and the basic stage is stage 1

Rl"g

3 * (l!1)#1, l"2, . . . , s (15)

For the scenario where the bottleneck stage is in the middle, i.e. stage (s#1)/2 (we consistentlytest instances with an odd number of stages) and the basic stages are stages 1 and s,

Rl"G

g3 * (l!1)#1,

g3 * (s!l )#1,

l"1, . . . , (s#1)/2

l"(s#3)/2, . . . , s(16)



The processing times of the jobs have to be adjusted so that each stage meets its targetworkload ratio. At "rst, temporary values are generated for the processing times p0

jl, j"1, . . . , n,

l"1, . . . , s, uniformly between 1 and 40. We then compute the workload at all the stages. Wecalculate for each stage l the actual workload ratio

R@l"

=l

=.*/

(17)

Then we set

pjl"p0

jl *R

lR@

l

(18)

This guarantees

=l

=.*/

"Rl

Fixing the number of stages at seven, we generate two sets of testing data. One set consists of 27instances and each instance has 20 jobs. The other set also consists of 27 instances, but each one ofthese instances has 50 jobs. For each set, we generate one instance for a combination of the threeparameters g

1, g

2and g

3. The parameter g

1is chosen from the numbers 1.1, 1.3 and 1.5,

representing a decreasing tightness in job due dates. The parameter g2

represents one of the threescenarios: the bottleneck is at the beginning, in the middle or at the end of the #exible #ow shop.The parameter g

3has three values as well, namely, 0.125, 0.25 and 0.375, representing an

increasing criticality of the bottleneck stage. The number of machines at each stage is randomlychosen from the numbers 2}4.

We test the 54 instances as follows: for each instance, we apply the decomposition algorithm"rst. Then we apply two versions of the local search algorithm: one is a short version where therunning time of each instance is set equal to the running time of the decomposition algorithm forthat instance, the other is a long version where we set the running time "ve times longer than theshort version. We then apply the hybrid algorithm of which the total running time is set equal tothe running time of the longer version of the local search. Considering the probabilistic nature ofthe local search mechanisms in all three algorithms, we apply each algorithm "ve times to eachinstance.

For comparison purposes, we also apply a dispatching rule that is one of the best known fortotal weighted tardiness objective among those used in practice. It is based on the modi"ed ATCrule as described in Section 3 and is further adapted so that it is applicable to the entire #exible#ow shop. More speci"cally, we start scheduling all the jobs at stage 1, then we schedule stage 2,and so on, until we "nish with stage s. Scheduling at stage l is done in the same way as describedearlier, with a slightly modi"ed priority index, namely

I@jl(t)"

wj

p@jl

exp A!max(0, d

j!p@

jl!max(t, r

j))

Kp@i

B (19)



Table I. Results for the 20-job instances.

Average Minimum Maximum

Instance Best Dcmp LSs LS1 Hyb Dcmp LSs LS1 Hyb Dcmp LSs LS1 Hyb Disp

(1, 1, 1) 2525 3.7 27.9 27.9 1.1 2.4 26.8 26.8 0 4.7 29.4 29.4 2.1 145.8(1, 1, 2) 1222 6.7 1.7 1.3 6.5 5.6 0.7 0 5.4 7.8 2.2 2.1 7.4 10.0(1, 1, 3) 828 7.2 2.9 2.6 4.1 6.5 0.7 0 2.7 7.7 4.2 4.0 5.8 23.9(1, 2, 1) 1776 4.2 14.1 12.6 0.4 2.1 12.7 10.0 0 5.3 15.8 15.8 0.7 55.3(1, 2, 2) 670 4.5 16.3 15.1 1.9 1.2 15.7 14.0 0 5.5 17.3 15.7 4.9 76.7(1, 2, 3) 960 8.4 9.0 6.8 3.2 7.1 0.9 0.9 0 10.8 15.4 10.6 5.0 61.1(1, 3, 1) 868 5.3 10.0 8.2 3.4 1.0 8.4 4.1 0 8.5 12.8 12.7 7.0 52.5(1, 3, 2) 2252 7.4 6.0 6.0 4.2 1.9 3.2 3.2 0 10.7 8.2 8.2 9.1 60.4(1, 3, 3) 1052 8.7 29.6 26.7 3.3 4.8 22.1 15.7 0 14.8 33.8 33.5 6.1 125.5

(2, 1, 1) 724 2.5 3.5 3.3 1.6 1.4 0 0 0.8 4.8 8.6 8.6 3.2 36.7(2, 1, 2) 496 2.6 19.9 17.5 2.6 0 15.5 12.9 0 4.0 25.0 21.6 4.0 80.4(2, 1, 3) 445 10.6 7.2 3.4 5.2 6.1 4.5 0 3.4 13.9 9.2 7.9 6.3 42.7(2, 2, 1) 391 25.8 18.3 13.0 15.8 16.6 5.9 0 3.3 33.8 26.6 22.5 27.9 143.0(2, 2, 2) 110 38.2 15.2 7.9 5.2 31.8 3.6 1.8 0 48.2 27.3 14.5 12.7 181.8(2, 2, 3) 459 5.7 2.3 1.4 2.1 4.8 0 0 0 7.0 5.9 3.1 4.6 32.2(2, 3, 1) 361 22.3 22.3 21.0 3.0 19.7 14.1 10.0 0 23.8 33.0 33.0 5.5 359.0(2, 3, 2) 1038 13.0 22.8 18.8 3.8 4.2 17.9 8.7 0 19.9 31.7 29.5 10.4 157.4(2, 3, 3) 247 25.9 13.8 9.3 10.8 19.8 4.9 0 8.9 30.8 20.6 15.8 13.8 145.3

(3, 1, 1) 266 8.9 26.2 25.7 3.6 0.4 9.8 9.8 0 13.5 42.1 41.4 10.5 377.4(3, 1, 2) 59 19.2 13.6 6.8 4.5 6.8 6.8 1.7 0 32.2 18.6 16.9 8.5 198.3(3, 1, 3) 200 18.5 2.5 2.3 12.0 16.5 0.5 0 10.5 19.5 5.5 5.5 14.0 82.5(3, 2, 1) 22 142.4 95.5 78.8 68.2 127.3 54.5 54.5 0 168.2 136.4 122.7 127.3 886.4(3, 2, 2) 26 126.9 228.2 217.9 29.5 111.5 115.4 115.4 0 153.8 292.3 276.9 53.8 992.3(3, 2, 3) 105 30.8 32.1 22.9 6.7 4.8 30.5 7.6 0 53.3 34.3 34.3 18.1 276.2(3, 3, 1) 18 190.7 118.5 55.6 85.2 111.1 11.1 0 72.2 261.1 255.6 122.2 100.0 1066.7(3, 3, 2) 21 47.6 47.6 41.3 23.8 23.8 9.5 9.5 0 61.9 71.4 61.9 38.1 1761.9(3, 3, 3) 63 75.7 74.6 63.0 35.4 36.5 47.6 38.1 0 106.3 95.2 90.5 61.9 441.3

where p@jl

is the total remaining processing time of job j (that is, the sum of all processing time of

job j at this stage and all subsequent stages) and p@lis the average of the total remaining processing

time of the set of unscheduled jobs at this stage up to time t.The results for the 27 instances with 20 jobs are presented in Table I. The "rst column of the

table indexes the instance by means of the triplet (a1, a

2, a

3). The a

1denotes the due date tightness

factor of the instance. Instances with a1"1 have g

1"1.1, those with a

1"2 have g

1"1.3 and

those with a1"3 have g

1"1.5. The a

2denotes the bottleneck location factor of the instance.

Instances with a2"1 have the bottleneck at the beginning, instances with a

2"2 have the

bottleneck in the middle and instances with a2"3 have the bottleneck at the end. The a

3denotes

the bottleneck criticality factor of the instance. Instances with a3"1 have g

3"0.125, instances

with a3"2 have g

3"0.25 and instances with a

3"3 have g

3"0.375. For example, (1, 2, 3)

implies that this instance is generated in such a way that the due date tightness factor is 1.1, thebottleneck is in the middle and the bottleneck criticality factor is 0.375. In column 2, we put thebest solution value of the instance that is achieved by the di!erent algorithms. For our speci"c



Table II. Summary for the 20-job instances.



(1, *, *) 1350 6.2 13.1 11.9 3.1 3.6 10.1 8.3 0.9 8.4 15.5 14.7 5.4 67.9(2, *, *) 475 16.3 13.9 10.6 5.6 11.6 7.4 3.7 1.8 20.7 20.9 17.4 9.8 131.0(3, *, *) 87 73.4 71.0 57.1 29.9 48.7 31.7 26.3 9.2 96.7 105.7 85.8 48.0 675.9(*, 1, *) 752 8.9 11.7 10.1 4.6 5.1 7.3 5.7 2.5 12.0 16.1 15.3 6.9 110.9(*, 2, *) 487 42.9 47.2 41.3 14.9 34.1 26.6 22.6 0.7 53.7 62.2 56.6 28.4 296.4(*, 3, *) 658 44.1 38.4 27.7 19.2 24.8 15.4 9.9 9.0 59.8 62.5 45.2 28.0 463.3(*, *, 1) 772 45.1 37.4 27.3 20.3 31.3 15.9 12.8 8.5 58.2 62.2 45.4 31.6 347.0(*, *, 2) 655 29.6 41.2 36.9 9.1 20.8 20.9 18.6 0.6 38.2 54.9 49.7 16.6 391.0(*, *, 3) 484 21.3 19.3 15.4 9.2 11.9 12.4 6.9 2.8 29.4 24.9 22.8 15.1 136.8(*, *, *) 635 32.0 32.6 26.5 12.9 21.3 16.4 12.8 4.0 41.9 47.2 39.2 21.1 291.1

problem, it is very di$cult to obtain an optimal solution or a good lower bound for each one ofthe instances. Therefore, to compare the di!erent algorithms, we use the relative deviation withrespect to the best solution value achieved by one of the algorithms, i.e. if C

Bis the best solution

value achieved, and CH

is the solution value by a heuristic, then the relative deviation is de"ned as

CH!C

BC

B

100%

Columns 3}6 contain the relative deviation of the average solution value from the "ve indepen-dent runs. Columns 7}10 present the relative deviation of the best solution value, while columns11}14 contain the relative deviation of the worst solution value from the same "ve independentruns. The column &Dcmp' gives the results of the decomposition algorithm; the column labelled&LS-s' gives the results of the short version of the local search algorithm; the column labelled&LS-1' gives the results of the long version of the local search algorithm and the column labelled&Hyb' the results of the hybrid algorithm. Finally, the last column labelled &Disp' refers to theresults obtained with the dispatching rule. All the instances are run on a Pentium 200 PC.Running time of the decomposition algorithm for the 20 job instances is never longer than 60 s.Therefore, the running time of the short version of the local search algorithm is set equal to oneminute, while the running time of the long version of the local search algorithm and the hybridalgorithm are both set equal to 5 min. The dispatching rule is very fast and the time it takes is lessthan 5 s for each instance.

In Table II, we summarize the results in Table I by taking the averages of the relative deviationover di!erent sets of instances. The notation (a

1, *, *) represents the average deviation of the nine

instances with the given a1

value. Similarly, (*, a2, *) and (*, *, a

3) respectively represents the

average deviation of the nine instances with the given a2

or a3value. Therefore, (*, *, *) represents

the average deviation of all the 27 instances.The results for the 27 instances with 50 jobs are presented in Tables III and IV, which are

organized in the same manner as Tables I and II.From the results, we see that all three algorithms we developed outperform the dispatching rule

by a wide margin. Among the three algorithms, the decomposition algorithm on average gives



Table III. Results for the 50-job instances.



(1, 1, 1) 11697 4.1 20.5 20.1 0.7 3.6 18.7 18.2 0 4.8 22.2 22.2 1.0 86.0(1, 1, 2) 17811 3.2 35.7 34.6 1.3 1.7 32.9 31.8 0 5.7 41.4 39.2 2.7 110.9(1, 1, 3) 15269 3.5 17.8 17.3 1.9 2.2 15.8 15.6 0 5.0 21.1 20.4 4.6 98.4(1, 2, 1) 16940 6.1 19.4 19.1 2.6 2.1 15.7 15.7 0 12.4 21.4 21.3 7.1 111.2(1, 2, 2) 11984 4.9 4.2 4.1 1.5 2.6 1.1 1.1 0 4.0 6.5 6.5 3.2 54.5(1, 2, 3) 10020 5.7 12.3 11.4 1.4 2.1 9.0 8.8 0 7.9 14.9 14.9 3.6 41.5(1, 3, 1) 12018 8.5 19.9 14.9 1.1 7.2 15.0 12.9 0 9.7 24.5 17.0 2.6 86.5(1, 3, 2) 7969 6.4 12.3 12.0 2.2 4.4 10.6 10.0 0 9.6 14.3 14.3 4.4 97.0(1, 3, 3) 7725 8.4 14.3 13.9 2.7 7.1 10.8 9.8 0 10.1 17.5 17.5 4.2 90.2

(2, 1, 1) 5911 5.5 4.6 3.1 1.4 3.5 4.3 2.3 0 6.7 4.7 4.7 3.5 32.1(2, 1, 2) 6481 6.5 14.6 13.0 2.5 3.8 9.7 9.0 0 8.0 20.7 17.0 5.9 30.3(2, 1, 3) 5910 1.9 14.0 13.2 0 1.6 13.3 10.8 0 2.1 14.6 14.6 0.1 39.3(2, 2, 1) 4735 11.9 20.9 18.8 6.4 8.0 16.3 15.5 0 9.2 28.6 23.0 13.9 81.6(2, 2, 2) 12400 6.7 12.4 10.7 0.7 4.9 10.5 9.6 0 9.0 14.1 12.1 2.0 91.9(2, 2, 3) 15002 2.4 30.4 30.4 1.0 1.1 27.1 27.1 0 4.2 33.5 33.5 2.0 75.2(2, 3, 1) 12342 7.0 18.8 16.7 2.6 4.6 15.6 14.6 0 11.2 20.7 19.2 6.4 142.8(2, 3, 2) 12878 6.5 16.1 15.0 1.6 5.0 13.2 10.2 0 9.1 18.1 17.7 2.8 62.9(2, 3, 3) 11928 9.9 7.0 6.6 2.9 7.3 4.7 4.6 0 13.1 9.8 8.9 4.5 104.2

(3, 1, 1) 8431 2.8 19.6 18.3 1.0 1.1 18.4 17.9 0 4.7 20.7 19.0 2.1 101.2(3, 1, 2) 9248 4.8 21.3 20.7 2.1 2.0 16.8 16.6 0 8.5 25.7 25.7 6.2 200.4(3, 1, 3) 6324 5.5 18.6 17.6 2.2 1.4 15.7 15.7 0 8.5 22.1 19.2 5.5 72.7(3, 2, 1) 6028 10.1 30.4 28.0 5.5 3.8 23.0 18.6 0 14.1 34.7 33.5 9.0 127.6(3, 2, 2) 6176 8.8 21.9 20.0 1.4 6.7 16.7 16.5 0 10.4 26.3 23.0 3.4 115.0(3, 2, 3) 5912 5.6 14.8 12.5 0.8 3.7 11.6 9.7 0 8.2 18.7 14.4 2.2 212.9(3, 3, 1) 4603 7.7 17.8 17.5 1.6 5.9 11.9 11.2 0 8.9 29.1 29.1 3.2 171.8(3, 3, 2) 8844 9.5 12.9 7.9 2.3 6.5 10.1 1.0 0 11.8 14.5 13.9 4.1 102.3(3, 3, 3) 9759 6.8 11.1 10.1 2.5 6.5 6.7 5.1 0 7.4 16.3 14.6 4.2 57.5

Table IV. Summary for the 50-job instances.



(1, *, *) 12381 5.6 17.4 16.4 1.7 3.7 14.4 13.8 0 7.7 20.4 19.2 3.7 86.3(2, *, *) 9732 6.5 15.4 14.2 2.1 4.4 12.7 11.5 0 8.1 18.3 16.7 4.6 73.4(3, *, *) 7258 6.9 18.7 17.0 2.2 4.2 14.5 12.5 0 9.2 23.1 21.4 4.4 129.0(*, 1, *) 9676 4.2 18.5 17.6 1.5 2.3 16.2 15.3 0 6.0 21.5 20.2 3.5 85.7(*, 2, *) 10494 6.7 19.1 17.9 2.4 3.9 15.3 14.4 0 8.5 22.8 20.8 5.3 107.6(*, 3, *) 9785 7.9 14.5 12.7 2.2 6.0 11.0 8.8 0 10.1 18.3 16.9 4.1 101.7(*, *, 1) 9189 7.1 19.1 17.4 2.6 4.4 15.4 14.1 0 9.1 23.0 21.0 5.4 104.5(*, *, 2) 10421 6.4 16.8 15.3 1.7 4.2 13.5 11.8 0 8.5 20.2 18.8 3.9 96.1(*, *, 3) 9761 5.5 15.6 14.8 1.7 3.7 12.7 11.9 0 7.4 18.7 17.6 3.4 88.0(*, *, *) 9791 6.3 17.2 15.8 2.0 4.1 13.9 12.6 0 8.3 20.6 19.1 4.2 96.2



better solutions than the local search algorithm. This is true not only when the two algorithms arerun for the same amount of time, it is even true when the local search algorithm runs for "ve timesthat amount of time. However, the hybrid algorithm further improves the quality of the solutionsobtained with the decomposition algorithm and gives the best results among the four. It showsthat using the hybrid algorithm is much more e!ective than just running either the decompositionalgorithm or the local search algorithm longer. Besides the comparison of the performance of thethree algorithms, we also have the following observations regarding the possible e!ect the threecharacteristic factors, i.e. g

1, g

2and g

3, have on the performance of the decomposition heuristic.

(i) The decomposition heuristic performs better on instances with tighter due dates. This is notdi$cult to see from results presented in Tables II and IV. Solutions obtained with the decomposi-tion heuristic deviate the least from the best solution among (1, *, *) instances; they deviate moreamong (2, *, *) instances and the most among (3, *, *) instances. The hybrid heuristic improves onthe decomposition heuristic the most with (3, *, *) instances, less with (2, *, *) instances and theleast with (1, *, *) instances. The reason for the decomposition heuristic to perform poorer withlooser due dates, we conjecture, is that in this situation, when formulating the subproblems, moreoperations at the current stage have relatively loose local due dates, which do not providesigni"cant information for generating good schedules at the current stage. With tighter due dates,the interactions between the stages are stronger in the subproblem formulation and in the controlstructure of the algorithm. Therefore, the algorithm seems to be more e$cient.

(ii) The decomposition heuristic performs better on instances with the bottleneck at thebeginning of the #exible #ow shop. This conclusion is drawn based on the same observations ofthe results with regard to the due date tightness. The explanation for this phenomenon is that inthe case of the bottleneck at the beginning of the #exible #ow shop, the order of scheduling thestages is from upstream of downstream according to the way we measure the degree of congestionat a stage. In a #exible #ow shop con"guration, all the jobs follow the same route throughout theshop. Therefore, good schedules at the upstream stages are critical since the schedules atdownstream stages are greatly a!ected, if not more or less determined, by the schedules of the jobsat the upstream stages. By scheduling "rst the bottleneck stage at the beginning of the #exible#ow shop, we put a stronger emphasis and more e!ort in getting a better schedule for this stage,which bene"ts the overall schedule.

(iii) The decomposition heuristic performs better on instances with a higher criticality of thebottleneck stage. This result is anticipated when considering the structure of the decompositionmethod. When there are certain stages that are clearly more congested than others, the quality ofthe schedule for the entire #exible #ow shop depends more heavily on good schedules at thesecritical stages. These critical stages should therefore be analysed with more care. This is exactlywhat the decomposition method does and it explains its superiority on these kind of instances.

We are also interested in scenarios with perfectly balanced stages, that is, each stage has thesame number of machines and the total workload is also the same. It means that all the stages areevenly loaded and no stage in particular is a bottleneck. Our conjecture is that in this case theorder in which the stages are scheduled plays a role in the performance of the decompositionheuristic. We apply the decomposition heuristic using three di!erent orderings in scheduling thestages, namely, starting at stage 1 and going towards stage s, starting at stage s and going towardsstage 1, and starting at the middle stage and going towards the two ends of the shop. We generateinstances with three g

1values, 1.1, 1.3 and 1.5, and three di!erent number of stages, 5, 9 and 13.

For each combination of the two factors, we generate "ve instances. We therefore have a total of



Table V. Summary for the 45 instances of balanced #exible #ow shop.

From beginning From middle From end

Factors Average +jwj¹

jTime(s) Average +

jwj¹

jTime(s) Average +

jwj¹

jTime(s)

Overall 520 19 534 12 547 9g1"1.1 1020 22 1057 15 1059 12

g1"1.3 403 20 398 12 420 9

g1"1.5 138 14 147 9 161 8

s"5 755 5 799 5 784 4s"9 519 18 525 12 549 10s"13 334 36 321 21 354 16

45 instances with 20 jobs. A summary of the results is presented in Table V. The numbers in eachrow are the average values taken over 15 instances with the given value of g

1or s.

We see from the table that, if everything else remains the same, solving the subproblems ina particular order does make a di!erence. We see that scheduling the stages starting at thebeginning yields better solutions than starting in the middle, while scheduling the stages startingin the middle yields better solutions than starting at the end. This observation is consistent withthe conclusion that we drew earlier with regard to the fact that the decomposition heuristicperforms better when the bottleneck is at the beginning, because in this case we are dealing withthe stages from upstream to downstream. However, there is a big di!erence in computation time.We see that starting at the end is about twice as fast as starting at the beginning, and starting inthe middle is somewhere in between. These results are not surprising: recall that in the formula-tion of each subproblem we need to compute the local release date and the local due dates foreach operation; these correspond to the longest path calculations in the corresponding directedgraph. Each operation has n local due dates while only one local release date. Scheduling from theend implies that the downstream stages are rescheduled more often than the upstream stages,which saves time in the computation of the local due dates. As was observed in Reference [2], thelongest path calculations are a major computational burden for this kind of heuristic.

7. DISCUSSION

In this paper, we have discussed three heuristics for solving the #exible #ow shop total weightedtardiness problem. The decomposition heuristic solves the #exible #ow shop problem by solvinga series of single stage subproblems which interact with one another through the subproblemformulation and the control structure of the algorithm. The local search heuristic improves overan initial schedule by adjusting the assignment of the jobs at each stage and by manipulating thecritical arcs in the corresponding disjunctive graphs. The hybrid heuristic has been designed asa combination of the "rst two heuristics and, as expected, outperforms each one of the "rst twoheuristics; it is able to drive the search into a new region by moving into another neighbourhoodwhen the local optimum in one neighbourhood has been reached. In fact, in this particular case,since the machine loading phase of the local search heuristic is accomplished by the routine usedin the subproblem solution of the decomposition heuristic, the hybrid heuristic can also be seen asa version of the local search heuristic with the only di!erence being that the former has a more



sophisticated initial solution, i.e. the schedule given by the decomposition algorithm. So thesuperiority of the hybrid heuristic over the basic version of the local search heuristic can be seenas an indication of the importance of a good initial solution for the quality of a local searchmethod in general. Several extensions of the model appear to be interesting. We are interested inthe one with machine eligibility constraints at each one of the stages. In this situation, a job canonly be processed by a machine that belongs to a certain subset of the machines at a stage. We arealso interested in the generalization with setup times in between two successive jobs on the samemachine.

ACKNOWLEDGEMENT

The research of the second author has been partially supported by DAAD (HSP II).

REFERENCES

1. Balas E. Machine sequencing via disjunctive graphs: an implicit enumeration algorithm. Operations Research 1969;17:941}957.

2. Adams J, Balas E, Zawack D. The shifting bottleneck procedure for job shop scheduling. Management Science 1988;34(3):391}401.

3. Singer M. Private Communication, 1996.4. Vepsalainen A, Morton TE. Priority rules and lead time estimation f/r&J/b&shop scheduling with weighted tardiness

costs. Management Science 1987; 33:1036}1047.5. Lee YH, Pinedo M. Scheduling jobs on parallel machines with sequence-dependent setup times. European Journal of

Operational Research 1997; 100:464}474.6. Metropolis N, Rosenbluth A, Rosenbluth M, Teller A, Teller M. Equation of state calculations for fast computing

machines. Journal of Chemical Physics 1953; 21:1087}1092.7. van Laarhoven PJM. Theoretical and computational aspects of simulated annealing. Ph.D. ¹hesis, Erasmuy

University, Rotterdam, 1988.8. Balas E. Private Communication, 1997.9. Ovacik I, Uzsoy R. Decomposition Methods for Complex Factory Scheduling Problems. Kluwer Academic Publishers:

Dordrecht, 1997.10. Martin O, Otto SW, Felten EW. Large step Markov Chains for the TSP incorporating Local Search Heuristics.

Operations Research ¸etters 1992; 11:219}224.11. Lourenco HR. Job shop scheduling: computational study of local search and large step optimization methods.

European Journal of Operational Research 1995; 83:347}364.12. van Laarhoven PJM, Aarts EHL, Lenstra JK. Job shop scheduling by simulated annealing. Operations Research 1992;

40(1):113}125.13. Vaessens RJM, Aarts EHL, Lenstra JK. Job shop scheduling by local search. IN-FORMS Journal of Computing 1996;

8(3):302}317.14. Dell'Amico M, Trubian M. Applying tabu search to the job shop scheduling problem. Annals of Operations Research

1993; 41:231}252.15. Nowicki E, Smutnicki C. A fast taboo search algorithm for the job shop problem. Management Science 1996;

42(6):797}813.16. Matsuo H, Suh CJ, Sullivan RS. A controlled search simulated annealing method for the general jobshop scheduling

problem. Annals of Operations Research 1998; 21:85}108.17. Balas E, Vazacopoulos A. Guided local search with shifting bottleneck for job shop scheduling. Management Science

1995; 44(2):262}275.18. Glover F, Taillard E, Werra D. A user's guide to tabu search. Annals of Operations Research 1993; 41:3}28.19. Hutchison J, Leong K, Snyder D, Ward P. Scheduling approaches for random job shop #exible manufacturing

systems. International Journal of Production Research 1991; 29(5):1053}1067.20. Pinedo M. Scheduling: ¹heory, Algorithms and Applications. Prentice-Hall: Englewood Cli!s, NJ, 1995.21. Pinedo M, Singer M. A shifting bottleneck heuristic for minimizing the total weighted tardiness in a job shop. Naval

Research ¸ogistics 1999; 46(1):1}17.22. Schutten JMJ, Leussink RAM. Parallel machine scheduling with release dates, due dates and family setup times.

International Journal of Production Economics 1996; 46:119}125.



Documents

Heuristics for minimizing total weighted tardiness in flexible flow shops