An experimental and analytical study of order constraints for single machine scheduling with quadratic cost

Transcription

1 An experimental and analytical study of order constraints for single machine scheduling with quadratic cost Wiebke Höhn Tobias Jacobs Abstract We consider the problem of scheduling jobs on a single machine. Given a quadratic cost function, we aim to compute a schedule minimizing the ed total cost, where the cost of each job is defined as the cost function value at the job s completion time. Throughout the past decades, great effort has been made to develop fast exact algorithms for the case of quadratic costs. The efficiency of these methods heavily depends on the utilization of structural properties of optimal schedules such as order constraints, i.e., sufficient conditions for pairs of jobs to appear in a certain order. A considerable number of different kinds of such constraints have been proposed. In this work we enhance the map of known order constraints by proving an extended version of a constraint that has been conjectured by Mondal and Sen more than a decade ago. Besides proving this conjecture, our main contribution is an extensive experimental study where the influence of different kinds order constraints on the performance of exact algorithms is systematically evaluated. In addition to a best-first graph search algorithm, we test a Quadratic Integer Programming formulation that admits to add order constraints as additional linear constraints. We also evaluate the optimality gap of well known Smith s rule for different monomial cost functions. Our experiments are based on sets of problem instances that have been generated using a new method which allows us to adjust a certain degree of difficulty of the instances. Introduction We investigate algorithms for scheduling jobs on a single machine in a nonlinear cost scenario. The input consists of n jobs, each having a nonnegative and processing time. We refer to the jobs as integers,..., n, and denote the processing time and hoehn@math.tu-berlin.de. Technische Universität Berlin, Germany. Supported by the Deutsche Forschungsgemeinschaft (DFG) as part of the Priority Program Algorithm Engineering (37). tobias.jacobs@neclab.eu. NEC Laboratories Europe, Heidelberg, Germany. Work supported by a fellowship within the Postdoc-Programme of the German Academic Exchange Service (DAAD). of a job j {,..., n} by p j and w j, respectively. The objective is to schedule these jobs nonpreemptively on a single machine such that the ed sum of quadratic completion times n j= w jcj 2 is minimized, where C j is the completion time of job j. Following the three-field notation [7], this problem is denoted by w j Cj 2. An important alternative interpretation of this problem (or, more general, the problem variant of minimizing w j f(c j ) for a nonlinear function f) is the scenario of linear cost and nonuniform processor speed. Assume that the processor speed at any time t is given by a nonnegative function g : R R, and the processing times (or workloads) p j of the jobs are given with respect to a unit speed processor. The total workload processed until time t is G(t) := t g(t)dt. Conversely, if the total workload of job j and all jobs processed before it is t, then the cost of j in the schedule is G (t ). Therefore, the problem is equivalent to w j G (C j ). Getting back to the original setting, nonlinear cost functions are commonly used as a tradeoff between worst case minimization and the flowtime minimization problem w j C j. The latter is solved to optimality by the well-known Smith s rule which schedules the jobs in nonincreasing order of their wj p j -ratios [7]. Verifying optimality of this method is very easy. Still, in the next paragraphs, we use its discussion to exemplify the terminology of local and global order constraints, which play a central role in this work. Whenever in an optimal schedule for w j C j jobs i and j are processed consecutively, then w i / > w j /p j is a sufficient condition for i being processed before j. This follows directly by an exchange argument. The fact that job i must be processed before j whenever these jobs are adjacent is expressed by the notation i l j. We say that the jobs i and j are locally comparable when either i l j or j l i holds. A local order constraint is an implication of the form C i l j, where C is a proposition about i and j. In our example, the local order constraint reads as w i / > w j /p j i l j. In contrast, a global order constraint is an implication of the form C i g j. The relation i g j ex-

