Metaheuristics for scheduling jobs with

Journal of the Operational Research Society (2011) 62, 2083–2096

© 2011 Operational Research Society Ltd. All rights reserved. 0160-5682/11 www.palgrave-journals.com/jors/

Metaheuristics for scheduling jobs with incompatible families on parallel batching machines 1

2*

C Almeder and L Mo¨nch 1

2

Vienna University of Economics and Business, Vienna, Austria; and University of Hagen, Hagen, Germany In this paper, we discuss the scheduling of jobs with incompatible families on parallel batching machines. The performance measure is total weighted tardiness. This research is motivated by a scheduling problem found in the diffusion and oxidation areas of semiconductor wafer fabrication where the machines can be modelled as parallel batch processors. Given that this scheduling problem is NP-hard, we suggest an ant colony optimization (ACO) and a variable neighbourhood search (VNS) approach. Both metaheuristics are hybridized with a decomposition heuristic and a local search scheme. We compare the performance of the two algorithms with that of a genetic algorithm (GA) based on extensive computational experiments. The VNS approach outperforms the ACO and GA approach with respect to time and solution quality. Journal of the Operational Research Society (2011) 62, 2083–2096. doi:10.1057/jors.2010.186 Published online 29 December 2010 Keywords: batching; scheduling; ant colony optimization; variable neighbourhood search; total weighted tardiness

1. Introduction Semiconductor wafer fabrication facilities (wafer fabs) contain hundreds of very expensive machines. The different products have routes with hundreds of processing steps. The overall complexity is increased by re-entrant product flows, sequence dependent setups, a diverse product mix, and batch processing machines (cf. Uzsoy et al, 1994). Batch processing machines, for short batching machines, allow for processing several jobs together simultaneously. It is hard to meet customer due dates and ensure a good on-time delivery performance in manufacturing environments with these characteristics. We focus on diffusion and oxidation operations which are performed on batching machines. Effective scheduling of these operations is important because some batch processing steps in the semiconductor industry have extremely long processing times (up to 12 h) compared to other operations (1–2 h) (cf Mehta and Uzsoy, 1998). While several jobs can be processed at the same time, jobs of different families cannot be processed together due to the chemical nature of the process. Depending on customer Correspondence: L Mo¨nch, Department of Mathematics and Computer Science, University of Hagen, Hagen 58097, Germany. E-mail: [email protected]

requirements, some jobs have a higher importance, that is, weights, than others and products need to meet internal/ external due dates. External due dates refer to the point of time where a customer expects to get the product that is associated with the job, whereas internal due dates are related to the completion of certain operations of a job. In this research, diffusion and oxidation machines are modelled as parallel batching machines with incompatible job families. The performance measure to be minimized is Total Weighted Tardiness (TWT). The tardiness of job j is defined as Tj ¼ max(0, Cjdj), where Cj is the completion time and dj is thePdue date of job j. The TWT measure is given by TWT ¼ wjTj, where we denote by wj the weight of job j. The problem is an extension of the single machine problem with TWT measure which is NP-hard (cf Lawler, 1977). We propose two metaheuristic approaches that provide better results in a shorter period of time as the genetic algorithm suggested by Balasubramanian et al (2004). The first metaheuristic is an ant colony optimization (ACO) type approach, the second one is a variable neighbourhood search (VNS) algorithm. Both metaheuristics are used to solve hard problems from combinatorial optimization. However, only some preliminary results for batching problems are known from the literature for ACO

2084

Journal of the Operational Research Society Vol. 62, No. 12

(cf. Srinivasa Raghavan and Venkataramana, 2006, Li et al, 2008, Venkataramana and Srinivasa Raghavan, 2010). To the best of our knowledge there is no literature on VNS applied to batching problems except our preliminary results in Almeder and Mo¨nch (2009). The contribution of this work is twofold: K

K

We develop an ACO and a VNS algorithm for the scheduling problem of jobs with incompatible families on parallel batching machines. We provide an extensive numerical study comparing the proposed methods with a suitable list scheduling heuristic and a GA described in the literature demonstrating the advantage of ACO and VNS. Furthermore, a comparison with optimal solutions obtained by mixed-integer programming (MIP) verifies that the new heuristics are able to deliver optimal solutions for small instances.

The paper is organized as follows. We describe the problem and assumptions in Section 2. In Section 3, we discuss previously done research involving the scheduling of batching machines. In Section 4, we explain the proposed ACO algorithm, the details of the decomposition heuristic, and the local search scheme used within this study. The suggested VNS scheme is also presented in Section 4. We describe experiments and computational results in Section 5. Finally, Section 6 contains our conclusions and future research directions.

2. Problem description Throughout the rest of the paper we use the a|b|g notation for the classification of scheduling problems introduced by Graham et al (1979). The a field describes the machine environment and the b field specifies the process restrictions. Finally, the g field denotes the used performance measure. Using the a|b|g notation the problem can be represented as Pm jbatch; incompatiblejTWT:

ð1Þ

We have m machines in parallel. The important process restriction is batching of the jobs with incompatible families. The performance measure is TWT. The assumptions of this research are as follows: 1. 2. 3. 4.

Jobs of the same family have the same processing times. All jobs are available at time zero. All parallel batch processing machines are identical. No preemption is allowed, once a batch processing machine is started, it cannot be interrupted.

Note that all jobs are available at time zero, and each job has a specific due date and weight. The assumption of zero release times is reasonable in situations where the batching

operations form a bottleneck step and a large number of jobs are queuing in front of the batching machines. This happens quite often due to dynamic bottlenecks in wafer fabs. Three different decisions have to be made. In a first step, batches of size B or less (if there are less than B jobs available) are formed. The formed batches have to be assigned to the parallel machines. Finally, the batches have to be sequenced on each machine. It would be desirable to take these three decisions simultaneously because they are highly dependent. However, because of the NP-hardness of the scheduling problem, we adopt a decomposition approach that treats the three decision phases in an independent manner. A description of the problem as MIP can be found in the Appendix. Note that using a standard MIP-solver for problems with 30 jobs is not possible using our MIP formulation, especially within tight time constraints as they usually occur for such short-term planning tasks. We will use that MIP formulation to compare optimum solutions of smallsized instances with the results of our proposed algorithms.

3. Related literature Batching problems are considered by many researchers because of their real-world relevance. We refer to the survey papers by Brucker et al (1998) and by Potts and Kovalyov (2000). A survey of batching models in semiconductor manufacturing is provided by Mathirajan and Sivakumar (2006). The reference most closely related with the scheduling problem being researched herein is Balasubramanian et al (2004). Two different heuristics based on GAs are suggested in this paper. The first heuristic forms batches based on the Apparent Tardiness Cost (ATC) dispatching rule. Then a GA is used to assign these batches to the machines and sequence them. Jobs are assigned via a GA to the machines in the case of the second one. We will use the first heuristic within this paper for comparison purposes because it clearly outperforms the second heuristic. The GA type approaches are further improved by a decomposition heuristic and local search (cf the description in Section 4.2). Heuristics based on local search are not very common for batch scheduling problems in semiconductor manufacturing. Only three papers deal with such problems. Yugma et al (2008) suggested a simulated annealing scheme for a real-world batch scheduling problem based on a disjunctive graph formulation. Tabu-search techniques are applied to a batch scheduling problem that can be found in semiconductor backend facilities are discussed by Chandra et al (2008). A similar problem is solved using simulated annealing by Mathirajan et al (2004). ACO has been applied to different scheduling problems. Bauer et al (2000) developed first an ACO algorithm for

