1 Introduction
Scheduling problems come in a wide variety and it is natural to think that methods specifically engineered for each variant would have the best performance. However, it was recently shown this is not always true. Tamura et al. introduced an encoding of disjunctive and precedence constraints into conjunctive normal form formulae [22]. Thanks to this reformulation they were the first to report optimality proofs for all open shop scheduling instances from three widely studied benchmarks. Similarly the hybrid CP/SAT solver lazyFD [10] was shown to be extremely effective on ResourceConstrained Project scheduling (RCPSP) [21].
Previously, we introduced an approach for open and job shop problems with a variety of extra constraints [12, 13] using simple reified binary disjunctive constraints combined with a number of generic SAT and AI techniques: weighted degree variable ordering [5], solution guided value ordering [3], geometric restarting [25] and nogood recording from restarts [15]. It appears that the weighted degree heuristic efficiently detects the most constrained parts of the problem, focusing search on a fraction of the variables.
The simplicity of this approach makes it easy to adapt to various constraints and objective functions. One type of objective function that has proven troublesome for traditional CP scheduling techniques involves minimizing the sum of earliness/tardiness costs, primarily due to the weak propagation of the sum objective [8]. In this paper we show how our basic JSP model can be adapted to handle this objective. Experimental results reveal that our approach is competitive with the state of the art on the standard benchmarks from the literature.
Moreover, we introduce two refinements of our approach for problems with maximum time lags between consecutive tasks, where we incorporate domain specific information to boost performance. These time lag constraints, although conceptually very simple, change the nature of the problem dramatically. For instance, it is not trivial to find a feasible schedule even if we do not take into account any bound on the total makespan (unless scheduling jobs back to back). This has several negative consequences. Firstly, it is not possible to obtain a trivial upper bound of reasonable quality may be found by sequencing the tasks in some arbitrary order. The only obvious upper bound is to sequence the jobs consecutively. Secondly, since relaxing the makespan constraint is not sufficient to make the problem easy, our approach can have difficulty finding a feasible solution for large makespans, even though it is very effective when given a tighter upper bound. However because the initial upper bound is so poor, even an exploration by dichotomy of the objective variable’s domain can take a long time.
We introduce a simple search strategy which, when given a large enough upper bound on the makespan, guarantees a limited amount of backtracking whilst still providing good quality solutions. This simple strategy, used as an initial step, greatly improves the performance of our algorithm on this problem type. We report several new best upper bounds and proofs of optimality on these benchmarks. Moreover, we introduce another improvement in the model of the particular case of No wait JSP where the tasks of each job must be directly consecutive. This variant has been widely studied, and efficient metaheuristics have been proposed recently. We report new best upper bound, and close new instances in standard data sets.
Finally, because there are few comparison methods in the literature for problems with strictly positive time lags, we adapted a job shop scheduling model written in Ilog Scheduler by Chris Beck [3], to handle time lag constraints. Our method outperforms this model when time lag constraints are tight (short lags), however when time lags are longer, the Ilog Scheduler model together with geometric restarts and solution guided search is better than our method.
2 Background & Previous work
An job shop problem (JSP) involves a set of tasks , partitioned into jobs , that need to be scheduled on machines . Each job is a set of tasks . Conversely, each machine denotes a set of tasks (to run on this machine) such that: .
Each task has an associated duration, or processing time, . A schedule is a mapping of tasks to time points consistent with sequencing and resource constraints. The former ensure that the tasks of each job run in a predefined order whilst the latter ensure that no two tasks run simultaneously on any given machine. In the rest of the paper, we shall identify each task with the variable standing for its start time in the schedule. We define the sequencing (2.1) and resource (2.2) constraints in Model 1.
Moreover, we shall consider two objective functions: total makespan, and weighted earliness/tardiness. In the former, we want to minimize the the total duration to run all tasks, that is, if we assume that we start at time . In the latter, each job has a due date, . There is a linear cost associated with completing a job before its due date, or the tardy completion of a job, with coefficient and , respectively. (Note that these problems differ from Just in Time job shop scheduling problems[2], where each task has a due date.) If is the last task of job , then is its completion time, hence the cost of a job is then given by:
(2.1)  
(2.2) 
2.1 Boolean Model
In previous work [13] we described the following simple model for open shop and job shop scheduling. First, to each task, we associate a variable taking its value in that stands for its starting time. Then, for each pair of tasks sharing a machine we introduce a Boolean variable that stands for the relative order of these two tasks. More formally, for each machine , and for each pair of tasks , we have a Boolean variable , and constraint (2.2) can be reformulated as follows:
(2.3) 
Finally, the tasks of each job , are kept in sequence with a set of simple precedence constraints for all .
For jobs and machines, this model therefore involves Boolean variables, as many disjunctive constraints, and precedence constraints. Bounds consistency (BC) is maintained on all constraints. Notice that state of the art CP models use instead global constraints to reason about unary resources. The best known algorithms for filtering unary resources constraints implement the edge finding, notfirst/notlast, and detectable precedence rules with a time complexity [24]. One might therefore expect our model to be less efficient as grows. However, the quadratic number of constraints – and Boolean variables – required to model a resource in our approach has not proven problematic on the academic benchmarks tested on to date.
2.2 Search Strategy
We refer the reader to [12] for a more detailed description of the default search strategy used for job shop variants, and we give here only a brief overview.
This model does not involve any global constraint associated to a strong propagation algorithm. However, it appears that decomposing resource constraints into binary disjunctive elements is synergetic with adaptive heuristics, and in particular the weighteddegreebased heuristics [5]. (We note that the greater the minimum arity of constraints in a problem, the less discriminatory the weightdegree heuristic can be.) A constraint’s weight is incremented by one each time the constraint causes a failure during search. This weight can then be projected on variables to inform the heuristic choices.
It is sufficient to decide the relative sequencing of the tasks, that is, the value of the Boolean variables standing for disjuncts. Because the domain size of these variables are all equal, we use a slightly modified version of the domain over weighteddegree heuristic, where weights and domain size are taken on the two tasks whose relative ordering is decided by the Boolean variable. Let be the number of times search failed while propagating any constraint involving task , and let and be, respectively, the minimum and maximum starting time of at any point during search. The next disjunct to branch on is the one minimizing the value of:
A second important aspect is the use of restarts. It has been observed that weighted heuristics also have a good synergy with restarts [11]. Indeed, failures tend to happen at a given depth in the search tree, and therefore on constraints that often do not involve variables corresponding to the first few choices. As a result, early restarts will tend to favor diversification until enough weight has been given to a small set of variables, on which the search will then be focused. We use a geometric restarting strategy [25] with random tiebreaking. The geometric strategy is of the form where is the base and is the multiplicative factor. In our experiments the base was 256 failures and the multiplicative factor was 1.3. Moreover, after each restart, the dead ends of the previous explorations are stored as clausal nogoods [15].
A third very important feature is the idea of guiding search (branching choices) based on the best solution found so far. This idea is a simplified version of the solution guided approach (SGMPCS) proposed by Beck for JSPs [3]. Thus our search strategy can be viewed as variable ordering guided by past failures and value ordering guided by past successes.
Finally, before using a standard Branch & Bound procedure, we first use a dichotomic search to reduce the gap between lower and upper bound. At each step of the dichotomic search, a satisfaction problem is solved, with a limit on the number of nodes.
3 Job Shop with Earliness/Tardiness Objective
In industrial applications, the length of the makespan is not always the preferred objective. An important alternative criterion is the minimization of the cost of a job finishing early/late. An example of a cost for early completion of a job would be storage costs incurred, while for late completion of a job these costs may represent the impact on customer satisfaction.
Although the only change to the problem is the objective function, our model requires a number of additional elements. When we minimize the sum of earliness and tardiness, we introduce additional variables. For each job we have a Boolean variable that takes the value iff is finished early and the value otherwise. In other words, is a reification of the precedence constraint . Moreover, we also have a variable standing for the duration between the completion time of the last task of and the due date when is finished early: . Symmetrically, for each job we have Boolean variable taking the value iff is finished late, and an integer variable standing for the delay (Model 2).
(3.1)  
(3.2)  
(3.3)  
(3.4)  
(3.5)  
Unlike the case where the objective involves minimizing the makespan, branching only on the disjuncts is not sufficient for these problems. Thus we also branch on the early and late Boolean variables, and on the variables standing for start times of the last tasks of each job. For these extra variables, we use the standard definition of domain over weighted degree.
4 Job Shop Scheduling Problem with Time Lags
Time lag constraints arise in many scheduling applications. For instance, in the steel industry, the time lag between the heating of a piece of steel and its moulding should be small [27]. Similarly when scheduling chemical reactions, the reactives often cannot be stored for a long period of time between two stages of a process to avoid interactions with external elements [19].
4.1 Model
The objective to minimise is represented by a variable linked to the last task of each job by precedence constraints: . The maximum time lag between two consecutive tasks is simply modelled by a precedence constraint with negative offset. Letting be the maximum time lag between the tasks and , we use the following model:
(4.1)  
(4.2)  
4.2 Greedy Initialization
In the classical job shop scheduling problem, one can consider tasks in any order compatible with the jobs and schedule them to their earliest possible start time. The resulting schedule may have a long makespan, however such a procedure usually produces reasonable upper bounds. With time lag constraints, however, scheduling early tasks of a job implicitly fixes the start times for later tasks, thus making the problem harder. Indeed, as soon as tasks have been fixed in several jobs, the problem becomes difficult even if there is no constraint on the length of the makepsan. Standard heuristics can thus have difficulty finding feasible solutions even when the makespan is not tightly bounded. In fact, we observed that this phenomenon is critical for our approach.
Once a relatively good upper bound is known our approach is efficient and is often able to find an optimal solution. However, when the upper bound is, for instance, the trivial sum of durations of all tasks, finding a feasible solution with such a relaxed makespan was in some cases difficult. For some large instances, no nontrivial solution was found, and on some instances of more moderate size, much computational effort was spent converging towards optimal values.
We therefore designed a search heuristic to find solutions of good quality, albeit very quickly. The main idea is to move to a new job only when all tasks of the same machine are completely sequenced between previous jobs. Another important factor is to make decisions based on the maximum completion time of a job, whilst leaving enough freedom within that job to potentially insert subsequent jobs instead of moving them to the back of the already scheduled jobs.
We give a pseudocode for this strategy in Algorithm 1. The set stands for the jobs for which sequencing is still open, whilst contains the currently processed job, as well as all the jobs that are completely sequenced. On the first iteration of the outer “while” loop, a job is chosen. There is no disjunct satisfying the condition in Line LABEL:dchoice, so this job’s completion time is fixed to a value given by the stretched procedure (Line LABEL:tchoice), that is, the minimum possible starting time of its first task, plus its total duration, plus the sum of the possible time lags.
On the second iteration and beyond, a new job is selected. We then branch on the sequencing decisions between this new job and the rest of the set before moving to a new job. We call the job that contains task , and observe that for any unassigned Boolean variable , either or must be the last chosen job . The sequencing choice that sets a task of the new job before a task of previously explored jobs is preferred, i.e., considered in the left branch. Observe that a failure due to time lag constraints can be raised only in the inner “while” loop. Therefore, if the current upper bound on the makespan is large enough, this heuristic will ensure that we never backtrack on a decision on a task. We randomize this heuristic and use several iterations (1000 in the present set of experiments) to find a good initial solution.
4.3 Special Case: Job Shop with nowait problems
The job shop problem with nowait refers to the case where the maximum timelag is set to 0, i.e. each task of a job must start directly after its preceding task has finished. In this case one can view the tasks of the job as one block.
In [12] we introduced a simple improvement for the nowait class based on the following observation: if no delay is allowed between any two consecutive tasks of a job, then the start time of every task is functionally dependent on the start time of any other task in the job. The tasks of each job can thus be viewed as one block. We therefore use a single variable standing for the starting times of the job of same name.
We call the job of task , and we define as the total duration of the tasks coming before task in its job . That is, . For every pair of tasks sharing a machine, we use the same Boolean variables to represent disjuncts as in the original model, however linked by the following constraints:
Although the variables and constants are different, these are the same constraints as used in the basic model. The nowait JSP can therefore be reformulated as shown in Model 4, where the variables represent the start time of the jobs and .
(4.3)  
(4.4) 
However, we can go one step further. For a given pair of jobs the set of disjunct between tasks of these jobs define as many conflict intervals for the start time of one job relative to the other. For two tasks and , we have . However, these intervals may overlap or subsume each other. It is therefore possible to tighten this encoding by computing larger intervals, that we shall refer to as maximal forbidden intervals, hence resulting in fewer disjuncts. We first give an example, and then briefly describe a procedure to find maximal forbidden intervals.