2 presses that job i is processed before j by any optimal schedule, even and this is the difference to local order constraints if there are other jobs scheduled between i and j. The jobs i and j are called globally comparable if i g j or j g i. In case of w j C j, the above local order constraint is actually a global one: Any job pair i, j is either locally comparable, or w i / = w j /p j and their processing order does not impact the objective function value if being processed consecutively. This implies the optimality of Smith s rule. When considering the quadratic cost function instead, there are no obvious local or global order constraints which immediately lead to an optimal schedule (cf. [3]). In particular, the above condition w i / > w j /p j is not even sufficient for local comparability. Due to nonlinearity, the benefit of interchanging adjacent jobs i and j can be positive or negative, depending on the position of the job pair in the schedule. Problem w j Cj 2 has been studied to a great extent with a focus on exact solution methods; see e. g., [, 2, 5, 8, 2, 3,, 2]. Most of these works utilize branch-and-bound approaches with pruning rules based on order constraints. In this work we extend the set of known constraints and evaluate their influence on the performance of various algorithms in an extensive experimental study. Related work. Half a century ago, Schild and Fredman [] proposed a complete enumeration scheme to solve the problem for quadratic cost functions, taking into account a local order constraint to reduce the solution space. Nearly two decades later, Townsend [2] was the first to solve problem w j Cj 2 by branchand-bound. For pruning, he uses a lower bound on the optimal cost related to a local order constraint (see Section 3.). This initial article triggered a long series of papers proposing many improvements of the branchand-bound algorithm. Bagga and Kalra [2] add a further node elimination rule, which is a sufficient condition for sets of jobs appearing at the first r positions in an optimal schedule. Global order constraints in this context were first used by Gupta and Sen [8], who proved the sufficient condition p j > w j p j < w i. Order constraints that additionally depend on the time interval within which the job pair is processed are used in [] and [5]. Finally, Mondal and Sen [2] conjectured the global order constraint w i w j w i / w j /p j i g j and demonstrated in an experimental setup that this constraint would significantly further reduce the resource requirements. An overview of the order constraints known so far can be found in Figure (a). In the original branch-and-bound method by Townsend, nodes represent prefixes of schedules. Sen et al. [5] propose to reduce the number of generated nodes by using a graph searching procedure. There, nodes alternatively represent unordered sets of jobs, and a schedule is then represented by a path in that graph. Kaindl et al. observe in [] that it is more efficient to build the schedule from the end to the beginning than vice versa. As we adopt these ideas, a more detailed description of them can be found in Section 3.. The algorithms mentioned in the previous paragraphs are practically efficient, but have exponential worst-case runtime. In fact, up to today it is not known if w j Cj 2 is NP-hard. Recently, there has been much progress concerning approximation algorithms for w j f(c j ) with general cost function f, and even for f j (C j ), where each job j has its individual cost function f j. Bansal and Pruhs [3] have given a geometric interpretation of the latter problem that yields a O(log log np )-approximation in the presence of release dates and preemption. In the special case of uniform release dates, their method achieves the constant approximation factor of. That factor has been improved to 2 + ɛ via a primal-dual approach by Cheung and Shmoys []. For w j f(c j ) with arbitrary concave f, Stiller and Wiese [8] show that Smith s rule guarantees an approximation factor of ( 3 + )/2 which is tight when f is part of the problem input. Moreover, they construct an efficient polynomial time approximation scheme for the problem variant with release dates. Also taking into account release dates, Epstein et al. provide an approximation algorithm for the problem by generalizing their results on scheduling unreliable machines []. Their method generates a schedule which has approximation guarantee + ε for any cost function. In a companion paper [] we derive a simple method to calculate the tight approximation factor of Smith s rule for any particular convex or concave cost function. The resulting factor for the quadratic case considered in this paper is.3. In the companion paper we also show that the problem is NP-hard for a class of cost functions that corresponds to periodically alternating processor speed. Our contribution. The focus of this paper is on exact methods for problem w j Cj 2. We prove an extended version of the global order conjecture by Mondal and Sen [2] that has remained open since 2. The resulting improvement to the map of known order constraints is illustrated in Figure. Besides this theoretical result, our main contribution is an extensive experimental study, where algorithmic approaches that have been proposed throughout the

3 (a) w i (b) w i i g j by [] j l i by [] j g i j g i by [8] i l j by [] j l i j l i by [] i l j by [] i g j by [8] i g j by [] w j = 2 w i p j i g j i l j w j = w i p j w j = w i 2+p j +2p j p j processing time processing time w j = w i p j w j = w i p j w j = w i 2+p j +2p j p j w j = w i 2 p j Figure : The figures show the known order constraints for the problem w j Cj 2 in comparability maps with respect to a job i. Figure (a) shows the results known from previous works, whereas Figure (b) integrates the new insights of this paper. In a comparability map, each job is represented by a point in R 2 where the first component is its processing time and the second its. past three decades are systematically evaluated. A special focus is on the influence of order constraints on the performance of the algorithms. We tested different variants of the graph search procedure stated above, and also a Quadratic Integer Program formulation that admits to add order constraints in the form of simple linear constraints. In addition, we evaluated the practical solution quality of Smith s rule for different monomial cost functions. It turns out that this simple heuristic is almost optimal for all test instances. To the best of our knowledge, all previous experimental work has been based on instances that were generated by choosing both the and the processing time uniformly and independently at random. From Figure, one would intuitively expect that those instances are easier to tackle than instances with a positive correlation between the processing time and the of a job. We have generated our test set using a new method where this correlation can be set as a parameter. Our experiments reveal that the difficulty of problem instances indeed increases with the correlation. Paper organization. In the following section we describe the global order constraints evaluated in our experimental study, and prove an extended version of the global order constraint conjectured by Mondal and Sen. The algorithmic approaches and data sets investigated in our experiments are presented in Section 3 and. Thereafter, in Section 5, we discuss the results of the computational study. Section concludes this work. 2 Global order constraints In this section, we introduce the five types of global order constraints whose benefits are evaluated in our experiments. Two of them are consequences of an extended version of the conjecture by Mondal and Sen [2], which we prove in the second part of the section. 2. Constraint types. The following conditions are all global, i.e., sufficient conditions for i g j. Basic constraint: The global constraint < p j w i > w j i g j has been given by Sen et al. []. We note that it still holds when one of the two relations in the sufficient condition is an equality instead of an inequality. In fact, this constraint holds also for the problem w j f(c j ) with nondecreasing cost function f. constraint: An a-gap constraint is a sufficient condition of the form w i / > a w j /p j. We show in the next subsection that our problem observes the global constraint. Weight constraint: The global constraint has been conjectured by Mondal and Sen. It states that i g j holds if w i w j and w i / w j /p j, and the jobs i and j are not identical. We prove it together with the global constraint in the next section. Decomposition: The technique has been proposed by Szwarc et al. [9]. It is based on local comparability. Recall that i l j means that in any optimal schedule where the jobs i and j are adjacent, i must precede j. It is known that for any pair of adjacent jobs i, j there is a point in time t ij such that i must be processed before j when the first of these jobs starts before time t ij, and vice versa when they are processed after t ij. This critical point in time can be easily computed from the characteristics of the two jobs. Let P be the total processing time of all jobs in a problem instance. Any schedule takes place within the time interval [, P ]. Therefore i l j holds if t ij > P p j, and j l i holds whenever t ij <. In the first step, the method determines for

