A genetic algorithm for minimizing maximum lateness on parallel identical batch processing machines with dynamic job arrivals and incompatible job families

We consider the problem of minimizing maximum lateness on parallel identical batch processing machines with dynamic job arrivals. We propose a family of iterative improvement heuristics based on previous work by Potts [Analysis of a heuristic for one machine sequencing with release dates and delivery times. Operations Research 1980;28:1436–41] and Uzsoy [Scheduling batch processing machines with incompatible job families. International Journal for Production Research 1995;33(10):2685–708] and combine them with a genetic algorithm (GA) based on the random keys encoding of Bean [Genetic algorithms and random keys for sequencing and optimization. ORSA Journal on Computing 1994;6(2):154–60]. Extensive computational experiments show that one of the proposed GAs runs significantly faster than the other, providing a good tradeoff between solution time and quality. The combination of iterative heuristics with GAs consistently outperforms the iterative heuristics on their own.     

Minimizing total weighted tardiness on a single batch process machine with incompatible job families

The diffusion step in semiconductor wafer fabrication is very time consuming, compared to other steps in the process, and performance in this area has a significant impact on overall factory performance. Diffusion furnaces are able to process multiple lots of similar wafers at a time, and are therefore appropriately modeled as batch processing machines with incompatible job families. Due to the importance of on-time delivery in semiconductor manufacturing, we focus on minimizing the total weighted tardiness in this environment. The resulting problem is NP-Hard, and we decompose it into two sequential decision problems: assigning lots to batches followed by sequencing the batches. We develop several heuristics for these subproblems and test their performance.     

A branch and bound algorithm for minimizing total completion time on a single batch machine with incompatible job families and dynamic arrivals

In this paper, we consider a single batch machine scheduling problem with incompatible job families and dynamic job arrivals. The objective is to minimize the total completion time. This problem is known to be strongly NP-hard. We present several dominance properties and two types of lower bounds, which are incorporated to construct a basic branch and bound algorithm. Furthermore, according to the characteristics of dynamic job arrivals, a decomposed branch and bound algorithm is proposed to improve the efficiency. The proposed algorithms are tested on a large set of randomly generated problem instances.     

An ACO algorithm for makespan minimization in parallel batch machines with non-identical job sizes and incompatible job families

We study the problem of scheduling a set of N jobs with non-identical job sizes from F different families on a set of M parallel batch machines; the objective is to minimize the makespan. The problem is known to be NP-hard. A meta-heuristic based on Max–Min Ant System (MMAS) is presented. The performance of the algorithm is compared with several previously studied algorithms by computational experiments. According to our results, the average distance between the solutions found by our proposed algorithm and the lower bounds is about 4% less than that of the best of all the compared algorithms, demonstrating that our algorithm outperforms the previously studied algorithms.     

Heuristic scheduling of jobs on parallel batch machines with incompatible job families and unequal ready times

This research is motivated by a scheduling problem found in the diffusion and oxidation areas of semiconductor wafer fabrication, where the machines can be modeled as parallel batch processors. We attempt to minimize total weighted tardiness on parallel batch machines with incompatible job families and unequal ready times of the jobs. Given that the problem is NP-hard, we propose two different decomposition approaches. The first approach forms fixed batches, then assigns these batches to the machines using a genetic algorithm (GA), and finally sequences the batches on individual machines. The second approach first assigns jobs to machines using a GA, then forms batches on each machine for the jobs assigned to it, and finally sequences these batches. Dispatching and scheduling rules are used for the batching phase and the sequencing phase of the two approaches. In addition, as part of the second decomposition approach, we develop variations of a time window heuristic based on a decision theory approach for forming and sequencing the batches on a single machine.     

A best possible deterministic on-line algorithm for minimizing makespan on parallel batch machines

We study on-line scheduling on parallel batch machines. Jobs arrive over time. A batch processing machine can handle up to B jobs simultaneously. The jobs that are processed together form a batch and all jobs in a batch start and are completed at the same time. The processing time of a batch is given by the processing time of the longest job in the batch. The objective is to minimize the makespan. We deal with the unbounded model, where B is sufficiently large. We first show that no deterministic on-line algorithm can have a competitive ratio of less than 1+(?{m²+4}-m)/21+(\sqrt{m^{2}+4}-m)/2 , where m is the number of parallel batch machines. We then present an on-line algorithm which is the one best possible for any specific values of m.     

