A computational evaluation of constructive heuristics for the parallel blocking flow shop problem with sequence-dependent setup times

Article history: Received September 13 2020 Received in Revised Format November 28 2020 Accepted January 22 2021 Available online January, 22 2021 This paper deals with the problem of scheduling jobs in a parallel flow shop environment without buffers between machines and with sequence-dependent setup times in order to minimize the maximum completion time of jobs. The blocking constraint normally leads to an increase in the maximum completion time of jobs due to the blockage of machines, which can increase even more so when setup times are considerable. Hence, the heuristic to solve this problem must take into account these specificities in order to minimize the timeout of machines. Because the procedures designed to solve the parallel flow shop scheduling problem must deal not only with the sequencing of jobs but also with their allocation to the flow shops, 36 heuristics have been tested in this paper, of which 35 combine sequencing rules with allocation methods while the last one takes a different approach that is more related to the nature of this problem. The computational evaluation of the implemented heuristics showed good performance of the heuristic designed especially for the problem (RCP0) when the setup times are considerable. Furthermore, the evaluation has also allowed us to propose a combined heuristic that leads to good solutions in a short CPU time. © 2021 by the authors; licensee Growing Science, Canada


Introduction
This paper addresses the problem of scheduling n jobs in F identical parallel flow shops without buffers and with sequencedependent setup times to minimize the maximum completion time of jobs (makespan). The parallel flow shop is a productive configuration found in different industries, such as the glass industry (He et al., 1996) or the production process of electrical appliances and industrial supplies (Jiang and Wan, 2011). The parallel permutation flow shop scheduling problem (PPFSP) with only two machines was studied by He et al. (1996) to deal with the scheduling problem in a glass manufacturing facility, for which they proposed using mixed integer programming and an efficient heuristic. The same problem was later addressed by Cao and Chen (2003) who developed a mathematical model and a tabu search algorithm; by Al-Salem (2004) who proposed a new polynomial-time heuristic; and by Zhang and Van De Velde (2012), who presented approximation algorithms with worst-case performance guarantees for scheduling jobs in two and three lines. The general case (i.e., the m-machine PPFSP) was studied by Jiang and Wan (2011), who proposed a quantum algorithm. The Parallel Permutation Flow Shop scheduling problem is similar to the Distributed Permutation Flow Shop scheduling problem (DPFSP), which deals with scheduling jobs in several identical factories in which each has one flow shop (line) in the production system. Although both problems are conceptually different, the solution methods proposed for one can also be used to solve the other. The DPFSP for minimizing total makespan has been studied by several authors since Naderi and Ruiz (2010) first presented the problem, for which various metaheuristics have been proposed to solve it (Liu and Gao, 2010;Gao and Chen, 2011;Gao et al., 2012;Gao et al., 2013;Lin et al., 2013;Wang et al., 2013;Xu et al., 2013;Fernandez-Viagas and Framinan, 2014;Naderi and Ruiz, 2014).
In this paper, we study two extensions of the classical PPFSP in order to bring the problem closer to the reality of production environments. On the one hand, we consider that no intermediate storage (buffers) exists between machines, which can provoke the blockage of machines if the job being processed finishes before the next machine is free. The blocking constraint allows modeling several production systems in which machines can be blocked due not only to the lack of buffers but also to other manufacturing or technological constraints, for instance, in systems where the parts move using robots and the treated parts must wait in the machine until the robot can pick them up and move them to the next machine (Sethi et al. (1992). Additional examples are found in the iron and steel industry (Gong et al. 2010), the processing of industrial waste, and the production of metallic parts (Martinez et al, 2006). Recently, Miyata and Nagano (2019) published a comprehensive review of the blocking flow shop problem, in which they analysed the proposed heuristic methods in order to solve the problem. The parallel blocking flow shop problem (PBFSP) has been studied by Ribas et al. (2017) who analyzed the performance of an iterated local search algorithm and an iterated greedy algorithm in order to minimize the makespan and Ribas et al.(2019) who proposed an iterated greedy algorithm to minimize total tardiness. On the other hand, we consider setup times, which are the periods of time when the machines are prepared, adjusted, or cleaned between two consecutives jobs. Setup times can be sequence-independent or sequence-dependent. In the former case, the setup time depends on the job to be processed; in the latter one, the amount of time required to configure machines also depends on the job that was previously processed in that machine. Setup activities are very important in some production systems and imply a loss of available capacity. Trovinger and Bohn (2005) reported direct savings of $1.7 million per year due to reduced setup times in a printed circuit board assembly plant. Even though considering setup times in scheduling decisions can help increase productivity and reduce both waste and non-value-added activity while improving the use of resources and meeting deadlines, it is addressed by only about 10% of the existing literature on scheduling (Allahverdi, 2015). To solve the blocking flow shop scheduling problem with setups, two aspects should be considered: when the machines can be set up and when the jobs processed by one machine can move on to the next machine. Regarding the moment in which setup can begin, three possibilities exist. For the sake of clarity, let h be the job being processed by the considered machine and i the next job to be processed in that machine: a) When job h has finished. b) When job h has left the machine. c) When job i has arrived at the machine.
Concerning the moment in which a job can move from its current machine to the next one, two possibilities exist: i. When job h has left the machine. ii. When the setup for processing job i has finished.
In this research, we consider that setup can be performed when job h has left the machine (option b) and job i can move on to the next machine once job h has left it, even though the setup is not finished. To the best of our knowledge, the PBFSP with sequence-dependent setup times, has not been studied before, for which we have designed different constructive heuristics that combine several sequencing rules and allocation strategies in order to provide simple methods for solving the problem. Therefore, this paper tests the performance of several constructive procedures in order to propose a simple but efficient method to minimize makespan. The remainder of the paper is organized as follows. Section 2 is devoted to defining the problem. Section 3 describes the constructive methods proposed. The computational results and comparisons are shown in Section 4. Finally, Section 5 concludes and proposes future lines of research.

