1. Introduction
This study deals with a scheduling problem in a flow shop with urgent jobs and limited waiting times. Urgent jobs refer to jobs that must be processed faster due to higher urgency than normal jobs. Limited waiting time is to limit the time that a job completed on the first machine waits to start the next process on the second machine. These two scheduling requirements are very common in semiconductor manufacturing processes.
In general, semiconductor manufacturing systems are operated in high-variety small-volume production and make-to-order policies. Nowadays, because the semiconductor foundry market is growing rapidly, customer order management and fast demand response capability are considered as very important competitive factors. To cope with this environment, jobs are classified into two (or more) groups depending on the urgencies of customer orders, i.e., a normal job and an urgent job. In this case, for normal jobs, a schedule is established with the objective of minimizing the maximum completion time (makespan) to raise throughput rate. However, urgent jobs are required to start processing as early as possible when they arrive at workstations. To accomplish this, each urgent job has a calculated due date, assuming that it is processed through all steps without waiting immediately upon arrival. That is, the due date on each step is equal to the earliest possible completion time. Based on this assumption, the objective of minimizing total tardiness can be considered as the scheduling measure for the urgent jobs. If normal and urgent jobs are required to be scheduled together on the same machine or shop, the scheduling measure is treated as a multi-objective because the makespan for normal jobs and total tardiness for urgent jobs are combined. Especially in semiconductor manufacturing, the urgent job is called
hot-lot and managed with a high priority. The urgent jobs can be found in many make-to-order manufacturing systems besides semiconductors. In general, prototypes, samples, and lots to make up for the defective products are regarded as urgent jobs, and such jobs account for 30–50% of all jobs [
1]. So, it is essential to make an effective and efficient schedule while considering the urgent jobs.
Semiconductor manufacturing has many chemical processes. To prevent quality problems of wafer lots caused by the characteristics of chemical processes, waiting time constraints are required between consecutive processes (or stages). For example, the waiting time constraints are set between operations in etch-oxidation-deposition-diffusion work areas [
2]. If the chemical treatment is effective only within a certain period of time, the chemically treated wafer lot has to be entered into the next process before it exceeds the limited time. In the case that the first process of two consecutive processes is such a chemical process, the limited waiting time constraint is applied between the two processes. Moreover, wafers are naturally oxidized if wafers are left in the air for a certain period of time [
3]. On the other hand, the waiting time constraint is also required to reduce the possibility of contamination that causes quality degradation. When the surface of a wafer is exposed to air for a long time before the next process, impurities such as particles may sit on the surface, which can cause a serious quality problem. To prevent this problem, the exposure time is limited by setting the waiting time constraint. A representative example with the waiting time constraint is a two-stage flow shop of clean-diffusion consecutive steps. In order to prevent the above problems, the waiting times between the clean and diffusion processes are limited by the constraint. If a wafer exceeds the constrained waiting time, the cleaning process is reworked, or if contamination is severe, the wafer is scrapped. The rework and scrap degrade productivity and cause losses of management. Therefore, the waiting time constraint should be considered for the flow shops where the above quality problems are likely to occur.
This study considers a scheduling problem for a flow shop with urgent jobs and a waiting time constraint. As mentioned, the urgent jobs want to be processed without causing tardiness. Due to the urgent jobs, normal jobs may be relatively delayed, but their waiting times must also be kept. Therefore, it is essential to develop an effective scheduling algorithm to efficiently operate such a manufacturing system. This scheduling problem can be proved to be NP-hard, because a two-machine flow shop total tardiness problem is NP-hard in the strong sense [
4], and also a two-machine flow shop makespan problem with limited waiting time is NP-hard [
5]. Since the considered problem is NP-hard, it is very tough to find an optimal solution. Hence, this study adopts metaheuristic algorithms to find a good (or near-optimal) solution. To the best of our knowledge, this study is the first attempt to consider the urgent jobs and waiting times simultaneously. In addition, the main contribution is that this work is expected to contribute to the improvement of productivity of semiconductor manufacturing systems.
The remainder of this paper is structured as follows.
Section 2 introduces previous studies related to this study.
Section 3 details the considered scheduling problem with assumptions and presents a mixed integer programming formulation.
Section 4 describes the heuristic algorithms for the problem, and
Section 5 reports the performance of the proposed algorithms through computational experiments. Finally,
Section 6 discusses and concludes this paper with future research directions.
2. Previous Studies
This section introduces the previous studies related to the scheduling problem considered in this study.
First, the considered problem with urgent jobs can be classified as a multi-objective scheduling problem because two types of measures are combined, i.e., the makespan for normal jobs and total tardiness for urgent jobs. Recently, multi-objective scheduling problems are becoming popular as the manufacturing environments become more complex. Liang et al. [
6] proposed a self-adaptive differential evolution algorithm for minimizing the maximum tardiness and makespan simultaneously in a flow shop with limited buffers. Anjana et al. [
7] provided four metaheuristics for a flow shop that requires sequence-dependent setup times, with the objective of minimizing makespan and mean tardiness together, while Rifai et al. [
8] considered a distributed reentrant permutation flow shop with sequence-dependent setup times for minimizing makespan, tardiness and production costs. Recently, multi-objective flow shop problems derived from energy consumption issues were considered in [
9,
10,
11]. They suggested metaheuristic algorithms to minimize total energy consumption and makespan simultaneously.
However, the combined objective of this problem is different from a typical multi-objective. In this study, the objective functions for the two classes are different because jobs are classified into two classes depending on their urgencies. On the contrary, in the typical multi-objective problems, two or more objectives are applied in common to all jobs. Therefore, this problem can be regarded as a multi-agent problem that is the special case of multi-objective problems [
12]. In multi-agent problems, there are two or more agents, and each agent has a different objective function for its own jobs. If the different classes with different objectives are defined as different agents, this problem can be regarded as a multi-agent problem.
Most studies on multi-agent scheduling considered problems for a single machine. Baker et al. [
13] developed algorithms for the multi-agent problem of a single system, considering the maximum delay, total weighted completion times and makespan for objective function. Agnetis et al. [
12] proposed algorithms for getting constrained optimal and pareto optimal solutions for the multi-agent on single machine problems and proved that the problem is NP-hard. Ng et al. [
14] studied the problem of two-agents on a single machine with the objective functions that the total completion time of the first agent is minimized and the number of tardy jobs of the second agent cannot exceed a predetermined number. Leung et al. [
15] proved that the same problem is NP-hard even if the number of tardy jobs for the second agent is limited to zero. Cheng et al. [
16] proposed an algorithm for a two-agent problem on a single machine with the objective of minimizing the total weighted number of tardy jobs of each agent, and they also studied a multi-agent single machine problem with the max-form objective functions in [
17]. Liu et al. [
18] studied a single machine with a two-agent problem in which each job has a linear deteriorated processing time. Additionally, polynomial time solution algorithms for a single-machine with two agents were suggested in [
19,
20].
For a flow shop with multi agents, there have been only a few studies. Agnetis et al. [
12] studied a two-agent problem on a flowshop for minimizing makespan of jobs in each agent. Lee et al. [
21] developed a metaheuristic algorithm and a branch and bound algorithm to solve a two-agent problem in a two-machine flowshop. In addition, Lee et al. [
22] studied a flowshop problem with two agents where the objective of each agent is to minimize the number of tardy jobs and the total tardiness, respectively. Mor et al. [
23] studied three different flowshop problems with two agents and developed polynomial time solution algorithms for each problem. Fan and Cheng [
24] proposed a linear programming-based approximation algorithm for a two-agent flowshop problem. Jeong and Shim [
1] proposed a metaheuristic algorithm for a reentrant flowshop problem with two agents. Jeong et al. [
25] presented a two-machine flowshop problem considering urgent jobs and developed metaheuristic algorithms and a branch and bound algorithm. Azerine et al. [
26] considered a two-machine no-wait flow shop problem with two competing agents and proposed a branch and bound algorithm for small size problems and tabu search metaheuristics for large sized problems.
Now, a survey on flow shop problems with limited waiting times is provided. Most studies on flow shops with limited waiting times considered two-machine problems. For the objective of minimizing the makespan, the two-machine flow shop problem was proved to be NP-hard in [
5]. To find an optimal solution for the problem, several branch and bound algorithms were developed by [
5,
27,
28]. In addition, the reversibility property for the scheduling problem was proved and a constructive heuristic algorithm based on an insertion mechanism was developed in [
2]. On the other hand, there are also studies with different scheduling measures. Hamdi and Loukil [
29] developed a heuristic algorithm and a Lagrangian relaxation-based lower bound strategy for minimizing total tardiness, while Dhouib et al. [
30] proposed simulated annealing algorithms to hierarchically minimize the number of tardy jobs and the makespan for a flow shop.
In addition, there have been studies considering variant problems with waiting time limits. Kim and Lee [
31] developed a branch and bound algorithm to minimize the makespan in a three-machine flow shop with overlapping waiting time constraints. Furthermore, An et al. [
3] suggested a branch and bound algorithm and heuristic algorithms for a two-machine flow shop with the waiting time constraints and sequence-dependent setup times to minimize the makespan, while Lee [
32] provided a genetic algorithm to minimize total tardiness for the same flow shop. In addition, a case in which several jobs can skip the first stage was considered in [
33], and mathematical properties for the problem were proposed. In addition, for a problem with a batch machine followed by a discrete machine, a hybrid membrane computing metaheuristic algorithm was developed in [
34] to minimize the makespan. Additionally, there are recent studies considering flow shop problems with various scheduling requirements as well as limited waiting times [
35,
36,
37,
38,
39,
40,
41].
5. Computational Experiments
This section reports and analyzes the performance of the proposed algorithms through computational experiments on randomly generated problem instances. All the tested algorithms were coded in Java programming language, and the experiments were conducted on a personal computer with a 2.6 GHz CPU.
To generate problem instances, (urgent and normal) jobs and limited waiting times were generated by the methods used in [
25] and [
28], respectively. Processing times were randomly generated from a discrete uniform distribution with a range of [1, 100], i.e.,
U[1, 100]. Let
h be the proportion of urgent jobs to all jobs. For urgent jobs, three levels (0.3, 0.5 and 0.7) were considered for
h, and three levels (0.5, 0.7 and 0.9) were considered for the weight for total tardiness of urgent jobs (
α). The release times of urgent jobs were generated randomly from
U[0,
LB], where
LB is a lower bound on the makespan of normal jobs. The lower bound is obtained by scheduling only normal jobs with Johnson’s rule [
45], assuming that their waiting times are infinite. Note that if all release times are zero or greater than
LB, the problem can be solved more easily. In addition, limited waiting times were randomly generated from
U[0, 100].
Prior to evaluating the proposed algorithms, calibration for the suggested two metaheuristic algorithms were performed to achieve better performance, because performance of metaheuristic algorithms generally depends on their parameters. For the calibration experiments, three levels of n = (50, 200, and 400) were considered, and three instances for each combination of (n, h, and α) were generated. For the termination condition, the maximum computation time was set to 50n milliseconds. Because the IG and SA are stochastic algorithms, they can find a good or bad solution coincidentally. To avoid such a coincidental solution, both algorithms solved each instance three times independently, and the average objective value was used. In addition, to compare the objective values obtained by the algorithms, the relative deviation index (RDI) was used as a measure, defined as (objx − objmin)/(objmax − objmin) where objx, objmin and objmax are the objective function value from algorithm x, the minimum and the maximum, respectively.
The proposed IG has only one parameter which is the destruction size,
d. To find the most appropriate value of
d for the considered problem, eight IGs with different
d = (4, 8, 10, 12, 14, 16, 18 and 20) were tested, respectively. Note that the original IG in [
43] used
d = 4, which showed the best performance in the computational experiment. The results are summarized in
Figure 4 which shows the average RDIs. As shown in the figure, IG with
d = 14 showed the lowest RDI, which means the best performance. Unlike the original IG, the RDI of IG with
d = 4 was the highest among the test results. In addition, the
bath-
curve was observed, meaning that both lower and higher values from
d = 14 deteriorate the performance and hence 14 is validated for the appropriate destruction size. Consequently,
d = 14 was used in the subsequent experiments.
The proposed SA has two types of parameters: cooling ratio
γ and epoch length
E. For the calibration, four levels of
γ and
E were considered, i.e.,
γ = (0.99, 0.993, 0.996, and 0.999) and
E = (40, 80, 120, and 160). Hence, a total of 16 combinations were tested in this calibration. The results were summarized in
Figure 5. Similar to the IG calibration, the bath-curves were observed for the cooling ratio and epoch length. Therefore, (
γ and
E) = (0.996 and 80) were used in the subsequent experiments.
The performance of the proposed MIP was evaluated using a commercial optimization solver, CPLEX 12.10. For experiments, three levels of
n = (10, 20, and 30) were considered, and five instances were generated for each combination of (
n,
h, and
α). The maximum time limit for CPLEX was set to 3600 s to avoid an excessive computation time. The results were summarized in
Table 2. From the table, CPLEX required a longer CPU time for the instances when
h was increased and
α was decreased. The reason is that as urgent jobs become more important, they must be scheduled closer to their arrival time, which reduces the number of sequencing candidates to consider. In addition, most of the problems with more than 20 jobs were not terminated within the maximum time limit. Considering that problem size with 20 jobs is not large enough, these results demonstrate the necessity to develop heuristic algorithms that perform well.
We compared the performance of proposed algorithms with that of CPLEX. For experiments, heuristic algorithms solved the same instances used to evaluate the MIP. Let IG(
x) and SA(
x) denote the IG and SA algorithm, respectively, with the makespan
nx milliseconds as a termination condition. Note that the destruction size for instances with
n = 10 was set to 5 which is a half of
n because using the determined value (
d = 14) was impossible. The results are summarized in
Table 3, which shows the average percentage errors (APE) of solutions from the proposed heuristics to those of CPLEX and the number of instances (out of 45) for which the algorithm found solutions better than or equal to those from CPLEX. If CPLEX failed to solve the problem to optimality within the time limit, the best solution obtained within the time limit was compared. In the table, negative APE indicates that the solutions from the heuristic were better than those from CPLEX. As can be seen from the table, NEH could significantly improve the MEDD solutions. In addition, because CPLEX could not solve most problems with more than 20 problems, IG and SA provided better solutions than CPLEX in the 20–30 size problems. In addition, IG showed better performance than SA. That is, the greedy search is more effective than a random search in small sized problems.
Additionally, to examine the performance of the proposed algorithms, IG and SA were compared with a tabu search (TS) based metaheuristic algorithm suggested in the latest study [
26], which is the most similar one to our study. They considered a two-machine no-wait flow shop with two agents. The TS was also coded in Java language and ran on the same computer for comparison. The same parameters used in [
26] were set, but the TS used the same initial sequences that were used in IG and SA, because the flow shop considered in [
26] is different from this study. These comparison tests were conducted on medium and large size problems. We considered five instances for each combination of (
n,
h, and
α) where
n = 50, 100, 200, 300, 400, and 500. The objective values from each algorithm (
x) were measured by the relative percentage deviation (RPD), defined as (
objx −
objmin)/
objmin. The results are summarized in
Table 4, which shows the average RPD. Overall, the proposed IG and SA outperformed by far TS from [
26], except for only one case of (
n = 50,
h = 0.5,
α = 0.9).
Hence, we focused on the comparison between IG and SA. When the problem size is small and medium, IG found better solutions than SA, However, as the problem size increased, SA showed better performance than IG. This is probably because IG needs to check all insertion positions and this repeated procedure can be a significant computational burden for large size problems. In contrast, because SA generates a neighborhood solution with a simple insertion, the time to generate a new solution is almost the same for large size problems. According to the results, it can be said that IG is more efficient for a small size problem, whereas SA works better for a large size problem.
Based on the results, we plotted the interaction between algorithms and problem parameters (
n,
h and α) to check the effect on the performance of the algorithms. The interval plots are given in
Figure 6, the 95% confidence interval for the mean RDIs. For the number of jobs
n, as we stated, IG was better than SA with up to
n = 200. However, SA outperformed IG in problem instances over
n = 300. For the proportion (
h) of urgent jobs to all jobs, SA showed better performance when
h = 0.3 and 0.5. However, when
h = 0.7, IG was superior to SA, and TS also showed good performance. In other words, three algorithms can be used in complement to one another when there are more urgent jobs than normal jobs. For the weight for total tardiness of urgent jobs (
α), SA and IG far outperformed TS, and SA performed a little better than IG.
Finally, to see statistically significant differences in the performance of IG and SA, Kruskal–Wallis (KW) tests, which are non-parametric methods, were performed with a commercial statistical analysis problem SPSS. For these tests, instances were divided into two groups according to the number of jobs. This is because IG worked well on small sized instances, whereas SA performed better on large sized instances. Thus, one was a small group (n = 10, 20, 30, 50 and 100), and the other was a large group (n = 200, 300, 400, and 500). Since objective values have different scales according to n, RPD values among IG(50), IG(100), SA(50) and SA(100) were set as the dependent variable for the tests. To perform the tests, a significance level was set to 0.05. In addition, to check the effectiveness of problem parameters (h and α) on the performance of the proposed algorithms, KW tests were performed for (algorithms × h values) and (algorithms × α values) as well as algorithms.
For the small group, all
p-values in the three KW tests were close to zero, i.e., less than the significance level. Detailed results were summarized in
Table 5, which shows the results of pairwise comparisons from KW tests. The results confirmed a statistically significant difference between the performances of IG and SA. Thus, it can be said that IG is superior to SA for the small group. In addition, the performance of SA(50) and SA(100) was not different for the small group.
As in the KW tests for the small group, all
p-values were close to zero and less than the significance level for the large group. Therefore, the results confirmed that there were statistically significant differences between algorithms.
Table 6 shows the detailed test results. As stated earlier,
p-values from pairwise comparisons between algorithms were less than 0.05, and hence it can be said that SA significantly outperformed IG. As shown in
Figure 6, there were no significant differences between IG and SA when urgent jobs are more than normal jobs, i.e.,
h = 0.7, and the weights for two classes are equal, i.e.,
α = 0.05. Therefore, IG can be an alternative for these cases.