A synergetic combination of small and large neighborhood schemes in developing an effective procedure for solving the job shop scheduling problem

This paper presents an effective procedure for solving the job shop problem. Synergistically combining small and large neighborhood schemes, the procedure consists of four components, namely (i) a construction method for generating semi-active schedules by a forward-backward mechanism, (ii) a local search for manipulating a small neighborhood structure guided by a tabu list, (iii) a feedback-based mechanism for perturbing the solutions generated, and (iv) a very large-neighborhood local search guided by a forward-backward shifting bottleneck method. The combination of shifting bottleneck mechanism and tabu list is used as a means of the manipulation of neighborhood structures, and the perturbation mechanism employed diversifies the search. A feedback mechanism, called repeat-check, detects consequent repeats and ignites a perturbation when the total number of consecutive repeats for two identical makespan values reaches a given threshold. The results of extensive computational experiments on the benchmark instances indicate that the combination of these four components is synergetic, in the sense that they collectively make the procedure fast and robust.


Introduction
As an integrated component of computerized and flexible manufacturing systems, the Job-Shop Scheduling Problem (JSP) is encountered in many industrial contexts. The importance of this problem is two-fold. First, it has a widespread applicability in manufacturing, and second, despite its easy-to-state description, it is a notoriously difficult and intractable problem which provides an ideal framework to evaluate innovative algorithmic approaches. Successful approaches for this easy-to-state problem can be later modified to cope with hard-to-state scheduling circumstances.
Among many different procedures developed to cope with the JSP, those which employ local searches have the most robust and effective aspects. A local search differs from a systematic tree search in that systematic tree search expands a graph of partial solutions, whereas a local search explores a virtual graph connecting each complete solution to its neighboring complete solutions. The number of arcs in this virtual graph is affected by the neighborhood scheme employed by the local search, with the larger size of neighborhood leading to higher number of arcs and consequently larger or even impractical required computational times. That is why the endeavor of defining a proper neighborhood scheme highly determines the success of any local search algorithm.
Defining a proper neighborhood scheme for a local search is, however, involved with highly conflicting factors, in the sense that despite the fact that many neighborhood schemes seem to be only superficial variation of one another, they can easily demonstrate entirely different results. The reason of this phenomenon has been partly described by the notion of fitness landscape (Forrest and Mitchell 1993), and it seems that successful neighborhood schemes have the capability of effectively managing a trade-off between computational time and the number of arcs in their virtual graphs.
In tackling the JSP, this paper presents a procedure that combines small and large neighborhood structures. The procedure, called SLENP (Small-Large Embedded Neighborhood Search), has four synergetic characteristics of (i) making use of a forward-backward construction method for generating initial solutions, (ii) employing a small neighborhood search, (iii) using a feedback-based mechanism in generating perturbation for improving the result of the small neighborhood search, and (iv) using a largeneighborhood search for improving the overall result of the combination of the small-neighborhood search and the perturbation mechanism employed.
The feedback process employed for igniting solution perturbation is based on memorizing the values of solutions generated, and is aimed at minimizing the chance of existing any redundancy in the search. The rationale behind the use of this feedback process in performing perturbation is that any perturbation contributes to exploration but spoils any exploitation aspect of the search and hence it should be performed by extreme care. Memory undeniably is a vital constituent of any successful search, and here it has been used for igniting perturbation to avoid the same area of the virtual graph to be visited repeatedly.
Mixing different neighborhood structures is one of the building blocks of the variable neighborhood search (Hansen and Mladenović 2003), and it seems that combining small and large neighborhood schemes can have dual benefits. On the one hand, the poor decision made in a small neighborhood, which is the natural consequent of its limited scope, may be rectified, and on the other hand, because of the comparatively high quality of its initial solution, the employed large neighborhood search may require less computational effort in producing its final result.
The SLENP performs its large neighborhood search through a variant of the shifting bottleneck procedure which works both in the forwards and backward directions. By performing in the backward direction, the ordinary operations of the shifting bottleneck procedure are executed on an inverted network, called mirror network. The term mirror best reflects how, by reversing the precedence relations of the initial network, this modified network is created and why the overall solution based on this modified network can be mirrored to show a solution to the original network.
The outline of the paper is as follows. The next section starts with presenting the formulation of the job shop problem and providing a brief literature survey on the problem. Section Related works presents the related work. In Section The SLENP, the SLENP is discussed and a stepwise description is provided that describes how the procedure operates and clarifies how its different components interact with one another. Section Computational experiments presents the results of computational experiments. A summary of the results as well as the suggestions for future work are discussed in Section Concluding remarks.