In Figure (a)a we illustrate two jobs and . The number and shades of grey stand for the machine required by each task. The length of the tasks are respectively for and for . In Figure (b)b we give, for each machine, the pair of conflicting tasks, their durations and the corresponding forbidden intervals.
For each machine , let be the task of and the task of that are both processed on machine . Following the reasoning used in Model 4, we have a conflict interval (represented by black arrows in Figure (a)a) for each pair of tasks sharing the same machine: . In the example the forbidden intervals for are therefore: . However, these intervals can be merged, yielding larger (maximal) forbidden intervals, in which case we have: .
Given two jobs and , Algorithm 2 computes all maximal forbidden intervals efficiently (in steps). First, we build a list of pairs whose first element is an end point of a conflict interval, and second element is either if it is the start, and otherwise. Then these pairs are sorted by increasing first element. Now we can scan these pairs and count, thanks to the second element, how many intervals are simultaneously open. When we go from to open intervals, this marks the start of a maximal forbidden interval, and conversely the end when we go from to open intervals. The list has elements, and the and elements are read as the start and end of a forbidden interval.
Given this set of forbidden intervals, we can represent the conflicts between and with the following set of Boolean variables and disjunctive constraints:
In the previous encoding we would have needed Boolean variables and as many disjunctive constraints (one for each pair of tasks sharing a machine). We believe, however, that the main benefit is not the reduction in size of the encoding. Rather, it is the tighter correlation between the model and the real structure of the problem which helps the heuristic to make good choices.
(4.5)  
(4.6) 
5 Experimental Evaluation
The full experimental results, with statistics for each instance, as well as benchmarks and source code are online: http://homepages.laas.fr/ehebrard/jspexperiment.html.
5.1 Job Shop with Earliness/Tardiness Objective
The best complete methods for handling these types of problem are the CP/LP hybrid of Beck and Refalo [4] and the MIP approaches of Danna et al. [9], and Danna and Perron [8], while more recently Kebel and Hanzalek proposed a pure CP approach [14]. Danna and Perron also proposed an incomplete approach based on large neighborhood search [8].
Our experiments were run on an Intel Xeon 2.66GHz machine with 12GB of ram on Fedora 9. Each algorithm run on a problem had an overall time limit of 3600s, and there were 10 runs per instance. We report our results in terms of the best and worst run. We tested our method on two benchmarks which have been widely studied in the literature. The comparison experimental results are taken from [9] and [8], where all experiments were performed on a 1.5 GHz Pentium IV system running Linux. For the first benchmark, these algorithms had a time limit of 20 minutes per instance, while for the second benchmark the algorithms had a time limit of 2 hours.
The comparison methods are as follows:

MIP: Default CPLEX in [9], run using a modified version of ILOG CPLEX 8.1

CP: A pure constraint programming approach introduced by Beck and Refalo in [4], run using ILOG Scheduler 5.3 and ILOG Solver 5.3

CRSALL: A CP/LP hybrid approach proposed by Beck and Refalo in [4], run using ILOG CPLEX 8.1, ILOG Hybrid 1.3.1, ILOG Scheduler 5.3 and ILOG Solver 5.3

uLNS: An unstructured large neighborhood search MIP method proposed by Danna and Peron in [8], run using a modified version of ILOG CPLEX 8.1

sLNS: A structured large neighborhood search CP/LP method proposed by Danna and Peron in [8], run using ILOG Scheduler 5.3, ILOG Solver 5.3 and ILOG CPLEX 8.1
The first benchmark consists of 9 sets of problems generated by Beck and Refalo [4] using the random JSP generator of Watson et al. [26]. For instance size x
, there were three sets of ten JSPs of size 10x10, 15x10 and 20x10 generated. The second benchmark is taken from the genetic algorithms (GA) literature and was proposed by Morton and Pentico
[18]. There are 12 instances, with problem size ranging from 10x3 to 50x8. Jobs in these problems do have release dates. Furthermore earliness and tardiness costs of a job are equal.We present results on the randomly generated ETJSPs in Table 1 in terms of number of problems solved to optimality and sum of the upper bounds, for each algorithm.^{1}^{1}1Note that sLNS is not complete, hence it never proved optimality. Here, the column “Best” for our method means the number of problems solved to optimality on at least one of the ten runs on the instance, while the column “Worst” refers to the number of problems solved to optimality on all ten runs. We also report the mean cpu time in seconds for our method.
MIP  CP  uLNS  sLNS  CRSAll  Model 2  
Best  Worst  Avg.  
opt.  ub  opt.  ub  opt.  ub  ub  opt.  ub  opt.  ub  opt.  ub  Time (s)  
1.0  0  654,290  0  1,060,634  0  156,001  52,307  7  885,546  10  30,735  8  38,416  2534.86 
1.3  14  26,930  6  1,248,618  30  8,397  8,397  30  8,397  30  8,397  30  8,397  0.36 
1.5  27  7,891  6  1,672,511  30  6,964  6,964  30  6,964  30  6,964  30  6,964  0.18 
Notes: Comparison results taken from [9], except uLNS, taken from [8].  
Figures in bold are the best result over all methods. 
We first consider the number of problems solved to optimality (columns “Opt.”). While there is little difference in the performance of our method and that of uLNS and CRSALL on the looser instances (looseness factor of 1.3 and 1.5), we see that our method is able to close three of the 23 open problems in the set with looseness factor 1.0. An obvious reason for this improvement with our method would be the difference in time limits and quality of machines. However, analysis of the results reveals that of the 68 problems solved to optimality on every run of our method, only 8 took longer than one second on average, and only one took longer than one minute (averaging 156s). Furthermore, uLNS only solved two problems to optimality when the time limit was increased to two hours [8]. Clearly our method is extremely efficient at proving optimality on these problems.
The previous results suggest that CRSALL is much better than uLNS on these problems. However, as was shown by Danna et al. [9], this may not be the case when the algorithms are compared based on the sum of the upper bounds found over the 30 “hard” instances (i.e. with looseness factor 1.0). In order to assess whether there was a similar deterioration in the performance of our method as for CRSALL on the problems where optimality was not proven, we report this data in the columns “ub” of Table 1.
We find, on the contrary, that the performance of our approach is even more impressive when algorithms are compared using this metric. The two large neighborhood search methods found the best upper bounds of the comparison algorithms with sLNS the most efficient by a factor of 2 over uLNS. However, there are a couple of points that should be noted here. Firstly sLNS is an incomplete method so cannot prove optimality, and secondly the sum of the worst upper bounds found by our method was still significantly better than that found by sLNS. Indeed, there was very little variation in performance for our method across runs, with an average difference of 256 between the best and worst upper bounds found.
Danna and Perron also provided the sum of the best upper bounds found on the hard instances over all methods they studied [8], which was 36,459. This further underlines the quality of the performance of our method on these problems. Finally, we investigated the hypothesis that the different time limit and machines used for experiments could explain these results. We compared the upper bounds found by our method after the dichotomic search phase, where the maximum runtime of this phase over all runs per instance was 339s. The upper bound sums over the hard instances were 32,299 and 49,808 for best and worst respectively, which refutes this hypothesis.
Instance  Size  MIP  CP  uLNS  sLNS  CRSAll  GA  Model 2  
Best  Best  Worst  
jb1  10x3  0.191*  0.474  0.191*  0.191  0.191*  0.474  0.191*  0.191* 
jb2  10x3  0.137*  0.746  0.137*  0.137  0.531  0.499  0.137*  0.137* 
jb4  10x5  0.568*  0.570  0.568*  0.568  0.568*  0.619  0.568*  0.568* 
jb9  15x3  0.333*  0.355  0.333*  0.333  1.216  0.369  0.333*  0.333* 
jb11  15x5  0.233  0.365  0.213*  0.213  0.213*  0.262  0.221  0.235 
jb12  15x5  0.190*  0.239  0.190*  0.190  0.190*  0.246  0.190*  0.190* 
GMR  1.015  1.774  1  1  1.555  1.610  1.006  1.017  
ljb1  30x3  0.215*  0.847  0.215*  0.215  0.295  0.279  0.215  0.221 
ljb2  30x3  0.622  1.268  0.508  0.508  1.364  0.598  0.590  0.728 
ljb7  50x5  0.317  0.614  0.123  0.110  0.951  0.246  0.166  0.256 
ljb9  50x5  1.373  1.737  1.270  1.015  2.571  0.739  1.157  1.513 
ljb10  50x8  0.820  1.569  0.558  0.525  1.779  0.512  0.499  0.637 
ljb12  50x8  1.025  1.368  0.488  0.605  1.601  0.399  0.537  0.623 
GMR  1.943  3.233  1.213  1.170  4.098  1.220  1.299  1.686  
Overall GMR  1.329  2.434  1.084  1.068  2.305  1.408  1.118  1.256  
Comparison results taken from [9]. Figures in bold indicate best upper bound  
found over the different algorithms. “*” indicates optimality was proven by the algorithm. 
Table 2 provides results on the second of the benchmarks (taken from the GA literature). Following the convention of previous work on these problems [23][4][9], we report the cost normalized by the weighted sum of the job processing times. We include the best results found by the GA algorithms as presented by Vázquez and Whitley [23]
. We also provide an aggregated view of the results of each algorithm using the geometric mean ratio (GMR), which is the geometric mean of the ratio between the normalized upper bound found by the algorithm and the best known normalized upper bound, across a set of instances.
The performance of our method was less impressive for these problems, solving two fewer problems to optimality than uLNS, and achieving a worse GMR than either of the large neighborhood search methods. However, we remind the reader that all comparison methods had a 2 hour time limit on these instances, except the GA approaches for which the time limit was not reported. We further note that we find an improved solution for one instance (ljb10) and outperform all methods other than uLNS and sLNS.
5.2 Job Shop Scheduling Problem with positive Time Lags
These experiments were run using the same settings as in Section 5.1. However, because of the large number of instances and algorithms, we used only 5 random runs per instance.
There are relatively few results reported for benchmarks with positive maximum time lag constraints, as most publications focus on the “no wait” case. Caumond et al. introduced a genetic algorithm [7]. Then, Artigues et al. introduced a Branch & Bound procedure that allowed them to find lower bounds of good quality [1]. Therefore, in order to get a better idea of the efficiency of our approach, we adapted a model written by Chris Beck for Ilog Scheduler (version 6.3) to problems featuring time lag constraints. This model was used to showcase the SGMPCS algorithm [3]. We used the following two strategies: In the first, the next pair of tasks to schedule is chosen following the Texture heuristic/goal predefined in Ilog Scheduler and restarts following the Luby sequence [16] are performed, this was one of the default strategies used as a reference point in [3]. In the second, branching decisions are selected with the same “goal”, however the previous best solution is used to decide wich branch should be explored first, and geometric restarts [25] are performed, instead of the Luby sequence. In other words, this is SGMPCS with a singleton elite solution. We denote the first method TextureLuby and the second method TextureGeom+Guided. These two methods were run on the same hardware with the same time limit and number of random runs as our method. Finally, we report results for our approach without the greedy initialization heuristic (Algorithm 1) in order to evaluate its importance.
We used the benchmarks generated by Caumond et al. in [7] by adding maximal time lag constraints to the Lawrence JSP instances of the ORlibrary^{2}^{2}2http://people.brunel.ac.uk/~mastjjb/jeb/info.html. Given a job shop instance N, and two parameters and , a new instance N__ is produced. For each job all maximal time lags are given the value , where is the average processing time over tasks of this job. The first parameter corresponds to minimal time lags and will always be 0 in this paper.
Instance  [AHL]  [CLT]  Model 3  