C Almeder and L Mo¨nch—Metaheuristics for scheduling jobs

the single machine total tardiness problem. den Besten et al (2000) and Merkle and Middendorf (2003) applied ACO to the problem 1||TWT. A fast ACO approach for the same problem was suggested by Holthaus and Rajendran (2005). Liao and Juan (2007) use an ACO approach to solve the scheduling problem 1|skj|TWT where skj indicates sequence-dependent setup times. ACO type approaches were also suggested for scheduling problems related to parallel machines. Here, usually the assignment and the sequencing decisions are represented by pheromone trails. Srinivasa Raghavan and Venkataramana (2009) studied the problem Pm||TWT using ACO. Zhou et al (2007) and Mo¨nch (2008) suggested different ACO type approaches for the unrelated parallel machine scheduling problem Rm||TWT. Arnaout et al (2008) applied an ACO type decomposition scheme to Pm jskj jCmax where the notation Cmax is used for the makespan. Ying and Lin (2006) solved flow shop scheduling problems by using ACO type approaches for a makespan objective. A flow shop scheduling problem may be considered as a sequence of parallel machine scheduling problems. Finally, Song et al (2007) implemented an ACO approach to schedule jobs on the bottleneck tool group in one of the Intel semiconductor wafer fabrication facilities using a combined objective function and multiple consecutive periods of time. There are also some papers that discuss the application of ant-based approaches to the solution of job shop scheduling problems like for Jm||Cmax (cf Huang and Liao, 2008). So far only some preliminary work related to batch scheduling is described in the literature. Srinivasa Raghavan and Venkataramana (2006) and Venkataramana and Srinivasa Raghavan (2010) applied an ACO type approach to problem (1). They used an ATC type approach to form batches. An ACO type approach is used to assign batches to machines. The obtained solution quality in (Srinivasa Raghavan and Venkataramana, 2006) is less than those of the GA reported by Balasubramanian et al (2004). Li et al (2008) considered the scheduling problem Pm|skj,rj,incompatible,batch|TWT where rj denotes the ready time of job j. They form batches using the time window technique suggested by Mo¨nch et al (2005). Then an ant system is used to assign the batches to machines and sequence them. However, only a few computational results are available. Kashan and Karimi (2008) suggested ant systems P for the scheduling problem 1|batch,incompatible| wjCj. Some preliminary computational results related to our ACO approach and related to a MAX-MIN ant system approach for problem (1) are presented in Mo¨nch and Almeder (2009). However, we extend this presentation considerably by suggesting the VNS scheme that outperforms our ACO approach and by providing a much more detailed computational assessment of the ACO scheme. VNS is a metaheuristic method proposed by Mladenovic´ and Hansen (1997). It is based on a local search algorithm

2085

extended by mechanisms that allow escaping from local optima. There are some articles on VNS applied to single machine (cf Liao and Cheng, 2007; Wang and Tang 2009) and parallel machine scheduling problems (cf Anghinolfi and Paolucci, 2007; Rocha et al, 2007). Furthermore, the Jm||Cmax job shop scheduling problem is tackled by Sevkli and Aydin (2006) using a VNS-like approach, and Ribeiro et al (2008) present a VNS for the car-sequencing problem. The main contribution of this paper can be summarized as follows. To the best of our knowledge, there is no work on VNS applied to batch scheduling problems except some preliminary computational results that we reported in Almeder and Mo¨nch (2009). With respect to ACO, we use a different representation compared to Srinivasa Raghavan and Venkataramana (2006) and Venkataramana and Srinivasa Raghavan (2010) that offer the advantage to include batch formation, assignment, and sequencing. Furthermore, no comparison study for ACO, VNS, and for GAs for batch scheduling problems is available in the literature.

4. Heuristic solution approaches In this section, we start by introducing some notation. Then we summarize very briefly the main ideas of a list scheduling approach to solve problem (1). We continue with the description of the two proposed metaheuristics in Subsection 4.2 and Subsection 4.3, respectively.

4.1. Notation We use the following notation throughout the rest of the paper: f n m ns wjs djs ps B

Bks Cjs wjsTjs

number of incompatible job families total number of jobs waiting to be scheduled number of identical parallel machines number of jobs of family s to be scheduled: Pf n ¼ n s¼1 s priority weight for job j of family s due date of job j of family s processing time of jobs of family s capacity of the batch processing machine, that is, B jobs can be processed simultaneously. We call B the maximum batch size. batch k of family s completion time of job j of family s the weighted tardiness of job j of family s, wjsTjs: ¼ wjs(Cjsdjs) þ . Here we use the notation x þ : ¼ max(x, 0).

4.2. ATC-BATC-type heuristics We start by describing a simple list-based scheduling approach. Every time a machine becomes free, one batch

2086


from each family is formed, and one of all the formed batches is selected to be scheduled next. The number of batches will be equal to the number of families that contain unscheduled jobs. The batch is chosen based on the ATC dispatching rule. This heuristic is simple but it is known to give reasonable solutions within seconds (cf Balasubramanian et al 2004). The ATC index Ijs for a job j belonging to family s calculated at time t is given below: þ ! djs ps t wjs : exp Ijs ðtÞ :¼ ps k p

ð2Þ

Here, we use the following notations: t p k

time at which the machine becomes free average processing time of the remaining jobs scaling parameter.

The jobs in each family are ordered in decreasing order of their ATC indices, and a batch of the first B jobs is formed per family. In order to schedule one of these batches the Batched Apparent Tardiness Cost (BATC) rule is used. At time t, for all the batches the following index is calculated: X Ijs ðtÞ; ð3Þ IBATC ðk; s; tÞ :¼ j2Bks

where IBATC(k,s,t) is the BATC index for batch k of family s at time t. The batch with the highest BATC index is scheduled. Thus, BATC is a sequencing rule for batches that have been formed. We call the heuristic that forms batches using ATC and sequence the batches by BATC in the remainder of this paper ATC-BATC-H. It is known that ATC type rules lead to small TWT values when the scaling parameters are set appropriately (Vepsalainen and Morton, 1987; Balasubramanian et al, 2004). In this research, we use a grid search approach, that is, we consider all kA{0.5, 1.0, . . . , 5.0}, fix one of these values, solve (1) using ATC-BATC-H and take finally the value of k that leads to the smallest TWT value for the given instance. Furthermore, we will use a decomposition heuristic to improve the schedules obtained from ATC-BATC-H. This approach is used for single machine batch sequencing only and is similar to the one described in Mehta and Uzsoy (1998). From an initial sequence obtained by ATCBATC-H a sub-sequence of size l is solved to an optimal sequence using complete enumeration. We have to consider l! different sub-sequences. The first a batches of this optimal sub-sequence are fixed into the final sequence, and the next l unscheduled batches are considered. This process is repeated until all jobs are scheduled and no improvement is made in the TWT value of the final sequence. At maximum iter iterations are allowed. The larger the value of l, the higher the computation time and