Problem definition
The parallel blocking flow shop scheduling problem (PBFSP) consists of scheduling a set of n jobs in F identical flow shops (lines). Each line has m machines and each job must be allocated to one of the f lines. The jobs allocated to a line has to be processed, in the same order, in all machines. Each job i, i ϵ {1, 2,..., n} requires a fixed processing time pj,i and a setup time on every machine j, j ϵ {1, 2,..., m}. Jobs and machines are available from time zero onwards. The objective is to allocate the jobs to the lines and schedule them in order to minimize the maximum makespan (Cmax) among lines. We denote as nf the set of jobs assigned to line f; σf is the sequence of the nf jobs assigned to line f; and fmax is the line with the maximum Cmax. Hence, a solution  is composed of the sequence of jobs in each line (=( σ 1 , σ 2 , …, σ F )).
Next, we present additional notation to define the makespan calculation. Let [k] be the index of the job in the kth position in the sequence. Sj,i,k are the sequence-dependent setup times (SDST) needed in machine j after having processed job i and before processing job [k]. This setup can be done once job i has left the machine. Let Sj,0,k be the setup time required to process the first job in the sequence; σk,f is the job [k] in line f; and cj,k,f is the departure time of job [k] from machine j of line f. Notice that if machine j+1 is available, job i can leave machine j when it is completed. In this situation, cj,k,f is the completion time of job [k] in machine j of line f. The outline of the makespan calculation is shown in Fig. 1.

Constructive heuristics
The scheduling of jobs in a parallel flow shop has to determine the assignment of jobs to lines and the sequence of job allocated to each line. Hence, constructive heuristics can be built by combining ordering rules with allocation strategies. In this paper, we have tested 36 heuristics, of which 35 are the result of combining seven sequencing rules with five allocation methods plus an improvement phase. The last one, named RCP0, is totally different and is explained at the end of this section. The sequencing rules used in the first 35 heuristics are: Largest Processing Time (LPT); Shortest Processing Time (SPT); Trapeziums (TRA) (Companys, 1966); the Palmer heuristic (PAL) (Palmer, 1965); two variants of PF (McCormick et al., 1989) and HPF (Ribas and Companys, 2015).
 LPT sequences the jobs in non-increasing order of their total processing time (sum of the processing time in each machine).  SPT sequences the jobs in non-decreasing order of their total processing time (sum of the processing time in each machine).  TRA calculates two indexes for each job (S1i and S2i) according to (1) and (2), respectively. Next, Johnson's algorithm (Johnson, 1954) is used to sequence the jobs by considering S1i and S2i as the processing time of job i in the first and second machine, respectively.
 PAL sequences the jobs in increasing order of S3i=S1i-S2i.
