Assessing the quality of heuristic solutions to parallel machines min–max scheduling problems

ARTICLE IN PRESS Int. J. Production Economics 122 (2009) 755–762

Contents lists available at ScienceDirect

Int. J. Production Economics journal homepage: www.elsevier.com/locate/ijpe

Assessing the quality of heuristic solutions to parallel machines min–max scheduling problems Alessandro Agnetis a, Arianna Alfieri b,, Gaia Nicosia c a b c

` di Siena, via Roma 56, 53100 Siena, Italy Dipartimento di Ingegneria dell’Informazione, Universita Dipartimento di Sistemi di Produzione e Economia dell’Azienda, Politecnico di Torino, Corso Duca degli Abruzzi 24, 10129 Turin, Italy ` di ‘‘Roma Tre’’, via della Vasca Navale 79, 00146 Rome, Italy Dipartimento di Informatica e Automazione, Universita

a r t i c l e in fo

abstract

Article history: Received 21 November 2008 Accepted 2 July 2009 Available online 9 July 2009

In this paper, we propose a tool for testing the quality of heuristic solutions for scheduling problems with a min–max objective function, such as, for example, the minimization of maximum tardiness or makespan. We present a bounding scheme which is powerful enough to allow an accurate quality assessment of the available solutions in most cases of practical relevance. In order to validate the effectiveness of our assessment approach, we discuss a real-life application and perform experimental tests on the actual applicative scenario and on possible future scenarios. & 2009 Elsevier B.V. All rights reserved.

Keywords: Scheduling Heuristics performance evaluation Column generation Dynamic programming

1. Introduction Scheduling is a very important activity of many firms, especially in a make-to-order environment, where there is a strong interaction between production and market demand and usually demand fluctuations cannot be smoothed by inventory. In such a context, poor due date performance may lead to high penalty costs and/or order cancelation. Hence, it is very important to schedule the orders so as to minimize the total cost of delay. Typically, customers may tolerate small delays with respect to promised due dates. Hence, a reasonable measure of the delay cost is represented by the maximum order tardiness. In other common situations, one simply wants to complete the jobs as early as possible, since this corresponds to maximizing resource utilization. In both cases, the objective of the problem is to minimize the maximum value of indices associated with the jobs’ completion times.

 Corresponding author.

E-mail addresses: [email protected] (A. Agnetis), arianna.alfi[email protected] (A. Alfieri), [email protected] (G. Nicosia). 0925-5273/$ - see front matter & 2009 Elsevier B.V. All rights reserved. doi:10.1016/j.ijpe.2009.07.001

Despite the specific objective, finding the optimal schedule is, in general, a difficult task (Lenstra et al., 1977). Hence, in practice, one has very often to resort to general purpose commercial schedulers, which provide heuristic solutions with no guarantee of optimality. In this context, it is relevant to have information on how far from optimality is the current solution. For example, if we have a solution for which the maximum tardiness is very high, the management may wonder whether this very high value is due to a particularly unfavorable situation (e.g., many orders have very tight due dates), or to the ineffectiveness of the algorithm used by the commercial scheduler. Typically, in the literature, to establish the quality of a heuristic solution, a comparison is made either with a lower bound or with another heuristic. Examples of such approaches can be found in several papers, including Haouari et al. (2006), Kurz and Askin (2001), Nait Tahar et al. (2006), Su and Lien (2009) and Li et al. (2008) in which the authors address the problem of minimizing makespan in a parallel machine environment with some specific characteristics (such as set-up activities and/or job splitting). In particular, Nait Tahar et al. (2006) and Haouari et al. (2006) assess their heuristic approach

ARTICLE IN PRESS 756

A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

through a comparison with some lower bounds, while Kurz and Askin (2001), Su and Lien (2009) and Li et al. (2008) develop and compare several heuristics. For a survey on these results see for instance Leung and Li (2008). In this paper, we propose a tool for testing the quality of a heuristic solution (e.g., the solution provided by a commercial scheduler). Our tool is specifically designed for scheduling problems with a min–max objective function (e.g., minimization of maximum tardiness or makespan). Note that we do not provide an exact solution algorithm, nor do we foster a specific heuristic approach. Rather, we present a bounding scheme which is powerful enough to allow an accurate quality assessment of the current available solution in most cases of practical relevance. Clearly, performing such assessment on a large sample of solutions produced by a certain heuristic may allow to assess the suitability of the heuristic for the particular application on hand. In the literature similar approaches have been presented in Agnetis et al. (2009) and van den Akker et al. (2006). In particular, Agnetis et al. (2009) develop a heuristic branch-and-bound and a column generation algorithm to solve a class of single-machine problems and to certify the quality of the heuristic solution, respectively. van den Akker et al. (2006) propose a solution framework that can be applied to a number of nonpreemptive scheduling problems, by first deriving a lower bound (obtained through a somewhat sophisticated column generation phase) and then seeking for a matching upper bound. Our certification approach is similar to that of Agnetis et al. (2009), but, differently from Agnetis et al. (2009), the assessment tool proposed in this paper is not tailored on a very specific class of problems (single machine problems with maximum tardiness as objective function). The approach we develop here is general enough to be applied to a larger set of problem types, namely parallel machine problems, not necessarily preemptive, and with general min–max objective functions. Moreover, the assessment approach is not based on the structure of the solution found by a certain scheduling problem, and hence it can be used regardless how was the schedule obtained. The paper is organized as follows. In Section 2, the problem is formally defined and notation is introduced. In Section 3, the assessment approach, based on column generation and dynamic programming techniques is outlined. Section 4 reports the results of our approach applied to an industrial case and to random generated instances. Finally, Section 5 concludes the paper.