the better the solution quality. We call the heuristic based on the decomposition heuristic DH(l,a,iter). To improve upon the solution obtained by ATC-BATC-H and DH, a corrective stage where the composition of batches is changed is included. After we get a complete solution of batches sequenced on all the machines, we attempt to improve the solution through the swapping techniques suggested by Devpura et al (2000) for a single machine and extended by Balasubramanian et al (2004) to the case of parallel machines. The swapping algorithm is implemented as follows. We keep the position of the batches fixed and try to interchange jobs between batches of the same family. Initially for each family we consider the batch with the earliest start time. Considering all jobs in the batch starting from first to last, we look for the possibility of a swap with jobs in other compatible batches with start times later in the order of non-decreasing start times by calculating the TWT value of the old and the new schedule. Whenever a swap occurs we go back to the first job of the batch and start over. When there are no more improvements in this batch we move on to the next batch and check if we can swap the jobs in it with jobs in batches scheduled after it. The procedure is continued till all the batches of all the families are covered. We denote the swap procedure in the remainder of this paper by Swap. Note that in Balasubramanian et al (2004) batches are formed by using ATC-BATC-H. These batches are assigned to the machines via a GA. DH and Swap are used to improve the schedules. The schedules obtained by using these algorithms lead to the smallest TWT among all the tested heuristics. Therefore, we use this heuristic as a reference heuristic within this research. This approach is called ATC-GA1a-DH þ swap in Balasubramanian et al (2004). In this paper, we call it only GA for abbreviation.

4.3. ACO approach ACO is a population-based metaheuristic designed to solve combinatorial optimization problems. For more details on ACO and its variants the reader is referred to Dorigo and Stu¨tzle (2004). We start by describing the underlying principles of batch formation and assignment used within the ACO algorithm. We represent the scheduling problem (1) as a pure sequencing problem. We use a permutation p :¼ ðp½1; . . . ; p½nÞ

ð4Þ

of all jobs as a representation for the scheduling problem (1). Subsequent jobs (at maximum B jobs) of the same family form a batch. A final schedule for the batches can be obtained by assigning one batch after another to the next available machine starting with the first batch in (4). We construct a permutation by adding the jobs of a newly formed and chosen batch to the end of the partial sequence starting from an empty sequence.


In order to form batches we consider an ordering of the jobs for each family s that are not included in the partial sequence of representation (4): pts :¼ ps ½1; . . . ; ps ½ns; curr ; ð5Þ where ps[i] denotes the job of family s that is sequenced on position i in pts and the notation ns,curr is used for the number of jobs that are not already part of the partial schedule that corresponds to (4). We determine pts by sorting the jobs in non-increasing order with respect to a specific index. When we describe a single iteration of our ACO scheme, we will see that we use the ACO specific index defined by expression (8). The time t denotes the time when the newly formed batch can start with processing. It is obtained by translating the partial sequence (4) into a partial solution of the scheduling problem (1) and determining the time when the next machine is available. Starting from pts, we obtain a sequence of batches by considering sub-sequences of the form: Bws :¼ ðps ½wB þ 1; ps ½wB þ 2; . . . ; ps ½ðw þ 1ÞBÞ;

ð6Þ

where wA{0, . . . Jns,curr/Bn}. Note that only the last batch formed in this way may have less than B jobs. The batches of a family are sequenced in non-increasing order of importance, where each batch is evaluated by taking the sum of the indices that lead to pts for all jobs of the batch. The used measure is described in expression (11), but for now its concrete form is not important. We select the most important batch among the B0s, s ¼ 1, . . . , f and add it to the partial sequence to construct the job permutation (4).

Figure 1 describes the process of batch formation and building the permutation (4). The necessary steps to obtain a solution for (1) are: 1. Start with current time t ¼ 0. 2. Form and order of batches of the same family for all unscheduled jobs for starting time t. 3. Select a batch and add it to the end of the partial sequence (4). 4. Obtain new starting time t of next batch by interpreting the partial sequence (4) as a solution of problem (1). 5. If there are still unscheduled jobs, continue with Step 2, otherwise stop. Based on this procedure, it is enough to describe a heuristic to find job permutations that lead to small values of TWT. We use an ACO-type approach to tackle this problem. The main idea of ACO is to let several agents (ants) construct solutions of the given problem. This solution construction is guided by some memory (pheromone) reflecting the solutions of previous iterations and using also heuristic information about the problem. While constructing the solution ants provide information in those pheromone values to guide the search of the other ants (so-called local pheromone update). The best ant updates the pheromone information to guide other ants of the next iteration (so-called global pheromone update) after each iteration. In most applications of ACO the solutions generated by the ants are improved by applying a local search procedure. The

1. Determine next availability time.

2. Batch selection by ant batches for each family family C best batch for family C

... family B

4. Add batch to schedule and update availability times.

2087

best batch for family B

... family A

best batch for family A

...

solution representation for ACO

3. Append jobs of the selected batch to partial job sequence.

Figure 1 Representation for ACO.

2088


overall scheme of an ACO algorithm (cf. den Besten et al, 2000) is given in pseudocode notation: (1) Set parameters (2) Initialize pheromone trails (3) Repeat until termination condition is met (a) Construct solution, perform step-bystep pheromone update (b) (Optional) Apply local search (c) Update pheromone trails globally.

Initialize Algorithm

In the remainder of this section, we describe the tailoring of the steps of the general ACO scheme to solve problem (1). We denote by Zij the heuristic information of the desirability for setting p[i]: ¼ j. The Zij values are typically derived by using appropriate problem specific dispatching rules. In this research, we use the ATC dispatching rule with priority index (2) where t is the time when the next machine gets available. We denote by tij (liter) the pheromone intensity that is associated with the setting p[i ]:¼ j, that is, job j is placed on position i in p. The parameter liter is used for the current iteration of the ACO scheme. The maximum number of ants used within one iteration is denoted by na max. The construction of a solution of an ant within one iteration of the ACO scheme works as follows. 1. Denote the set of jobs that are not used to construct p by JU. Initialize the set with JU:¼ {1, . . . , n}. We denote by JUs the following set: JUs :¼ fj 2 JU jj is part of family sg:

ð7Þ

Sequence the jobs j in JsU in non-increasing order with respect to the index ! i X tlj ðliter Þ Zbij ð8Þ Iij ðliter Þ :¼ l¼1

to obtain

pts.

2. Create a sample of a U[0,1] distributed random variable. Denote the obtained value by q0. We assume that we have ns,curr40 jobs in JUs. Let Bs,curr :¼ min(B, ns,curr). When q0pq then the ps[1], . . . , ps[Bs,curr] jobs that maximize the value of Fsi :¼

1

BX s;curr

Bs; curr

g¼1

Iiþg1;ps ½g ðliter Þ

ð9Þ

over all families s are set into the current partial sequence on position i, . . . , i þ Bs,curr1. A similar pheromone summation rule is suggested by Merkle and Middendorf (2000) for the scheduling problem 1||TWT. Using the sum of pheromone values of job j up to position i offers the advantage that the selection of jobs j that are chosen by previous ants for positions smaller than i will be enforced. The quantity b40 is a parameter of the ACO scheme that

is related to the importance of the desirability. Here, qA[0,1] is a fixed number that is a parameter of the ACO algorithm. Usually, q is selected close to 1, that is, a large portion of the new ants will find the next jobs to be scheduled with respect to the pheromone trail information and the heuristic information. Hence, the ant makes the best decision with a probability of q as indicated by the heuristic information and the pheromone trails. If q04q then job jAJUs is selected for position i according to the following discrete distribution with the probabilities pij given by 8 Pi tlj ðliter Þ Zbij < P l¼1 Pi when j 2 JUs tlr ðliter Þ Zbir ð10Þ pij :¼ s l¼1 : r2JU 0 otherwise: For each family, we select a job j according to this discrete probability distribution. We form the batch including this job and the next Bs,curr1 jobs from pts. Note that we choose only the first job of the batch according to the discrete probability distribution (10) because we are not interested in completely destroying the structure of batches formed by ATC type rules. We evaluate the batches for all families according to expression Fsij :¼