4 all job pairs i, j if one of these two relations hold. It then tries to decompose the instance into two subinstances by deriving global order constraints from the local ones. Assume for simplicity that the jobs are indexed such that w /p w 2 /p The method tries to identify an index k such that i l j for all i k < j. When such an index is found, it is clear that in any optimal schedule all jobs,..., k are scheduled before the jobs k +,..., n. In other words, the global order constraint i g j holds for any i k < j. We then also know that,..., k are processed inside the time interval [, P ] with P := p p k, and the jobs k +,..., n are scheduled in the interval [P, P ]. Now the procedure is recursively applied to these two job subsets and respective time intervals. Note that the more restricted time intervals can lead to new local order relations. Combined constraint: This constraint is simply a combination of the four constraints above. If one of the constraints implies an ordering relation, then so does the constraint. 2.2 Proof of and constraint. We continue with proving the global and constraint, the former being conjectured in [2]. Theorem 2.. Problem w j C 2 j observes the global constraint and the global constraint: For any pair of jobs i, j, we have i g j if one of the following sufficient conditions hold: (a) w i w j, wi (b) wi 2 wj p j. wj p j, and i, j are not identical, Proof. Both constraints are proven simultaneously by induction on the number of jobs that are scheduled between a job pair satisfying the respective constraint. More specifically, we show for increasing values of k that there is no optimal schedule where for a pair of jobs i, j satisfying (a) or (b) the job j is processed before i and there are at most k other jobs between them. The base case k = are the local variants of both constraints. Their proofs are given in Lemma 2. and 2.2 for the more general case of monomial cost functions. By the induction hypothesis, we assume that the theorem holds when, for some fixed k, there are less than k jobs scheduled between two jobs i and j satisfying property (a) or (b). Based on these assumptions, we first show the induction step for (a) in Lemma 2.3. This lemma is then used in the induction step for (b) in Lemma 2.. The proof of these two lemmas will complete also this proof. In the proofs of the following lemmas we will use the fact that problem w j Cj 2 is invariant to scaling, i.e., after multiplying all s by the constant c and all processing times by d, the cost of any schedule for the scaled instance is obtained from the cost of the same schedule for the original instance by multiplication with cd 2. Hence, also optimal schedules coincide. Lemma 2.. Problem w j Cj k, k N, observes the local constraint. Proof. Whenever i l j holds for jobs i and j, then it still holds after the processing time of i has been made shorter. Thus, we can assume without loss of generality that w i / = w j /p j. By the above scaling argument, we can also assume that w j = p j = and < w i = =: a. Comparing the cost of scheduling at some point in time t firstly i and then j and vice versa, i l j holds if and only if the following inequality is satisfied a ((t + a) k (t + a + ) k) < (t + ) k (t + a + ) k. We define the function g : x (t + a + x) k (t + a + ) k. As the subtracted term is a constant and x x k strictly convex on R +, g is strictly concave on R+. Now the above inequality reads as a g() < g(a), which holds true due to the strict concavity of g. Lemma 2.2. Problem w j Cj k, k N, observes the local k-gap constraint. Proof. (sketch) We need to show that given two jobs i, j with w i / k w j /p j it holds that i l j. Analogously to the previous lemma, consider the defining condition for i l j. Resolving it for w i, we get the necessary and sufficient condition w i > g t ( ) for each t, where g t : (t + + ) k (t + ) k (t + + ) k (t + ) k. For any t, the function g t can be shown to be concave, to be for =, and to satisfy g t() k. These properties imply that each point w i k lies above all curves g t. Lemma 2.3. Assume that for some fixed k Theorem 2. holds for any pair of jobs i, j which satisfy (a) or (b) and between which less than k other jobs are scheduled. Then constraint (a) holds also for the case when there are k jobs scheduled between i and j. Proof. Assume for contradiction that there is an optimal schedule where job pair i, j satisfies (a), j is processed before i, and there are k jobs in between. We make three simplifying assumptions. Firstly, we assume that w j = p j =. This is without loss of generality, because the optimality of a schedule is invariant to