PF sequences the jobs in an order that minimizes the idle time of machines. Next, two variants are presented (PF1 and PF2) which differ in their calculations of timeout duration.
 PF1 considers, as do Takano and Nagano (2019), timeout to be the time when the machine is not working because it is not processing any jobs or is not being prepared for the next job. This timeout can be due to idle time, blocking time, or the sum of both. Here, the total timeout duration of machines is calculated as in (3), where i denotes the job, k the position,  the sequence of jobs already sequenced, and *i the partial sequence plus job i. Notice that timeout in this case is the difference between the departure time between job i and the previous job in the sequence, minus its processing time and the setup time required to process job i. This is because setup can be performed once the previous job has left the machine: (3) The job selected is the one that leads to the minimum timeout.
considers a machine to be idle when it is not processing any job, but not when it is being setting up. Therefore, the total timeout of machines is now calculated as in (4): The job selected is the one that leads to the minimum timeout.
 HPF builds the sequence in order to minimize both the timeout of machines and the total flowtime, which is carried out with the index ind1(i, k) that is calculated according to (5).
The five allocation methods used in the first 35 heuristics can be separated into two groups. In the first group (methods 1, 2 and 3), jobs are allocated to the lines. Then, the sequence of jobs assigned to each line is improved upon by an adaptation of the NEH-insertion procedure (Nawaz et al., 1983) . Each method is described as follows: (1) Assign job j to the factory with the lowest current Cmax, not including job j, at the end of its partial sequence.
(2) Assign job j to the factory that can complete it at the earliest time, at the end of its partial sequence.
(3) Create a sequence in each line by assigning a similar load (ΣPi/F). This process starts in one of the lines (all of them are identical) by assigning jobs until it reaches the mean load. The process is repeated for each line.
In the second group are methods 4 and 5, for which the allocation and improvement phases are mixed. This means that a job assigned to a line is allocated to the best position, i.e., the one that minimizes the partial makespan. These methods are described as follows: (4) Assign job j to the line with the lowest current C max , not including job j. Next, sequence the job at the position that minimizes its Cmax. (5) Assign job j to the line that would finish it at the earliest time if placed at the end of the sequence. Next, place the job at the position that minimizes its Cmax.
The heuristics that result from combining the seven sequencing rules with the five allocation methods are labeled with the name of the sequencing rule plus the number of the allocation method: The last proposed heuristic method uses a totally different approach, given that the job and line are selected at the same time.
 RCP0: At each iteration, select the line that has the last machine available sooner. Next, choose the job that leads to the minimum timeout, which is calculated by equation (4). This process is repeated until all jobs have been assigned. Finally, the sequence of jobs in each line is improved by an adaptation of the NEH-insertion procedure (Nawaz et al., 1983).

Computational evaluation
This section shows the computational evaluation of the heuristics, which was conducted on a set of instances that was generated ad-hoc. The instances were combinations of n={25, 50, 75, 100, 150, 200} and m={5, 10, 15, 20}. There were 24 groups of instances and 10 instances per group, for a total of 240 instances that are solved for F={2, 3, 4, 5} and three levels of setup times. Hence, the test is conducted on over 2880 instances. The processing time was generated according to a uniform distribution in the range [1,99], as is done in the scheduling literature. Finally, we generated the three levels of setup according to a uniform distribution. For the low level, the range interval is [1, 20]; for the medium level, it is [1, 50]; and for the high level, it is [1,120]. The evaluation of the heuristics is done by comparing the quality of their solutions and the CPU time required to reach these solutions. The quality of solutions is measured by the relative percentage deviation (RPD) that is calculated in (6): With Soli,j being the makespan obtained by heuristic j in instance i, and Besti is the minimum makespan obtained by any of the heuristics tested over the same instance. The computational effort is measured by the average CPU time (ACPU), in seconds, required by the heuristic to solve the instances. The heuristics were codified in QB64 and tested on the same computer: an Intel i3 with 2.3 GHz and 8 GB RAM memory. Both instances and solutions are available from the authors on request. The first analysis allows comparing the heuristics in terms of their relationship between solution quality and computational effort. Fig. 1 shows the ARPD versus ACPU values for each heuristic. It can be observed that heuristics using allocation methods 4 and 5 require more computational effort than the others do. Notice that these heuristics are grouped at around 0.45s to the right side of the figure, far from the other heuristics, which are grouped at around 0.1s. Regarding the ARPD, we find the best performing procedures at the bottom of the figure. It is worth noting that, although TRA5 has the lowest overall ARPD, the time required to find the solution is about four times that of RCP0, whose overall ARPD is not too far from the best one. To facilitate this analysis, Table 1 details the ARPD and ACPU per heuristic, as well as the breakdown of the overall ARPD by each level of setup times. This table has been ordered according to the overall ARPD. The position in the ranking is shown to the left of each heuristic's name.