1

BX s; curr

Bs; curr

g¼1

Iiþg1; ps ½p1 ½jþg1 ðliter Þ s

ð11Þ

and consider the batch with the largest value Fsij. Hence, the ant performs a biased exploration with a probability of 1q. Note that p1 s [ j] is the position of job j in the family based ordering (5). 3. A local step-by-step update of the pheromone trail is performed immediately after an ant has added all jobs of a batch to the partial sequence by tij ðliter Þ :¼ ð1 yÞtij ðliter Þ þ yt0 ;

ð12Þ

where yA(0,1] and t040 are parameters of the ACO scheme. The local update is necessary to make the decision to put job j on position i less desirable for consecutive ants. The exploration of different sequences is enforced by performing the step-by-step update. 4. Remove all jobs added to the partial solution in the previous step from JU. When JUa+ repeat Step 2. When JU ¼ + then improve the schedule by applying DH and Swap. Note that those improvement heuristics work on the final schedule. Therefore changes performed by those heuristics have to be duplicated in the representation (4). After all ants of an iteration have constructed a solution, the pheromone values are updated. When job j is scheduled on position i in the global best solution at iteration liter then we update the global pheromone trail by the following expression: tij ðliter þ 1Þ :¼ ð1 rÞtij ðliter Þ þ r=TWT ;

ð13Þ


where rA(0,1] is a parameter of the ACO approach that is used to model the pheromone evaporation. TWT is the smallest TWT value obtained so far by an ant for the scheduling problem (1). We summarize the tailored ACO scheme in the following pseudocode: Initialize

Algorithm

(1) Set q, r, y, b, namax. (2) For k ¼ 0.5 to 5 with steps 0.5 do use ATC-BATC-H to find the best TWT value, called TWTbest. Set t0: ¼ 1/TWTbest. (3) Repeat until termination condition is met (a) Construct solution based on ATCBATC-H as heuristic information, perform step-by-step pheromone update using expression (12). (b) Apply DH(5,2,15) and Swap. (c) When the maximum number of ants per iteration is reached then update the trails based on expression (13).

Note that we perform also some additional experimentation with a pure ant system (AS) and a MAX-MIN AS (cf. Mo¨nch and Almeder, 2009 for details on MAX-MIN AS). Here, we set basically q ¼ 0 and avoid any local update of the pheromone trails. In this preliminary experimentation, we were able to obtain the same solution quality as with our ACO approach. But much more time was required for computation. Since the time needed for computation is one of the comparison criterions among the metaheuristics in this research we do not look into more detail to other antbased metaheuristics.

4.4. Variable neighbourhood search VNS is a local-search-based metaheuristic (cf Mladenovic´ and Hansen, 1997; Hansen and Mladenovic´, 2001). The main idea is to enrich a simple local search method in order to enable it escaping from local optima. This is done by restarting the local search from a randomly chosen neighbour of the incumbent solution. This restarting step (so-called shaking) is performed using different neighbourhoods of increasing sizes. There are many different variations of VNS, such as variable neighbourhood descent (VND) or reduced variable neighbourhood search (RVNS). Our approach will be based on the basic VNS given in pseudocode notation as follows: Initialize

Algorithm

(1) (2) (3) (4)

Define K different neighbourhoods Nk. Generate an initial solution x. Set k’1. Repeat until stopping criterion is met (a) Shaking: choose randomly x’’ANk(x). (b) Local search: Improve x’ by a local search method.

2089

(c) Accept? If x’ is better than x, then x’x’ and k’1 otherwise k’(k mod K) þ 1. The VNS algorithm designed for the batching problem operates on the final solution representation, that is, each job is assigned to a batch and each batch is assigned to a certain position on that machine. The proposed local search method used for the VNS consists of three different steps. The first step is balancing the workload of the machines. If the last batch of the machine with the maximum completion time starts later than the completion time of the machine with the smallest workload, the batch is moved to that machine. This step is repeated until no batch can be moved. We will denote this improvement step with Balancing. The second step is the application of DH as used for the ACO scheme (see Sections 4.2 and 4.2). For each machine the batch sequence is improved by DH(l,a,iter), that is, taking a subsequence of l batches, determine the optimal sequence using complete enumeration and fix the first a batches and continuing with the next l batches. The third and last step concerns the jobs itself. We apply the swapping technique as proposed by Balasubramanian et al (2004), that is, exchanging jobs of different batches of the same family, if the weighted tardiness can be improved. This swapping is performed until all jobs are tested (cf the more detailed description in Section 4.2). Steps two and three of the local search method described above are improving the batch sequence on each machine separately and the assignment of jobs to batches. Therefore the design of the neighbourhood structure for the shaking step of the VNS considers only manipulations of whole batches (across different machines). We define four classes of neighbourhoods: swapBatch(n)

swapSeq(n)

moveBatch(n)

moveSeq(n)

Select randomly two batches from different machines and exchange their positions. Repeat this step n times. Randomly select two positions on different machines and exchange the batch sequences starting from that position of at most length n (n or all remaining batches). Select randomly a batch from a machine and remove it. Insert it on a random position on a randomly selected machine. Repeat this step n times. Randomly select a position on a machine. Remove a sequence of at most n (n or all remaining batches) and insert either this partial sequence or the reversed one on another machine at a randomly selected position.

2090


Table 1 Performance of different single and combined neighbourhood structures Single neighborhood moveBatch moveSeq swapBatch swapSeq

8.65% 8.45% 8.74% 8.80%

Combined neighborhoods mB-mS-sB-sS sB-sS-mB-mS mixed (swap-move) mixed (move-swap)

8.71% 8.79% 8.75% 8.83%

Table 2 Neighbourhood structure sB-sS-mB-mS used for the VNS Number of neighbourhood (k)

Method used

k=1, . . . , 5 k=6, . . . , 10 k=11, . . . , 15 k=16, . . . , 20

swapBatch(3(k1) þ 1) swapSeq(3(k5)) moveBatch(3(k11) þ 1) moveSeq(3(k15))

The average improvement compared to ATC-BATC –H after 5 s runtime for 48 small instances is given.