5 and cost scaling. Secondly, we can assume that i is the very last job, since after removing all jobs scheduled after i we obtain an optimal schedule for the remaining jobs for which we then show the contradiction. Thirdly, we assume that < = w i. The first inequality holds because otherwise the assumption of (a) being satisfied and the jobs not being identical would imply that = p j = and w i > w j =, so the global constraint (see Subsection 2.) immediately leads to a contradiction. Hence, we have w i >. The reason why = w i can be assumed without loss of generality is that lowering the of i preserves the optimality of the schedule under consideration. In fact, if there was a better schedule for the instance with w i decreased, a straightforward calculation shows that this schedule would also be less costly for the original instance. Finally, we relabel the jobs and refer to job j as (, ), to job i as (b, b) with b := w i =, and the jobs between them are assumed to be,..., k. To make the notation even shorter we also write J...k instead of,..., k. We now define a function measuring the cost increase or decrease when the sub-schedule J...k is interchanged with a job (x, x) having identical processing time and x (the job (x, x) is used as an abstraction of the jobs (, ) and (b, b)). This function depends on the jobs J...k, the value of x, and the starting time t of (x, x) or J...k (depending on which one is processed first). However, we suppress the dependence on everything but x by writing (x) = k w l (t + l= ) 2 ( l p m + x t + m= x (t + x) 2 k w l (t + x + l= k p m + x m= ) 2 l p m. m= ) 2 Whenever is negative (positive), it is strictly cheaper to schedule J...n before (after) (x, x). being zero means that both possibilities have equal cost. The second derivative of in x is 2 k l= (2p l w l ). This is the point where we require the induction hypothesis. Property (b) and the characteristics of job (, ) imply that w l < 2p l for l =,..., k. Therefore, the second derivative of is strictly positive, and hence, is strictly convex and has at most two roots. One of those roots is at x =, so there is some x such that (x) < for x (, x ), (x ) =, and (x) is strictly increasing for x x. Note that possibly x = and might be completely nonnegative. The optimal schedule under consideration contains (, ), J...k, (b, b) as a contiguous sub-schedule. If () <, then one obtains a cheaper schedule by interchanging (, ) and J...k, a contradiction to optimality. If (), then (b) > (). In that case consider the alternative schedule obtained by the following operations: () interchange (, ) and J...k, (2) interchange (, ) and (b, b), (3) interchange J...k and (b, b). The second operation decreases the cost, due to the local version of the constraint (Lemma 2.). The first operation does not decrease the cost due to (), but the increase is more than compensated for by the third operation because (b) > (). All in all we obtain a cheaper schedule, which contradicts the optimality of the original one. Lemma 2.. Assume that for some fixed k, Theorem 2. holds for any pair of jobs i, j which satisfy (a) or (b) and between which less than k other jobs are scheduled. Then constraint (b) holds also for the case when there are k jobs scheduled between i and j. Proof. Assume for contradiction that there is an optimal schedule where job pair i, j satisfies (b), j is processed before i, and there are k jobs in between. Like in the proof of Lemma 2.3, we assume w.l.o.g. that w j = p j =, and we rename the k jobs between j and i to,..., k and use J,...,k as an abbreviation for that sequence, of course also assuming i, j > k. The job i satisfies w i 2. We can also assume that < because otherwise the job pair i, j would satisfy property (a), which is impossible due to Lemma 2.3. Furthermore, is must hold that w i, because otherwise we would have < p j and w i w j, and the constraint (see Subsection 2.) would immediately prove suboptimality. Summarizing, it suffices to analyze the situation w j = p j = > w i 2. In the following notation we ignore all jobs scheduled before and after the jobs j, J...k, i; slightly abusing notation, we refer to the schedule and also to its cost by [j, J,...,n, i], analogously for other permutations of this job subset. Claim: [j, i, J...k ] [j, J...k, i] < [i, j, J...k ] [i, J...k, j]. If that claim is true, then the suboptimality of [j, J...k, i] can be shown by calculating [i, J...k, j] < [i, j, J...k ] [j, i, J...k ] + [j, J...k, i] < [j, J...k, i], where the second inequality is due to the local version of the constraint (Lemma 2.). To prove the claim, let T be the point in time when job i completes in the optimal schedule [j, J...k, i]. Let further p...k be the total processing time of all jobs in J...k. We regard the cost caused by these k jobs as a function F of the completion time of the last job k. The left hand side of the claimed inequality accounts for the (positive or negative) cost gain (i.e. cost

6 decrease) of transforming [j, i, J...k ] into [j, J...k, i]. By this transformation the jobs J...k become processed earlier, their cost decreasing by g L (gain), and job i becomes more expensive, requiring to pay an additional amount of l L (loss). On the right hand side of the inequality, [i, j, J...k ] is transformed into [i, J...k, j], corresponding to analogous variables g R and l R. Recalling that we denote the cost function of the jobs J...k by F, these variables compute as g L := F (T ) F (T ), l L := w i (T 2 (T p...k ) 2 ), g R := F (T ) F (T ), and l R := T 2 (T p...k ) 2. To conclude this proof we require the estimate g L < w i g R, which is equivalent to F (T ) F (T ) < w i (F (T ) F (T )). The loss terms satisfy l L = w i l R. We are going to show below that g L < w i g R, which implies the claim as follows: [j, i, J...k ] [j, J...k, i] = g L l L < w i (g R l R ) g R l R = [i, j, J...k ] [i, J...k, j]. The first inequality is due to the optimality of schedule [j, J...k, i], the second one follows from l L = w i l R and the above proposition that g L < w i g R, and the third inequality follows from w i. It remains to show the proposition g L < w i g R, which is equivalent to proving F (T ) F (T ) < w i (F (T ) F (T )). All we need to know about F is that it is a nonnegative quadratic function that is strictly increasing on [T, ). As we are reasoning about the difference of function values, the same reasoning will hold after the function curve of F has been shifted vertically. We can also shift the function horizontally if we shift the points of evaluation T,T, and T along with it. For the sake of simpler calculations, we do transformations of that kind, such that we obtain T = F (T ) =. Then F can be written as F (t) = a t (t + b) with a >. Furthermore, F cannot have a positive root and therefore b. Utilizing w i 2 and T =, we can write F (T ) F (T ) = F () F ( ) a( + b) a( w i /2)( w i /2 + b), the right hand side of which can be reformulated to a( + b) a( w i + ( w i /2)b + w 2 i /). This quantity is strictly smaller than a(+b) a( w i +( w i )b) = w i a(+b) = w i (F () ), which is equal to w i (F (T ) F (T )). 3 Exact algorithms In this section we go into details about the exact algorithms we have implemented and tested. Global order constraints are treated as a black box here. 3. Graph search. We consider an exact algorithm combining the insights of the two major approaches discussed in previous articles. On the one hand side, there are standard branch-and-bound methods whose intelligence consists of utilizing order constraints, the latest work being by Mondal and Sen [2]. On the other hand, Sen et al. [5] and Kaindl et al. [] propose a best-first graph search (BFGS), exploring the graph in forward (BFGS f ) and backward (BFGS b ) manner, respectively. See e. g., [9] for a general description of the very popular best-first search algorithm A. The BFGS approaches in [5, ] utilize the lower bound shown by Townsend [2] for its branch-and-bound algorithm. However, regarding the use of order constraints for pruning the search space, they only exploit the rather weak constraint by Bagga and Kalra [2] which uses the local version of the constraint for a limited of the problem instance. To the best of our knowledge, global order constraints have not yet been integrated into BFGS methods for the problem w j Cj 2. Sen et al. [5] showed in their experiments that, comparing (forward) best-first graph search BFGS f, best-first tree search and depth-first search, BFGS f is by far the fastest on their randomly generated instances. The experiments by Kaindl et al. [] demonstrated that BFGS b is even faster. Opting for the fastest variants, we will consider BFGS f and BFGS b which we further speed up by integrating our constraints. However note that for larger instances depth-first search might become the method of choice due to its lower memory consumption. Graph-based search with A. We consider BFGS f and BFGS b based on the best-first search algorithm A [9]. We extend the methods proposed in [5, ] by integrating global order constraints to prune the search space. When describing the algorithm, we focus on BFGS b since it is slightly less intuitive and faster than BFGS f. At the end of this section, we remark on the modifications that are necessary for BFGS f.

