Greedy heuristics for identical parallel machine scheduling problem with single server to minimize the makespan

This paper considers the problem of scheduling a set of n independent jobs on m identical parallel machines with setup times constraints. Immediately before processing, each job must be loaded on a common server to perform the setup operation. During the loading operation, both the machine and the server are occupied. Two greedy heuristics are developed for (m ≥ 2) in order to minimize respectively the server waiting time and the machine idle time. These heuristics generalize those proposed in the literature for the case of two machines. The computational results show the efficiency of the proposed heuristics.


Introduction
In this paper, we consider a parallel machine scheduling problem with a single server (PSS) and the minimization of the makespan. Throughout this paper we consider the static version of the problem were all jobs are available at the beginning of the schedule. Scheduling problem under server constraints are intensively studied, only for special cases such as equal setup time, equal processing time and equal length (the sum of setup time and processing time), regular job constraints or the case of two machines. In this paper, the case of an arbitrary number of machines for the PSS problem is studied.
The PSS problem is denoted by Pm, S 1|s j , p j |C max using the standard scheduling notation, where m represents the number of identical parallel machines, S 1 represents the only available server, and s j and p j are respectively the setup time of job j and its processing time. The objective function considered in this problem is the minimization of the makespan C max . The complexity has been studied by Kravchenko and Werner [1]. The authors showed that the problem Pm, S 1|s j = 1|C max is unary NP-hard and analyze several list scheduling heuristics. The complexity for the case of two machines and also an arbitrary number of machines is discussed by Bruker et al. [2] for all of the well-known objective functions C max ; C j ; w j C j ; U j , w j U j ; T j ; w j T j and L max .
In 2006 Abdelkhodaee et al. [5] extended their previous study in [4], [3] dealing with the regular case where p i − p j ≤ s j ∀i, j and the case of equal setup time and equal processing (see also [13]) for the P2, S 1|s j , p j |C max . The authors proposed two greedy heuristics, a genetic algorithm, and the Gilmore-Gomory algorithm for the gene-mail: abdelhakelidrissi@research.emi.ac.ma eral case of the P2, S 1||C max . The analysis started in [5] has been extended by Gan et al. [6], in which two mixed integer linear programming formulations and two variants of a branch-and-price scheme were developed.
Moreover, Hasani et al. [7] developed two metaheuristics namely simulated annealing (SA) and genetic algorithm (GA), for the problem P2, S 1||C max . The results obtained are much better than all the previous algorithms and models proposed in [5], [6]. Hasani et al. [8] proposed also two algorithms to solve very large instances for P2, S 1||C max . The computational results showed that the two algorithms outperformed the precedent methods existing in the literature, however, for small-sized and mediumsized instances, the results obtained were not promising.
Recently, Arnaout [9] proposed an ant colony optimization (ACO) metaheuristic for P2, S 1||C max . The computational results showed that the proposed method outperformed the metaheuristics (SA) and (GA) proposed in [7] for large instances of the problem. The problem with several machines (m ≥ 3) was only studied by Kim and Lee [10]. The authors proposed two mixed integer programming formulations. The first one is developed using assignment and positional date variables, and the second one is developed by adding the concept of the server waiting time. A hybrid heuristic algorithm combining simulated annealing and tabu search is also suggested.
The remainder of this paper is organized as follows. In Section 2, we present the problem formally. In Section 3, two greedy heuristics algorithms for an arbitrary number of machines are proposed with two lower bounds. We conduct computational experiments in Section 4 to show the performance of those heuristics in comparison with the literature. The conclusion and future works end this paper.