Note, that the two move operations lead to an imbalanced workload on the machines. Neither the DH nor the Swap algorithm is moving batches between machines. That is the reason why the local search method starts with the Balancing step. A preliminary study of neighbourhood structures for such a problem can be found in Almeder and Mo¨nch (2009). We tested different combinations and sizes of the above neighbourhoods on a subset of 48 small test instances described in Sections 5.1 and 5.2 in more detail. Table 1 summarizes those tests for single neighbourhood structures considering only a single neighbourhood with increasing size and combined neighbourhood structures. mB-mS-sB-sS denotes a neighbourhood structure consisting of five increasing moveBatch, five moveSeq, five swapBatch, and five swapSeq operations. sB-sS-mB-mS orders the neighbourhoods similar, but starts with the swap operations. The other two structures consider a cycling structure of all four operations starting either with the swap or the move iterations and a strictly non-decreasing neighbourhood size. We call the two resulting neighbourhoods mixed (swap-move) and mixed (move-swap) respectively. The solution quality of all tested neighbourhood structures is very similar. The swapSeq neighbourhood— the best single neighbourhood structure—operates only very locally (only two machines are affected and only a part of the batch sequences). Therefore, this single neighbourhood structure, although it performed well for small instances, was not taken into consideration for the larger test instances. The two best combined neighbourhood structures—sB-sS-mB-mS and mixed (move-swap)— were also tested on large size instances, where the first one performed better. The complete neighbourhood structure used for the VNS is depicted in Table 2. Note that move and swap operations are different and one is not a special case of the other. So any combined neighbourhood structure containing move and swap operations is not nested. Also note that the sizes of the neighbourhoods depicted in Table 2 are not increasing, that is, when switching from N5 to N6 (as well as N10 to N11 and N15 to N16) the neighbourhood sizes decrease. Here, we denote by Nk the kth neighbourhood in Table 2. This result of non-nested and eventually decreasing

neighbourhood structures are comparable with the observations of den Besten and Stu¨tzle (2001) for VND for a single machine scheduling problem. As an initial incumbent solution we use the solution from ATC-BATC-H with applied decomposition heuristic and swap, iterated for the best kA[0.5,5] in steps of 0.5. In order to extend the VNS in such a way that it may also accept worse solutions, we have tested different acceptance strategies, such as Threshold Accepting (TA) and Simulated Annealing (SA), but none of them could improve the results. So we use the classical acceptance criteria of the VNS. The entire VNS algorithm for the problem (1) is given in pseudocode notation as follows: Initialize

Algorithm

(1) Set neighbourhoods. (2) For k ¼ 0.5 to 5 with steps 0.5 do Use ATC(k)-BATC-DH(5, 2, 15)-Swap to determine xk. Set initial solution x according to best xk. Set k according to best xk. (3) Set k’1. (4) Repeat until stopping criterion is met (a) Shaking: choose randomly x’ANk(x). (b) Balancing: balance x’. DH: apply DH(5,2,15). Swap: apply the swap algorithm. (c) Accept? If x’ is better than x, then x’x’ and k’1 otherwise k’(k mod K) þ 1.

5. Computational experiments In this section, we start with describing the design of our experiments. Then we explain how we select the various parameters of the different heuristics. We present the computational results in Subsection 5.3. Finally, we discuss the obtained results in Subsection 5.4.

5.1. Design of the experiments For testing our heuristic approaches, random problem instances are generated in a manner similar to Mehta and


Uzsoy (1998) and subsequently adapted by Balasubramanian et al (2004) to the case of parallel machines. Since we are dealing with scheduling problems that are motivated by semiconductor manufacturing, we include the number of incompatible families as an additional factor. Table 3 contains the factors used for test instance generation and their different levels. For due date generation, there are two parameters: R and T. The value of R controls the range of the due dates, while the value of T represents the approximate percentage of tardy jobs. In order to ensure comparability with the results of the paper by Balasubramanian et al (2004) the design of the previous paper is included as a subset of our test instances. In order to carry out a fair comparison of the three different metaheuristics we limit the computational time to 5, 10, 30, and 60 s. The experimentation with different maximum computing times up to 1 min is reasonable because of the following reasons. A dispatching rule-based decision-making is still dominating in real-world complex manufacturing systems like wafer fabs (cf Varadarajan and Sarin, forthcoming). Hence, a competitive scheduling approach has to be quick. When a scheduling approach is performed each time a machine becomes available in a parallel machine environment with a large number of machines like in wafer fabs, then a short time for making each scheduling decision is also required. Finally, short computing times of a scheduling approach for problem (1)

Table 3 Design of experiments Parameter Number of families f Number of jobs per family Batch size Family processing times

Weight Job due dates

Number of machines m Total parameter combinations Number of independent test instances Total

Values

Count

3,6,12 180/f; 240/f; 300/f

3 3

4,8 2 with probability of 0.2 4 with probability of 0.2 10 with probability of 0.3 16 with probability of 0.2 20 with probability of 0.1 wjBU[0,1] Tightness of schedules: TA{0.3,0.6} Due date Range RA{0.5,2.5} expected processing time E(p) makespan estimator Cˆmax:=nE(p)/(mB) m=Cˆmax(1T) dijBU[m(1R/2), m(1 þ R/2)] 3,4,5,6

2 1

1 4

2091

are also justified by the fact that parallel machine scheduling problems of the type discussed in this paper are subproblems in decomposition approaches for largescaled job shops like the shifting bottleneck heuristics (cf Mo¨nch et al, 2007). Here, a large number of such subproblems have to be solved frequently. Hence, small computing times are also desirable. It also makes sense to assign a subproblem specific maximum amount of computing time to the different subproblems. Therefore, the experimentation with a different amount of computing time is reasonable. In order to select the various parameters of the ACO scheme and the VNS, we performed experiments on a subset of the test instances generated as described in Table 3. We fix f ¼ 3 and B ¼ 4. The remaining factor levels are the same as in Table 3. This leads to a group of 48 test instances used for parameter adjustment.

5.2. Parameter settings The heuristic DH is used for both ACO and VNS. In order to compare the performance of the two new solution techniques with the GA, we simply apply the same parameter setting as in Balasubramanian et al (2004), that is, we set l ¼ 5, a ¼ 2, and iter ¼ 15. For the ACO we test different parameter settings on the above-mentioned group of 48 instances. The tested values for q are {0.1, 0.2, . . . , 0.9}. For the pheromone evaporation parameter r we test {0.01, 0.1, 0.2, 0.3}, and y is selected among {0.01, 0.1, 0.2, 0.3}. We perform experiments with {5, 10, 15, 20, 25} ants. We consider all parameter combinations and apply the corresponding ACO scheme to all 48 test instances. After extensive computational experiments we decide to select the parameters found in Table 4. Note that we found in some preliminary experiments that using 20 ants leads to a slightly better solution quality compared to ACO with five ants. But this is only true when the time for computing is not a constraint. Because of the small improvements, VNS still considerably outperforms ACO in this situation. Therefore, we run the final experiments with five ants. As described in Section 4.4, we performed some experimentation to find appropriate combinations and

Table 4 Parameters for ACO Parameter 4 288 5 1440

Number of ants na max Parameter related to q Parameter used for local update t0 Parameter used for local update y Parameter used for global update r Coefficient of the desirability b

Value 5 0.9 1/TWTbest 0.1 0.01 1.0

2092


sizes of the proposed neighbourhoods of the VNS. This experimentation is based on the 48 test instances. The results are shown in Table 1, and the used neighbourhood structure is depicted in Table 2.

5.3. Results All the tests are performed on an Intel Pentium D with 3.2 GHz CPU and 4 GB of random access memory with SUSE Linux 10 as operating system. All algorithms are implemented in C++, for the GA implementation the framework Galib (cf Wall, 2010) is used. In order to compare the results of ACO and VNS, it was necessary to adapt the implementation of the GA of Balasubramanian et al (2004) to handle also the new larger test instances with more families and machines. For 10 very small-sized instances with 16 respectively 24 jobs we are able to obtain the optimal solutions applying the MIP formulation (see Appendix) using ILOG CPLEX 11.1. For larger problems it is not possible to compute optimal solutions or feasible solutions with a similar quality as ATC-BATC-H within several hours. The ACO as well as the VNS algorithm are able to find the optimal solution for all instances within a few seconds compared to runtimes of up to 1300 s for solving the MIP. Using the GA approach, we are able to find for nine out of the 10 instances the optimal solution. For all algorithms we use only a time limit as stopping criterion. All algorithms are tested for 5, 10, 30, and 60 s runtime applied to all 1440 test instances. For each test instance and each runtime three runs with different seeds