Fig.1. ARPD versus ACPU per heuristic
Regarding the overall ARPD values, the top ten heuristics (see Table 1) notably use allocation methods 3, 4 and 5; but, interestingly, the heuristic RCP0 also appears in this group. Recall that this is the heuristic using a different approach that is more related to the nature of the problem, meaning that the line and job are selected simultaneously at each iteration. It is worth mentioning that the top five rankings include-apart from heuristic RCP0-the heuristics formed by the TRA and LPT sequencing rules. This means that neither the allocation method nor the ordering rule is in itself relevant, only the combination of both.

ARPD vs ACPU
Next, we conduct a deeper analysis on the performance of these top ten heuristics by examining their behaviors in terms of number of lines and level of setup time (Fig. 2) and number of jobs per each level of setup time (Fig. 3). Fig. 2 shows that the behaviors of most heuristics are similar in terms of the number of lines and the setup level. Their ARPD is quite similar when setup time is in the low or moderate levels, and their performance is worse (higher ARPD) when the setup level is high. This is due to the procedure RCP0, which has an excellent performance when the setup time is high (especially for two and three lines) and is thus able to find most of the best solutions for these instances. On the other hand, the behavior of heuristic HPF5 (at the bottom of our top ten ranking) is also different from the majority of the other methods, since it becomes worse when setup time increases. Regarding the number of lines when considering all heuristics that rank less than RCP0, HPF3 is the best-performing heuristic when there are two lines; but its performance worsens when the number of lines increases, a situation in which TRP5 is better, followed by LPT5. However, allocation methods 4 and 5 require four times more CPU time than RCP0 and HPF3. Looking at the effect of the number of lines (Fig. 3), we can see that the performance of RCP0 increases when the number of jobs increases. The first panel of Fig. 3 shows that ARPD is around zero when the number of jobs is 200 and the setup level is high, which means that ARPD obtains the best solutions for these instances. This affects the ARPD of the other heuristics for this level of setup times, where the performance is worse when the number of jobs increases. Conversely, for low and moderate levels of setup times: the higher the number of jobs, the better the ARPD value. Thus, RCP0 is recommended when the setup times can be about the same magnitude as the processing time of jobs, since it provides a good solution in little CPU time. However, TRA5 and LPT5 are the ones with similar behavior in all situations and additionally provide good solutions, but both require greater computational effort. Finally, even though HPF3 is in the fifth position of the ARPD ranking, it also provides a competitive solution in less time than TRA5 and LPT5. Therefore, these four procedures are recommended not only for solving the problem but also as the initial solution procedure of metaheuristic methods, since this difference between solution quality and required CPU time makes it impossible to know beforehand which one can help metaheuristics to find better solution. Regarding which of these procedures would be more suitable as a scheduling method in a real environment, we recommend creating a process that runs both RCP0 and HPF3 and keeps the best of both solutions. This would lead to reaching very competitive results (as seen in Table 2) in half the time needed by TRA5 and LPT5 to reach a solution.

Conclusions
This paper has approached the parallel flow shop scheduling problem with blocking and sequence-dependent setup times. To the best of our knowledge, this is the first attempt to study and propose heuristics for solving this problem. The procedures for addressing the scheduling problem in this environment must consider the allocation of jobs to lines and the scheduling of jobs in each line. The way in which these two related decisions are taken can affect the performance of heuristics, since the timeout of machines can be affected by both blocking and setup times. Hence, this paper has tested 36 heuristics, of which 35 combine seven ordering rules with five allocation methods. The heuristics with allocation methods 1, 2, 4, and 5 first order the jobs according to a sequencing rule, then the jobs are assigned to the lines according to a given criterion. Allocation method 3 is slightly different, since a line is first selected and the jobs are then sequenced in this line until reaching the average workload, which is the moment when the process starts again for another line. Conversely, the 36 th heuristic, named RCP0, selects a line at each iteration and assigns the job that leads to the minimum timeout of machines. Our computational evaluation indicates that the heuristic with the best average performance is TRA5, but it requires four times more CPU time than the very competitive performances of RCP0 and HPF3. This is especially true for RCP0 when the setup times are high, a situation in which it performs the best. A deeper analysis on the combined effect of setup times and numbers of lines and of jobs showed that the behaviors of RCP0 and HPF3 are complementary, i.e., when one is best the other is not as competitive and vice versa. For this reason, we propose running these two procedures in one integrated heuristic that keeps the best of both results. Such an integrated heuristic could reach a solution in half the time of TRA5 and thus lead to very competitive results.