Problem formulation
The JSP consists of n jobs and m machines, with each job having a specific processing order on the machines. A typical schedule for the JSP is the allocation of jobs to the time slots of the machines to minimize the makespan. In other words, each job is comprised of a sequence of m operations, each to be processed on a specified machine within a particular time. The goal is to minimize the finish time of the last activity completed subject to the constraint that, once started, an operation cannot be interrupted and should continue until it has been completed. It is worth noting that makespan is a regular criterion and any method capable of handing this criterion has the potential of being modified to handle other regular criteria like total weighted flow time, weighted tardiness, weighted sum of tardy jobs, and maximum tardiness (Mati et al. 2011). The reverse is also true with the procedures handling other regular criteria, like weighted tardiness (Bülbül 2011;Kreipl 2000).
As an NP-hard problem (Lawler et al. 1982), the JSP is a notoriously difficult and an intractable combinatorial optimization problem. An evidence for its intractability is that finding the optimal solution of a relatively small problem instance presented in (Fisher and Thompson 1963), with the dimension of 10*10, despite the focus of intensive research on it, remained unsolved for 26 years until it was solved by the exact procedure developed in (Carlier and Pinson 1989). This celebrated instance, which in the literature is called ft10, is still used by many researchers to test their algorithms. The other exact procedures that have been successfully applied to small instances have been developed in (Applegate and Cook 1991) and (Brucker et al. 1994). By exploring specific knowledge about the longest path in the disjunctive graph and employing the cutting-plane method for obtaining lower bounds, these methods are aimed at applying sophisticated inference rules to cut the enumeration tree in its early expansion phase, with both of the methods able to solve the ft10 to optimality within several minutes.
One of the most effective formulations of the JSP is performed by the use of disjunctive graphs (Brucker et al. 1994). Figure 1 shows a sample problem and Figures 2 and 3 show two different fixation settings for the disjunctive arcs of the sample problem. As is seen, the makespan of the problem, as the longest path from the starting to the ending node, is different for Figures 2 and 3. In effect, Figure 3 shows an optimal fixation setting for the disjunctive arcs, which has led to the optimum makespan of 22.
Since all operations executed on the same machine require a given order, the notion of feasible order plays a key role in such graphs, with machine i being associated with the order π i , which shows the permutation of jobs on that machine. An order, Π, which consists of {π 1 , π 2 ,....,π m } is feasible if it does not introduce any loop in the graph. Figure 4 shows an infeasible fixation of disjunctive arcs and the resultant loop produced.
Denoting the completion time of the last completed job with makespan, the JSP can be simply formulated as follows: min