are performed and the average values are used for comparison. Note that we also performed some experimentation with computing times of 5 min per test instance, but compared to the results obtained for 1 min computing time, we obtain only for some instances slightly better results that do not justify the much longer computing time. Table 5 summarizes the computational results in terms of TWT by reporting the average improvement compared to ATC-BATC-H (cf. Balasubramanian et al, 2004), that is, we calculate the ratio TWTðATC BATC HÞ TWTðHÞ ; TWTðATC BATC HÞ

ð14Þ

where we denote the new heuristic simply by H. The performance of the GA is slightly worse compared to the results reported by Balasubramanian et al (2004). The reasons are that, first, the complexity of the test instances has been increased significantly (more job families and more machines) and second, for all three methods the same basic implementation is used which causes some loss of performance (compared with specialized implementations for each algorithm), but allows a fair comparison of all three methods. Looking at the overall results the GA continuously improves with increasing runtime, but the ACO reaches after 30 s already a better solution quality than the GA after twice that time. Clearly the VNS is the best performing method. After 5 s runtime it reaches a better solution quality than GA and ACO after 60 s runtime. Furthermore, the results show that ACO and VNS convergence fast to a good solution and the additional

Table 5 Results of the GA, ACO, and VNS for all test instances aggregated according to different properties Class of instances

GA

ACO

VNS

Aggregation

#

5s (%)

10 s (%)

30 s (%)

60 s (%)

5s (%)

10 s (%)

30 s (%)

60 s (%)

5s (%)

10 s (%)

30 s (%)

60 s (%)

Jobs=180 Jobs=240 Jobs=300 B=4 B=8 M=3 M=4 M=5 M=6 R=0.5, T=30% R=0.5, T=60% R=2.5, T=30% R=2.5, T=60% f=3 f=6 f=12

480 480 480 720 720 360 360 360 360 360 360 360 360 480 480 480

3.12 1.36 0.05 0.20 2.62 2.87 1.97 0.90 0.47 8.97 1.57 2.21 2.96 4.49 1.31 1.34

4.99 3.22 1.47 1.79 4.53 3.98 3.56 2.92 2.73 12.65 2.40 1.02 1.65 5.75 3.26 0.69

7.00 6.31 4.44 4.77 6.94 5.58 5.90 6.10 6.35 17.97 3.75 0.68 0.75 7.42 6.09 4.26

7.34 7.18 5.90 6.11 7.39 6.12 6.73 7.14 7.50 19.47 4.23 1.29 1.75 7.93 7.03 5.49

6.55 6.64 5.83 6.23 6.33 6.31 6.47 6.43 6.37 17.26 3.35 1.41 2.81 7.41 6.83 4.79

6.87 7.07 6.27 6.65 6.70 6.64 6.89 6.83 6.82 18.31 3.56 1.53 3.03 7.77 7.25 5.20

7.19 7.52 6.82 7.08 7.16 7.02 7.32 7.26 7.35 19.41 3.81 1.68 3.30 8.20 7.73 5.63

7.37 7.74 7.12 7.31 7.39 7.22 7.56 7.49 7.61 20.00 3.96 1.76 3.41 8.43 7.95 5.87

9.11 9.13 7.94 8.24 9.11 7.90 8.62 9.16 9.48 22.37 4.87 2.47 4.30 9.24 9.27 7.70

9.42 9.51 8.36 8.66 9.42 8.21 8.99 9.53 9.89 23.06 5.07 2.61 4.61 9.46 9.66 8.20

9.73 9.92 8.92 9.20 9.73 8.58 9.42 9.97 10.35 23.88 5.33 2.82 5.08 9.69 10.10 8.81

9.85 10.10 9.20 9.45 9.87 8.74 9.61 10.18 10.56 24.28 5.46 2.91 5.32 9.77 10.30 9.10

1440

1.34

3.10

5.79

6.78

6.21

6.61

7.05

7.28

8.61

8.97

9.40

9.59

Overall

The numbers given are the average improvement compared to the ATC-BATC rule.


solution quality gained by extending the runtime is small. For both methods the difference between solutions obtained after 5 and 60 s runtime is less than 1%. Looking at the detailed results for different number of jobs, respectively different number of families, it seems that the performance of the GA drops significantly if the problem gets more complex (more jobs, or more families). ACO and VNS show this performance difference only for short runtimes of 5 or 10 s, but those differences level out for longer runtimes except using the ACO for 12 job families. So it seems that an increasing number of job families make the problem more difficult. But obviously the due dates (parameters R and T ) have the greatest impact on the solution quality. For test instances with a small range of the due dates (R ¼ 0.5) together with a low number of tardy jobs (T ¼ 30%) the ATC-BATC-H solution can be improved by more than 20%. If the range of the due dates is large (R ¼ 2.5) or the number of tardy jobs is high (T ¼ 60%) the average improvement of all three methods is significantly less, but still the ordering GA 4 ACO 4 VNS with respect to solution quality is the same. In case of small values for R and T, ATC-BATC-H performs not so well because the due dates are wide in this situation and hence the second term in expression (2) is close to 0. Hence the ATC values are all similar for most jobs and lead to wrong orderings. In this situation, the usage of metaheuristics offers much room for improvements. The batch size (parameter B) seems to have only a minor impact on the performance of the algorithms, as well as the number machines. But larger values for B and m lead to larger improvements. This observation is also supported by the results found in Srinivasa Raghavan and Venkataramana (2008) for B ¼ 1 where they were able to obtain only 6% of improvements compared to similar dispatching rules as in the present paper. In order to show the differences of the methods, we also applied a Wilcoxon signed-rank test (Wilcoxon, 1945) with a significance level of 1%. Table 6 shows that for each method the increase of run time improves the results significantly and that GA 4 ACO 4 VNS. Only the results of the GA running for 60 s and the ACO running for 5 s do not show a statistically significant difference. Note that although the average improvement compared to ATC-BATC-H for the GA (60 s) is larger than for the ACO (10 s), the statistical test shows that the ACO approach behaves more stable and delivers significantly better results.

5.4. Discussion Summarizing the computational results, it is obvious that the GA requires a large number of iterations to deliver good results, but even with long runtimes it depends more on different problem characteristics and increased

2093

Table 6 Results of the Wilcoxon signed-rank test with the 1% significance level GA

ACO

VNS

5 s 10 s 30 s 60 s 5 s 10 s 30 s 60 s 5 s 10 s 30 s 60 s GA 5s 10 s 30 s 60 s ACO 5s 10 s 30 s 60 s

4

4 4

4 4 4 4 4 4 4 4 4 = 4

4 4 4 4

4 4 4 4

4 4 4 4

4 4 4 4

4 4 4 4

4

4 4

4 4 4 4 4 4 4 4 4 4 4

4 4 4 4

4 4 4 4

4

4 4

4 4 4

VNS 5s 10 s 30 s 60 s

4 4 4 4

‘4’ indicates that the algorithm of the column performs significantly better than the algorithm of the row. ‘=’ indicates that there seems no difference between the two algorithms.