time (s)  time (s)  time (s)  
la06_0_10  707.00  927  0.00  926  0.03  926 
la06_0_1  524.00  1391  1839.00  1086  70.60  926 
la07_0_10  518.00  1123  25.00  890  3600.00  890 
la07_0_1  754.00  1065  1914.00  1032  3600.00  896 
la08_0_10  260.00  863  2.00  863  0.07  863 
la08_0_1  587.00  1052  1833.00  1048  615.80  892 
average  558.33  1070  935.50  974  1314.41  898 
18.88  8.32  0.00 
Due to space limitations, we present most of our results in terms of each solver’s average percentage relative deviation (PRD) given by the following formula: , where is the best makespan found by the algorithm and is the best upper bound among all considered algorithms^{3}^{3}3To the best of our knowledge, these are the best known upper bounds.. In Table 3, we first report a comparison with the genetic algorithm described in [7], denoted [CLT] and the adhoc Branch & Bound algorithm introduced in [1], denoted [AHL]. We used only instances for which results were reported in both papers, and where the time lags were strictly positive, hence the relatively small data set. Despite that, and despite the difference in hardware and time limit, it is quite clear that our approach outperforms both the complete and heuristic methods on these benchmarks.
Instance Sets  Texture  Model 3  

Luby  Geom+Guided  no init.  init. heuristic  
Opt.  Opt.  Opt.  Opt.  
la[1,40]_0_0  0.12  25.37  0.12  16.15  0.37  10.42  0.35  0.06 
la[1,40]_0_0.25  0.20  22.98  0.25  12.01  0.37  3.46  0.40  0.00 
la[1,40]_0_0.5  0.22  19.47  0.25  5.17  0.37  2.62  0.42  0.00 
la[1,40]_0_1  0.35  15.76  0.42  1.18  0.40  17.43  0.45  0.47 
la[1,40]_0_2  0.67  7.35  0.75  0.13  0.67  74.16  0.70  0.37 
la[1,40]_0_3  0.75  3.47  0.92  0.00  0.75  95.91  0.77  0.29 
la[1,40]_0_10  0.95  0.10  0.97  0.00  0.92  0.04  0.92  0.05 
Next, in Table 4, we report results on all modified Lawrence instances for both Ilog Scheduler models, and the two version of Model 3, with and without the greedy initialization heuristic. Since there are 280 instances in total, the results are aggregated by the level of tightness of the time lag constraints. For each set, we give the ratio of instances that were solved to optimality in at least one of the five runs in the first column, as well as the mean PRD in the second column.
First, we notice the great impact of the new initialization heuristic on our method. Without it, the Ilog Scheduler model was more efficient for instances with , and the overall results are extremely poor for larger values of . However, the mean results are deceptive. Without initialization, Model 3 can be very efficient, although in a few cases no solution at all can be found. Indeed, relaxing the makespan does not necessarily makes the problem easy for this model. The weight of these bad cases in the mean value can be important, hence the poor PRD. On the other hand, we can see that the Ilog Scheduler model is more robust to this phenomenon: a nontrivial upper bound is found in every case. It is therefore likely that the impact of the initialization heuristic will not be as important on the Ilog model as on Model 3.
We also notice that solution guidance and geometric restarts greatly improve Ilog Scheduler’s performance. Interestingly, we observe that our approach is best when the time lag constraints are tight. On the other hand, Scheduler is slightly more efficient on instances with loose time lag constraints and in particular proves optimality more often on these instances. However, whereas our method always finds nearoptimal solutions (the worst mean PRD is 0.47 for instances with ), both scheduler models find relatively poor upper bounds for small values of .
5.3 Job Shop Scheduling Problem with no wait constraints
For the nowait job shop problem, the best methods are a tabu search method by Schuster (TS [20]) and a hybrid constructive/tabu search algorithm introduced by Bożejko and Makuchowski in 2009 (HTS [6]). We also report the results of a Branch & Bound procedure introduced by Mascis and Pacciarelli [17]. This algorithm was run on a Pentium II 350 MHz.
Instance  Mascis et al.  Schuster  Bożejko et al.  Model 4  Model 5  