Related works
Solution strategies presented for the JSP range from artificial bee colony optimization and hybrid genetic tabu searches (Banharnsakun et al. 2012;Meeran and Morshed 2012;Zhang et al. 2013;Zhang et al. 2008b) through dynamic and linear programming (Gromicho et al. 2012;Bülbül and Kaminsky 2013) to path relinking and particle swarm optimization (Pongchairerks 2014;Nasiri and Kianfar 2012). In an overview of scheduling models presented in (Framinan et al. 2014) several of these strategies have been examined. Non-exact solution strategies for the JSP, to which the method presented in this paper belongs, can be categorized into six different categories, namely (i) construction methods, (ii) local searches, (iii) metaheuristics, (iv) evolutionary algorithms, and (iv) hybrids. Interestingly, nearly all successful techniques in these categories model the JSP as a disjunctive graph. In each category, only those works have been discussed which have affected the SLENP. Construction methods build a solution progressively, starting with a null schedule and expanding it gradually until a full schedule is obtained. In the process of creating a full schedule, a sequence of intermediate partial schedules is created, with each partial schedule expanding the previous partial schedule. In general, myopic decisions are the backbone of such methods in the progressive expansion of the intermediate partial schedules. Priority-based techniques are the oldest techniques classified as construction methods.
The method presented in (Giffler and Thompson 1960) is one of the most effective methods in the category of construction methods. This method is able to accept a set of priorities and create either an active or a non-delay schedule through a dispatching mechanism which schedules eligible operations one at a time based on their priorities.  The second major construction method is the shifting bottleneck procedure (SBP) (Adams et al. 1988), which decomposes the JSP into several, m, one machine problems and solves each problem to optimality with the Carlier's method. As an intricate algorithm, the SBP repeatedly redirects the search towards scheduling the machine which imposes the most severe constraint in the sense of increasing the objective function.
As the counterpart of gradient optimization in continuous spaces, local searches probe discrete spaces through the fundamental notion of move to find local optimal solutions. In effect, modern local searches are now the leading procedures in solving the JSP, and this is mainly due to effective neighborhood schemes developed in the last three decades. In general, local searches convert a complete solution to another complete solution through local changes.
A major point with local searches is that they cannot be effective unless they exploit the structure of the problem through a proper definition of a neighborhood structure and an effective mechanism for the manipulation of such a structure. Nearly all effective neighborhood structures for the JSP are based on the basic notion of critical path in a resolved disjunctive graph. In effect, each critical path represents the longest route through operations and its length is equal to the makespan. Major neighborhood structures for the JSP are as follows.
N1 neighborhood has been proposed in (Van Laarhoven et al. 1992) and defines a move by interchanging two successive operations of the same machine on a critical path. The design of N1 has been made based on two principles: (i) changing the order of two non-critical operations cannot improve the solution and may only create a cycle in the disjunctive graph, and (ii) changing the order of two adjacent operations cannot create a cycle.
N2 neighborhood (Dell'Amico and Trubian 1993) can reverse more than one arc on the critical path. Assuming i and j are two consecutive operations of the same block  and one of them is at an extreme point of the block, the predecessor of i and the successor of j can also be subject to reversal with their predecessors and successors, respectively.
In the N3 neighborhood (Dell'Amico and Trubian 1993), a sequence of three operations on the critical path can be reversed subject to the condition that such a reversal does not lead to any loop. As an extension of N1, N3 is not limited to the reversal of triplets and includes the interchange of a pair of operations as well.
In N4 neighborhood (Dell'Amico and Trubian 1993), each operation of a block can move to any location of the block, subject to creating no cycle. Unlike in the other three neighborhood schemes, which are based on adjacent interchanges of operations, in this neighborhood a shift is performed. Based on this shift, an operation jumps over several other operations in its corresponding block to the left or right. In effect, this neighborhood can be considered as an expansion of all other previous ones.
As a restricted version of both N1 and N4, N5 is a neighborhood scheme, developed in (Nowicki and Smutnicki 1996), in which the first two or the last two operations of each block are interchanged. The only exceptions are the first and last blocks, in which only their last and first two operations are interchanged, respectively.
The rationale behind the development of N5 is that the size of N1 is large and includes a large percentage of moves that cannot lead to any improvement. These unfruitful moves are those which are involved with two internal operations in the corresponding block. The removal of these unfruitful moves out of N1 leads to the creation of N5, which includes a restricted collection of highly effective moves.
However, despite using such highly effective moves, a drawback with N5 neighborhood is that its corresponding search space is disconnected. This disconnection removes any guarantee for the existence of a path between an optimal solution and an arbitrary seed. In comparison with N4, N5 is involved with the reversal of only one disjunctive arc, and this makes its corresponding neighborhood considerably smaller.
In N6 neighborhood (Balas and Vazacopoulos 1998), each operation of a block can move precisely after the last or before the first operation of the black, subject to creating no cycle. N6 is very close to N4, and the major difference existing between these two neighborhood schemes is that N4 allows each operation of the block to move to any other location of the block, subject to creating no cycle. This makes the size of N6 slightly smaller than that of N4. N6 has been extended to N6' in (Zhang et al. 2008a) by being allowed to move the first or the last operation of the block into the interior operation inside the block.
It is worth mentioning that in the literature these notations are not unique and different authors have used different notations. For instance, whereas in (Blazewicz et al. 1996), N5 is referred to the same neighborhood we mentioned, in (Vaessens et al. 1996) N5 is used to refer to the neighborhood scheme developed in (Adams et al. 1988), which, as a very large neighborhood, can completely change the order of operations on one machine. That is why in this paper, we refer to that neighborhood schemes as N5'.
Local searches, in general, and neighborhood schemes, in particular, are mainly used in the context of metaheuhurtics. Tabu searches, as part of metaheuristic category, select improving moves, and are aimed at avoiding to return to the solutions they have visited recently. In the cases where no improving move exists, simply the least disapproving move is chosen. The tabu search presented in (Nowicki and Smutnicki 1996) has been one of the most effective searches presented for the JSP. Although it owes its effectiveness to both the employed neighborhood structure and the balance it maintains between diversification and intensification, restarting the search form elite solutions plays a crucial role in its success. In this metaheuristic, the search is controlled through a backtracking scheme, and the seed are provided through generating active schedules. The backtracking process embedded in the search causes the search to restart from various high quality solutions encountered from the beginning of the search. In other words, it recovers elite solutions with which to restart the search.
In the JSP whose fitness landscape has big valley structure (Pardalos et al. 2010), the recovery of elite solutions and then restating the search with these solutions using different parameters has proved to be very effective. Because of a random setting, even with using the same high quality solution as a seed, each restarting initiates finding a new promising trajectory. It is through these trajectories that the big valley structure of the JSP is exploited and high quality solutions are obtained.
As two other effective tabu searches, we can name those presented in (Taillard 1994) and (Barnes and Chambers 1995), with both using N1 as their neighborhood structure. Whereas the first procedure changes the size of tabu iteratively and calculates the objective function value of each neighbor approximately, the other procedure has a fixed-length tabu list and computes the objective function value of each neighbor exactly. For generating a seed, several non-delay schedules are generated and the best one is selected.
As another metaheurstic, the guided local search presented in (Balas and Vazacopoulos 1994), uses a variable neighborhood search in escaping local optimality. The main difference between this search and a typical variable neighborhood search is that it uses a tree whose nodes correspond to the orientations, with each descendant node being a neighbor of its parent node. In (Mattfeld 1996), this search has cleverly been classified as a variable depth search due to the famous algorithm of (Lin and Kernighan 1973), which has first been applied to the Travelling Salesman Problem (TSP). As another variable neighborhood search for the JSP we can mention the VNS presented in (Wang and Zhang 2011).
The variable depth search starts with an initial solution, and in each iteration of the search, it starts with the best solution found in the previous iteration. Unlike in tabu search, each iteration performs not one but a number of potential profitable moves, which in general may be worsening moves, and during the corresponding iteration never reverses any of those moves.
Despite the fact that in the next iteration, previously prohibited moves are allowed to be performed again, the list of forbidden moves in the variable depth search grows much faster than that in tabu search. The other variable depth search procedure developed for the JSP, is the procedure presented in (Dorndorf and Pesch 1993). Unlike in the TSP, this search has not been extremely successful for the JSP. It seems that this is partly due to the complicated structure of the JSP, which makes potentially profitable moves unrecognizable.
In (Lourenco 1995;Lourenço and Adviser-Shmoys 1993), a combination of N1 and a large step optimization search has been employed to tackle the problem. In the corresponding large step optimization, randomly two machines are selected and all disjunctive arcs related to these two machines are removed. Then, a new order is found for each of these machines through using the Carlier's method (Carlier 1982), which solves one machine problem to optimality.
The fourth category, genetic algorithms, is not much related to our work, and the most successful genetic algorithms provided for the JSP include those presented in (Yamada and Nakano 1992), (Dorndorf and Pesch 1995), (Falkenauer and Bouffouix 1991), and (Gonçalves et al. 2005). Finally, we briefly survey hybrids as the last category. They comprise a variety of algorithms ranging from genetic (Qing-dao-er-ji and Wang 2012) through ant bee-based (Zhang et al. 2013) to differential evolution hybrids (Ponsich and Coello Coello 2013).
The first related hybrid discussed is the algorithm based on global equilibrium presented in (Pardalos and Shylo 2006). This algorithm, which is called Global Equilibrium Search (GES), has some common features with simulated annealing algorithm. In each stage of the search, GES collects information about the solution space for its next stages, and similar to the SA, the GES performs the search as a chain of temperature rounds.
The procedure also employs a local search which uses two neighborhood structures. The first neighborhood structure is N1 and the second structure manages to move each operation on the block either to the beginning or to the end of its corresponding block, similar to N4. The authors have modified an accelerating method in literature for the evaluation of moves in their second neighborhood structure. This method, which instead of computing the exact value associated with a move, calculates its tight lower bound at the cost of negligible computational effort, has significantly contributed to the effectiveness of the procedure.
The next related work in the hybrids is a filter-and-fan approach presented in (Rego and Duarte 2009). The authors have presented a filter and fan approach for solving the JSP. The SBP (Shifting bottleneck procedure) has been used both for generating initial solutions and enhancing the final solutions as a post optimization procedure. It incorporates a tree search for restricting the solution space and works similar to the beam search.
Whereas beam search works in construction heuristics, filter and fan search, as its natural generalization, can work both in construction heuristics and local searches. When used in local searches, it places a local optimal solution at the root of the search tree, and the best m solutions obtained in this process are located at level 1, among the neighbors of these m solutions, the best m neighbors are selected and are placed in level 2. In effect, each level consists of m nodes that are selected among the best neighbors of nodes existing in its previous level. By using a hash mechanism, any repeat in this search tree is prevented. After generating k solutions and selecting the best solution obtained in the process, it becomes the root of the tree, and the search restarts.
The employed filter and fan procedure can work based on the first-improvement strategy as well. This means that whenever in the process, the root is improved, the enhanced solution becomes the root, and the best m solutions obtained in the previous search tree are placed in the first level of the next search tree.
The next related work in hybrids is a TS/SA algorithm presented in (Zhang et al. 2008a). The procedure developed by these authors is based on their conjecture that the quality of solutions obtained by the tabu search is determined based on the quality of the initial solutions. That is why they use a simulated annealing algorithm to generate high quality initial solutions for a tabu search. In other words, the main principle guiding this search is that SA generates elite solutions and TS improves the solutions generated by SA.
These kinds of integration are usually very effective. For instance, in (Huang and Liao 2008) ant systems are combined with tabu searches and provide assistance for a decomposition method inspired by the shifting bottleneck procedure, used as the construction method of the procedure. Having briefly reviewed the related work, we can now describe the SLENP.

The SLENP
The SLENP combines small and large neighborhood schemes in coping with the job shop problem. Four modules have been combined to create this procedure. The first module is aimed at generating semi-active schedules by a forward-backward method called Semi-Active Schedule Generator (Forward-Backward-SASG). The second module is based on a local search that manipulates a small neighborhood structure guided by a tabu list, and the third module includes a feedback-based mechanism for perturbing the solutions generated. A very large-neighborhood local search, which is guided by a forward-backward shifting bottleneck (Forward-Backward-SBP) method, comprises the fourth module. Whereas the shifting bottleneck mechanism and tabu list are used as a machinery to manipulate the neighborhood structures, the perturbation mechanism diversifies the examined solutions, and the semi-active generator generates initial schedules.
The employed small neighborhood structure is highly restrictive, and the reason we have used semi-active, instead of active schedules, is that in (Jain et al. 2000), through computational experiments, it has been shown that semi active schedules better match with restrictive neighborhood structures. The conclusion made in (Jain et al. 2000) is partly based on semi-active schedules employed in (Nowicki and Smutnicki 1996). It should be noticed that when the employed neighborhood structure is not restrictive, active schedules perform better than semi-active schedules. The reason is twofold. First, makespan is a regular criterion and the optimum belongs to the set of active schedules. Second, active schedules are a subset of semi-active schedules, and, on average, are of higher quality than semi-active schedules.
In the procedure, the repeats are detected by a feedback mechanism called repeat-check, which causes perturbation to occur whenever the total number of successive repeats for two identical values of the makespan reaches a given threshold. The shifting bottleneck module manipulates a large-neighborhood and is aimed at enhancing the solution obtained by the other three modules. To improve the results obtained by the shifting bottleneck method, a forward/backward mechanism has been added to it.
The pseudocode of the SLENP has been represented in Figure 5. The integrating part of the pseudocode is Elite Heap, which is a priority queue for keeping high quality solutions for possible improvement and releasing them based on their quality. First, at line 3, the Elite-Heap is initially filled by repeatedly calling the Forward-BackwardSASG procedure. This is performed through generating n solutions by the Forward-BackwardSASG procedure, and selecting the best m solutions among them. The Forward-BackwardSASG procedure has its own pseudocode and will be discussed in detail.
After the filling of the EliteHeap, the main loop in pseudocode starts at line 5. The main goal of this loop is to make possible improvement in the solutions located in the Elite-Heap. Line 7 removes a solution from the EliteHeap and line 9 performs a limited tabu-search on this solution. In this tabu search, the tabu list includes elements which show the sequence of operations on a particular machine. In this tabu search, both N5 and N6′ neighborhoods are used. As discussed, N6′ is a version of N6 in which the possibility of moving the starting and ending operations of the block to the interior positions of the block have been considered.
The employed tabu list is aimed at determining whether, within a particular short-term period, a potential solution has been visited and decreases the possibility of repeatedly visiting the same sequence of solutions. Since this particular short-term memory cannot exclude the large sequences of repeats, lines 13 and 14 record the occurrence of every two consecutive solution values, and line 15 prevents any such possible repeat through making a perturbation in the current solution, aiming at further decrease in the possibility of repeats.
The performance of such perturbation depends on detecting a large sequence of repeats. For this purpose, if x has been followed by x' previously, C[x,x'] > 1, the value of totalRepeats is incremented at line 14, and as soon as totalRepeats exceeds a certain threshold, the current solution is perturbed using the N1 neighborhood. As lines 17 and 18 indicate, with each perturbation, the history of the recorded solution values is discarded. The reason for discarding this history is that any perturbation changes the course of possible repeats. Line 22 ensures that the procedure is repeated until there is no improvement for MaxIter iterations. The loop terminates at line 23.
The best solution obtained in the loop undergoes an iterated forward-backward, one-machine post-optimization process for possible further improvement. The loop terminates at line 23, and line 24 applies a large-neighborhood search to the best solution obtained. This is performed by calling ForwardBackwardSBP, whose complete pseudocode has been given in Figure 6.
This complete pseudocode describes a modified version of the post-optimization phase of the shifting bottleneck procedure (SBP) (Adams et al. 1988). The modification performed includes adding a backward process to the procedure. The pseudocode starts with initializing a list of machines, L, at line 5.Then a loop starts at line 9. In each iteration of this loop, at line 12 the status of a machine is set to open (i.e. "not scheduled"), and at line 14 the subproblem corresponding to that machine is given to the Carlier procedure to be solved.
Based on line 11, the procedure randomly switches from the forward case to the backward case and vice versa. After solving the corresponding one machine problem with the Carlier method at line 14, the output sequence is  applied to the solution and the makespan is calculated at line 15. Then, line 16 replaces the previous sequence with the new one if the new sequence is of higher quality than the previous one. Lines 7,9,19, 21 ensure that the procedure is terminated if there is no improvement for 2m consecutive iterations. As lines 23 through 27 show, after each full optimization cycle for all m machines, the machine numbers in the list L are rearranged based on their solution cost to the one-machine problem, with the machines producing the longest makespan sitting in the top of the list and those producing the smallest makespan sitting in the bottom of the list. The pseudocode terminates at line 29.
As mentioned, the EliteHeap is filled by repeatedly calling the Forward-BackwardSASG procedure. The pseudocode of this procedure has been presented in Figure 7. The pseudocode, which generates semi-active schedules, starts with lines 4 and 5 and initializes a forward and backward binary heap, respectively. Then with a loop starting at line 8, forward and backward processes are used alternatively, starting with the forward process, which is set at line 7. Depending on whether the forward or backward process is in place, an element is taken from the forward or backward heap in lines 11 and 13, respectively.
The pseudocode constructs a solution by iteratively sequencing jobs on machines. This is done in the two directions of forward and backward alternatively, in the sense that in each iteration based on the value of the direction variable, an operation is scheduled on the beginning or the end of the schedule, respectively. Since in lines 11 and 13 from the top k elements of forward_BinaryHeap or backward_BinaryHeap, an element is chosen, and larger values of k can cause further diversification, the parameter k plays a key role in the quality of solutions generated.
The smaller values of k lead to generating a limited number of solutions, all in the same high quality region. On the other hand, when the value of k is increased, say to 3 or 5, the diversification is increased at the cost of decreasing the quality of regions. Since for filling the EliteHeap, this module is called for n times and among the n solutions generated the best m solutions are selected, the values of each of the three parameters k, m, and n should be selected based on the other two parameters.
The other issue contributing to the effectiveness of the procedure is the forward-backward mechanism embedded in the Carlier's method as the key component of the shifting bottleneck procedure. Both in the forward and backward processes, it is vital that the sub-solution provided by the Carlier's procedure matches with the current solution, in the sense that the Carlier' procedure should not introduce any loop in the current disjunctive graph. As it has been stated in (Adams et al. 1988), introducing loops through the Carlier's procedure is not a common occasion and rarely can happen in practice. In our implementation, both in the forward and backward processes, we have prevented loops as follows. Suppose, that the Carlier's procedure suggests 71, 78, 30, 1, 42, and 35 as the sequence of operations that should be processed, one after another, on the corresponding machine. Now in the disjunctive graph, we find all successors of the operation 35 and make sure that none of the operations before the operation 35 in the proposed sequence by the Carlier's procedure is among these successors. Then we find all successors of the operation 42, and make sure that none of the operations before the operation 42 is among them. Checking for the existence of any violation continues until we find that the operation 71 is not among the successors of the operation 78.
In case of encountering any violations, they are recorded, and the Carlier's procedure is called again, albeit with the set of recorded violations as a constraint for being avoided. This process is repeated until the subsolution provided by the Carlier's procedure matches with the current solution. The employed tabu search selects improving moves and avoids returning to the solutions it has visited recently.

Computational experiments
The SLENP has been implemented in C++ and compiled via GNU GCC compiler on a DELL PC with 2.2 Ghz speed. The benchmark problems to which the procedure has been applied include 43 instances extracted from ORLIB site managed by Brunel University, UK. The  selected instances comprise a combination of representative problems collected from the literature. They range from 6 × 6 to 20 × 20 in size, with the first number showing the number of jobs and the second number showing the number of machines. They include 3 instances, ftxx, from (Fisher and Thompson 1963), 11 instances, laxx, from (Lawrence 1984), 5 instances, abzx, from (Adams et al. 1988), 10 instances, orbxx, from (Applegate and Cook 1991), 4 instances, ynx, from (Yamada and Nakano 1992), and 10 instances, swvxx, from (Storer et al. 1992).
The procedure has 11 parameters, and most of these parameters have been set in terms of the number of jobs, n, and the number of machines, m. In setting the parameters, care has been taken to increase the exploration power of the procedure with respect to the increase in m, and ⌊n/m⌋. Table 1 shows how these parameters have been set. A brief description of these parameters is as follows; (i) TotSol denotes the number of total initial solutions generated, (ii) k represents diversification parameter of the Forward-BackwardSASG module which controls the diversity of initial solutions, (iii) EliteHeapSize indicates the size of EliteHeap, (iv) PerturbProb represents the chance by which the solution is perturbed after being removed from eliteheap, (v) MaxIterNonImprov denotes the number of iterations after which the tabu search stops if no improvement occurs in makespan, (vi-vii) TabuSize min and TabuSize max show the extremes of the bound in which the size of the tabu list as a uniform random variable can change in each run, (viii-ix) RepeatTolerance min , and RepeatTolerance max represent the extremes of the bound in which the tolerance for accepting consecutive makespan repeats is changed randomly, (x) N5N6′Prob denotes the chance of selecting N5 neighborhood in each iteration and consequently the chance of selecting N6′ neighborhood is 1-N5N6′Prob, (xi) TripleMovesProb represents the probability by which at the start and the end of the critical block a triple move is performed.
As stated in the previous section, the SLENP uses both N5 and N6′ as its small neighborhood. That is why among the parameters described above, the parameter N5N6′Prob has been used to determine the chance of selecting each of the two neighborhoods. Using one of the two neighborhoods randomly causes that starting with the same initial starting point leads to different courses of actions and consequently to different solutions, improving the diversity of solutions generated and increasing the chance of escaping local optimality.
Before presenting the performance of the procedure for the benchmark instances and comparing the obtained results with the best available solutions, we first show the results of its operations on the ft10, which is the most famous instance. Figure 8 shows the solution value (makespan) per each schedule evaluation. As is seen, the makespan has converged towards 930, which is the optimal solution of the problem. It is worth mentioning that value of 930 has been found after applying the shifting bottleneck improvement heuristic in the final stage of the procedure. The shifting bottleneck improvement heuristic has been executed after the procedure has evaluated 272850 schedules, and has been performed on a solution whose makespan was 934. Figure 9 shows the best makespan obtained for each element removed from the elite heap. In effect, for 90 Figure 10 The changes of global best solution per each removal from the elite heap. different elements taken from the elite heap, this figure has presented the trend in which the corresponding element has been improved in the search. The 90 different peaks in the figure correspond to the 90 solutions taken out from the heap and each shows the makespan of the corresponding element. Associated with each peak is a dip which shows the makespan of the best solution obtained.
As is seen in Figure 9, each of the elements taken from the heap has led to a different solution, and sometimes high quality elements taken from the heap have produced solutions which cannot compete with solutions produced by low quality elements. The trend, however, is towards the improvement of the final solution. Figure 10 shows such a trend by depicting the changes in the global best solution per the removal of each element from the elite heap. Now we present the results of applying the procedure to the entire benchmark instances selected. To remove the effect of the random seed, in line with other procedures, for each instance, the SLENP has been run for 10 times each with a different random seed. The time allowed for each run is n(9n-60)/m seconds for instances with n ≥ 10 (jobs) and 1 second for the instances with n < 10. Moreover, since in the case of availability of the optimal makespan it is given to the procedure as an input, the procedure can stop as soon as a solution with such quality is achieved.
With respect to performance, Table 2 compares the procedure with one of the fastest available procedures for the JSP, namely TSSA (Tabu Search Simulating Annealing) (Zhang et al. 2008a). In this table, %DEV best represents the deviation percentage of the obtained solution from the best available solution in the literature, BKS, and has been obtained based on the formula of (s-BKS)/BKS, with s being defined as the best solution returned by procedure. The running times of the TSSA have been reported on a Pentium IV 3.0 Ghz CPU. Table 2 shows that, in 25 out of 43 cases, the SLENP has been able to find the best known solution for the corresponding benchmark instance. As is seen in Table 2, for four of the benchmark instances, the TSSA has no corresponding output. Removing these four rows out of consideration, the following conclusions can be drawn. In 53.8%, 21/39, of cases, the SLENP has generated solutions with the same quality as those generated by the TSSA and in general the solutions generated by the TSSA are on average around 1.05% better than those generated by the SLENP. However, the solutions produced by the SLENP have been obtained on average 112.85% faster than those generated by the TSSA. Since both procedures have used only a single processor, taking the difference between the clocks pulses on which these two procedures have been run, 2.2 versus 3.0 Ghz, implies the chance that this speed percentage may be larger than the value presented.
Also since in (Chassaing et al. 2014), a comparison has been made among several procedures based on their performance on solving la01 to la40 instances, we have tested our procedure on these instances as well. It is worth noting that despite the fact some of these instances were included in our first experiments, we have solved them again, with new initial random solutions. The results have been shown in Table 3. As is seen, except for three instances, the SLENP has been able to find the optimal solutions of all instances. One of these instances belongs to what those authors have classified as strongly large instances, and the other two instances belong to what they have classified as large instances.

Concluding remarks
Towards generating both fast and high-quality solutions to the JSP, the SLENP has synergistically combined a construction method, a local search, and a large-neigh borhood technique as a post-optimization component. Its construction technique constructs feasible schedules iteratively, one element at a time. The innovative feature of this component is the use of a forward-backward mechanism in scheduling activities.
The second component has been a local search, which starts with the initial schedules generated by the construction method. Consistent with all current effective neighborhood structures for the JSP, the employed local search has been founded on the concept of the critical block, which guides the construction neighbors. The innovative feature of this component is the use of two different neighborhoods that a parameter decides which to work in each round.
The third major component of the SLENP is the postoptimization method whose development has been inspired by the combination of the forward-backward shifting bottleneck procedure and the biased randomizing search. The reason for selecting this procedure as the postoptimization component for the SLENP has been twofold.
First, the shifting bottleneck heuristic is one of the most effective heuristics for the JSP which by sequencing the bottleneck machine successively, can provide high quality solutions for the JSP. Second, equipping this mechanism with a forward-backward process can further improve the accuracy of this highly effective mechanism.
By using these components, the SLENP can find solutions with high quality in a matter of seconds. This indicates that the components of the procedure act synergistically. Towards its enhancement, three major directions can be envisaged for sketching the procedure.
First, since a large portion of execution time is spent on calculating the values of the makespan, a faster evaluation technique, which without explicit calculation can estimate the makespan, can lead to producing solutions with higher quality through increasing search efficiency.
Second, in a parallel environment, various local searches can simultaneously operate to cooperatively locally optimize various parts of the same encoding. In this parallel environment, the local searches can communicate with one another so that each local search can ignore those parts of the encoding fixed by other local searches and concentrate only on manipulating its own part.
Third, since in the employed tabu search, the management of tabu list, which, as a short term memory, keeps the forbidden moves, has played a critical role in the quality of the overall result, other possible mechanisms in managing the tabu list can be tested. One promising mechanism is an adaptive tabu list, which based on a feedback received from the corresponding fitness landscape, can alternate between a fixed list and a random-sized list. Such a flexible tabu list, whose size is determined adaptively, can properly adjust the short term memory of the search and can possibly lead to higher quality solutions.