complexity than ACO and VNS. The ACO approach performs much better, in terms of time as well as solution quality. The speedup of more than two between GA and ACO shows that the ACO algorithm is able to develop much faster good solutions using the pheromone information. Nevertheless, a simple basic VNS improves the solutions quality further by 2–3%. We conclude that a local-search-based metaheuristic is advantageous compared to population-based approaches for this kind of problem. Considering the easy design of the VNS compared to the GA and the ACO, VNS is clearly the method to choose for tackling this batch scheduling problem.

6. Conclusions and future research In this paper, we suggested an ACO and VNS approach for scheduling jobs with incompatible families on parallel identical batching machines. Both approaches decompose the overall scheduling problem in several phases. We compared the solution quality and the time needed for computation of the two metaheuristic approaches with results for a GA suggested in a previous research. All the three approaches were hybridized by a decomposition scheme and local search approaches. It turned out that all three approaches provide a good solution quality compared with ATC-BATC-H. The VNS approach outperforms the remaining approaches. The ACO approach is between the VNS and the GA with

2094


respect to solution quality, that is, solutions obtained by ACO are slightly better compared to those of the GA. But the GA takes considerably longer to provide results of similar solution quality. Among the three metaheuristics the VNS approach is the fastest one. A small time for computation is especially interesting when using one of the metaheuristic approaches within decomposition approaches like the shifting bottleneck heuristic (cf Mo¨nch et al, 2007) for entire wafer fabs because in this case we have to solve a large number of scheduling problems for jobs on parallel machines. There are several directions for future research. It seems possible to extend this research to the case of ready times greater than zero. We expect that time window techniques as in Mo¨nch et al (2005) can be used. It is also interesting to relax the assumption of identical parallel machines. This type of solution techniques can be applied in decomposition approaches like the shifting bottleneck heuristic to schedule jobs in complex job shops like, for example, wafer fabs. We expect that the techniques applied in this paper can be used for a wider class of scheduling problems. In a series of papers by Mason and his group (cf, for example, Qu and Mason, 2005), multiple orders per job (MOJ) scheduling problems in 300 mm wafer fabs are introduced. Here, several customer orders have to be assigned to one FrontOpening-Unit-Pod (FOUP). The FOUPS travel around the wafer fab and the wafers that form the content of the FOUP will be processed on different machines. The problem of FOUP formation is similar to our batching problem. That is why we think that we can use algorithms from this research in parts to tackle MOJ scheduling problems. However, carry out all the details is part of future research. Acknowledgements —The authors gratefully acknowledge the testing efforts of Markus Erhardt.

References Almeder C and Mo¨nch L (2009). Variable neighborhood search for parallel batch machine scheduling. Preprints of the VIII Metaheuristics International Conference, Hamburg. Anghinolfi D and Paolucci M (2007). Parallel machine total tardiness scheduling with a new hybrid metaheuristic approach. Comput Opns Res 34: 3471–3490. Arnaout J-P, Musa R and Rabadi G (2008). Ant colony optimization algorithm to parallel machine scheduling problem with setups. Proceedings IEEE Conference on Automation Science and Engineering, IEEE: Washington, DC, USA, pp 578–582. Balasubramanian H, Mo¨nch L, Fowler JW and Pfund M (2004). Genetic algorithm based scheduling of parallel batch machines with incompatible job families to minimize total weighted tardiness. Int J Prod Res 42(8): 1621–1638. Bauer A, Bullnheimer B, Hartl R and Strauss C (2000). Minimizing total tardiness on a single machine using ant colony optimization. Cent Eur J Opns Res 8(2): 125–141.

Brucker P, Gladky A, Hoogeveen H, Kovalyov MY, Potts CN, Tautenhahn T and van de Velde S (1998). Scheduling a batching machine. J Scheduling 1: 31–54. Chandra SM, Mathirajan M, Gopinath R and Sivakumar AI (2008). Tabu search methods for scheduling a burn-in oven with non-identical job sizes and secondary resource constraints. Int J Opl Res 3(1–2): 119–139. den Besten ML and Stu¨tzle T (2001). Neighborhoods revisited: An experimental investigation into the effectiveness of variable neighborhood descent for scheduling. Proceedings of the 4th Metaheuristic International Conference MIC’2001, Porto, pp 545–549. den Besten M, Stu¨tzle T and Dorigo M (2000). Ant colony optimization for the total weighted tardiness problem. Proceedings 6th International Conference Parallel Problem Solving from Nature (PPSN VI), LNCS Vol. 1917, Springer: Berlin, Heidelberg, New York, pp 611–620. Devpura A, Fowler JW, Carlyle M and Perez I (2000). Minimizing total weighted tardiness on a single batch processing machine with incompatible job families. Proceedings of the Symposium on Operations Research, Dresden, Germany, pp 366–371. Dorigo M and Stu¨tzle T (2004). Ant Colony Optimization. MIT Press: Cambridge, MA. Graham RL, Lawler EL, Lenstra JK and Rinnooy Kan AHG (1979). Optimization and approximation in deterministic sequencing and scheduling: A survey. Ann Discrete Math 5: 287–326. Hansen P and Mladenovic´ N (2001). Variable neighborhood search: Principles and applications. Eur J Opl Res 130: 449–467. Holthaus O and Rajendran C (2005). A fast ant-colony algorithm for single-machine scheduling to minimize the sum of weighted tardiness of jobs. J Opl Res Soc 56: 947–953. Huang K-H and Liao C-J (2008). Ant colony optimization combined with taboo search for the job shop scheduling problem. Comp Opns Res 35(4): 1030–1046. Kashan AH and Karimi B (2008). Scheduling a single batch processing machine with arbitrary job sizes and incompatible job families: An ant colony framework. J Opl Res Soc 59: 1269–1280. Klemmt A, Horn S, Weigert G and Hielscher T (2008). Simulationbased and solver-based optimization approaches for batch processes in semiconductor manufacturing. Proceedings of the 2008 Winter Simulation Conference, IEEE: Miami, pp 2041–2049. Lawler EL (1977). A ‘Pseudopolynomial’ time algorithm for sequencing jobs to minimize total tardiness. Ann Discrete Math 1: 331–342. Li L, Qiao F and Wu Q (2008). ACO-based scheduling of parallel batch processing machines with incompatible job families to minimize total weighted tardiness. Proceedings ANTS 2008, LNCS 5217, Springer: Berlin, Heidelberg, New York, pp 219–228. Liao C-J and Cheng C-C (2007). A variable neighborhood search for minimizing single machine weighted earliness and tardiness with common due date. Comp Ind Eng 52: 404–413. Liao C-J and Juan H-C (2007). An ant colony optimization for single-machine tardiness scheduling with sequence-dependent setups. Comp Opns Res 34(7): 1899–1909. Mathirajan M and Sivakumar AI (2006). A literature review, classification and simple meta-analysis on scheduling of batch processors in semiconductor. Int J Adv Manuf Technol 29: 990–1001. Mathirajan M, Sivakumar AI and Kalaivani P (2004). An efficient simulated annealing algorithm for scheduling burn-in oven with non-identical job sizes. Int J Appl Mngt Technol 2(2): 117–138. Mehta SV and Uzsoy R (1998). Minimizing total tardiness on a batch processing machine with incompatible job families. IIE Trans 30: 165–178.