Problem description
The aim of this section is to give a detailed description of the PSS problem. It can be described as follows. Suppose there are m identical parallel machines which must process n independent jobs. Each job i has a known integer processing time p i . Immediately before its processing, job i must be loaded on a machine by the server. This duration, which can be also considered as a setup operation has a known integer value s i . During the setup operation, both the machine and the server are occupied and after loading a job on a particular machine the server becomes available for loading the next job. The processing operation starts immediately after the end of setup. The preemption during setup and processing operations of jobs is not allowed. The objective is to find a feasible schedule that minimizes the makespan.
The following notations are used to define the problem throughout the paper: • n: number of jobs.
• m: number of machines.
• p i : the processing time of the job i. • R 1 : Sort the jobs in increasing order of their processing times (SPT).
• R 2 : Sort the jobs in decreasing order of their processing times (LPT).
• R 3 : Sort the jobs in increasing order of their setup times (SST).
• R 4 : Sort the jobs in decreasing order of their processing times (LST).
• R 5 : Sort the jobs in increasing order of the sum of their processing and setup times (SPST).
• R 6 : Sort the jobs in decreasing order of the sum of their processing and setup times (LPST).

Two Greedy heuristics
In this section, we propose two complementary greedy heuristics called HS1 and HS2 for the PSS problem under consideration in order to minimize respectively the server waiting time and the machine idle time. Indeed, it has been shown that the minimization respectively of the total server waiting time (i.e. the gaps between the loading of two jobs) and the minimization of the machine idle time is equivalent to the minimization of the makespan (see Kim and Lee [10]). The basic aim at each step of the two heuristics is, if possible, not to generate any machine idle time or any server waiting time.

Greedy heuristic HS1
This heuristic HS1 aims, to minimize machine idle time (the time machines are idle due to unavailability of the server). The pseudo-code of the proposed heuristic is as follows (see Algorithm 1).
In the first step jobs are arranged in a list in increasing order of their setup times. Then the first available m − 1 jobs of the list are sequenced on the first available machines. After that, we sort the available unsequenced jobs according to some criterion and then choose an eligible job (i.e. one that would not create any machine idle time). If no eligible jobs exist we select the first job in the list. The list may be arranged in decreasing or increasing order of job lengths, setup times or processing times.

Illustrative example
Given an instance of n = 10 jobs and m = 3 machines. The processing times p i and setup times of the jobs s i are given in Table 1. The makespan value can be obtained by applying the heuristic HS1 as given above. It takes 0.002 seconds to solve the problem with the heuristics HS1. All the heuristics have been implemented using C++ language on a personal computer Intel(R) Core(TM) i5-2410M CPU @ 2.30 GHz with 8 GB of RAM memory. The feasible sequence is shown in Figure 1. With a value of the objective function (makespan) of 53. Job 1 2 3 4 5 6 7 8 9 10 p i 9 11 13 6 8 14 9 8 7 9 s i 2 4 6 1 3 10 5 4 3 7 Table 1: Example instance with (n = 10, m = 3) In this illustrative example, we sort the initial list of jobs in increasing order of their setup times, then we schedule the first m−1 jobs on the first available machines, after this step, we sort for the second time the remaining jobs with the R 2 rule (longest processing time) and we start the job selection. Thus job J4 and job J1 are considered as the first jobs. Then, the third job must be scheduled on the first available machine (machine M3) and a decision must be made according to the end of the setup time of the last scheduled job J1, the completion time of the last job scheduled on the next available machine, in this step the machine M1 was the next available one and the completion time of last job scheduled on the current available machine. Indeed, to minimize the machine idle time as much as possible, the best way is to choose a job whose loading time is less than or equal to the completion time of the next available machine minus the maximum value of the end of setup time of the last scheduled job in the finale list B and the completion time of the last job scheduled on the current available machine. Thus, the job J2 has to be selected as the third job. The fourth unscheduled job, which has to be determined, must be scheduled on the first available machine (machine M1) and must have a set-up time less than or equal to the completion time of the next available machine (Machine M2) minus the maximum value of the end of setup time of the last scheduled job (job J2) and the completion time of the last job scheduled on the current available machine (job J4). Among the remaining unscheduled jobs, job J7 will be chosen. And so on until scheduling all of the remaining jobs.

Greedy Heustic HS2
In this section, we present the second greedy heuristic HS2 to minimize the gap between the completion time of the setup operation of a job and the start of setup operation of the next job. Contrarily to the heuristic Min-loagap proposed for the case of two machines by Hasani et al. [8] where the jobs were scheduled in staggered order on machines (i.e. jobs alternate between machines), in this heuristic the jobs are scheduled according to the availability of the machines. And the job with the minimal processing time is considered as the last job to be scheduled in the final sequence.

