Cooperative metaheuristics for the permutation flowshop scheduling ...

Cooperative metaheuristics for the permutation flowshop scheduling problem Eva Vallada∗, Rubén Ruiz Grupo de Sistemas de Optimización Aplicada Instituto Tecnológico de Informática Universidad Politécnica de Valencia Edificio 7A. Camino de Vera S/N, 46021, Valencia, SPAIN email: {evallada,rruiz}@eio.upv.es

April 11, 2007

Abstract In this work we propose cooperative metaheuristic methods for the permutation flowshop scheduling problem considering two objectives separately: total tardiness and makespan. We use the island model where each island runs an instance of the algorithm and communications start when the islands have reached certain level of evolution, that is, communication is not allowed from the beginning of the execution. Subsequent ones occur when new better solutions are found. We carry out an exhaustive comparison of the cooperative methods against the sequential counterparts running in completely comparable scenarios. Results have been carefully analysed by means of statistical procedures and we can conclude that the cooperative methods yield much better results than the sequential algorithms and state-of-the-art methods running in the same number of processors but without communications. The proposed cooperative schemes are easy to apply to other algorithms and problems.

Keywords: cooperative metaheuristics, scheduling, permutation flowshop, total tardiness, makespan. 1

Corresponding author. Tel: +34 96 387 70 07, ext: 74911. Fax: +34 96 387 74 99

1

1

Introduction