Merkle D and Middendorf M (2000). An ant colony optimization algorithm with a new pheromone evaluation rule for total tardiness problems. Proceedings of the EvoWorkshops 2000, LNCS 1803, Springer: Berlin, Heidelberg, New York, pp 287–296. Merkle D and Middendorf M (2003). Ant colony optimization with global pheromone evaluation for scheduling a single machine. Appl Intell 18(1): 105–111. Mladenovic´ N and Hansen P (1997). Variable neighborhood search. Comp Opns Res 24: 1097–1100. Mo¨nch L (2008). Heuristics to minimize total weighted tardiness of jobs on unrelated parallel machines. Proceedings of the IEEE Conference on Automation Science and Engineering, IEEE: Washington, DC, USA, pp 572–577. Mo¨nch L and Almeder C (2009). Ant colony optimization approaches for scheduling jobs with incompatible families on parallel batch machines. Proceedings MISTA, Dublin, pp 106–114. Mo¨nch L, Balasubramanian H, Fowler JW and Pfund ME (2005). Heuristic scheduling of jobs on parallel batch machines with incompatible job families and unequal ready times. Comp Opns Res 32: 2731–2750. Mo¨nch L, Schabacker R, Pabst D and Fowler JW (2007). Genetic algorithm-based subproblem solution procedures for a modified shifting bottleneck heuristic for complex job shops. Eur J Opl Res 177(3): 2100–2118. Potts CN and Kovalyov MY (2000). Scheduling with batching: A review. Eur J Opl Res 120: 228–249. Qu P and Mason SJ (2005). Metaheuristic scheduling of 300 mm lots containing multiple orders. IEEE Trans Semiconductor Manuf 18(4): 633–643. Ribeiro CC, Aloise D, Noronha TF, Rocha C and Urrutia S (2008). An efficient implementation of a VNS/ILS heuristic for a real-life car sequencing problem. Eur J Opl Res 191: 596–611. Rocha ML, Ravetti MG, Mateus GR and Pardalos PM (2007). Solving parallel machines scheduling problems with sequencedependent setup times using variable neighbourhood search. IMA J Mngt Math 18: 101–115. Sevkli M and Aydin MEA (2006). Variable neighbourhood search algorithm for job shop scheduling problems. Proceedings EvoCOP 2006, LNCS 3906, Springer: Berlin, Heidelberg, New York, pp 261–271. Song Y, Zhang MT, Yi J, Zhang L and Zheng L (2007). Bottleneck station scheduling in semiconductor assembly and test manufacturing using ant colony optimization. IEEE Trans Automat Sci Eng 4(4): 569–578. Srinivasa Raghavan NR and Venkataramana M (2006). Scheduling parallel batch processors with incompatibe job families using ant colony optimization. Proceedings of the 2006 International Conference on Automation Science and Engineering, IEEE: Shanghai, pp 507–512. Srinivasa Raghavan NR and Venkataramana M (2009). Parallel processor scheduling for minimizing total weighted tardiness using ant colony optimization. Int J Adv Manuf Tech 41(9–10): 986–996. Uzsoy R, Lee CY and Martin-Vega LA (1994). A review of production planning and scheduling models in the semiconductor industry. Part II: Shop floor control. IIE Trans 26: 44–55. Varadarajan A and Sarin SC (forthcoming). A survey of dispatching rules for operational control in wafer fabrication. Prod Plann Control. Venkataramana M and Srinivasa Raghavan NR (2010). Ant colony-based algorithms for scheduling parallel batch processors with incompatible job families. Int J Math Opl Res 2(1): 73–98.

2095

Vepsalainen A and Morton TE (1987). Priority rules and lead time estimates for job shop scheduling with weighted tardiness costs. Mngt Sci 33: 1036–1047. Wall M (2010). GaLib. A C++ Library of genetic algorithm components. http://lancet.mit.edu/ga/. Wang X and Tang L (2009). A population-based variable neighborhood search for the single machine total weighted tardiness problem. Comp Opns Res 36(6): 2105–2110. Wilcoxon F (1945). Individual comparisons by ranking methods. Biometrics 1: 80–83. Ying K-C and Lin S-W (2006). Multiprocessor task scheduling in multistage hybrid flow-shops: An ant colony system approach. Int J Prod Res 44(16): 3161–3177. Yugma C, Dauzere-Peres S, Derreumaux A and Sibille O (2008). A batch optimization software for diffusion area scheduling in semiconductor manufacturing. Advanced Semiconductor Manufacturing Conference 2008 (ASMC 2008), IEEE/SEMI: Cambridge, MA, pp 327–332. Zhou H, Li Z and Wu Z (2007). Scheduling unrelated parallel machines to minimize total weighted tardiness using ant colony optimization. Proceedings of the 2007 IEEE International Conference on Automation and Logistics, IEEE: ShandongDaxue, China, pp 132–136.

Appendix Mixed-integer programming model We use the following notation for the MIP model: Indices: b ¼ 1, . . . , nb s ¼ 1, . . . , f j ¼ 1, . . . , n l ¼ 1, . . . , m

batch index job family index job index machine index

Parameters: B dj ejs G ps wj

maximum batch size due date of job j 1 if job j belongs to family s 0 otherwise large enough constant value processing time of jobs of family s weight of job j

Decision variables: Cbl

Xjbl Ybls

completion time of bth batch on machine l ( if job j is assigned to the 1 bth batch of machine l 0 otherwise 1 if batch b of machine l is of family s 0 otherwise

2096


Tj

tardiness of job j

Cðb1Þl þ

f X

ps Ybls pCbl ;

s¼1

The scheduling problem (1) may be formulated as follows: min

n X

wj Tj

ðA:1Þ

j¼1

nb X m X

Xjbl ¼ 1;

8j ¼ 1; . . . ; n;

ðA:2Þ

b¼1 l¼1

Xjbl pB;

8b ¼ 1; . . . ; nb ; l ¼ 1; . . . ; m;

ðA:3Þ

Ybls ¼ 1;

8b ¼ 1; . . . ; nb ; l ¼ 1; . . . ; m;

ðA:4Þ

j¼1 f X

8b ¼ 2; . . . ; nb ; l ¼ 1; . . . ; m; Cbl dj G 1 Xjbl pTj ; 8j ¼ 1; . . . ; n; b ¼ 1; . . . ; nb ; l ¼ 1; . . . ; m;

Cbl ; Tj X0; Xjbl ; Ybls 2 f0; 1g:

subject to

n X

s¼1

ejs Xjbl pYbls ; 8j ¼ 1; . . . ; n; b ¼ 1; . . . ; nb ; l ¼ 1; . . . ; m; ðA:5Þ ps Y1ls pC1l ;

8l ¼ 1; . . . ; m; s ¼ 1; . . . ; f ;

ðA:6Þ

ðA:7Þ ðA:8Þ ðA:9Þ

The objective (A.1) intends to minimize the TWT. Constraints (A.2) ensure that each job is assigned to a batch and constraints (A.3) do not allow more than B jobs to be assigned to the same batch. With constraints (A.4) we make sure that each batch belongs to a single job family and constraints (A.5) ensure that the families of the jobs assigned to a batch match the family of the batch. Using constraints (A.6) the completion times of the first batches on each machine are computed, whereas constraints (A.7) ensure the correct completion times for all subsequent batches. Finally, constraints (A.8) express the tardiness for each job, and in (A.9) the trivial constraints are denoted. A similar formulation for minimizing the makespan can be found in Klemmt et al (2008).

Received July 2010; accepted November 2010