7 In the graph G considered in this context, nodes represent subsets of jobs S. Slightly abusing notation, we refer to the nodes by the corresponding job sets. Let J denote the set of all jobs in the instance. From each node S J there is a directed arc to node S = S \ {j} for all j S, i. e., each arc corresponds to a job j, and its cost c(s, S ) is set to the cost incurred by job j when scheduling it inbetween S and J \ S. So formally c(s, S ( ) 2. ) = c(s, S\{j}) = w j i S Now, each path from J to {} in G naturally corresponds to a schedule for w j Cj 2, because the arcs of the path represent a permutation π(), π(2),..., π(n) of the jobs. As we perform backward search, the corresponding schedule is π(n), π(n ),..., π(). In other words, each partial path from J to some node S represents a partial schedule where the jobs J \S are processed after the jobs from S. Due to cost of corresponding paths and schedules being the same, there is a one-to-one relation between minimum cost paths from J to {} and optimal schedules for w j Cj 2. The remainder of the algorithm is ally to run A on this graph. Two versions of an admissible lower bound heuristic h guiding the search are described below. For the sake of memory efficiency the graph is built dynamically, generating new nodes as we approach them during the search. Furthermore and that is the point where we extend the algorithms in [5, ] a node S is infeasible when there is a pair of jobs i J \S, j S with i g j. During the search infeasible nodes are ignored. For the forward variant BFGS f we need to modify the above as follows. The arcs are going from S to all neighbors S {j}, j / S, and the cost c(s, S ) of such an arc is given by the cost incurred by appending j at the end of a schedule for the jobs in S. The root node is given by {}. Consequently, paths from {} to J correspond to schedules for w j Cj 2, and here the permutation π does not need to be inverted. We continue with a discussion of the used lower bounds, and refer to [9] for more details on the A procedure itself. Lower bounds. In order to test the impact of the different order constraints without external influence of sophisticated lower bounds, we consider a rather lower bound besides Townsend s lower bound [2]. In this context, a lower bound is a function h on subsets of jobs S. For the backward variant BFGS b this corresponds to providing a bound on the cost of a schedule for the jobs in S, starting at time. Inversely, for BFGS f this bound needs to be computed with respect to J\S and time j S p j. So in fact, h can be formulated as a function on the start time t of a schedule and on the jobs J J to be scheduled. The lower bound (B) simply is given by the total cost of all jobs in J when starting them at time t. Townsend s lower bound (T) is based on the local constraint. He first computes a schedule by sorting the jobs by nonincreasing ratio w j /p j. Assume for simplicity that this order is,..., n. The optimal schedule can be obtained from that schedule by a series of local interchange operations where the order of two adjacent jobs i, j with i < j is changed to j, i. An upper bound on the cost reduction of such an operation is (c j c i )w i w j. Townsend computes this upper bound for each job pair i, j, and whenever it is positive it is subtracted from the cost of schedule,..., n. This gives a lower bound on the optimal cost. The relation with the local constraint is due to the fact that the amount subtracted for job pair i, j is zero whenever the constraint for this job pair is satisfied. Also observe that Townsend s lower bound is independent of the time t at which the schedule under consideration starts. When referring to a combination of a graph search algorithm with a specific lower bound, we add the lower bound s name as superscript to the algorithm name, e. g., BFGS B f or BFGS T b. Implementation note. Since global order constraints are evaluated extremely often during a run of the algorithm, we transfer their evaluation to a preprocessing step by computing an n n comparability matrix. By this, the time for evaluating constraints becomes negligible later on, and moreover, it is independent of the constraint used. For checking the feasibility of a node S reached from a (feasible) node S during the main computation, one only has to test the constraint matrix for the job pairs i, j with i S, j / S and i, j S (i, j / S for forward search). The number of such pairs is smaller than n. 3.2 Quadratic Integer Programming. There are several possibilities to express w j Cj 2 in terms of a Mathematical Program. The reason why we have chosen the Quadratic Integer Programming (QIP) formulation below is that it admits to directly add order constraints in the form of linear constraints to the program. We used CPLEX 2. for its solution. For each pair of distinct jobs i < j we introduce a binary variable x ij which is defined to be if i is scheduled before j. In order to ensure that any feasible solution represents a total order, we add constraints enforcing transitivity by preventing each triple of jobs to occur in cyclic order. Furthermore, we add a