In a flowshop problem there is a set N = {1, . . . , n} of n jobs that have to be processed on a set M = {1, . . . , m} of m machines in the same order, which can be assumed to be 1, 2, . . . , m. This problem is one of the most studied in the field of scheduling, especially the well-known permutation flowshop problem (PFSP) where the job sequence is the same for all the machines. The objective is to find a sequence such that a given criterion is optimised. The most widely studied objective in the literature is the makespan or Cmax , that is, to find a minimum completion time sequence which is denoted as F/prmu/Cmax according to Pinedo (2002). Researchers have also focused on other objectives, especially those related to due dates, which are very significant in industry due to the importance of the fulfillment of delivery dates agreed with customers. Among due date criteria, the total tardiness has been thoroughly studied. Therefore, the PFSP with this criterion is P denoted as F/prmu/ Tj (Pinedo, 2002) where Tj = max{Cj − dj , 0} is the tardines of job j, being dj its due date and Cj its completion time at the last machine of the shop. In the literature, we can find very efficient methods for the PFSP dealing with these objectives, which are usually tested in single processor computers. However, one of the most promising ways to improve the effectiveness of a metaheuristic method is to develop cooperative or parallel algorithms which employ several processors. Parallelisation in computer science has been traditionally used as a means of shortening the execution time of heavy algorithms. From its origins (see Gill, 1958, Holland, 1959 or Conway, 1963) and up to the early nineties, parallel computing required special and very expensive mainframes out of the scope of many researchers. However, nowadays local networks allow the connection of personal computers in a very affordable, easy and quick way. Moreover, Internet makes possible to solve problems using the distributed technology known as grid, where one can access idle computers in the net (http://www.grid.org/home.htm for more details). On the other hand, recent personal computers include dual processing cores in the processors, that is, two processors inside the same chip (more details in http://www.intel.com/core2duo/ and www.multicore.amd.com). In fact, technology progresses very fast and personal computers with four cores are already available (www.intel.com/quadcoreserver). These new technologies allow the development of parallel algorithms using only one computer. For all these reasons, parallel computing has attracted a renewed interest in the research community. This paper introduces new cooperative metaheuristic methods with some innovative features that can be run over standard personal computers interconnected in a typical local network. Contrary to the usual trend in parallel computing, the aim of the proposed

2

methods is not to reduce the computation time, but also to provide much better solutions for the PFSP considering the makespan and the total tardiness criteria in a separate way. As the results will point out, the cooperative methods greatly outperform state-of-the-art sequential heuristics when tested in completely comparable scenarios. The rest of the paper is organised as follows: in Section 2 we present an overview of sequential and parallel algorithms for the PFSP considering makespan and total tardiness criteria. Section 3 describes in detail the parallel metaheuristic methods proposed, including a calibration of different parameters and operators of the proposed algorithms by means of a Design of Experiments approach. Computational results and a comparison of the proposed methods are given in Section 4, taking into account both objectives, makespan and total tardiness. Finally, in Section 5 we provide some conclusions about the study and indicate some future research directions.

2

Literature review

Considering that we deal with two different objectives, in the next subsections we present an up-to-date review of algorithms proposed for the PFSP minimising makespan and total tardiness just as the parallel algorithms we can find for the same problem.

2.1

Metaheuristic methods for the PFSP minimising makespan

The makespan criterion for flowshop scheduling has been thoroughly studied since Johnson’s seminal paper back in 1954. Nevertheless, it is still a hot topic of research as shown in the recent reviews by Framinan et al. (2004), Hejazi and Saghafian (2005), Ruiz and Maroto (2005) and Gupta and Stafford (2006). Exact approaches have shown limited results for medium or large problems and are specially sensible to the number of machines as can be observed in the works of Tseng et al. (2004) or Ladhari and Haouari (2005). As a result, there is a wealth of literature on heuristic and metaheuristic methods for the PFSP problem and makespan criterion. Among the existing heuristics, the insertion method of Nawaz et al. (1983), referred to as NEH, is the best performer even when compared against more modern constructive methods according to the results of the computational evaluation given in Ruiz and Maroto (2005). It appears that the performance of NEH is now being scrutinised and promising results are appearing in the literature, some examples are the study of Framinan et al. (2003) or the heuristics of Kalczynski and Kamburowski (2007) and Farahmand Rad et al. (2007). According to this last paper, several new extensions of the insertion method outperform

3

NEH albeit at the expense of a small CPU time penalty. As regards metaheuristic methods for the PFSP and makespan criterion, a increasing number of research papers are being published since the late 80s. Grouping these contributions by category results in the following relevant contributions in simulated annealing approaches (Osman and Potts, 1989; Ogbu and Smith, 1990), tabu search (Reeves, 1993; Nowicki and Smutnicki, 1996; Grabowski and Wodecki, 2004), genetic algorithms (Reeves, 1995; Murata et al., 1996; Reeves and Yamada, 1998; Ruiz et al., 2006), ant colony optimisation (Ying and Liao, 2004; Rajendran and Ziegler, 2004), iterated local search, Stützle (1998), scatter search, Nowicki and Smutnicki (2006), particle swarm optimisation, Tasgetiren et al. (2007) and more recently, iterated greedy methods, Ruiz and Stützle (2007). From the extensive computational evaluation carried out in Ruiz and Stützle (2007), it seems that these methods are at the same time very simple to code and very effective when compared against the state-of-the-art.

2.2

Metaheuristic methods for the PFSP minimising total tardiness

In Vallada et al. (2007) we can find a recent and exhaustive literature review along with a comparative evaluation considering the PFSP with the objective of total tardiness minimisation. Here we review the most important results reviewed in that work. The four heuristic methods proposed by Gelders and Sambandam (1978) based on priority rules are the first ones we can find for the PFSP minimising total tardiness. Ow (1985) developed a heuristic based on a priority rule for the proportionate flowshop problem. Some adaptations of algorithms for different objectives, mainly the makespan, are proposed by Kim (1993). In Raman (1995), several rules and heuristics originally proposed for the single machine and two machine cases are adapted to the m-machine case. Finally, in Kim et al. (1996) we can find several improvement and local search heuristics. Regarding the metaheuristic algorithms, in Adenso-Díaz (1992) and Kim (1993) we can find adapted versions of the well-known tabu search by Widmer and Hertz (1989) originally proposed for the makespan objective. The same authors proposed several tabu search and simulated annealing methods in Adenso-Díaz (1996) and Kim et al. (1996). We can also find two very similar simulated annealing algorithms in Parthasarathy and Rajendran (1997a) and Parthasarathy and Rajendran (1997b) where local search procedures are applied to improve the initial solution. A genetic algorithm considering three objectives (total tardiness, tardy jobs and both objectives at the same time) was proposed by

4

Onwubolu and Mutingi (1999). Armentano and Ronconi (1999) presented a basic tabu search and extensions with diversification, intensification and restricted neighborhood strategies. Rajendran and Ziegler (2003) proposed several heuristic and metaheuristic methods with the objective to minimise the sum of weighted flowtime and weighted tardiness. Another simulated annealing method is that proposed by Hasija and Rajendran (2004) where an initial solution by Parthasarathy and Rajendran (1998) is improved by means of a local search procedure. In Onwubolu and Davendra (2006) we can find a differential evolution algorithm with different objective functions: makespan, flowtime and total tardiness. Lastly, in a recent work by Vallada and Ruiz (2007), three genetic algorithms are proposed which include advanced techniques like path relinking, local search and a procedure to control the diversity of the population. These genetic algorithms show the best performance for the PFSP minimising total tardiness up to date according to the results of Vallada and Ruiz (2007) and Vallada et al. (2007) where 40 algorithms were exhaustively compared.

2.3

Parallel algorithms for the PFSP

The basic idea behind a parallel algorithm is to divide a task into several independent parts and to solve them simultaneously using multiple processors or computers. Parallelisation is usually employed as a means of reducing the time requirements of heavy algorithms. The desired goal is to obtain a speed-up factor (serial algorithm required time/parallel algorithm required time) equal to the number of parallel processors or computers used. A parallel computing environment is needed in order to run a parallel algorithm. This environment can be a computer with several processors or several interconnected computers (see Flynn, 1972, Kumar et al., 1994, Culler and Pal Singh, 1999 or Alba, 2005 for more details). Once the parallel environment is established, one has to choose the working scheme between the computers. The master-slave model is very common and consists of a master processor which distributes the workload among the remaining processors (slaves). The master has to carry out synchronisation tasks among the slaves and these send data back to the master, usually when they finish processing. A different model consists of a set of processors which solve a problem in a cooperative way through the exchange of information at predefined intervals. This scheme is known as island model and is the most studied in the literature about parallel metaheuristics. The islands can run the same algorithm, different algorithms, same algorithms with different parameters, etc. We find more details about these schemes in Alba (2005). Focusing our attention in the literature about parallel algorithms dealing with PFSP, 5

we find in Stoppler and Bierwirth (1992) a parallel genetic algorithm for makespan minimisation. The experiments were carried out using four computers with a population of four individuals on each one. The parallel genetic algorithm method was tested on randomly generated problems of up to 100 jobs and 10 machines in size. The authors compared the results with the SPT rule and with a heuristic based on job interchange, obtaining the proposed algorithm better results. In Vignier and Venturini (1996) a parallel genetic algorithm for the hybrid flowshop problem was proposed. In this case, the shop consists of k stages with m parallel machines on each one and all the jobs have to be processed by one machine at each stage. The objective of the parallel algorithm, which is based on the master-slave model, is to reduce the computation time needed by the sequential version. Experiments were carried out with problems of up to five stages and 50 jobs using four computers (a master and three slaves), with the objective of makespan minimisation. Results show that slaves can evaluate twice the number of individuals than the serial counterpart. Wodecki and Bozejko (2002) presented a parallel simulated annealing based on the island model which starts from the solution provided by the NEH heuristic (Nawaz et al., 1983). The objective is again the makespan and the authors test the method with instances of up to 200 jobs and 50 machines. Experiments were carried out using four computers with and without communications. The best combination is formed by the four processors with communications, especially for the largest instances. Bozejko and Wodecki (2002) reported a parallel tabu search for the PFSP and the same optimisation objective. The method is tested using four computers where the best solutions are sent to the remaining islands from time to time. The authors use problems of up to 100 jobs and five machines and they compare the results with those obtained by the NEH heuristic (Nawaz et al., 1983) obtaining better results. In Oğuz et al. (2003) a parallel genetic algorithm for the multiprocessor tasks case is presented, that is, each task has to be processed by a set of machines in the same stage at the same time. The method is based on islands which run several execution threads, with communications from time to time. Problems of up to 300 jobs, two stages and two machines per stage are used. They use four or eight islands with up to 60 execution threads in each one. Another parallel genetic algorithm is given by Bozejko and Wodecki (2003) where the objective in this case is the minimisation of the total completion times of the jobs. The algorithm is based on the island model but crossover between individuals from different islands is allowed. Computational experiments were carried out with four islands and with problems of up to 50 jobs and 10 machines. They compare the results with and without communication among the islands and different parameter values. The best results were achieved by the four islands with communications and with different parameter values at each one. In Bozejko and Wodecki (2004) we can 6

find a parallel simulated annealing based on the master-slave model. In this case, slaves run the algorithms with different temperature values sending the best solutions to the master, which sends the best solution received back to all the slaves from time to time. Experiments were carried out in up to four computers and with problems of up to 50 jobs and 20 machines. They compare the results with the sequential counterpart obtaining an improvement of 40% in the effectiveness. Recently, the same authors presented another parallel genetic algorithm based on the island model (Bozejko and Wodecki, 2006) where the crossover operator is allowed between individuals from different islands. Instances of up to 100 jobs are solved using four islands. Results are compared with the serial version obtaining an important improvement in the quality of the solutions. Finally, Melab et al. (2006) proposed parallel metaheuristic methods for the PFSP considering two objectives at the same time, makespan and total tardiness. They use the grid technology with hundreds of idle heterogenous processors connected to different nets. The proposed method requires several days to return a solution.

3

Cooperative metaheuristics for the flowshop problem

Some conclusions can be drawn from the previous review. For the PFSP, most proposed methods deal with the makespan objective and in most cases instances no larger than 100 jobs are solved. Additionally, in many occasions the proposed parallel methods are compared against the sequential counterparts and not against state-of-the-art algorithms. As a result, it is not clear how these parallel methods would perform if compared against high performing metaheuristics. Regarding the parallel computing environment, there is no a clear trend about which one is the most suitable. The island and master-slave models are the most common. A possible explanation is that these two models can be tested with relative ease on affordable systems. In fact, it is very difficult to test a parallel method using different parallel computing environments since most of them consist of multiprocessor computers which are out of the scope of many researchers. In general, it seems that the master-slave model is used when the aim is to improve the efficiency of a sequential algorithm, that is, to reduce the execution time. On the other hand, when the objective is to improve the effectiveness of the sequential algorithm, the island model with cooperative algorithms is the most frequent. With respect to the comparison of results, most of the parallel methods available from the literature are compared only against priority rules, as well as against the serial versions. Comparisons of different parallel algorithms are not available, not even when the 7

methods are proposed by the same authors (Bozejko and Wodecki, 2002, 2003, 2004 and 2006). From the previous review it is clear that there are no parallel methods for the PFSP with the objective to minimise the total tardiness although this is a very important criterion in practice. For all these reasons and taking into account the good performance shown by genetic algorithms for this problem, we propose three cooperative genetic algorithms for the PFSP minimising total tardiness. Since the makespan criterion is the most studied in the literature, we also propose a cooperative genetic algorithm just as a cooperative iterated greedy method for the same problem minimising the makespan objective. More specifically, the three cooperative genetic algorithms proposed to minimise the total tardiness are based on those presented by Vallada and Ruiz (2007). The cooperative genetic algorithm and the cooperative iterated greedy method to minimise the makespan are based on Ruiz et al. (2006) and on Ruiz and Stützle (2007), respectively. However, and as we will see, the parallel versions incorporate a series of novel approaches and operators not applied to the PFSP before. The parallel architecture chosen is a set of independent computers since, as we have mentioned, this is very flexible and affordable. Moreover, the main goal is to improve the effectiveness of the sequential methods as they are very efficient already. The communications are carried out by message passing among computers and there is no master to coordinate the tasks. As a result, the parallel structure proposed is simple. The island model where each computer or node runs an independent instance of the algorithm. Experiments are conducted in a cluster of up to 12 computers with dual core processors (Intel Core 2 Duo) running at 2.4 Ghz each one with 1 GB of main memory. The islands are totally connected through a switch in a GigaLan network. The algorithms have been coded in Delphi 2006 and the communications package Msgconnect has been used (see http://www.msgconnect.com) for the communications among algorithms. In the following, we describe in detail the operators and parameters of the proposed methods. These are initially obtained from the calibrations carried out for the sequential algorithms of Vallada and Ruiz, 2007, Ruiz et al., 2006 and Ruiz and Stützle, 2007. It is important to note that the three sequential genetic algorithms proposed for the PFSP to minimise total tardiness include path relinking techniques and a procedure to control the diversity of the population (Vallada and Ruiz, 2007). Therefore, once the parallel environment is chosen, the main aspects to consider in the cooperative metaheuristic proposed are related to the migration operators. Other aspects are when and how individuals are sent, which individuals are to be sent and what to do with the received individuals. These aspects are discussed below.

8

3.1

Emigration Operator

When to send individuals to other islands (emigrants) is an important decision that clearly affects the performance of cooperative metaheuristics. There are several aspects involved in the emigration operator. First, when the initial emigration must occur. Second, how many times emigrants are sent throughout the execution of the algorithm. If the initial emigration occurs too soon, like for example, from the beginning of the execution, the islands might not have independently evolved to different solutions. The result is an algorithm with a large and mostly homogeneous population distributed among several computers. In order to avoid this situation, it is necessary to let the different islands evolve independently. By doing so, elite individuals selected for emigration are likely to be different and of better quality. For this reason and considering that the termination criterion for all the cooperative metaheuristics is a maximum elapsed CPU time, we evaluate two emigration schemes: to send from the beginning of the execution of the algorithm and to send when half of the maximum allotted CPU time has elapsed. Another aspect to consider is which individuals are selected for emigration. Clearly, a random selection of the individuals without control about their quality or without considering if they were already sent before does not seem a good option, since the network could be flooded with lots of useless messages. In the proposed methods, we carry out a selective selection which consists of sending only when an algorithm finds a new better solution, that is, we send one newly found better solution. Additionally, the emigration method used is cloning, i.e. a copy of the selected solution for emigration is sent to all the other islands. Furthermore, the emigration is carried out by a single ethernet broadcast packet thus enabling fewer and more effective communications in the local computer network. The aforementioned emigration operator, together with the broadcast technique renders the cost of communications as negligible. As a final note, the emigration operator is carried out in a separated process thread, which further reduces its interference with the algorithm. Taking into account all the aforementioned aspects, we can conclude that the proposed cooperative methods are asynchronous, since each island will send the best individual found in different moments.

3.2

Immigration operator

Reception of emigrants from other islands (immigrants) is done asynchronously. This means that each island has a queue of immigrants received from other islands which is managed in a separated processing thread. After sending emigrants, each island checks 9

wether the immigrant queue is empty or not. If it is empty, execution continues, otherwise immigrants are processed and a decision must be made about their acceptance. This acceptance consists of determining when and how the individuals are inserted into the current population. In the proposed algorithms we evaluate two alternatives. The first one is to immediately consider the received immigrants, that is, when an immigrant is received we have to decide if it forms part of the current population. This decision is related to the quality of the immigrant, if it is better than the worst individual in the current population of the island, the immigrant replaces this worst individual. An additional check is carried out and the immigrant is not included if this would result in clones in the population. This acceptance allows the proposed algorithms to overcome the problem of rapid convergence to local optima and enforces some degree of diversification in the islands. The second option to accept immigrants is motivated by the fact that in the proposed methods, procedures to control the diversity of the population together with restart mechanisms are applied. Taking advantage of this situation, a pool of received individuals is created and when the restart mechanism is applied to renew the population, individuals from the pool of immigrants are randomly selected. If the size of the pool is smaller than the population size, the remaining individuals are generated randomly in the restart procedure. Once the immigrants are inserted into the population, they are removed from the pool. For more details about the diversity and restart mechanisms, the reader is referred to Vallada and Ruiz (2007).

3.3

Calibration of the algorithms

We proceed now with the evaluation of the different algorithmic alternatives discussed earlier in order to obtain the best combination. We have to remind that the remaining regular operators and parameters were calibrated in the corresponding works where the sequential algorithms were proposed (Ruiz et al., 2006, Vallada and Ruiz, 2007, Ruiz and Stützle, 2007). We refer to the three cooperative genetic algorithms, based on the genetic algorithms of Vallada and Ruiz (2007) for the PFSP minimising total tardiness as CGA_PR, CGA_PR2 and CGA_DV, respectively. Regarding the remaining cooperative methods, we refer to the cooperative genetic algorithm and the cooperative iterated greedy for the PFSP minimising makespan as CGA and CIG, respectively (Ruiz et al., 2006, Ruiz and Stützle, 2007). Since the results of the calibration were similar and due to space limitations, we detail the calibration of one of the algorithms, more specifically the CGA_PR calibration. For this method, we control the following factors at the specified levels:

10

• Instant at which to start sending emigrants (Start): two values (start sending from the beginning or midway through the execution) • Process for accepting immigrants (Process): two values (Insert, Pool) For the experiments, we use a subset of the benchmark of instances proposed in Vallada et al. (2007) and used in Vallada and Ruiz (2007). The benchmark is formed by 540 problems with sizes ranging from 50 to 350 jobs and from 10 to 30 machines. The processing times of the jobs in the machines are uniformly distributed between 1 and 99 as it is common in the literature. The due dates are generated according to the Tardiness Factor (T ) and the Due Date Range (R) parameters with a uniform distribution between P (1 − T − R/2) and P (1 − T + R/2) following the method presented in Potts and Van Wassenhove (1982) which is often used in the literature. P is a tight lower bound of the makespan proposed by Taillard (1993). The following combinations for T and R are used: T = {0.2, 0.4, 0.6} and R = {0.2, 0.6, 1}. For the experiments, we select the hardest instances from the T and R factors point of view, that is, the highest T value (0.6) and the lowest R value (0.2). It has to be noted that the notation of “instance hardness” is in itself a rather complicated issue. However, high T values result in very early due dates and a low R value results in packed due dates. Both combined values yield instances in which the due dates are obviously hard to satisfy. Therefore, experiments are carried out with the subset of 60 instances where T =0.6, R=0.2 and where the number of jobs range from 50 to 350 and the number of machines from 10 to 30. The reason for selecting a part of the benchmark is due to the computation time needed to evaluate all the existing 540 problems. On the other hand, the use of cooperative metaheuristics is motivated by the difficulty of the problem to solve. Therefore, the effect of the cooperative mechanism is more easy to observe on hard instances, since for easy instances we can use sequential algorithms, which are much simpler. This benchmark along with the best solutions for each instance is available from http://www.upv.es/gio/rruiz. Each method is run five independent times and the stopping criterion for all algorithm alternatives in the experiment is set to a maximum computation time of n · (m/2) · 60 milliseconds. Setting the time limit in this way allows more computation time as the number of jobs or the number of machines increases. For the calibration we use the maximum number of available islands, that is, 12. Regarding the performance measure, we use the Relative Percentage Deviation (RP D) over the best solution: Relative Percentage Deviation (RP D) =

11

M ethodsol − Bestsol · 100, Bestsol

(1)

Where Bestsol is the best known solution and M ethodsol is the solution given by any of the alternatives for a given problem instance in the following way. For cooperative metaheuristics, we select the best solution among all the processors or islands for each replicate of each instance. Once we have this value, we compute expression 1. When we have a RP D value for each replicate, five in this case, we compute the average for these 5 replicates, obtaining the average RP D for each instance. However, in the case of the total tardiness flowshop problem, the best solution could be zero (and therefore optimal), so the above equation gives a division by zero. In this case, we avoid the division by zero because in the few cases were a given best solution was found to be zero, all other methods did also obtain this optimal solution. Therefore, the RP D will be zero for all the algorithms in these few cases. The results are analysed by means of a multifactor analysis of variance (ANOVA) where n and m are also considered as uncontrolled factors. First, we check the three main hypotheses of ANOVA: normality, homocedasticity and independence of the residuals (Montgomery, 2005). Residuals from the experiments satisfied all three hypotheses. We have two factors (Start and Process) apart from the number of jobs and machines, n and m. Due to the large number of data points, the observed p-values are very small. Therefore, we focus our attention on the F -ratio, that is, the ratio between the variance explained by a factor and the unexplained residual variance. The greater this ratio, the more effect the factor has over the response variable. We do not consider interactions of more than two factors since their F -ratios resulted to be very small. In order to set the factor levels, we select the factor or the interaction with the greatest F -ratio value, then we observe the means plot and we fix the most suitable level for the factor. Then we move to the second highest F -ratio value and repeat the process until all factors are fixed to a given level. In this case, for the CGA_PR, the highest F -ratio value corresponds to the factor Process. We can see the means plot with Tukey HSD intervals in Figure 1 where it is clear that the first level for the Process parameter is the best option, that is, to immediately consider the received immigrants. [Insert Figure 1 about here]

The next greatest F -ratio value corresponds to the factor m followed by the n, but these two factors can not be really controlled. Therefore, we focus our attention on the interaction between the two parameters we are calibrating, Process and Start. We can see the means plot in Figure 2. Taking into account that the Process factor has been set to the first level (Insert), the best option is to start the communications when half of the

12

maximum allowed CPU time has elapsed. Furthermore, the differences are visible across all the instances sizes and these are shown to be not only statistically significant, but also practically relevant. [Insert Figure 2 about here] Therefore, the best combination for the cooperative metaheuristics proposed is to send individuals when half of the total CPU time is elapsed. Although not shown here, identical calibration results are observed for the remaining proposed cooperative metaheuristics CGA_PR2, CGA_DV, CGA and CIG. This is a desirable outcome, since we can conclude that proposed cooperative scheme is not only simple, but also robust with respect to the underlying metaheuristic.

4

Computational results

As we have mentioned before, computational experiments are carried out considering two optimisation criteria, total tardiness and makespan. In the first case, we compare the results obtained with the three proposed cooperative genetic algorithms against the serial counterparts (Vallada and Ruiz, 2007) and against two methods proposed originally for a different objective and adapted to the total tardiness (Ruiz and Stützle, 2007, Ruiz and Allahverdi, 2006), since they showed a very good performance according to Vallada and Ruiz (2007). We refer to these methods as CGA_PR, CGA_PR2, CGA_DV, GA_PR, GA_PR2, GA_DV, IG_T and SGALS_T, respectively. In the second case, we proposed a cooperative genetic algorithm together with a cooperative iterated greedy for the makespan objective which are compared against the serial counterparts (Ruiz et al., 2006, Ruiz and Stützle, 2007). We refer to these methods as CGA, CIG, GA and IG, respectively. In order to check the effect of the communications, all the serial methods are tested in the same number of processors that the cooperative algorithms but in an isolated way, that is, without migration operators. In the next subsections we detail the experiments carried out for both objectives as well as the statistical analyses used to validate the results.

4.1

Tardiness criterion

To test the proposed and adapted methods, we use the same subset of instances as in the calibration section (3.3), from the complete benchmark available for download from http://www.upv.es/gio/rruiz. Recall that this benchmark subset is formed by 60 instances. As before, all methods have been coded in Delphi 2006 and run five independent 13

times on dual core computers with Intel Core 2 Duo processors running at 2.4 Ghz and each one with 1 GB of main memory. The stopping criterion for all methods is set to a maximum computation time of n · (m/2) · 90 milliseconds, that is, from 22.5 seconds for the smallest instances to 13.5 minutes for the largest instances. Cooperative algorithms and the serial counterparts are run in 4, 8 and 12 computers, allowing communications in the cooperative case. We use the Relative Percentage Deviation (RP D) again as the performance measure. The results for 4, 8 and 12 islands are shown in Tables 1, 2 and 3, where we have averaged the 25 results of each n × m group (the instance set contains 5 replicates for each n × m group and each instance has been tested 5 independent times). We can also see in Table 4 the results for the serial versions running in one computer. [Insert Tables 1-4 about here] The first interesting outcome is the good performance of the cooperative methods if we compare the results with the serial counterparts running in one computer (Table 4). We can see that the CGA_PR running on 4 islands improves a 57% the serial counterpart and a 116% and a 150% for 8 and 12 islands, respectively. These results are similar for the remaining cooperative methods. Note that the comparative percentages are computed following the expresion:

Asol − Bsol · 100, Bsol

(2)

where Asol and Bsol are the the average deviation obtained by the methods A and B according the expression (1) such that Bsol value is lower than Asol value. However, we should note that this comparison is unfair, since we are comparing the results obtained with one computer against the results obtained with several computers as well as with communications. For this reason, we evaluate the serial methods under the same conditions that the cooperative algorithms, that is, the serial metaheuristics are run in the same number of processors but without communications. In this way, we can check if the communications are improving the quality of the solutions. According to the results shown in Tables 1-3, we can see that with 4 processors or islands, the effectiveness of the serial methods is improved in almost a 19%. This difference increases as the number of islands increases, being 44% for 8 islands and 56% for 12 islands. This improvement in the effectiveness is greater if we compare the results with the IG_T metaheuristic, being the CGA_PR2 algorithm 74% better with 12 islands. We have to stress now that these improvements are now comparable, since the sequential metaheuristics and the cooperative ones use the same number of processors. As a result, the observed improvement can only be attributed to the communication schemes employed. 14

Regarding the comparison among the cooperative methods, we can see that the results are very similar regardless of the number of islands. The same behavior was obtained for the serial versions according to Vallada and Ruiz (2007). Nevertheless, we can clearly observe that the three proposed cooperative genetic algorithms yield much better results than those of the remaining methods when run isolated. In order to validate the results, it is interesting to check wether these observed differences in the RP D values are statistically significant. We apply an analysis of variance (ANOVA), (Montgomery, 2005), once the three hypotheses needed are checked. We consider as factors the number of processors or islands (p), the algorithm (Alg) and the size of the instance (n, m). The first factor to consider, according to the ANOVA’s results is the number of processors or islands (p). We can see in Figure 3 the means plot with HSD Tukey intervals (α=0.05). We can observe that the effectiveness of all algorithms improves as the number of processor or islands increases. This is an important result, specially for the cooperative methods, since it shows that the communication costs does not affect the performance of the algorithms. We have to recall that the stopping criterion used is the maximum CPU time. Results with 12 islands are the best, as is expected, but we have to take into account that the differences between 4 and 8 processors are much higher than those between 8 and 12 processors. [Insert Figure 3 about here] We can see in Figure 4 the corresponding means plot with HSD Tukey intervals for the algorithm factor (Alg). We can clearly see that there are statistically significant differences between the average RP D values. We can observe that the cooperative genetic algorithms show a very good and similar performance overcoming all other methods. We can also see that the serial methods show a very similar performance except for the IG_T whose results are slightly worse. [Insert Figure 4 about here] Another interesting result is the interaction between the p and Alg factors. In Figure 5 we see the corresponding means plot. As can be observed, the number of islands (p) affects in a much more clear way the cooperative methods. A very important observation is that the results obtained by the cooperative genetic algorithms with 4 islands are statistically similar to those obtained by the sequential methods running in 12 isolated processors. This again shows the good performance of the communications between the islands, resulting in very effective cooperative algorithms. [Insert Figure 5 about here] 15

4.2

Makespan criterion

As it has been mentioned in previous sections, makespan objective is the most widely studied in the scheduling literature. For this reason, we also study this objective and we propose two cooperative metaheuristic methods. More specifically, a cooperative iterated greedy algorithm (CIG) and a cooperative genetic algorithm (CGA). These two methods are based on two modern and effective sequential algorithms which are currently considered as state-of-the art (Ruiz and Stützle, 2007, Ruiz et al., 2006). Therefore, we evaluate and compare the results obtained by the cooperative methods with the sequential counterparts in the same conditions that in the previous section, that is, sequential methods run in the same number of processors that the cooperative algorithms but without communications. For the experiments we use the well known set of instances of Taillard (1993). This set is composed of 120 different problem instances ranging from 20 jobs and 5 machines to 500 jobs and 20 machines. The benchmark contains 10 repetitions for each considered combination of n and m and the processing times are uniformly distributed between 1 and 99. The response variable is the relative percentage deviation (RP D) of the solution given by the tested method over the lowest known upper bound for Taillard’s instances as of January 2007 (these values can be consulted in Taillard, 2007), and is calculated following the expression (1). The stopping criteria for all methods is set to a maximum computation time of n · (m/2) · 60 milliseconds following Ruiz and Stützle (2007) and Ruiz et al. (2006). In Tables 5 through 7 we can observe the results of the sequential and cooperative metaheuristics running in 2, 4, 6, 8, 10 and 12 islands, respectively. In this case, we increase the number of experiments in the processors since the observed differences are smaller than with the total tardiness criterion. [Insert Tables 5-7 about here] We can observe that in this case, the differences between sequential and cooperative methods are very small. It seems that the cooperative methods are slightly better but we clearly need an statistical analysis to make conclusions. Nevertheless, the effect of increasing the number of processors seems clear. If we focus our attention on the CIG method running in 12 islands, we can see that the effectiveness improves almost a 41% with respect to the same method running in just 2 islands. In a similar way, the CGA method running on 12 islands improves a 37% with respect to running on just 2 islands. Therefore, we now analyse the results from a statistical point of view, that is, we want to know if the small observed differences are statistically significant. We apply again an analysis of variance (ANOVA) (Montgomery, 2005), once the three hypotheses are checked. In Figure 6 we can see the means plot with HSD Tukey intervals (α=0.05). According 16

to the statistical analysis, we can observe that the small observed differences are statistically significant across all instances, that is, we can conclude that the cooperative method CIG is more than a 9% better than the sequential counterpart (IG) running in 12 islands. This difference is about a 6% in the case of the cooperative genetic algorithm CGA respect to the sequential version (GA). If we compare both methods, we can see that the iterated greedy is better than the genetic algorithm and this applies both sequential as well as for the cooperative versions. This also confirms the previous results of Ruiz et al. (2006). [Insert Figure 6 about here]

A final analysis comes from the fact that in Tables from 5 to 7 we can see that there are several groups of instances where the RP D obtained is zero or almost zero for all compared methods. For this reason, in order to obtain a better picture, we select a group of hard instances and we analyse again the results through an ANOVA. Specifically, the selected group consists of the 10 instances with 500 jobs and 20 machines. In Figure 7 we can see the means plot where we can observe that the differences in this case are larger than those observed when considering all the instances. The effectiveness of the IG method is improved almost a 11% with the cooperative version, being this difference almost a 18% in the genetic algorithm case, running in 12 islands. As a result, we can conclude that the cooperative metaheuristics show a very good performance, improving the results of the sequential methods running in the same number of processors, that is, the communication scheme is working. This result is even more clear for hard and large instances where the observed improvements are worthwhile. It has to be stressed that we are dealing with state-of-the-art serial algorithms for the permutation flowshop scheduling problem under makespan criterion. Considering that this problem has been under study for more than five decades, improvements in the quality of the results from 11% to 18% are specially compelling. [Insert Figure 7 about here]

5

Conclusions and future work

In this work, we have proposed new cooperative metaheuristic methods for the permutation flowshop problem considering two separated objectives: total tardiness and makespan. The implemented communication scheme is very simple yet very effective as the results have shown. The island model is used where each island runs an instance of the algorithm and communications occur in the following way: the first one is carried out when half of the 17

total CPU time is elapsed. By doing so, we allow for a certain level of evolution at each island before communications start. Once communications begin, subsequent ones occur only when new better solutions are found. With respect to the received individuals, they are considered immediately and accepted in the population if they are better than the worst individual of the current population and at the same time are unique, i.e., there are no other identical individuals already in the population. We have carried out an exhaustive comparison of the cooperative methods with the sequential counterparts running in comparable scenarios. All the methods have been evaluated in 4, 8 and 12 islands or processors (total tardiness criterion), and on 2, 4, 6, 8, 10 and 12 islands or processors for the makespan criterion case. Results have been carefully analysed by means of statistical procedures. Results show that the cooperative methods yield much better results than those of the sequential algorithms, specially for the total tardiness criterion, being these up to 56% better. For the makespan criterion, these differences are on average smaller. The cooperative methods show improvements of around a 10%. However, these improvements are larger for harder instances. Therefore, we can conclude that the communication scheme is working very well. We have to remark that this scheme is very simple and easy to implement on regular networks. Future research directions involve the consideration of heterogenous islands to test cooperative metaheuristic methods where each island runs a different algorithm, different parameter values for the same algorithm, etc. Other promising research venues involve more complex scheduling problems like those resulting from the addition of setup times or parallel machines at each processing stage.

References Adenso-Díaz, B. (1992). Restricted neighbourhood in the tabu search for the flowshop problem. European Journal of Operational Research, 62:27–37. Adenso-Díaz, B. (1996). An SA/TS mixture algorithm for the scheduling tardiness problem. European Journal of Operational Research, 88:516–524. Alba, E. (2005). Parallel Metaheuristics. A New Class of Algorithms. Wiley. Armentano, V. and Ronconi, D. (1999). Tabu search for total tardiness minimization in flow-shop scheduling problems. Computers & Operations Research, 26:219–235. Bozejko, W. and Wodecki, M. (2002). Solving the flow shop problem by tabu search. In Proceedings of the International Conference on Parallel Computing in Electrical Engineering, pages 1730–1737. Bozejko, W. and Wodecki, M. (2003). Parallel genetic algorithm for the flow shop schedul18

ing problem. In Parallel Processing and Applied Mathematics, LNCS, volume 3019, pages 566–571. Bozejko, W. and Wodecki, M. (2004). Parallel genetic algorithm for minimizing total weighted completion time. In Artificial Intelligence and Soft Computing, Lecture Notes in Artificial Intelligence, volume 3070, pages 400–405. Bozejko, W. and Wodecki, M. (2006). A new inter-island genetic operator for optimization problems with block properties. In Artificial Intelligence and Soft Computing, Lecture Notes in Artificial Intelligence, volume 4029, pages 334–343. Conway, M. (1963). A multiprocessor system design. In AFIPS Fall Joint Computer Conf, volume 4, pages 139–146. Culler, D. and Pal Singh, J. (1999). Parallel Computer Architecture, a hardware/software approach. Morgan Kaufmann. Farahmand Rad, S., Ruiz, R., and Boroojerdian, N. (2007). New high performing heuristics for minimizing makespan in permutation flowshops. OMEGA, The International Journal of Management Science. In press. Flynn, M. (1972). Some computer organizations and their effectiveness. IEEE Transactions on Computing, 9(21):948–960. Framinan, J. M., Gupta, J. N. D., and Leisten, R. (2004). A review and classification of heuristics for permutation flow-shop scheduling with makespan objective. Journal of the Operational Research Society, 55:1243–1255. Framinan, J. M., Leisten, R., and Rajendran, C. (2003). Different initial sequences for the heuristic of Nawaz, Enscore and Ham to minimize makespan, idletime or flowtime in the static permutation flowshop sequencing problem. International Journal of Production Research, 41(1):121–148. Gelders, L. and Sambandam, N. (1978). Four simple heuristics for scheduling a flow-shop. International Journal of Production Research, 16(3):221–231. Gill, S. (1958). Parallel programming. The Computer Journal, 1:2–10. Grabowski, J. and Wodecki, M. (2004). A very fast tabu search algorithm for the permutation glow shop problem with makespan criterion. Computers & Operations Research, 31:1891–1909. Gupta, J. N. D. and Stafford, Jr., E. F. (2006). Flowshop scheduling research after five decades. European Journal of Operational Research, 169:699–711. Hasija, S. and Rajendran, C. (2004). Scheduling in flowshops to minimize total tardiness of jobs. International Journal of Production Research, 42(11):2289–2301. Hejazi, S. R. and Saghafian, S. (2005). Flowshop-scheduling problems with makespan criterion: a review. International Journal of Production Research, 43(14):2895–2929. 19

Holland, J. (1959). A universal computer capable of executing an arbitrary number of subprograms simultaneously. In East Joint Computer Conference, volume 16, pages 108–113. Johnson, S. M. (1954). Optimal two- and three-stage production schedules with setup times included. Naval Research Logistics Quarterly, 1:61–68. Kalczynski, J. P. and Kamburowski, J. (2007). On the NEH heuristic for minimizing the makespan in permutation flowshops. OMEGA, The International Journal of Management Science, 35(1):53–60. Kim, Y. (1993). Heuristics for flowshop scheduling problems minimizing mean tardiness. Journal of Operational Research Society, 44(1):19–28. Kim, Y., Lim, H., and Park, M. (1996). Search heuristics for a flowshop scheduling problem in a printed circuit board assembly process. European Journal of Operational Research, 91:124–143. Kumar, V., Grama, A., Gupta, A., and Karypis, G. (1994). Introduction to Parallel Computing. Benjamin/Cummings. Ladhari, T. and Haouari, M. (2005). A computational study of the permutation flow shop problem based on a tight lower bound. Computers & Operations Research, 32:1831–1847. Melab, N., Mezmaz, M., and Talbi, E. (2006). Parallel cooperative meta-heuristics on the computational grid. a case study: the bi-objective flow-shop problem. Parallel Computing, 32:643–659. Montgomery, D. (2005). Design and Analysis of Experiments. John Wiley & Sons, New York, sixth edition. Murata, T., Ishibuchi, H., and Tanaka, H. (1996). Genetic algorithms for flowshop scheduling problems. Computers & Industrial Engineering, 30(4):1061–1071. Nawaz, M., Enscore, Jr, E., and Ham, I. (1983). A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem. OMEGA, The International Journal of Management Science, 11(1):91–95. Nowicki, E. and Smutnicki, C. (1996). A fast tabu search algorithm for the permutation flow-shop problem. European Journal of Operational Research, 91:160–175. Nowicki, E. and Smutnicki, C. (2006). Some aspects of scatter search in the flow-shop problem. European Journal of Operational Research, 169:654–666. Ogbu, F. A. and Smith, D. K. (1990). The application of the simulated annealing algorithms to the solution of the n/m/Cmax flowshop problem. Computers & Operations Research, 17(3):243–253. Onwubolu, G. and Davendra, D. (2006). Scheduling flow shops using differential evolution algorithm. European Journal of Operational Research, 171:674–692. 20

Onwubolu, G. and Mutingi, M. (1999). Genetic algorithm for minimizing tardiness in flow-shop scheduling. Production Planning & Control, 10(5):462–471. Osman, I. H. and Potts, C. N. (1989). Simulated Annealing for Permutation Flow-Shop Scheduling. OMEGA, The International Journal of Management Science, 17(6):551– 557. Oğuz, C., Fung, Y., Fikret Ercan, M., and Qi, X. (2003). Parallel genetic algorithm for a flow-shop problem with multiprocessor tasks. In Proceedings of the International Conference on Computational Science, pages 548–559. Springer. Ow, P. (1985). Focused scheduling in proportionate flowshops. Management Science, 31(7):852–869. Parthasarathy, S. and Rajendran, C. (1997a). An experimental evaluation of heuristics for scheduling in a real-life flowshop with sequence-dependent setup times of jobs. International Journal of Production Economics, 49:255–263. Parthasarathy, S. and Rajendran, C. (1997b). A simulated annealing heuristic for scheduling to minimize mean weighted tardiness in a flowshop with sequence-dependent setup times of jobs - a case study. Production Planning & Control, 8(5):475–483. Parthasarathy, S. and Rajendran, C. (1998). Scheduling to minimize mean tardiness and weighted mean tardiness in flowshop and flowline-based manufacturing cell. Computers and Industrial Engineering, 34(2):531–546. Pinedo, M. (2002). Scheduling: Theory, Algorithms and Systems. Prentice Hall, New Jersey, second edition. Potts, C. and Van Wassenhove, L. (1982). A decomposition algorithm for the single machine total tardiness problem. Operations Research Letters, 1(5):177–181. Rajendran, C. and Ziegler, H. (2003). Scheduling to minimize the sum of weighted flowtime and weighted tardiness of jobs in a flowshop with sequence-dependent setup times. European Journal of Operational Research, 149(3):513–522. Rajendran, C. and Ziegler, H. (2004). Ant-colony algorithms for permutation flowshop scheduling to minimize makespan/total flowtime of jobs. European Journal of Operational Research, 155:426–438. Raman, N. (1995). Minimum tardiness scheduling in flow shops: Construction and evaluation of alternative solution approaches. Journal of Operations Management, 85:131–151. Reeves, C. and Yamada, T. (1998). Genetic algorithms, path relinking, and the flowshop sequencing problem. Evolutionary Computation, 6(1):45–60. Reeves, C. R. (1993). Improving the efficiency of tabu search for machine scheduling problems. Journal of the Operational Research Society, 44(4):375–382. Reeves, C. R. (1995). A genetic algorithm for flowshop sequencing. Computers & Opera21

tions Research, 22(1):5–13. Ruiz, R. and Allahverdi, A. (2006). No-wait flowshop with separate setup times to minimize maximum lateness. International Journal of Advanced Manufacturing Technology. In press. Ruiz, R. and Maroto, C. (2005). A comprehensive review and evaluation of permutation flowshop heuristics. European Journal of Operational Research, 165:479–494. Ruiz, R., Maroto, C., and Alcaraz, J. (2006). Two new robust genetic algorithms for the flowshop scheduling problem. OMEGA, The International Journal of Management Science, 34:461–476. Ruiz, R. and Stützle, T. (2007). A simple and effective iterated greedy algorithm for the permutation flowshop scheduling problem. European Journal of Operational Research, 177:2033–2049. Stoppler, S. and Bierwirth, C. (1992). The application of a parallel genetic algorithm for the n/m/p/cmax flowshop problem. New Directions for Operations Research in Manufacturing, pages 161–175. Stützle, T. (1998). Applying iterated local search to the permutation flow shop problem. Technical report, AIDA-98-04, FG Intellektik,TU Darmstadt. Taillard, E. (1993). Benchmarks for basic scheduling problems. European Journal of Operational Research, 64:278–285.

Taillard, E. (2007). Summary of best known lower and upper bounds of Taillard’s instances. http://ina.eivd.ch/collaborateurs/etd/problemes.dir/ordonnancement.dir/ordonna Tasgetiren, M., Liang, Y.-C., Sevkli, M., and Gencyilmaz, G. (2007). A particle swarm optimization algorithm for makespan and total flowtime minimization in the permutation flowshop sequencing problem. European Journal of Operational Research, 177:1930– 1947. Tseng, F. T., Stafford, Jr, E. F., and Gupta, J. N. D. (2004). An empirical analysis of integer programming formulations for the permutation flowshop. OMEGA, The International Journal of Management Science, 32(4):285–293. Vallada, E. and Ruiz, R. (2007). New genetic algorithms with path relinking for the minimum tardiness permutation flowshop problem. Technical Report (Submitted), http://www.upv.es/deioac/Investigacion/technical_reports.htm. Vallada, E., Ruiz, R., and Minella, G. (2007). Minimising total tardiness in the m-machine flowshop problem: a review and evaluation of heuristics and metaheuristics. Computers & Operations Research. In press. Vignier, A. and Venturini, G. (1996). Resolution of a hybrid flowshop with a parallel genetic algorithm. In Proceedings of the Fifth International Workshop on Project Man22

agement and Scheduling, pages 258–261. Widmer, M. and Hertz, A. (1989). A new heuristic method for the flow shop scheduling problem. European Journal of Operations Research, 41:186–193. Wodecki, M. and Bozejko, W. (2002). Solving the flow shop problem by parallel simulated annealing. In Parallel Processing and Applied Mathematics, LNCS, volume 2328, pages 236–244. Ying, K. C. and Liao, C. J. (2004). An ant colony system for permutation flow-shop sequencing. Computers & operations Research, 31:791–801.

23

24 1.67

1.83

1.66

1.40

1.68 0.99 0.66 1.90 1.67 1.07 1.71 1.47 1.32 1.47 1.55 1.31 1.41

1.33 0.88 0.66 1.82 1.52 1.01 1.75 1.70 1.61 1.59 1.66 1.45

1.40

1.41 0.91 0.64 1.84 1.60 0.91 1.69 1.64 1.54 1.52 1.66 1.46

Table 1: Average Relative Percentage Deviation (RP D) for the sequential and cooperative metaheuristics running in 4 islands (tardiness criterion).

1.66

1.23 1.01 0.70 1.91 1.86 1.13 2.18 2.07 1.81 2.16 2.01 1.80

1.66

0.84 0.67 0.63 1.75 2.33 1.53 2.04 2.98 2.37 1.78 2.50 2.51

Average

1.63 0.92 0.64 1.91 1.83 1.23 2.05 2.05 1.79 1.98 2.20 1.81

1.67 1.05 0.68 2.30 1.88 1.37 2.03 1.89 1.68 2.00 1.79 1.52

50 × 10 50 × 30 50 × 50 150 × 10 150 × 30 150 × 50 250 × 10 250 × 30 250 × 50 350 × 10 350 × 30 350 × 50

1.48 0.98 0.57 1.86 1.83 1.19 2.18 2.10 1.86 2.07 2.08 1.73

GA_PR GA_PR2 GA_DV IG_T SGALS_T CGA_PR CGA_PR2 CGA_DV

Instance

25 1.45

1.63

1.44

1.02

1.36 0.80 0.59 1.51 1.13 0.76 1.13 1.02 1.18 1.03 0.91 0.83 1.04

1.02 0.65 0.50 1.41 1.16 0.81 1.29 1.32 1.10 1.01 1.18 1.03

1.10

1.20 0.76 0.52 1.17 1.49 0.77 1.24 1.27 1.20 1.14 1.37 1.02


1.50

1.06 0.81 0.51 1.63 1.53 0.92 2.01 1.82 1.61 1.86 1.85 1.63

1.47

0.54 0.60 0.48 1.55 2.04 1.32 1.86 2.89 2.13 1.45 2.40 2.24

Average

1.38 0.74 0.61 1.50 1.64 0.95 1.89 1.86 1.66 1.81 1.76 1.64

1.55 0.89 0.67 1.87 1.67 1.01 1.85 1.58 1.53 1.87 1.69 1.50

50 × 10 50 × 30 50 × 50 150 × 10 150 × 30 150 × 50 250 × 10 250 × 30 250 × 50 350 × 10 350 × 30 350 × 50

1.32 0.80 0.61 1.60 1.66 1.03 1.99 1.93 1.76 1.69 1.96 1.64


Instance

26 1.36

1.50

1.34

0.88

1.26 0.70 0.52 1.33 1.07 0.72 1.15 0.89 0.85 0.74 0.73 0.57 0.86

0.93 0.53 0.47 1.02 1.24 0.70 0.92 0.98 1.01 0.72 0.96 0.87

0.87

1.18 0.69 0.46 1.03 0.80 0.71 0.94 1.09 1.12 0.80 0.91 0.70


1.40

0.98 0.70 0.45 1.50 1.43 0.86 1.81 1.75 1.52 1.77 1.72 1.56

1.37

0.47 0.51 0.43 1.36 1.85 1.22 1.66 2.75 2.04 1.33 2.23 2.18

Average

1.30 0.68 0.55 1.42 1.49 0.86 1.73 1.76 1.57 1.71 1.71 1.51

1.38 0.82 0.60 1.82 1.59 0.90 1.75 1.47 1.42 1.73 1.53 1.37

50 × 10 50 × 30 50 × 50 150 × 10 150 × 30 150 × 50 250 × 10 250 × 30 250 × 50 350 × 10 350 × 30 350 × 50

1.19 0.77 0.51 1.50 1.49 0.93 1.86 1.84 1.67 1.61 1.84 1.55


Instance

Instance

GA_PR GA_PR2 GA_DV IG_T SGALS_T

50 × 10 50 × 30

2.30 1.36

2.01 1.24

2.20 1.22

1.69 1.23

2.39 1.51

50 × 50 150 × 10 150 × 30 150 × 50 250 × 10

1.02 3.10 2.67 1.60 2.85

0.87 2.82 2.54 1.67 2.90

0.90 3.09 2.65 1.79 2.74

0.88 2.33 2.75 1.91 2.69

1.06 2.80 2.30 1.52 2.79

250 × 30 250 × 50 350 × 10 350 × 30

2.62 2.31 2.29 2.24

2.68 2.32 2.65 2.70

2.65 2.37 2.67 2.45

3.65 3.01 2.64 3.31

2.57 2.22 2.51 2.50

350 × 50

2.07

2.14

2.13

2.93

2.12

Average

2.20

2.21

2.24

2.42

2.19

Table 4: Average Relative Percentage Deviation (RP D) for the sequential metaheuristics running in one processor (tardiness criterion).

27

Instance

p=2 IG CIG GA CGA

p=4 CIG GA CGA

IG

20 × 5

0.02 0.00 0.04 0.04

0.00 0.01 0.04 0.04

20 × 10 20 × 20 50 × 5 50 × 10 50 × 20

0.01 0.01 0.00 0.40 0.77

0.01 0.01 0.00 0.37 0.73

0.05 0.03 0.00 0.54 0.96

0.05 0.04 0.00 0.51 0.90

0.01 0.00 0.00 0.34 0.67

0.00 0.00 0.00 0.33 0.71

0.03 0.01 0.00 0.46 0.85

0.02 0.02 0.00 0.45 0.78

100 × 5 100 × 10 100 × 20 200 × 10

0.00 0.14 0.94 0.05

0.00 0.11 0.91 0.06

0.01 0.17 1.26 0.10

0.01 0.16 1.23 0.09

0.00 0.07 0.81 0.04

0.00 0.07 0.76 0.05

0.00 0.13 1.14 0.06

0.00 0.10 1.02 0.08

200 × 20 500 × 20

1.05 1.02 1.23 1.24 0.48 0.48 0.61 0.59

0.95 0.93 1.15 1.17 0.45 0.43 0.57 0.56

Average

0.32 0.31 0.42 0.41

0.28 0.27 0.37 0.35

Table 5: Average Relative Percentage Deviation (RP D) for the sequential and cooperative metaheuristics running in 2 and 4 islands (makespan criterion).

28

Instance

p=6 IG CIG GA CGA

p=8 CIG GA CGA

IG

20 × 5

0.00 0.00 0.04 0.04

0.00 0.00 0.04 0.03

20 × 10 20 × 20 50 × 5 50 × 10 50 × 20

0.00 0.00 0.00 0.33 0.62

0.01 0.01 0.00 0.32 0.59

0.02 0.01 0.00 0.42 0.77

0.02 0.01 0.00 0.38 0.72

0.00 0.00 0.00 0.31 0.58

0.00 0.00 0.00 0.30 0.54

0.02 0.01 0.00 0.41 0.74

0.02 0.01 0.00 0.38 0.70

100 × 5 100 × 10 100 × 20 200 × 10

0.00 0.06 0.77 0.03

0.00 0.05 0.74 0.04

0.00 0.11 1.07 0.05

0.00 0.09 1.02 0.08

0.00 0.05 0.71 0.05

0.00 0.04 0.63 0.03

0.00 0.11 1.01 0.06

0.00 0.07 0.95 0.06

200 × 20 500 × 20

0.91 0.84 1.13 1.11 0.43 0.42 0.56 0.49

0.90 0.81 1.11 1.02 0.42 0.38 0.55 0.49

Average

0.26 0.25 0.35 0.33

0.25 0.23 0.34 0.31


29

Instance

p = 10 IG CIG GA CGA

p = 12 CIG GA CGA

IG

20 × 5

0.00 0.01 0.04 0.03

0.00 0.00 0.04 0.03

20 × 10 20 × 20 50 × 5 50 × 10 50 × 20

0.00 0.00 0.00 0.31 0.54

0.00 0.00 0.00 0.32 0.54

0.02 0.01 0.00 0.39 0.67

0.02 0.01 0.00 0.37 0.69

0.00 0.00 0.00 0.30 0.54

0.00 0.00 0.00 0.30 0.50

0.02 0.01 0.00 0.37 0.66

0.02 0.01 0.00 0.34 0.67

100 × 5 100 × 10 100 × 20 200 × 10

0.00 0.05 0.69 0.04

0.00 0.04 0.64 0.05

0.00 0.09 0.96 0.06

0.00 0.08 0.86 0.06

0.00 0.04 0.67 0.04

0.00 0.04 0.65 0.04

0.00 0.09 0.94 0.06

0.00 0.07 0.90 0.06

200 × 20 500 × 20

0.86 0.80 1.09 1.03 0.41 0.37 0.54 0.49

0.83 0.78 1.08 0.98 0.41 0.37 0.53 0.45

Average

0.24 0.23 0.32 0.30

0.24 0.22 0.32 0.30


30

Relative Percentage Deviation (RPD)

1.25

1.15

1.05

0.95

0.85 Insert

Pool

Process Figure 1: Means plot and Tukey HSD intervals at the 95% confidence level for the type of immigrant process (Process) factor. CGA_PR calibration experiment and total tardiness criterion.

31

Start


1.26

Half Begin

1.17 1.08 0.99 0.9 0.81 Insert

Pool Process

Figure 2: Means plot and Tukey HSD intervals at the 95% confidence level for the interaction between the Process factor and the Start factor. CGA_PR calibration experiment and total tardiness criterion.

32


1.65

1.55

1.45

1.35

1.25

1.15 4

8

12

p Figure 3: Means plot and Tukey HSD intervals at the 95% confidence level for the number of islands (p) for the serial and cooperative metaheuristics. Total tardiness criterion.

33


1.7

1.6

1.5

1.4

1.3

1.2

1.1

1

V D_ A G

RP _A G

2R P_ A G

T_ G I

V D _ A G C

RP _ A G C

2R P_ A G C

T_ SL A G S

Algorithm Figure 4: Means plot and Tukey HSD intervals at the 95% confidence level for the algorithm factor (Alg). Total tardiness criterion.

34

p

Relative Porcentual Deviation (RPD)

1.9

4 1.7

8 12

1.5

1.3

1.1

0.9

0.7

V D _A G

RP _A G

2R P_ A G

T_ G I

V D _ A G C

RP _ A G C

2R P_ A G C

T_ SL A G S

Algorithm Figure 5: Means plot and Tukey HSD intervals at the 95% confidence level for the interaction between the algorithm factor (Alg) and the number of processors or islands (p). Total tardiness criterion.

35


0.36 0.34 0.32 0.3 0.28 0.26 0.24 GA

IG

CIG

CGA

Algorithm Figure 6: Means plot and Tukey HSD intervals at the 95% confidence level for the algorithm (Alg) factor (makespan criterion, 12 islands).

36


0.58 0.55 0.52 0.49 0.46 0.43 0.4 GA

IG

CIG

CGA

Algorithm Figure 7: Means plot and Tukey HSD intervals at the 95% confidence level for the algorithm (Alg) factor for 500 × 20 instances (makespan criterion, 12 islands).

37