2. Problem definition In this section we formally define our class of scheduling problems. We are given a set J ¼ fJ 1 ; . . . ; Jn g of n jobs and a set M of m identical, parallel machines. Each job consists of a single task, which must be executed by a machine. Job Ji is released at time r i . Given a schedule s, C i ðsÞ denotes the completion time of Ji in s.

A performance index f i ðC i ðsÞÞ is associated with job J i . The objective is to schedule the jobs in a way that minimizes FðsÞ ¼ maxff i ðC i ðsÞÞg i2J

(1)

If each job Ji has a due date di , and f i ðC i ðsÞÞ ¼ maxf0; C i ðsÞ  di g, the objective is to minimize the maximum tardiness, T max . (Note that this includes makespan minimization as a special case with di ¼ 0 for all i.) Anyhow, our approach can be applied for any nondecreasing function f i ðÞ. As typical of most scheduling problems, we assume that all problem data are rational numbers. Within this framework, we consider a processing setting, called generalized preemption (Agnetis et al., 2009), which encompasses a wide variety of real-life situations. For each job, a certain total work pi must be done and an integer-valued progress function g i ðlÞ is defined, as follows. If job Ji is started or resumed at a certain time t, and then it is continuously executed until t þ l, the amount of work concerning job Ji carried out in the interval ½t; t þ l is given by g i ðlÞ. Clearly, if g i ðlÞ ¼ l for all i, we are in the standard preemptive scheduling setting and pi represents the job processing time. Notice that if, for all i, g i ðlÞ ¼ pi for l  pi and g i ðlÞ ¼ 0 for lopi, then we are in the standard nonpreemptive scheduling setting and, again, pi represents the job processing time. Note that the progress function allows to model situations in which preemption is permitted, but the progress of a job is somewhat affected by the fact that it is stopped and resumed later. For instance, in most mechanical machining processes, whenever a job J i is started or resumed, the machine must be inactive for setup for a time si . In this case (Preempt-setup, Julien et al., 1997), the progress function of a job is g i ðlÞ ¼ maxf0; l  si g. In other applications, when a job Ji is started or resumed, it must consecutively stay on the machine for at least a given time ti , before being preempted. In this case, ( 0 if loti (2) g i ðlÞ ¼ l if l  ti In other situations, the progress function may be more intricate, as in the painting process described in Section 4. In what follows, P will denote any scheduling problem of the described class, i.e., in which one wants to minimize a function as (1). Note that P is already NP-hard in the special case of m ¼ 1, no preemption and FðsÞ ¼ T max (Lenstra et al., 1977), since in this case it is the well-known NP-hard problem 1jr j jT max . For the developments which will follow, we need a few definitions concerning feasible job-schedules in a generalized preemption setting. Definition 2.1. For each job Ji , a job-schedule j is a set of hj mutually disjoint time intervals Ij1 ¼ ½Sj1 ; C j1 , Ij2 ¼ ½Sj2 ; C j2 ; . . . ; Ijh ¼ ½Sjh ; C jh , during which processing of j j j J i takes place. The length of interval Ijk is denoted by j j j l k ¼ C k  Sk . Note that C jh is the completion time C i of job J i . A jobj schedule is feasible if it entirely takes place after the

ARTICLE IN PRESS A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

757

release date of the job (if any), and if the total work done is at least pi . Formally:

denote by Si the set of feasible job-schedules for job J i . More formally:

Definition 2.2. In problem P, a job-schedule j is feasible for job J i if the following conditions hold:

Definition 3.1. A job-schedule j for job J i is feasible for problem QðP; s; kÞ if the following conditions hold:

 SPj1  ri .  hk¼1 g i ðljk Þ  pi .

 SPj1  ri .  hk¼1 g i ðljk Þ  pi .  C jh  Di .

j

j

An overall schedule s can be viewed as a collection of n feasible job-schedules, one for each job, such that at each time at most m schedules overlap. We will denote the optimal schedule and its value as s and Fðs Þ respectively. Table 1 reports the main notation used in the paper.

j

A feasible solution to QðP; s; kÞ is therefore given by a set of n0  n feasible job-schedules (referring to distinct jobs), such that at each time at most m schedules overlap, while the remaining n  n0 jobs are tardy (and we are not interested in their actual scheduling). Our assessment approach is based on the following result. Proposition 3.2. If z ðkÞon, then Fðs Þ4FðsÞ  k.

3. Assessment approach In this section we describe our approach to assess the quality of a heuristic solution. More precisely, given a min–max scheduling problem P, and a feasible schedule s, we want to measure the quality of s, in terms of distance from optimality. Given a schedule s of value FðsÞ and a real number k40, consider, for each job Ji , an auxiliary due date Di defined as the latest time at which the job J i can complete so that the performance value FðsÞ is improved by at least k, i.e., Di ¼ maxft 2 Z þ jf i ðtÞ  FðsÞ  kg

(3)

Now given P and a schedule s, we introduce an auxiliary optimization problem, in the following referred to as QðP; s; kÞ, which is identical to P, except for the objective function. Namely, the objective in QðP; s; kÞ is to maximize the number of jobs which are processed within their respective auxiliary due date Di . We let z ðkÞ indicate the optimal value of the objective function in QðP; s; kÞ, i.e., the maximum number of early jobs (with respect to Di ). In what follows, referring to QðP; s; kÞ, we say that a job-schedule is feasible if, besides verifying the conditions in Definition 2.2, the job completes within Di , and we

Table 1 Notation. J ¼ fJ 1 ; . . . ; J n g r i , di pi g i ðÞ

s C i ðsÞ FðsÞ

s Fðs Þ Di QðP; s; kÞ z ðkÞ

set of n jobs release and due date of job J i total work to be done on job J i (processing time) progress function of job J i a feasible schedule for the addressed problem P completion time of job J i in schedule s objective function value for schedule s an optimal schedule objective function value for optimal schedule s auxiliary due date for job J i auxiliary optimization problem optimal objective function value for problem QðP; s; kÞ

If z ðkÞon, in the optimal schedule for QðP; s; kÞ at least one job is tardy. Hence, there is no schedule in which all jobs complete within their respective auxiliary due date Di . From (3), this means that there is at least one job J i for which f i ðtÞ4FðsÞ  k. In most scheduling applications we are interested in integer-valued cost functions f i ðÞ, hence FðsÞ is also integer. From now on, we therefore assume integrality of data (including k) and cost function values. In these cases, if in the optimal schedule for QðP; s; 1Þ there is at least one tardy job, the optimality of the value FðsÞ for the original problem P is certified. To illustrate the concepts, consider the following example. Example 3.3. We are given four jobs, with the data reported in Table 2. Suppose that each job has progress function (2), with ti ¼ 5, and performance index f i ðC i ðsÞÞ ¼ maxf0; C i ðsÞ  di g, i ¼ A; B; C; D. Therefore, the overall objective is to minimize maximum tardiness. Consider the feasible schedule s shown in Fig. 1. For this schedule, FðsÞ ¼ 6, attained by job A. We now wish to have indications on the quality of schedule s. In particular, we might want to establish whether a schedule s0 such that

Table 2 Data for Example 3.3. i

ri

pi

di

A B C D

0 11 25 30

23 5 5 6

29 13 28 37

A 0

B 11

A 16

C 25

A 30

D 35

Fig. 1. A feasible schedule for Example 3.3.

41

t

ARTICLE IN PRESS 758

A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

Fðs0 Þ  4 exists. To this aim, we consider the auxiliary problem with k ¼ 6  4 ¼ 2, i.e., problem QðP; s; 2Þ. In this problem, the auxiliary due dates are set to Di ¼ maxft 2 Z þ jmaxf0; t  di g  FðsÞ  2g hence, since FðsÞ ¼ 6, this implies Di ¼ di þ 4 for all i. Problem QðP; s; 2Þ consists in maximizing the number of jobs which are processed within Di . In this example, in the optimal solution to QðP; s; 2Þ there are only three jobs completing within their Di. This means that all feasible schedules for the original problem P have maximum tardiness at least FðsÞ  k þ 1 ¼ 5. Therefore, we conclude that 5  Fðs Þ  6. Notice that the optimal solution to QðP; s; 2Þ is exactly as that depicted in Fig. 1. In fact, in that schedule, only job A is late with respect to its auxiliary due date (DA ). If we delay jobs B and C, so that they complete exactly at their respective auxiliary due dates (17 and 32), still the number of early jobs does not increase, due to the progress function used. On the contrary, this would delay job D, that would end after its auxiliary due date, hence decreasing the number of early jobs to 2. Obviously, QðP; s; kÞ is an NP-hard problem itself, since includes 1jr j jT max as a special case (if k ¼ FðsÞ, this is equivalent to establishing whether a schedule with zero tardiness exists, Lenstra et al., 1977). However, for our purposes we are not interested in solving it to optimality, but only to know whether in the optimal solution to QðP; s; kÞ there is at least one tardy job with respect to the auxiliary due dates. So, suppose that we can efficiently derive an upper bound u on the maximum number of early jobs in QðP; s; kÞ, and that uon. If this occurs, z ðkÞouon. Therefore, Proposition 3.2 holds again and we certify that FðsÞ differs from Fðs Þ of at most k  1. On the contrary, if u ¼ n, nothing can be inferred, and we must turn to a larger value of k to assess the quality of s. Example 3.4. Continuing Example 3.3, suppose that instead of exactly solving QðP; s; kÞ, we resort to computing upper bounds on z ðkÞ. Suppose that we found the values z ð1Þ  4, z ð2Þ  4 and z ð3Þ  3. Hence, for k ¼ 3, we are sure that no feasible schedule exists for QðP; s; 3Þ in which all four jobs are early, i.e., in any feasible schedule for P, the maximum tardiness is at least FðsÞ  k þ 1 ¼ 4, i.e., we conclude that 4  Fðs Þ  6. The effectiveness of this approach depends on the quality of the bound and on how efficiently it can be computed. As a means to obtain a good upper bound, first consider the following ILP formulation for QðP; s; kÞ. This formulation uses variables xij , in which i corresponds to job J i and j to one feasible job-schedule for Ji (j 2 Si ). Each feasible job-schedule can be seen as a list of unit time intervals ½t  1; t, during which the job is processed. We refer to the interval ½t  1; t as time slot t, and we write j t to indicate that a job-schedule j includes time slot t. The meaning of the variables is the following. xij ¼ 1 indicates that job J i is processed according to job-schedule j, i.e., J i is processed in all time slots t such that j t. If J i is processed according to a job-schedule different from j, or is not processed at all, then xij ¼ 0. The time

horizon T can be set to the largest due date, T ¼ maxi fDi g. Problem QðP; s; kÞ can then be formulated as follows: z ðkÞ ¼ max

n X X

xij

(4)

i¼1 j2Si

s.t.

n X X

xij  m

8t ¼ 1; . . . ; T

(5)

i¼1 j t

X

xij  1

8i ¼ 1; . . . ; n

(6)

8i ¼ 1; . . . ; n; 8j 2 Si

(7)

j2Si

xij 2 f0; 1g

Notice that the objective function (4) equals the number n0 of selected feasible job-schedules, i.e., the total number of jobs processed within their auxiliary due date Di . The left hand side of constraint (5) equals the number of selected job-schedules that include time slot t, i.e., the number of jobs simultaneously processed in t. This number must not exceed the number of machines, m. Constraints (6) express that at most one job-schedule can be selected for each job. In order to get an effective upper bound on z ðkÞ, the idea is to solve the LP relaxation of (4)–(7). Notice that the number of variables is huge, even for small size instances. In fact, from Definitions 2.1 and 2.2, it is clear that the number of feasible job-schedules can be very large, especially in a preemptive setting (just think of all possible starting times and durations of all time intervals making up a job-schedule j). Hence, it is impossible to explicitly generate the whole model. However, this aspect can be efficiently handled by means of a column generation technique, presented in the following. For the basics on column generation, see for instance Chvatal (1983).

3.1. A column generation approach We next present a column generation approach for the solution of the LP relaxation of (4)–(7). Column generation is used to handle problems in which most of the columns (variables) are hardly ever taken into account during the solution process, either because their cost is too high or for their inherent ‘‘incompatibility’’ with the columns already generated (Barnhart et al., 1998). In a column generation approach, at each step, the column set is enlarged by generating only the most promising columns, chosen among those having a negative reduced cost. We call restricted master problem (RMP) the problem derived from (4)–(7) generating only a subset X of variables. We initialize RMP with a set of columns corresponding to a feasible solution to QðP; s; kÞ, found by a very simple heuristic. (Just pick one job at a time and try to assign it to a single feasible interval.) At each step, X is extended by solving the pricing problem, i.e., finding one or more columns having negative reduced cost. If there are no such variables, the solution to RMP with the current X specifies an optimal solution to the LP.

ARTICLE IN PRESS A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

3.2. The pricing problem Let us consider the dual of the LP relaxation of (4)–(7). min

n X

yi þ m

s.t.

ut

(8)

(p  pi ). The following formula holds: 8 Uðt  1; pÞ > > ( ) < t P Uðt; pÞ ¼ min  min Uðq  1; p  g ðt  q þ 1ÞÞ þ u > i Rs > : ri þ1qt s¼q

t¼1

i¼1

X

T X

ut þ yi  1

8i ¼ 1; . . . ; n; 8j 2 Si

(9)

t j

ut  0

8t ¼ 1; . . . ; T

(10)

yi  0

8i ¼ 1; . . . ; n

(11)

The restricted dual is the problem obtained from (8)–(11), in which only the constraints corresponding to xij 2 X appear. Given an optimal solution fuR ; yR g to the restricted dual, the problem is to find one or more constraints (9) violated by fuR ; yR g, or prove that no such constraint exists. This means that we want to find a pair ði; jÞeX such that j 2 Si and X uRt þ yRi o1 (12) t j

We decompose the pricing problem according to the jobs, i.e., we fix one Ji at a time and search for a schedule j P  in Si such that t j uRt is minimum. If such minimum value is smaller than 1  yRi , we have found one violated constraint (actually, the most violated). Else, no violated constraint exists for that job. Note that the only values uRt considered in the pricing problem for job J i are those such that r i þ 1  t  Di , hence they are Di  r i . The pricing problem is therefore the following. Problem 3.5. For each Ji , i ¼ 1; . . . ; n, given the sequence of Di  r i values fuR;ri þ1 ; uR;ri þ2 ; . . . ; uR;Di g, find the set of intervals of minimum total value (given by the sum of all values uRt involved) corresponding to a feasible job-schedule for Ji. In what follows, we describe two approaches to deal with the pricing problem. In Section 3.2.1 we present an exact dynamic programming algorithm which finds, at each step, the most violated constraint (i.e., the most promising column). The approach works for any progress function g i ðÞ (including the preemptive and nonpreemptive cases). An alternative heuristic approach to the pricing problem is described in Section 3.2.2. It consists in quickly generating many columns at each step, though possibly not the most promising columns. As a result, when the heuristic stops, the dynamic programming procedure must be run to check whether other columns are still to be added. The idea is that, this way, we may reduce the number of times that the time-consuming dynamic programming procedure needs to be run. Such combined heuristic/dynamic programming approach requires only minor adjustments for different generalized preemption scenarios. 3.2.1. A dynamic program for the pricing problem We next describe a dynamic programming algorithm for the pricing problem, when a job J i is considered. Let P Uðt; pÞ indicate the minimum value of t j uRt , where j is a job-schedule fully contained in time interval from slot r i þ 1 to t (t  Di ), and the total work done on job J i is p

759

(13) The upper term refers to the case in which time slot t is not used by the job-schedule. The lower term considers the case in which time slot t is used. In this case, if ½q  1; t is the last processing interval of job J i , the contribution of Pt  such interval is given by s¼q uRs. The optimal value is then computed considering all possible values for q. Since q ranges within ri þ 1 and Di , each Uðt; pÞ can be computed in time OðDi  r i Þ. Hence, the running time of the whole procedure, for each job J i , is OððDi  r i Þ2 pi Þ. The following initial conditions hold: Uðt; pÞ ¼ þ1 Uðt; 0Þ ¼ 0

if g i ðt  r i Þop

(14)

for all r i  t  Di

(15)

Condition (14) indicates that, in order to have an amount p of work done by time t, t cannot be too small. Condition (15) simply establishes that there is no contribution if no work is done. In the special cases of preemption or nonpreemption, the dynamic program (13) simplifies. In particular, in the nonpreemptive case (qþp 1 ) i X  uRs UðtÞ ¼ min r i þ1qtpi

s¼q

while in the preemptive case UðtÞ is simply the sum of the pi smallest values uRs for r i þ 1  s  t. 3.2.2. A heuristic for the pricing problem We next describe a heuristic approach to the pricing problem. The idea is very simple. For each job Ji , we generate a large number of feasible job-schedules and evaluate the sum of all values uRt of the time slots of each job-schedule. Whenever condition (12) holds, a new column is generated. We generate two groups of job-schedules. The first group includes all job-schedules in which Ji is continuously processed in a single interval within ½ri ; Di . The length of such interval is l, such that g i ðlÞ ¼ pi . We call these schedules 1-windows. The second group includes job-schedules consisting of two non-overlapping intervals I1 ; I2 ½ri ; Di , of length l1 and l2 respectively, such that g i ðl1 Þ þ g i ðl2 Þ ¼ pi . (Clearly, these job-schedules do not apply to nonpreemptive problems.) We call these schedules 2-windows. In this case, the schedules are generated according to different schemes, concerning the sizes of I1 ; I2 and their time distance. For what concerns the sizes, we considered the following options: Equal_size I1 and I2 are of the same length l (such that g i ðlÞ ¼ pi =2). Different_size I1 is of length l1 depending on the progress function g i and I2 is of length l2 such that g i ðl2 Þ ¼ pi  g i ðl1 Þ.

ARTICLE IN PRESS 760

A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

For what concerns the distance between the intervals: Close_distance I1 and I2 are b slots apart from each other, where b is small enough to allow progress of another job (hence b depends on the specific progress function g i ). Long_distance I1 and I2 are ðDi  r i Þ  pi  a apart, for small values of a (i.e., the two intervals are very far from each other). The values for l1 (Different_size case), a and b used in the experiments will be described in Section 4. The heuristic proceeds as follows. Given the optimal solution of the initial RMP, we consider all 1-windows and add to X all variables having negative reduced cost. Then, RMP is solved again. From its optimal solution, we consider all 2-windows obtained combining Equal_size and Close_distance, and generate new columns. We do the same for the other three combinations of size and distance, and add all columns having negative reduced cost to X. After the heuristic columns have been generated, RMP is solved again and from then on we resort to the dynamic programming procedure until optimality is certified. Again we note that in the special case of nonpreemption, there is no need to resort to a heuristic approach, since the exact approach in the previous section is efficient enough. 4. Application and computational experiments In this section we validate the effectiveness of our assessment approach, discussing a real-life application. We refer to the wood-painting department of a kitchen furniture manufacturer (for more details see Agnetis et al., 2009). The problem can be described as follows. We are given a set of orders, each consisting of a large number of flat wooden parts which must be painted with a given color. All parts receive the same treatment, i.e., paint side 1, let it dry up, turn the part and paint side 2. An order can be produced in different runs. Each run consists of a number of parts, and has a certain duration. Once a part has been painted on both sides, it can be moved out of the painting station (and replaced by a part from a different order), even if side 2 is not dry yet. Parts require the same painting time on both sides, and parts cannot be turned before side 1 is dry. This leads to the following progress function, in which t is the run duration and T the drying time of side 1: 8 if l  T > <0 (16) g i ðlÞ ¼ 2l  2T if T  l  2T > :t if l  2T The function reflects the fact that no progress is possible until side 1 is dry, while, on the other hand, if the run is sufficiently long, by the time the last side 1 has been painted, the first side 1 is already dry (hence, the progress is identical to the run duration). In the actual scenario, the department has a single automated painting machine. Orders are processed through a centralized MRP system which works on a

weekly basis and assigns relatively large time windows to most orders. However, there also exists a number of urgent or special orders having strict time windows. These orders typically cause preemptions in the overall schedule. The major management objective is not to have orders which are too late, which translates into minimizing maximum tardiness. A first set of experiments was designed to test our approach on the present scenario. In these experiments, processing times and production mix reflect those of real life, for various time horizons (and hence, instance sizes). However, release and due dates have been modified to test the validity of our approach in a broader scenario. Besides testing the approach on the actual scenario, we designed a second set of experiments, concerning an upgraded department configuration, with two (identical) parallel painting machines. Data orders are generated in the same way as for the single machine. All tests were run on a IBM/RISC 6000 workstation (clock 400 MHz, ram 512 Mb), using CPLEX 8.0 to solve the LP relaxations of (4)–(7).

4.1. Single machine The first set of experiments mimics real instances, with a bit more randomness. Production data use blocks of 30 min as time unit. Drying time is 2 h, hence in the progress function (16), we set T ¼ 4. We generated instances with 10, 20, 30 and 40 orders (instance sizes), in the following referred to as jobs. In each instance, there are long and short jobs. The long jobs are 10% of the total and their processing times pi are uniformly distributed in the interval ½15; 50. For these jobs, the due dates di are randomly generated in the interval ½ri þ pi þ 15; r i þ pi þ 50, so they have slack (i.e., the quantity di  r i  pi ) varying between 30% and 300% of job length. The remaining 90% jobs are short. For each of them, the total work pi is uniformly distributed in the interval ½1; 10, while the due date is randomly generated in the interval ½ri þ pi ; r i þ pi þ T (hence, short jobs are more urgent than long jobs). For each size, we generated a set of 20 instances in which the release dates are P uniformly distributed in the interval ½0; 2 ni¼1 pi . The values of l1 (Different_size), a (Long_distance) and b (Close_distance) used in the experiments are such that g i ðl1 Þ ¼ 2T, b ¼ 2T and 0  a  T=2. Different algorithmic tools can be employed to address the problem, more or less sophisticated. We want to use our approach to assess the quality of a popular heuristic approach for preemptive problems, namely dynamic-earliest-due-date (DEDD). The heuristic works by always scheduling the most urgent available job. Hence, a job is preempted if a more urgent job is released during its execution. For instances of these sizes, it is possible to derive the optimal solution of the problem in a reasonable computation time, following the approach described in Agnetis et al. (2009). Here we want to use the information on the optimal solution value T max to evaluate the effectiveness of the assessment approach. In particular, let T H be the

ARTICLE IN PRESS A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

Table 3 Computational results for the single machine scenario. n

CPU time (s)

# Col

# Uncertif.

kmax

d

10 20 30 40

19.58 67.05 191.67 329.59

410.9 1469.5 2874.5 4643.4

5 7 8 5

11 19.28 3.75 1

0 0 0 0

value of maximum tardiness provided by DEDD, and sH the corresponding schedule. We call kmax the largest k for which the optimal value of the LP relaxation of QðP; sH ; kÞ is still equal to n. This means that T max  T H  kmax . Thus, even without knowing the optimal solution, we have that T H is at most kmax apart from optimality. In what follows, we call uncertified an instance for which kmax  1. Table 3 presents the results of this set of experiments. For each problem size, we report the following information: (1) the CPU time to solve one instance of the LP relaxation of QðP; sH ; kÞ (average on 20 instances); (2) the number of columns generated to solve each LP (average on 20 instances); (3) number (out of 20) of uncertified instances, i.e., how many times the DEDD solution was not proved optimal; (4) kmax (average taken only on uncertified instances); and (5) the difference d ¼ T max  T H þ kmax , which measures the distance between the optimal value and the lower bound provided by the certification approach (i.e., T H  kmax ). A few comments.

 Perhaps the most important fact is that, since d ¼ 0 in



all instances, when fed with the optimal value T max , we were always able to certify its optimality. In other words, although there is no theoretical guarantee that this will always occur, here we observe that whenever the optimal value of the LP relaxation of QðP; sH ; kÞ is equal to n, it is indeed possible to schedule the jobs with a maximum tardiness of T H  k. Hence, the lower bound T H  kmax is always tight. Given the results in Table 3, we can illustrate how our assessment allows to draw some indications on the behavior of a given solution approach (in this case the DEDD heuristic) in a given application setting. We can trust the DEDD solution in several cases, especially if the instance size is rather large. Computational times grow significantly with n, which may impose some restrictions on a frequent use of the assessment procedure if the instances on hand are large. However, consider that in general we must run the certification LP several times only if we want to find the precise value of kmax . If we expect that kmax is small, we can perhaps afford trying out all values 1,2,y,kmax . Otherwise, we can always resort to binary search in the interval ½1; T H , which would require Oðlog T H Þ

761

computation time. Instead, from a practical viewpoint, one may be interested only in knowing whether a given maximum tardiness value T˜ can be met or not. By setting k ¼ T H  T˜ in QðP; sH ; kÞ, if the optimal LP solution value is n, we can be confident that T˜ is a reasonable target in terms of maximum tardiness.

4.2. Two machines A different situation arises if the department is upgraded with an extra painting machine, which we assume to be identical to the other in terms of processing capacity and speed. In particular, note that now different runs from the same order may be processed on different machines. Moreover, unlike the single machine case, in this setting even makespan minimization is a nontrivial task. Therefore, the management may be interested in evaluating the gain in terms of both delivery performance (maximum tardiness) and overall machine utilization (makespan). The complexity of the scheduling problem increases, due to the higher scheduling flexibility of the new system. Actually, finding an exact solution may be a prohibitive task even on small instances. In fact, the number of feasible solutions is extremely large (due to preemption), and the particular structure of the progress function make it difficult to devise a mathematical formulation useful for practical purposes. The instances of this second set of experiments are the same instances generated for the single machine case. Also here we want to use our approach to assess the quality of two popular heuristic algorithms for preemptive problems, namely dynamic-earliest-due-date (DEDD), for the minimization of the maximum tardiness, and dynamic-longest-processing-time (DLPT), for the minimization of the makespan. In both cases, since we are now dealing with a parallel machine problem, we use the DEDD and DLPT rules in a list scheduling framework. More precisely, in case of DEDD, the most urgent available job is scheduled, possibly preempting a less urgent job already in execution on one of the two machines. When a job is resumed, it can be resumed on any of the two machines (i.e., it is not required that all runs of an order are processed on the same machine). DLPT is similar, but the highest priority is given to the available job with the longest remaining processing time. Since, due to the difficulty of the problem, it is not possible to efficiently derive an optimal solution, we are not able to exactly evaluate the distance between the optimal value and the lower bound provided by the certification approach, i.e., d. However, also in this case the certification approach can be useful. As already discussed in the single machine case, even if we do not know the optimal solution, we can still guarantee that the heuristic solution value is at most kmax apart from optimality. Tables 4 and 5 report the results for the two problems, minimization of T max and minimization of C max , respectively. These tables have the same structure of Table 3 (except that d is not reported).

ARTICLE IN PRESS 762

A. Agnetis et al. / Int. J. Production Economics 122 (2009) 755–762

Table 4 Computational results for the parallel machine scenario and T max . n

CPU time (s)

# Col

# Uncertif.

kmax

10 20 30 40

1.16 5.94 10.21 10.39

181.0 452.0 707.2 835.5

6 10 14 16

2.33 3.6 3.14 5.25

Table 5 Computational results for the parallel machine scenario and C max . n

CPU time (s)

# Col

# Uncertif.

kmax

10 20 30 40

1.83 36.80 53.12 194.19

248.8 446.1 831.1 1301.9

10 8 14 12

3.8 8.0 5.57 7.33

Comparing the values of CPU time and number of columns with those of Table 3, it is possible to notice that solving the LP relaxation in the parallel-machine case seems easier than for the single-machine case, i.e., both CPU times and number of generated columns are smaller. On the other hand, the number of uncertified instances is larger. These two facts are related to each other. In fact, by analyzing the results on each instance, we notice that, when we are not able to certify optimality (and therefore the heuristic solution may not be optimal), fewer columns and therefore fewer seconds are needed by the column generation algorithm. This occurs because the heuristically generated schedules (columns) allow to accommodate all n jobs, with no need to resort to the timeconsuming dynamic programming phase. This, in turn, is probably related to the fact that with two machines there is much more flexibility to allocate the same set of jobs. Since the number of uncertified instances is higher in the parallel-machine case than in the single-machine case, the average CPU time and the average number of columns are smaller. Even if it is not the aim of this work to evaluate the quality of heuristics, by comparing Tables 3 and 4 we can say that DEDD is more efficient for the single-machine case. In the parallel-machine case, makespan minimization is harder to certify than maximum tardiness, but the performances of DEDD and DLPT do not present significant differences, in terms of number of uncertified instances and kmax values. Finally, from Tables 3 and 4, we notice that in the parallel-machine case kmax values are smaller than in the single-machine case. In fact, in the parallel-machine case, although there are more uncertified instances, the solution values are closer to the certification lower bound. In other words, in this application scenario, DEDD fails to achieve the optimal T max more frequently than in the single-machine case, but the approximation is closer. The performance of the tested heuristics can be used to assess the benefits expected by acquiring a new painting machine. The observed significant reduction in makespan and maximum tardiness (at least, as long as the orders’

structure, amount and frequency do not significantly change) must be traded off with the required budget for machine acquisition and use. 5. Conclusions In this paper we proposed a general method to assess the quality of heuristic solutions in min–max scheduling problems on single and parallel machines environments. This method can be applied in conjunction with very general cost functions associated with each job, provided that these are nondecreasing in the jobs’ completion times. In particular, since the proposed scheme typically provides very tight lower bounds, it can be used to certify optimality when the quality of the heuristic solution is very high. However, even if this is not the case, we have shown that we can still get an upper bound on the error in reasonable computation time in many practical situations. We have shown how this approach can be used as a decision support tool in the process of deciding about a departmental upgrade. Although our experiments have dealt with single- and two-machine scenarios, there are no conceptual problems in applying it to any number of parallel machines. Further research and experimentation is needed to evaluate the effectiveness of this approach to large shops. In this case, sophisticated heuristics are expectedly required to provide meaningful benchmarks. References Agnetis, A., Alfieri, A., Nicosia, G., 2009. Single machine scheduling problems with generalized preemption. Informs Journal on Computing 21 (1), 1–12. van den Akker, J.M., Hoogeveen, J.A., van Kempen, J.W., 2006. Parallel machine scheduling through column generation: minimax objective functions. In: Azar, Y., Erlebach, T. (Eds.), ESA 2006, Lecture Notes in Computer Science, vol. 4168, 648–659. Barnhart, C., Johnson, E.L., Nemhauser, G.L., Savelsbergh, M.W.P., Vance, P.H., 1998. Branch-and-price: column generation for solving huge integer programs. Operations Research 46, 316–329. Chvatal, V., 1983. Linear Programming. Freeman, New York. Haouari, M., Gharbi, A., Jemmali, M., 2006. Tight bounds for the identical parallel machine scheduling problem. International Transactions in Operational Research 13 (6), 529–548. Julien, F.M., Magazine, M.J., Hall, N.G., 1997. Generalized preeemption models for single-machine dynamic scheduling problems. IIE Transactions 29, 359–372. Kurz, M.E., Askin, R.G., 2001. Heuristic scheduling of parallel machines with sequence-dependent set-up times. International Journal of Production Research 39 (16), 3747–3769. Lenstra, J.K., Rinnooy Kan, A.H.G., Brucker, P., 1977. Complexity of machine scheduling problems. Annals of Discrete Mathematics 1, 343–362. Leung, J.Y.T., Li, C.L., 2008. Scheduling with processing set restrictions: a survey. International Journal of Production Economics 116 (2), 251–262. Li, K., Sivakumar, A.I., Ganesan, V.K., 2008. Analysis and algorithms for coordinated scheduling of parallel machine manufacturing and 3PL transportation. International Journal of Production Economics 115 (2), 482–491. Nait Tahar, D., Yalaoui, F., Chu, C., Amodeo, L., 2006. A linear programming approach for identical parallel machine scheduling with job splitting and sequence-dependent setup times. International Journal of Production Economics 99 (1-2), 63–73. Su, L.H., Lien, C.Y., 2009. Scheduling parallel machines with resourcedependent processing times. International Journal of Production Economics 117 (2), 256–266.