8 variable y j for each job j representing its completion time, and a constraint which serves as lower bound on y j depending on the jobs scheduled before j. The order constraints can be easily integrated by fixing the respective variables x ij. The objective function results as n j= w jyj 2, where w j denotes the of job j. The Quadratic Integer Program results as: min. n w j yj 2 j= s. t. x ij + x jk + ( x ik ) 2 i, j, k n i < j < k x ij + p j + x ji ) y j j n i>j( i<j x ij = i g j x ij = j g i x ij {, }, y j i < j n 3.3 Smith s rule. In a companion paper [] we give a generic tight analysis of the worst-case approximation factor achieved by Smith s rule [7] for arbitrary convex or concave cost functions and various characteristics of the problem instance. Smith s rule orders the jobs by the decreasing ratio w j /p j. In order to evaluate also the practical approximation quality of Smith s rule in nonlinear cost settings, we implemented it and compared the cost of its solution with the optimal solution cost computed by BFGS. Data set Our experiments are based on random instances that have been generated using a combination of uniform and normal distribution. The random instance generator is configured by the three parameters (n, p max, σ). Parameter n is the number of jobs in the instance, the parameter p max specifies the maximum job length, and σ > represents, to a certain degree, the computational difficulty of the instance. The length p j of each job j is chosen as a uniform random integer between and p max. Note that assuming the minimum processing time to be is without loss of generality. This is because in case of monomial cost functions f, the problem w j f(c j ) is invariant to and cost scaling. The w j is then calculated from as w j := p j 2 N (,σ2), where N (, σ 2 ) means that the exponent is chosen according to normal distribution with mean and standard deviation σ. By plotting each job j as a point (p j, w j ) R 2, Figure 2 gives an impression on how instances generated with respect to different values of σ look like. The larger the σ-value the more the jobs are spread around = :2 = : = :8 Figure 2: Three instances generated for parameters σ =.2,. and.8. Each job j is depicted as point (p j, w j ) R 2 with respect to its processing time p j and its w j. the angle bisector. Going back to the global order constraints depicted in Figure (b), one gets an intuition why σ may be an important characteristic for the difficulty of an instance: If all jobs lie close to the angle bisector, then, for a fixed job, most of the other jobs lie in the area where the known global order constraints are not applicable. In contrast, if the jobs are evenly spread over the plane, the constraints will fix the relative order of many more job pairs, and by this, they allow to heavily prune the search space. In previous computational experiments (e. g., [2, 5, ]), processing times and s have been generated independently at random with respect to uniform distribution. This results in computationally rather simple instances even in the presence of many jobs. We run our experiments on five data sets. The set S n is used to study the behavior of BFGS and QIP with respect to increasing n. The remaining four set are generated to investigate the impact of σ. We use the sets Sσ B, Sσ T, Sσ Q and Sσ S to the analyze BFGS with and Townsend lower bound, QIP and Smith s rule, respectively. The parameters we used to generate the sets are summarized in Table. The parameter ranges have been chosen depending on the memory efficiency of the algorithms, so that the benefits of the different order constraints become visible and still the experiments can be performed on a standard PC. As a comparative study of the algorithms is not our main purpose, we believe that using an individual data set for each of them leads to the most meaningful results. 5 Experimental results Regarding the overall performance of the different algorithmic approaches we partly observed the same effect as Kaindl et al. [] that the backward variants of BFGS generate less nodes than forward variants, see below for a more detailed discussion. And clearly, using Townsend s lower bound, one outperforms the variants utilizing only the bound. In the following discussion, we consider BFGS T b as the default variant of

9 set n σ p max # inst. per fixed n or σ total # inst. Sσ B 2.,.,.2,..., Sσ T 25.,.,.2,..., Sσ Q.,.,.2,..., Sσ S 25.,.5,.2,...,. 8 S n,2,..., Table : Parameters for generating the test sets. BFGS, and also investigate BFGS B b and BFGST f differing from it by the lower bound and the search direction, respectively. Our QIP approach was not able to handle the same instance size as BFGS. However, this does not necessarily mean that Integer Programming approaches are less efficient in general. The purpose of our specific formulation was the usability of order constraints rather than efficiency. We measure the efficiency of the combinations of algorithms with order constraints in terms of the number of generated nodes, as this measure is independent of the concrete machine on which the experiments are run. Recall that the global constraint matrix is computed in a preprocessing step, and the corresponding overhead in terms of runtime is negligible. The main focus of our experimental study is on the impact of the different constraints from Section 2. on the behavior of the methods described in Section 3. As it turned out, the correlation parameter σ is significant in this context. The corresponding results are shown in Figure 3. It reads as matrix whose columns correspond to the different constraint and its rows to the considered algorithms. Moreover, we provide results of an additional computational study investigating the impact of the number of jobs n. Similar as for the study of σ, they are presented in a matrix of plots; see Figure. The solution quality Smith s rule achieved in our experiments is visualized in Figure 5. The numerical values corresponding to the Figures 3, and 5 are given in the Tables 2, 3 and, respectively. Main observations. From the plots in Figure 3,, and 5 we make the following observations. Highly correlated instances are generally difficult. The number of generated nodes always seems to decrease with σ, which can be observed on all plots of Figure 3. The first row of the figure shows that the number of comparable job pairs typically increases with σ, which partly explains the influence of this parameter. However, the performance of algorithms using Townsend s lower bound and the performance of QIP improves with σ even when no constraints are utilized. The number of comparable job pairs influences all algorithms. There is a clear correlation of the number of comparable job pairs and the number of nodes generated by the algorithms. This effect is especially strong, when considering BFGS without the advanced lower bound. Figure 3(b) reads almost as a mirrored image of Figure 3(a). The correlation is less pronounced for QIP due the additional elaborate techniques utilized within the QIP solver. The benefit of the constraint heavily depends on the parameter σ. The constraint performs rather bad in general, and in particular bad for small σ. This can be explained by comparing Figure (b) and 2, where one can observe that especially for small σ, there is a high probability that for every job almost all other jobs lie within the cone not covered by the constraint. The global constraint leads to good and reliable performance. As already observed by Mondal and Sen [2] and being the reason for conjecturing the global constraint comparing the constraint with the constraint, one clearly sees the benefit of strengthening the constraint to the constraint; see columns & 3 in Figure 3. The effectiveness can be explained by the fact that the constraint allows to compare jobs with similar ratio of and processing time; see Figure (b). This also is the reason for the constraint being by far the most efficient constraint for small values of σ. Especially the point clouds of the graph search algorithms using this constraint are very compact, which means that the performance is reliable. The effectiveness of the constraint has a high variance. From the fifth column of Figure 3 one can see that two types of clusterings are present in the plots for the constraint. One observation is that the number of comparable jobs is typically either small or large, and also the performance of the algorithms is either rather good or rather bad. An explanation of this effect is the recursive nature of the constraint: Whenever the problem can be sucessfully decomposed into two subproblems, there seems to be a high probability that these subproblems can be further decomposed. In particular, many of the low correlation instances could be almost completely decomposed. The other type of clustering is along certain horizontal lines. The points on these lines correspond to the

10 instances that could be decomposed only once. When such an instance splits into a set of k jobs to be processed first and another set of size n k to be processed thereafter, this immediately results in k (n k) comparable pairs of jobs, corresponding to a horizontal line at exactly this height. Combining the constraints yields the best results. The constrained of course profits from the advantages of all other constraints, and hence, it is best. For small σ, the good performance comes from the constraint, and for large σ it additionally benefits from the. The constraint turns back the advantage of backward search. Comparing the number of generated nodes by backward and forward search in Table 2 (c) and (d), one can observe that in particular for the harder instances with small values of σ there are settings where BFGS T b generates some hundred thousands nodes less than the BFGS T f. This has also been observed by Kaindl et al. []. However, as soon as one utilizes the constraint, the effect reverses and forward search is slightly better for all settings of σ. Finding a theoretical explanation for this observation remains an open question. The effects of the constraints are also observed when the number of jobs varies. In order to investigate the asymptotic behavior of the algorithms, a series of tests has been run for instances with fixed σ =.5 and varying number of jobs; see Figure. Also here it turns out that the constraint leads to good and stable results, which are only improved by the on some instances. The solution quality of Smith s rule is almost optimal. Our study of Smith s rule is motivated by a theoretical analysis of its approximation guarantee for problem w j f(c j ). In a companion paper [], we show a tight approximation guarantee for fixed convex cost functions. Additionally, we give a more realistic analysis being parametrized by the minimum and maximum processing time of a job and the total processing time. In this study, we investigate the optimality gap of Smith s rule for the cost functions x 2, x 3, x and x 5. By the theoretical worst case analysis we know that Smith s rule has a tight approximation guarantee of.3,.7, 2.3 and 2.93 for these functions, respectively. With regard to the expected total processing time of the generated instances, the parametrized analysis reduces these factors to.,.2,.8 and.23. However, the results in Figure 5 show that even these very small expected upper bounds are an overestimate of the outcome of the actual cost. Not surprisingly, even though the optimality gas very small for all considered monomials, one still sees the approximation ratio being less good for higher degree cost functions. Conclusion Our experimental study has demonstrated that global order constraints have a great influence on the performance of exact algorithms for problem w j C 2 j. This has been observed for all algorithms under consideration. It has also turned out that problem instances with highly correlated and processing time are the most difficult ones. This observation can be made for all combinations of algorithms and constraints. So the challenge is now to construct efficient algorithms also for highly correlated instances. Interestingly, it is also on perfectly correlated instances where Smith s rule reaches its worst case approximation ratio, as the analysis in [] shows. There are two major directions for future research, the design of efficient Linear Integer Programming (IP) formulation for quadratic cost functions, and more general, efficient solution methods for higher degree cost functions. Concerning the former, there are a number of possible formulations which in general, will benefit from the state-of-the-art IP solvers being much better developed than their quadratic counterparts. However, we are not aware of any IP formulation where order constraints can be integrated as easily as into our QIP formulation. Compared to quadratic cost, the case of higher degree cost functions is by far less well studied. Townsend s lower bound is not directly applicable here, the QIP formulation cannot be generalized, and also the set of known order constraints is much smaller. Although experiments with many instances make us believe that the global constraint holds for any convex cost function, we have only managed to prove the local constraint in this generality. References [] B. Alidaee. Numerical methods for single machine scheduling with non-linear cost functions to minimize total cost. J. Oper. Res. Soc., :25 32, 993. [2] P. C. Bagga and K. R. Kalra. A node elimination procedure for Townsend s algorithm for solving the single machine quadratic penalty function scheduling problem. Manage. Sci., 2:33 3, 98. [3] N. Bansal and K. Pruhs. The geometry of scheduling. In Proc. of the 5st Annual IEEE Symposium on Foundations of Computer Science (FOCS ), pages 7, 2.

11 (a) Number of comparable job pairs in dependency of σ for set SσT. This parameter is independent of the used algorithm SσB..2 in dependency of σ for set.2 BFGSB b (b) Number of generated nodes with T (c) Number of generated nodes with BFGST b in dependency of σ for set Sσ T (d) Number of generated nodes with BFGST f in dependency of σ for set Sσ (e) Number of generated nodes with QIP in dependency of σ for set SσQ. Figure 3: Study on the influence of σ in the considered methods. Each row shows the results for one particular method (except the first one showing the number of comparable job pairs) whereas the columns correspond to the different constraints (,,,,, ). Note that except for the first row everything is plotted with respect to logarithmic y-scale. The corresponding numerical values can be found in Table 2.

12 (a) Number of comparable job pairs in dependency of σ for set Sσ T. This parameter is independent of the used algorithm. σ avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. [.,.2[ [.2,.3[ [.3,.[ [.,.5[ [.5,.[ [.,.7[ [.7,.8[ [.8,.9[ [.9,.] (b) Number of generated nodes with BFGS B b in dependency of σ for set SB σ. σ avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. [.,.2[ [.2,.3[ [.3,.[ [.,.5[ [.5,.[ [.,.7[ [.7,.8[ [.8,.9[ [.9,.] (c) Number of generated nodes with BFGS T b in dependency of σ for set ST σ. σ avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. [.,.2[ [.2,.3[ [.3,.[ [.,.5[ [.5,.[ [.,.7[ [.7,.8[ [.8,.9[ [.9,.] (d) Number of generated nodes with BFGS T f in dependency of σ for set S T σ. σ avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. [.,.2[ [.2,.3[ [.3,.[ [.,.5[ [.5,.[ [.,.7[ [.7,.8[ [.8,.9[ [.9,.] (e) Number of generated nodes with QIP in dependency of σ for set S Q σ. σ avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. avg. std. dev. [.,.2[ [.2,.3[ [.3,.[ [.,.5[ [.5,.[ [.,.7[ [.7,.8[ [.8,.9[ [.9,.] Table 2: Numerical values corresponding to the plots in Figure 3. Averages have been taken over all results in the respectice parameter range.