Illustrative example
Given an instance of n = 10 jobs and m = 4 machines. The processing times p i and setup times of the jobs s i are given in Table 2. The makespan value can be obtained by applying the heuristic HS2 as given above. It takes 0.002 seconds to solve the problem with the heuristics HS2. The feasible sequence is shown in Figure 2. With a value of the objective function (makespan) of 90. In this example equality C max = LB holds.  In this illustrative example, we sort the initial list of jobs according to the longest processing time rule (R 2 ), then we schedule the first m − 1 jobs on the first available machines, and the job with the minimal processing time   is scheduled in the last position of the schedule. Thus job J8, job J3 and job J7 are considered as the first jobs. After this step, we start the job selection. The fourth job must be scheduled on the first available machine and a decision must be made according to the end of the setup time of the last scheduled job J7, the completion time of the last job scheduled on the next available machine, in our case the machine M1 was the next available one and the completion time of last job scheduled on the current available machine. Indeed, to minimize the server waiting time as much as possible, the best way is to choose a job whose loading time is greater than or equal to the completion time of the next available machine minus the maximum value of the end of setup time of the last scheduled job in finale list B and the completion time of last job scheduled on the current available machine. Thus, the job J9 has to be selected as the fourth job. The fifth unscheduled job, which has to be determined, must be scheduled on the first available machine (machine M1) and must have a set-up time greater or equal than the completion time of the next available machine (machine M2) minus the maximum value of the end of setup time of the last scheduled job and the completion time of last scheduled on the current machine (job J8). Among the remaining unscheduled jobs, job J6 will be chosen. And so on until scheduling all of the remaining jobs.

Lower bounds
The investigation of lower bounds is useful for benchmarking heuristic solutions. Thus, to evaluate the quality of the solutions, the following lower bounds are proposed.
is a lower bound for the problem of P, S ||C max .
Proof. by contradiction: In contradiction with the fact that the makespan cannot take a value less than the sum of the processing times and the setup times of all jobs divided by the number of machines. Proof. In an optimal schedule, the solution will have a value of 1≤ j≤n s j plus the processing time of the last scheduled job. Indeed, the makespan is equal to the sum of setup times plus the total server waiting times as shown by Kim et al. [10] i.e. C max = 1≤ j≤n s j + S WT T (with: S WT T is the total server waiting time) and in an optimal schedule the total server waiting time will be equal to the processing time of the last executed job. So to obtain a good lower bound, the last scheduled job in the sequence should have the smallest processing time.
Combining the two lower bounds LB1 and LB2, we obtain an overall lower bound LB = max{LB1; LB2} on the value of the makespan solution C max . To show the effectiveness of the lower bound, we have compared it with the linear relaxation of the MIP models proposed by El idrissi et al. [11] for several instances. We have found that our LB is approximately equal to the linear relaxation for the majority of the cases, which shows its effectiveness.

Computational experiments 4.1 Description of data
In this section, we conduct a computational experiment where the above, heuristics HS1, HS2 and lower bounds are implemented. The data was generated in the same way as described firstly by Koulamas [12], and also described lately by Abdekhodaee and Wirth [3] and Hasani et al. [8]. The data are generated in the uncorrelated case, where the processing time values p j are generated from a discrete uniform distribution U(0, 100) and setup time values s j are generated from a discrete uniform distribution U(0, 100L) where L = E(s j )/E(p j ) is the server load and E(x) denotes the mean of x.
HS1 was used for instances with LB = LB1, and HS2 for the instances with LB = LB2. From the experiments, it turned out that for all instances with L ∈ {0.1, 0.5, 0.8}, equality LB = LB1 always holds and for all instances with L ∈ {1.5, 1.8, 2}, equality LB = LB2 always holds. However, for the instances with L = 1, both lower bounds have to be taken into account. In the following, if L ∈ {0.1, 0.5, 0.8} HS1 is only used and if L ∈ {1.5, 1.8, 2} HS2 is only used.
In order to compare the performance of our proposed heuristics with the literature, three factors are used: a fixed number of machines, the problem size fixed to three levels: small-size instances with n ∈ (8, 20), medium-size instances with n ∈ (30, 40, 50, 100) and large-size instance with n ∈ (200, 250, 300, 350). The server load is also fixed to L ∈ {0.1, 0.5, 0.8, 1.5, 1.8, 2}, for each value of the server load 5 instances are generated randomly for n ∈ {8, 20} and 10 instances were generated randomly for each of the other value of n, m and L.