B&B  TS  HTS  HTS+  +  +  
la[110] 
0.00  4.43  1.77  1.77  0.00  0.00  0.00  0.00 
la[1120]  31.66  7.93  3.49  0.95  0.14  0.10  0.00  0.31 
la[2130]  61.09  10.43  7.25  0.08  1.16  0.57  0.25  0.84 
la[3140]  73.73  10.95  8.33  0.15  4.42  1.77  2.68  1.36 
abz[59]  47.04  9.01  5.95  0.78  2.47  1.14  1.13  1.20 
orb[110]  0.00  2.42  0.77  0.77  0.00  0.00  0.00  0.00 
swv[15]  60.85  3.94  3.67  0.00  2.54  0.77  0.00  0.43 
swv[610]  57.82  4.99  4.19  0.00  4.78  1.71  0.44  1.00 
swv[1115]  70.98  0.68  2.48  0.60  19.50  6.53  17.54  5.18 
swv[1620]  76.81  5.71  3.98  0.00  10.92  68.94  4.47  3.17 
yn[14]  72.74  12.40  8.85  0.32  5.60  5.75  2.37  2.88 
overall  44.72  6.51  4.36  0.52  3.53  5.50  1.97  1.13 
For the nowait class we used the same data sets as Schuster [20] and Bożejko et al. [6] where null time lags are added to instances of the ORlibrary. We report the best results of each paper in terms of average PRD. It should be noted that for HTS, the authors reported two sets of results. The former were run with a time limit based on the runtimes reported in [20] and varying from 0.25 seconds for the easiest instances to seconds for the hardest. The latter (in italic font, and referred to as HTS+ in Table 5) were run “without limit of computation time”. We use bold face to mark the best result amongst methods that had time limits, i.e. excluding HTS+. We ran two variable ordering heuristics for our method. First, the heuristics used for ETJSP and TLJSP, where the Boolean variable minimizing the value of is chosen first, denoted . Second, we used another heuristic, denoted + that selects the next Boolean variable to branch on solely according to the tasks’ domain sizes , and break ties with the Boolean variable’s own weight .
Instance  Schuster  Bożejko  Model 4  Model 5  