A branch-and-bound algorithm to minimize total weighted completion time on identical parallel machines with job release dates

In this paper, we consider an identical parallel machine scheduling problem with release dates. The objective is to minimize the total weighted completion time. This problem is known to be strongly NP-hard. We propose some dominance properties and two lower bounds. We also present an efficient heuristic. A branch-and-bound algorithm, in which the heuristic, the lower bounds and the dominance properties are incorporated, is proposed and tested on a large set of randomly generated instances.     

An efficient memetic algorithm for total weighted tardiness minimization in a single machine with setups

The single machine scheduling problem with sequence-dependent setup times with the objective of minimizing the total weighted tardiness is a challenging problem due to its complexity, and has a huge number of applications in real production environments. In this paper, we propose a memetic algorithm that combines and extends several ideas from the literature, including a crossover operator that respects both the absolute and relative position of the tasks, a replacement strategy that improves the diversity of the population, and an effective but computationally expensive neighborhood structure. We propose a new decomposition of this neighborhood that can be used by a variable neighborhood descent framework, and also some speed-up methods for evaluating the neighbors. In this way we can obtain competitive running times. We conduct an experimental study to analyze the proposed algorithm and prove that it is significantly better than the state-of-the-art in standard benchmarks.     

Minimizing total tardiness on parallel machines with preemptions

The basic scheduling problem we are dealing with in this paper is the following one. A set of jobs has to be scheduled on a set of parallel uniform machines. Each machine can handle at most one job at a time. Each job becomes available for processing at its release date. All jobs have the same execution requirement and arbitrary due dates. Each machine has a known speed. The processing of any job may be interrupted arbitrarily often and resumed later on any machine. The goal is to find a schedule that minimizes the sum of tardiness, i.e., we consider problem Q∣r _j ,p _j =p, pmtn∣∑T _j whose complexity status was open. Recently, Tian et al. (J. Sched. 9:343–364, 2006) proposed a polynomial algorithm for problem 1∣r _j ,p _j =p, pmtn∣∑T _j . We show that both the problem P∣ pmtn∣∑T _j of minimizing total tardiness on a set of parallel machines with allowed preemptions and the problem P∣r _j ,p _j =p, pmtn∣∑T _j of minimizing total tardiness on a set of parallel machines with release dates, equal processing times and allowed preemptions are NP-hard. Moreover, we give a polynomial algorithm for the case of uniform machines without release dates, i.e., for problem Q∣p _j =p, pmtn∣∑T _j .     

A memetic algorithm for minimizing the total weighted completion time on a single machine under step-deterioration

In this paper, we consider minimizing total weighted completion time criteria on a single machine. Jobs processing times are step function of its starting time and all jobs have a common due date. First, we present some new lemmas and dominance properties for this NP-hard problem, and then a memetic algorithm using these properties is developed. We compare the solutions of the memetic algorithm with optimal solutions obtained from complete enumeration. The results show that the average percentage error of the proposed algorithm from optimal solutions is about 2% and as the variance of processing time increase, the percentage errors decrease.     

A hybrid memetic algorithm for maximizing the weighted number of just-in-time jobs on unrelated parallel machines

This paper presents a hybrid memetic algorithm for the problem of scheduling n jobs on m unrelated parallel machines with the objective of maximizing the weighted number of jobs that are completed exactly at their due dates. For each job, due date, weight, and the processing times on different machines are given. It has been shown that when the numbers of machines are a part of input, this problem is NP-hard in the strong sense. At first, the problem is formulated as an integer linear programming model. This model is practical to solve small-size problems. Afterward, a hybrid memetic algorithm is implemented which uses two heuristic algorithms as constructive algorithms, making initial population set. A data oriented mutation operator is implemented so as to facilitate memetic algorithm search process. Performance of all algorithms including heuristics (H1 and H2), hybrid genetic algorithm and hybrid memetic algorithm are evaluated through computational experiments which showed the capabilities of the proposed hybrid algorithm.     

Machine learning techniques for scheduling jobs with incompatible families and unequal ready times on parallel batch machines