Performances
To evaluate the efficiency of the proposed heuristics, computational experiments were designed and conducted. The computational results with HS1 for small, medium and large-sizes instances are given in Table 3 and Table 4 and the computational results with HS2 for small, medium and large sizes instances are given in Table 5 and Table 6. In  Tables 3, 4, 5, 6 , column 1 gives the number of jobs, column 2 gives the number of machines, column 4 until the last column give the values R avg , denoting the average value of the ratio C max /LB, and R max , denoting the maximum value of the ratio C max /LB among all instances for a particular value of L and for a particular heuristic.
Comparing the obtained results for HS1 with the results in Hasani et al. [8] for the Min-idle algorithm which we denote as (Mit) and the results in Abdekhodaee and Wirth [3] for forward heuristic which we denote as (FH) and also comparing the obtained results for HS2 with the results in Hasani et al. [8] for the Min-loadgap algorithm which we denote as (Mlg) and the results in Abdekhodaee and Wirth [3] for backward heuristic which we denote as (BH) when using the same instances, the following summary can be given: In Table 3, HS1 is compared with FH and Mit for L ∈ {0.1, 0.5, 0.8} and for m = 2 since FH and Mit can be applied to only the case of two machines. It must be noted that FH and Mit provide the same result for all proposed instances. With R 2 (LPT) rule and for the case of L = 0.1 HS1 outperform by far the two heuristics FH and Mit for the majority of cases. For L = 0.5 and L = 0.8 FH and Mit are better than HS1 for the two proposed scheduling rules R 2 and R 4 .
In Table 4, HS1 is compared with FH in the case of L = 0.1 for medium/large instances. It is observed that HS1 with the LPST rule is better than FH in term of deviation from the lower bound in the most of the data sets n ∈ {50, 100, 150, 200}. In some cases of n ∈ {250, 300, 350}, HS1 with the LST rule gives the same results in comparison with FH.
In Table 5, HS2 is compared with BH and Mlg for small size instances. The symbol * is used to specify that no solution can be found since Mlg was proposed only for the case of two machines and for BH we adapted the algorithm for the case of arbitrary number of machines. With R 2 (LPT) rule and for the case of m ∈ {2, 3, 4, 5} HS2 is better than BH in term of deviation from the lower bound for some cases for m ≥ 2 and also it gives less precise results in comparison with Mlg.
In Table 6, HS2 is compared with BH for medium/large instances. With LPT rule and for m ∈ {3, 4, 5}, HS2 outperform BH in term of deviation from the lower bound for the most cases and for all values of the server load L ∈ {1.5, 1.8, 2}. Therefore, with LST rule the heuristic HS2 gave less precise results in comparison with BH and with the R 2 rule also. It must be noted that the solution time with all proposed heuristics (HS1, HS2, BH, FH, Mit, Mlg) and for all proposed instances don't exceed 0,006 seconds.

Conclusion
In this contribution, the problem Pm, S 1|s j , p j |C max was considered. Two greedy heuristics were proposed to solve this problem for small, medium and large instances. The first one was developed for instances with LB = LB1, and the second one for instances with LB = LB2. The heuristics performed extremely well in terms of the deviation from the proposed lower bounds for small/medium and large instances and also in terms of the low computational times. A performance comparison was performed between these two heuristics and other heuristics proposed in the literature for the case of two machines and also an arbitrary number of machines. The comparison shows that our heuristic HS1 outperform the literature in term of deviation from the lower bound in some cases. And the heuristic HS2 outperforms by far the literature for the case of arbitrary number of machines. In future work, it is intended to investigate several types of metaheuritics for the parallel machine scheduling problem with single server, and also take into consideration other types of objective functions such as the total completion time or the total tardiness.