BKS  TS  HTS  HTS+  +  +  
la11_0_0  2821  1737  1704  1621  1622  1619  1619*  1621 
la13_0_0  2650  1701  1696  1580  1582  1590  1580*  1580 
la14_0_0  2662  1771  1722  1610  1578  1578  1578*  1612 
la15_0_0  2765  1808  1747  1686  1692  1679  1671*  1691 
la26_0_0  4268  2664  2738  2506  2624  2511  2488  2540 
la28_0_0  4478  2886  2741  2552  2640  2605  2546  2569 
la30_0_0  4097  2939  2791  2452  2452  2452  2452*  2508 
la34_0_0  6380  3957  3936  3659  3914  3693  3817  3657 
la39_0_0  4295  2804  2725  2687  2660  2660  2660*  2660 
swv01  3824  2396  2424  2318  2344  2343  2318*  2333 
swv02  3800  2492  2484  2417  2440  2418  2417*  2417 
swv05  3836  2482  2489  2333  2433  2333  2333*  2333 
yn2  4025  2705  2647  2370  2486  2603  2427  2353 
yn4  4109  2705  2630  2513  2532  2573  2499  2582 
In Table 6 we report the results on nowait instances for which we obtained new upper bounds (5 instances) or new proofs of optimality (9 instances), thanks to the model introduced here.
6 Conclusions
We have shown that the simple constraint programming approach introduced in [13] can be successfully adapted to handle the objective of minimizing the sum of earliness/tardiness costs. These problems have traditionally proven troublesome for CP approaches because of the weak propagation of the sum objective [8].
Then we introduced a new heuristic to find good initial solutions for job shop problems with maximal time lag constraints. The resulting method greatly improves over state of the art algorithms for this problem. However, as opposed to the other aspects of the method (adaptive variable heuristic, solution guided branching, restarts with nogood storage) this new initialization heuristic is dedicated to job shop problems with time lag constraints.
Finally, we showed that domainspecific information can also be used to improve our model for nowait job shop scheduling problems, allowing us to provide several improved upper bounds and prove optimality in many cases.
References
 [1] C. Artigues, MJ. Huguet, and P. Lopez. Generalized Disjunctive Constraint Propagation for Solving the Job Shop Problem with Time Lags. EAAI, 24(2):220 – 231, 2011.
 [2] P. Baptiste, M. Flamini, and F. Sourd. Lagrangian Bounds for JustinTime Jobshop Scheduling. Computers & OR, 35(3):906–915, 2008.
 [3] J. C. Beck. SolutionGuided MultiPoint Constructive Search for Job Shop Scheduling. JAIR, 29:49–77, 2007.
 [4] J. C. Beck and P. Refalo. A Hybrid Approach to Scheduling with Earliness and Tardiness Costs. Annals OR, 118(14):49–71, 2003.
 [5] F. Boussemart, F. Hemery, C. Lecoutre, and L. Sais. Boosting Systematic Search by Weighting Constraints. In ECAI, pages 482–486, 2004.
 [6] W. Bozejko and M. Makuchowski. A Fast Hybrid Tabu Search Algorithm for the Nowait Job Shop Problem. Computers & Industrial Engineering, 56(4):1502–1509, 2009.
 [7] A. Caumond, P. Lacomme, and N. Tchernev. A Memetic Algorithm for the Jobshop with Timelags. Computers & OR, 35(7):2331–2356, 2008.
 [8] E. Danna and L. Perron. Structured vs. unstructured large neighborhood search: A case study on jobshop scheduling problems with earliness and tardiness costs. Technical report, ILOG, 2003.
 [9] E. Danna, E. Rothberg, and C. Le Pape. Integrating Mixed Integer Programming and Local Search: A Case Study on JobShop Scheduling Problems. In CPAIOR, 2003.
 [10] T. Feydy and P. J. Stuckey. Lazy Clause Generation Reengineered. In CP, pages 352–366, 2009.
 [11] D. Grimes. A Study of Adaptive Restarting Strategies for Solving Constraint Satisfaction Problems. In AICS, 2008.
 [12] D. Grimes and E. Hebrard. Job Shop Scheduling with Setup Times and Maximal TimeLags: A Simple Constraint Programming Approach. In CPAIOR, pages 147–161, 2010.
 [13] D. Grimes, E. Hebrard, and A. Malapert. Closing the Open Shop: Contradicting Conventional Wisdom. In CP’09, pages 400–408, 2009.
 [14] J. Kelbel and Z. Hanzálek. Solving production scheduling with earliness/tardiness penalties by constraint programming. J. Intell. Manuf., 2010.
 [15] C. Lecoutre, L. Sais, S. Tabary, and V. Vidal. Nogood Recording from Restarts. In IJCAI, pages 131–136, 2007.
 [16] M. Luby, A. Sinclair, and D. Zuckerman. Optimal Speedup of Las Vegas Algorithms. In ISTCS, pages 128–133, 1993.
 [17] A. Mascis and D. Pacciarelli. Jobshop Scheduling with Blocking and Nowait Constraints. EJOR, 143(3):498–517, 2002.
 [18] T. E. Morton and D. W. Pentico. Heuristic Scheduling Systems. John Wiley and Sons, 1993.
 [19] C. Rajendran. A NoWait Flowshop Scheduling Heuristic to Minimize Makespan. The Journal of the Operational Research Society, 45(4):472–478, 1994.
 [20] C. J. Schuster. Nowait Job Shop Scheduling: Tabu Search and Complexity of Problems. Math Meth Oper Res, 63:473–491, 2006.
 [21] A. Schutt, T. Feydy, P. J. Stuckey, and M. Wallace. Why Cumulative Decomposition Is Not as Bad as It Sounds. In CP’09, pages 746–761, 2009.
 [22] N. Tamura, A. Taga, S. Kitagawa, and M. Banbara. Compiling Finite Linear CSP into SAT. In CP, pages 590–603, 2006.
 [23] M. Vázquez and L. D. Whitley. A comparison of genetic algorithms for the dynamic job shop scheduling problem. In GECCO, pages 1011–, 2000.
 [24] P. Vilím. Filtering Algorithms for the Unary Resource Constraint. Archives of Control Sciences, 18(2), 2008.
 [25] T. Walsh. Search in a Small World. In IJCAI, pages 1172–1177, 1999.
 [26] JP. Watson, L. Barbulescu, A. E. Howe, and L. D. Whitley. Algorithm performance and problem structure for flowshop scheduling. In AAAI, pages 688–695, 1999.
 [27] D. A. Wismer. Solution of the FlowshopScheduling Problem with No Intermediate Queues. Operations Research, 20(3):689–697, 1972.
Comments
There are no comments yet.