Job shop scheduling with makespan objective : A heuristic approach

Article history: Received July 2 2013 Received in revised format September 7 2013 Accepted November 23 2013 Available online November 22 2013 Job shop has been considered as one of the most challenging scheduling problems and there are literally tremendous efforts on reducing the complexity of solution procedure for solving job shop problem. This paper presents a heuristic method to minimize makespan for different jobs in a job shop scheduling. The proposed model is based on a constructive procedure to obtain good quality schedules, very quickly. The performance of the proposed model of this paper is examined on standard benchmarks from the literature in order to evaluate its performance. Computational results show that, despite its simplicity, the proposed heuristic is computationally efficient and practical approach for the problem. © 2014 Growing Science Ltd. All rights reserved


Introduction
The job shop scheduling problem (JSP) is one of the most popular scheduling problems in the world (Jain & Meeran, 1998).It has attracted many researchers due to its wide applicability and inherent difficulty (Carlier & Pinson, 1989;Kolonko, 1999;Nowicki & Smutnicki, 1996;Yamada & Nakano, 1996;Ho et al., 2007).In the n×m classical JSP, set of n jobs must be processed on a group of m machines, where the processing of each job i consists of J i operations performed on these machines.Each job has a pre-specified processing order on the machines, which is fixed and known in advance, i.e., each operation needs to be executed on a given machine.Moreover, the processing times of all operations are also fixed and known in advance.Each machine is continuously available from time zero and can process at most one operation at a time.The operations are processed on all machines without interruption (Baker, 1974;Pinedo, 2002).A common objective function is to minimize the makespan, which is the time needed to complete all the jobs.
In this paper, we present a heuristic method based on a constructive procedure to solve the JSP with the objective of minimizing makespan (section 3).The primary objective is to produce reasonable and applicable schedules, very quickly.It can also be used to improve the quality of the initial feasible solution of metaheuristics applied to solve the problem, since the choice of a good initial solution is an important aspect of the performance of the algorithms in terms of computation time and solution quality (Dell'Amico & Trubian, 1993;Matsuo et al., 1988;Van Laarhoven et al., 1992).In order to evaluate the performance of the proposed heuristic, The proposed mode has examined on several wellknown benchmarks and the results of the computational experiments are presented (section 4).The results show that our novel method can obtain good solutions in very short time.Concluding remarks are given in the last section.
Other assumptions considered in this paper are as follows: (1) Jobs are independent of each other.
(2) Machines are independent of each other.
(3) Setup and transportation times are negligible.(4) All jobs have equal priorities.
(5) All jobs are available at time zero.
The notations used throughout the paper are as follows: n: number of jobs, m: number of machines, i,z: index of jobs; i,z=1,…,n, j: index of operations; j=1,…, m, k,y: index of machines; k,y=1,…,m, t ij : processing time of operation j of job i, t′ iy : processing time of job i on machine y, that is the processing time of an operation of job i which is processed on machine y, c ij : completion time of operation j of job i.

Literature review
The JSP has been proven to be NP-hard (Garey et al., 1976).Therefore, only small size instances of the JSP can be solved optimally with good computational time using exact solution methods (Carlier & Pinson, 1989;Lenstra, 1976).When the problem size increases, the computational time of exact algorithms grows exponentially.Heuristic algorithms have generally acceptable time and memory requirements to obtain a near-optimal or optimal solution.During the past few decades, most researches on the JSP have been concentrated on developing heuristic algorithms (Jain & Meeran, 1998;Blazewicz et al., 1996;Vaessens et al., 1996).Balas and Vazacopoulos (1998) developed a guided local search algorithm rooted in a specialized neighborhood tree for the JSP, which is considered as one of the most efficient neighborhood structures and algorithms for this problem.Pezzella and Merelli (2000) presented a heuristic algorithm based on a combination of tabu search (TS) method and shifting bottleneck (SB) procedure to solve the JSP.The SB was used to generate a good initial feasible solution, and a local re-optimization, based on the same procedure, was used to improve each current solution determined by the TS.Huang and Liao (2008) presented a hybrid approach combining ant colony optimization (ACO) algorithm with a TS algorithm to solve the JSP.In this hybrid algorithm, ACO was used to provide an appropriate initial schedule, and TS was applied to improve the solution quality.The proposed ACO algorithm employed a new decomposition method inspired by the SB procedure, and a mechanism of occasional re-optimizations of partial schedules.Zhang et al. (2008) presented a hybrid TS-SA algorithm in which simulated annealing (SA) was used to find the promising elite solutions inside big valley (BV) and TS intensified search around these solutions.This hybridization can reduce the influence of the initial solution in the TS algorithm.Rego and Duarte (2009) presented a heuristic algorithm based on a filter-and-fan (F&F) procedure for the JSP, which uses the SB procedure as a constructive method to generate a starting solution and to enhance the best schedules produced and a dynamic and adaptive neighborhood search procedure.The F&F approach is a local search procedure that generates compound moves by an abbreviated form of tree search.Fıglalı et al. (2009) conducted a statistical experiment on the JSP.They presented an ACObased software system to solve the problem and the parameters of this system were investigated on various sizes and randomly generated job shop scheduling problems by using design of experiments.The effects and interactions of the parameters were interpreted with the outputs of the experiments.Luh and Chueh (2009) presented a multi-modal immune algorithm to solve the JSP emulating the features of a biological immune system.Operation-based antibody/schedule representation was adopted to guarantee feasible schedules.The exploration and exploitation of solutions within a search space were realized through the procedures, which resemble antibody molecule structure, antibody-antigen relationships in terms of specificity, clonal proliferation, germinal center, and the memory characteristics of adaptive immune responses.Lin et al. (2010) presented a hybrid algorithm called MPSO consisting of particle swarm optimization (PSO), a multiple-type individual enhancement (MIE) scheme based on SA technique, and random-key (RK) encoding scheme for solving the JSP.The MPSO adopts continuous space as the search space called RK space and uses the RK encoding scheme to transform a position in RK continuous space to a discrete space, since the search space in the JSP is a discrete space.In RK space, a position of a particle composed of n×m real numbers can represent the permutation of all operations of all jobs by the encoding scheme.Asadzadeh and Zamanifar (2010) proposed an agent-based parallel genetic algorithm for the JSP.The agent-based parallel approach was used to parallelize the genetic algorithm and to accelerate the creation of the initial population of genetic algorithm.Some other recent studies on the problem are: (Gao et al., 2011;Kammer et al., 2011;Lochtefeld & Ciarallo, 2011;Mati et al., 2011;Sels et al., 2011;Ponsich & Coello, 2013;Zhang et al., 2013).

Proposed heuristic approach
In this section, a heuristic method is presented to solve the problem.This approach is motivated by the idea of developing a constructive heuristic, which considers simultaneously many factors influencing the solution quality and intelligently balances their effects, in the process of schedule generation, and the observation that it could lead to good results in some preliminary computational experiments on a wide range of complicated scheduling problems.This algorithm has a simple structure, is easy to implement, and requires very little computational effort; which makes it preferable over other more complex and time-consuming approaches, even if its results for benchmark instances are so weakly dominated the lower bounds in the literature.Some notations that will be used in the algorithm are defined as follows: sj i : total processing time of job i (i.e.,, ), sk y : total processing time on machine y which is calculated as follows: An outline of the proposed heuristic algorithm is given in Fig. 1. until all operations of all jobs are scheduled, repeat {  Find i, j (such that: 1. j=1 or (j-1)th operation of job i is already scheduled, and 2. jth operation of job i is unscheduled) that minimizes TC.
 Schedule jth operation of job i on the last position of current partial sequence on machine k (the machine capable of processing operation j of job i).}

Fig. 1. General outline of the proposed heuristic algorithm
The pseudocode of the proposed heuristic is shown in Fig. 2. In this algorithm, each unscheduled operation (i, j) (operation j of job i) to be scheduled on machine y is evaluated by the following criterion, and the unscheduled operation with minimum TC is selected for scheduling.
TC is weighted sum of some criteria which are established based on the factors affecting the objective function value.Minimization of TC in the process of schedule generation leads to improvement in solution quality.w r (r=1,2,…,6) are constants and x r (r=1,2,…,6) are integer variables used to increase the flexibility and effectiveness of criterion TC and have a significant impact on the performance of the algorithm.The constant weights (w r ) are preliminary estimated weights assigned to criteria according to their importance, and the coefficients x r are variables bounded in a given range and used to refine the TC.Cmax y is the maximum completion time across all the operations scheduled on machine y; that is, Cmax y is equal to the completion time of the operation situated just before operation j of job i on machine y.C 1 , C 2 and C 3 are applied to decrease Cmax y , idle times, and flowtime of jobs, respectively; clearly, all these three objectives affect the main objective function, i.e.C max .For assigning operations to a machine, their processing time are also taken into account by C 4 .According to C 5 , the jobs with larger sj i , are scheduled sooner.C 6 is used for taking into account the total processing time of machines.
Other notations used in the pseudocode of the proposed heuristic are as follows: TC*: denotes the best value of TC.After scheduling each operation, TC* is reset to M. L_x r (r=1,2,…,6): lower limit of x r .U_x r (r=1,2,…,6): upper limit of x r .
As it can be seen in the pseudocode of the heuristic, the algorithm first sorts the jobs in decreasing order of their sj i and then uses this order for evaluating their operations.Therefore, if two unscheduled operations belonging to two different jobs have the same value of TC, then according to this sorting of the jobs, the operation of job with greater sj i is selected for scheduling sooner than the other operation.This sorting may lead to better solutions.x r * (r=1,2,…,6) are the best values of variables x r (i.e. the values corresponding to the best solutions).Indeed, for various values of x r (r=1,2,…,6), the algorithm of Fig. 1 is run and a complete schedule is generated.Among all these schedules, the one with minimum makespan is reported as the final solution.The values of variables x r for this best solution are also reported and denoted by x r * (see Table 2).As mentioned earlier, the evaluation of the operations for scheduling them is done using the criterion TC, i.e. the unscheduled operation with minimum TC is selected for scheduling.

Initialization:
 Sort the jobs in increasing order of their sji and call the resulting set: i_sort.Let i_sortz be zth job of the list i_sort.

Computational results
This section describes the computational experiments conducted in order to evaluate the performance of the proposed heuristic method.First, some preliminary experiments have been conducted for the parameter settings.Regarding the test on various values for the parameters of the algorithm and considering the computational results, we use the settings of Table 1 for benchmarking the presented algorithm.The algorithm is coded in C language and run on a Pentium IV, 2.2 GHz and 2.0 GB RAM PC.Three sets of benchmark problem instances are considered: 32 instances denoted as (LA01−LA32) presented by Lawrence (1984), 3 instances (FT6, FT10, FT20) of Fisher and Thompson (1963), and 9 instances (ORB01−ORB9) of Applegate and Cook (1991).All the instances can be downloaded from OR-Library web site (http://people.brunel.ac.uk/~mastjjb/jeb/info.html).Table 2 shows a comparison of the makespan results of our algorithm with those of the recently published algorithm: the parallel agentbased genetic algorithm (PaGA) proposed by Asadzadeh and Zamanifar (2010).The first four columns provide the problem name, its size in terms of the number of jobs (n) and machines (m), and the best known solution (BKS) for each instance.The results obtained by proposed algorithm are shown in the last nine columns.Cmax and Time(s) stand for the makespan and the computational time (in seconds), respectively.The best values of variables x r (i.e.x r * ), r=1,2,…,6; are also reported in Table 2. Average values of x 3 , x 4, x 5 and x 6 are negative, that means they have adverse effect on C max .RPD is the relative percentage deviation to BKS and calculated as follows: where Cmax alg is the makespan obtained by the algorithm.PaGA and our algorithm have average RPD values of 4.27 and 5.91, respectively.Herein, the heuristic is statistically compared with PaGA.A oneway analysis of variance (ANOVA) (Montgomery, 2000) is performed to test the null hypothesis that the means of the two methods are equal.The results of this ANOVA are presented in Table 3.As can be seen, the difference between the methods is not meaningful at a significance level of 5%.However, the heuristic is very fast, and needs less than 0.5 sec.on average for all instances.

Conclusion
This paper has investigated the job shop scheduling problem with the objective of minimizing the makespan.The main purpose was to produce reasonable schedules very quickly.A simple and easily extendable heuristic based on a constructive procedure has been presented.The algorithm has beed examined on benchmark instances from the literature in order to evaluate its performance.The computational results have shown that even the relatively straightforward implementation of the approach as presented here, could yield good quality solutions with very little computational effort.
Since the proposed method is a heuristic, its results cannot be compared in a meaningful way with those of the methods evaluated as they are metaheuristic based algorithms.However, the computational times show the interest of the heuristic, since in a fraction of a second on average, it produces very good solutions.Although the solutions produced by this simple heuristic are weakly dominated the solutions of the metaheuristic methods evaluated, the procedure is useful in applications that deal with real time systems and that involve the generation of initial schedules for local search and metaheuristic algorithms.Further research needs to be conducted in applying other criteria in the TC in order to improve the solution quality and to adapt the approach to the flexible job shop scheduling problem.

Table 1
Parameter settings for the heuristic

Table 3
Results of one-way ANOVA for the methods: PaGA and proposed heuristic