This research is motivated by a scheduling problem found in the diffusion and oxidation areas of semiconductor wafer fabrication facilities, where the machines can be modeled as parallel batch processors. Total weighted tardiness on parallel batch machines with incompatible job families and unequal ready times of the jobs is attempt to minimize. Given that the problem is NP hard, a simple heuristic based on the Apparent Tardiness Cost (ATC) Dispatching Rule is suggested. Using this rule, a look-ahead parameter has to be chosen. Because of the appearance of unequal ready times and batch machines it is hard to develop a closed formula to estimate this parameter. The use of inductive decision trees and neural networks from machine learning is suggested to tackle the problem of parameter estimation. The results of computational experiments based on stochastically generated test data are presented. The results indicate that a successful choice of the look-ahead parameter is possible by using the machine learning techniques.     

A genetic local search algorithm for minimizing total weighted tardiness in the job-shop scheduling problem

This paper considers the job-shop problem with release dates and due dates, with the objective of minimizing the total weighted tardiness. A genetic algorithm is combined with an iterated local search that uses a longest path approach on a disjunctive graph model. A design of experiments approach is employed to calibrate the parameters and operators of the algorithm. Previous studies on genetic algorithms for the job-shop problem point out that these algorithms are highly depended on the way the chromosomes are decoded. In this paper, we show that the efficiency of genetic algorithms does no longer depend on the schedule builder when an iterated local search is used. Computational experiments carried out on instances of the literature show the efficiency of the proposed algorithm.     

Scheduling a batch processing machine with incompatible job families

The problem of scheduling batch processors is important in some industries and, at a more fundamental level, captures an element of complexity common to many practical scheduling problems. We describe a branch and bound procedure applicable to a batch processor model with incompatible job families. Jobs in a given family have identical job processing times, arbitrary job weights, and arbitrary job sizes. Batches are limited to jobs from the same family. The scheduling objective is to minimize total weighted completion time. We find that the procedure returns optimal solutions to problems of up to about 25 jobs in reasonable CPU time, and can be adapted for use as a heuristic for larger problems.     

A heuristic for job shop scheduling to minimize total weighted tardiness

This paper considers the job shop scheduling problem to minimize the total weighted tardiness with job-specific due dates and delay penalties, and a heuristic algorithm based on the tree search procedure is developed for solving the problem. A certain job shop scheduling to minimize the maximum tardiness subject to fixed sub-schedules is solved at each node of the search tree, and the successor nodes are generated, where the sub-schedules of the operations are fixed. Thus, a schedule is obtained at each node, and the sub-optimum solution is determined among the obtained schedules. Computational results on some 10 jobs and 10 machines problems and 15 jobs and 15 machines problems show that the proposed algorithm can find the sub-optimum solutions with a little computation time.     

A genetic algorithm for minimizing total tardiness/earliness of weighted jobs in a batched delivery system

This paper endeavors to solve a novel complex single-machine scheduling problem using two different approaches. One approach exploits mathematical modeling, and the other is based upon genetic algorithms. The problem involves earliness, tardiness, and inventory costs and considers a batched delivery system. The same conditions might apply to some real supply chains, in which delivery of products is conducted in a batched form and with some costs. In such delivery systems, the act of buffering the products can have both positive effects (i.e., decreasing the delivery costs and early jobs) and negative ones (i.e., increasing the number of tardy and holding costs). Accordingly, the proposed solution takes into account both effects and tries to find a trade-off between them to hold the total costs low. The suggestions are compared to existing solutions for older non-batched systems and have illustrated outperformance.     

Minimizing total tardiness for scheduling identical parallel machines with family setups

This paper presents several procedures for scheduling identical parallel machines with family setups when the objective is to minimize total tardiness. These procedures are tested on several problem sets with varying numbers of families, jobs and machines, varying setup time distributions and various levels of due date tightness and variability. The results show that genetic algorithms are the most effective algorithms for the problem.     

Impact of permutation enforcement when minimizing total weighted tardiness in dynamic flowshops with uncertain processing times

This paper is motivated by the problem of meeting due dates in a flowshop production environment with jobs with different weights and uncertain processing times. Enforcement of a permutation schedule to varying degrees for dynamic flowshops is investigated with the goal of minimizing total weighted tardiness (TWT). The approaches studied are categorized as follows: (1) pure permutation scheduling (2) shift-based scheduling (3) pure dispatching (which leads to non-permutation sequences). A simulation-based experimental study was carried out to study the performance of the above methods with respect to minimizing TWT when new jobs arrive to the flowshop at every shift change. Results indicate significant gains in performance are possible when the permutation requirement is relaxed and shift-based scheduling is allowed. Shift-based scheduling yields competitive results with respect to the pure dispatching approach, even though dispatching has the advantage of a full relaxation of the permutation requirement.