Scheduling job classes on uniform machines

Computers & Operations Research 39 (2012) 1927–1932

Contents lists available at SciVerse ScienceDirect

Computers & Operations Research

0305-05

doi:10.1

n Corr

E-m

journal homepage: www.elsevier.com/locate/caor

Scheduling job classes on uniform machines

Enrique Gerstl, Gur Mosheiov n

School of Business Administration, The Hebrew University, Jerusalem 91905, Israel

a r t i c l e i n f o

Available online 16 August 2011

Keywords:

Scheduling

Uniform machines

Earliness–tardiness

Minmax

Heuristics

48/$ - see front matter & 2011 Elsevier Ltd. A

016/j.cor.2011.08.004

esponding author. Tel.: þ972 2 588 3108; fax

ail address: [email protected] (G. Mosh

a b s t r a c t

We study a scheduling problem with job classes on parallel uniform machines. All the jobs of a given

class share a common due-date. General, non-decreasing and class-dependent earliness and tardiness

cost functions are assumed. Two objectives are considered: (i) minmax, where the scheduler is required

to minimize the maximum earliness/tardiness cost among all the jobs and (ii) minmax-minsum,

where the scheduler minimizes the sum of the maximum earliness/tardiness cost in all job classes.

The problem is easily shown to be NP-hard, and we focus here on the introduction of simple heuristics.

We introduce LPT (Largest Processing Time first)-based heuristics for the allocation of jobs to machines

within each class, followed by a solution of an appropriate non-linear program, which produces for this

job allocation an optimal schedule of the classes. We also propose a lower bound, based on balancing

the load on the machines. Our numerical tests indicate that the heuristics result in very small

optimality gaps.

& 2011 Elsevier Ltd. All rights reserved.

1. Introduction

The first published paper on scheduling jobs with job-dependentdue-dates and a minmax earliness/tardiness cost is that of Sidney [1].He assumed general asymmetric cost structure, where the earlinessis measured as the difference between a job-dependent targetstarting time and the actual starting time, and the tardiness ismeasured as the difference between the actual completion time anda job-dependent due-date. Sidney [1] showed that the minmax

earliness/tardiness value for this special version is obtained by theEDD (Earliest Due-Date first) sequence, and that the optimalschedule (i.e. the optimal job starting times) can be found in O(n2)time (where n is the number of jobs). Following Sidney [1], variousversions of minmax scheduling problems with earliness/tardinesscosts have been studied. Among them: Lakshminarayan et al. [2],Cheng [3], Li and Cheng [4], Cheng et al. [5], Federgruen andMosheiov [6], Mosheiov [7], Mosheiov and Shadmon [8], Mosheiov[9], Mosheiov and Oron [10], Lauff and Werner [11], and Janiaket al. [12].

The current paper extends the model studied in Mosheiov andOron [10], where jobs belong to classes, and all the jobs of a givenclass share a common due-date. Thus, the number of distinct due-dates is identical to the number of classes, (and may be substantiallysmaller than the number of jobs). We believe that this setting coversmany applications: due-dates are often specified as the end ofa period (a week say), and consequently each due-date refers to alarge number of jobs. The earliness and tardiness cost functions are

ll rights reserved.

: þ972 2 588 1341.

eiov).

assumed to be general non-decreasing, class-dependent, and asym-metric (the earliness and tardiness cost functions of a given class arenot necessarily identical). This general cost structure covers almostall settings studied in the literature, and, again, seems to cover mostreal life settings.

While Mosheiov and Oron [10] studied this minmax problemon parallel identical machines, we focus here on uniform

machines, where different machines have different speeds (seee.g. Emmons [13], Balakrishnan et al. [14], Raja et al. [15], andMosheiov and Sarig [16,17], for scheduling problems with ear-liness/tardiness costs on uniform machines). Since the classicalproblem of minimum makespan on parallel uniform machines isknown to be NP-hard, all extended minmax problems on uniformmachines (including the problem studied here) are NP-hard.Hence, we focus here on the introduction and evaluation of asimple and efficient heuristic. We restrict ourselves to EDDschedules, which appears to be appropriate for settings ofscheduling job classes: in many such settings, one has to com-plete processing the jobs of a given class before moving to thenext class. Thus, the decisions to be made refer to the jobsequencing within each class, and to the class scheduling (i.e.class starting times). Two problems are solved. The first is astandard minmax problem, where the largest cost of all the jobson all the machines is minimized. In the second problem (denotedby minsum–minmax), we minimize the sum of the largest costs ineach one of the classes. Both problems are solved by a simpleheuristic for the job allocation on the machines, followed by asolution of an appropriate non-linear optimization problem. Weperformed an extensive numerical study, which indicates that theheuristics produces very close-to-optimal schedules: the averageoptimality gap in all tested problem sets never exceeded 1.5%.

www.elsevier.com/locate/caor

www.elsevier.com/locate/caor

dx.doi.org/10.1016/j.cor.2011.08.004

mailto:[email protected]

dx.doi.org/10.1016/j.cor.2011.08.004

dx.doi.org/10.1016/j.cor.2011.08.004

E. Gerstl, G. Mosheiov / Computers & Operations Research 39 (2012) 1927–19321928

The paper is organized as follows. In Section 2 we introducethe notation and the formulation of the problem. Section 3presents the heuristics and lower bounds. Section 4 reports theresults of our numerical tests.

2. Formulation

n jobs need to be processed on m parallel uniform machines. Thespeed factor of machine i is si, i¼ 1,. . .,m: We assume that the jobsare partitioned into K distinct classes. The jobs belonging to a givenclass k share a common due-date denoted by dk, k¼ 1,. . .,K: Let nk

denote the number of jobs assigned to class k, k¼ 1,. . .,K : Clearlyn1þn2þyþnK¼n. The processing time of job j in class k is denotedby Pkj. The processing time of job j in class k if assigned to machine i

is denoted by Pkij ¼ Pkj=si, k¼ 1,. . .,K , i¼ 1,. . .,m, j¼ 1,. . .,nk.Without loss of generality, we assume that machine i is slower(not faster) than machine iþ1, i.e., sirsiþ1, i¼ 1,. . .,m�1.

The starting time of job j in class k if assigned to machine i isdenoted by Skij; its completion time is denoted by Ckij; its earlinessis given by Ekij ¼maxf0,dk�Ckijg ¼ ðdk�CkijÞ

þ , and its tardiness isgiven by Tkij ¼maxf0,Ckij�dkg ¼ ðCkij�dkÞ

þ . Additionally, let Fk andGk denote the earliness and tardiness cost functions of classk, respectively, k¼1,y,K. Fk and Gk are assumed to be non-decreasing, continuous, and normalized, i.e. Fk(x)¼Gk(x)¼0 forxr0, k¼ 1,. . .,K .

For a given schedule, let Ski (�minjfSkijg) and TLki (�SjPkij)

denote the starting time of the first job and the total load (totalprocessing time) in class k on machine i, i¼ 1,. . .,m, k¼ 1,. . .,K ,respectively. Let Smin

k denote the earliest starting time of class k:Smin

k ¼min1r irmfSkig, and let TLmaxk denote the maximal total load

(among the m machines) in class k: TLmaxk ¼max1r irmfTLkig. The

first objective is of a minmax type, i.e. we look for the allocationand scheduling of the jobs in each class, such that the largestearliness/tardiness cost is minimized:

Y1 ¼min maxf1rkrK , 1r irm, 1r jrnkg

fFkðEkijÞþGkðTkijÞg ð1Þ

An alternative objective function is of a minsum–minmax type,where we minimize the sum of the largest earliness/tardinesscost in all the classes:

Y2 ¼minXK

k ¼ 1

max1r irm, 1r jrnkf g

fFkðEkijÞþGkðTkijÞg ð2Þ

3. Heuristics for the minmax and the minsum–minmaxproblems

In minmax scheduling problems on parallel machines, an optimalsolution consists of (as close as possible to) equal allocation of thejobs among the machines. Therefore, our proposed heuristic is basedon the very popular LPT (Longest Processing Time first) allocationprocedure. This procedure, when performed on parallel uniformmachines, starts with an initial sorting of the jobs in a non-increasing order of processing times, and assigning them to themachines according to the ‘‘earliest completion time’’ rule, consider-ing the machines’ speeds.

It is clear that an optimal schedule exists with no idle timebetween consecutive jobs in a given class. Also, given the EDDassumption, the largest completion time in a given class on agiven machine is never larger than the starting time of the firstjob in the next class on the same machine. The initial LPTprocedure leads to an allocation of the jobs in class k to themachines, with TLki denoting (see above) the total load of class k

on machine i, k¼ 1,. . .,K , i¼ 1,. . .,m. Let Pmaxki denote the largest

processing time of a job in class k assigned to machine i. Clearly

(due to LPT), this job is assigned to the first position in class k onmachine i. Based on the above, we introduce the followingnon-linear programming formulation for the minmax problem(denoted by Y1):

minZ

S:T:

ZZFkðdk�Ski�Pmaxki Þ, k¼ 1,. . ., K , i¼ 1,. . .,m ð3Þ

ZZGkðSkiþTLki�dkÞ, k¼ 1,. . .,K , i¼ 1,. . .,m ð4Þ

S1iZ0, i¼ 1,. . .,m ð5Þ

SkiZSk�1,iþTLk�1,i, k¼ 2,. . .,K , i¼ 1,. . .,m ð6Þ

ZZ0, SkiZ0, k¼ 1,. . .,K , i¼ 1,. . .,m

Additionally, the following non-linear programming formula-tion for the minsum–minmax problem (denoted by Y2) is intro-duced:

minXK

k ¼ 1

Zk

S:T:

ZkZFkðdk�Ski�Pmaxki Þ, k¼ 1,. . .,K , i¼ 1,. . .,m ð7Þ

ZkZGkðSkiþTLki�dkÞ, k¼ 1,. . .,K , i¼ 1,. . .,m ð8Þ

S1iZ0, i¼ 1,. . .,m ð9Þ

SkiZSk�1,iþTLk�1,i, k¼ 2,. . .,K , i¼ 1,. . .,m ð10Þ

ZkZ0, k¼ 1,. . .,K , SkiZ0, k¼ 1,. . .,K , i¼ 1,. . .,m

A formal algorithm for solving each one of the above problemsis given below:

Algorithm 1 (Minmax). Step 1: Solve makespan minimization bythe LPT procedure (obtain TLki, Pmax

ki , k¼ 1,. . .,K , i¼ 1,. . .,m).

Step 2: Solve problem Y1.

Algorithm 2 (Minsum_minmax). Step 1: Solve makespanminimization by the LPT procedure (obtain TLki, Pmax

ki , k¼ 1,. . .,K , i¼ 1,. . .,m).


Running time: Step 1 (makespan minimization on m uniform

machines) requires Oðn lognþmnÞ time. (Clearly, for a given m

value, the complexity is Oðn lognÞ.) The running time of Step 2 is

dependent on the relevant earliness and tardiness cost functions,

and consequently on the related non-linear program (Y1 or Y2).

[Note that for linear Fk and Gk functions, Y1 is reduced to a linear

program with Kmþ1 variables, and Y2 is reduced to a linear

program with KmþK variables.]

In the following we introduce a lower bound on the optimalcost. Our proposed lower bound is based on the trivial propertythat for any given partition (of jobs to machines), the average loadper machine is not larger than the maximum load. Specifically, inthe case of uniform machines, a lower bound on the maximaltotal load on the machines (for a given class) is

TLmaxk ¼ max

1r irmTLki

� �Z

1

Smi ¼ 1si

Xm

i ¼ 1

TLki � TLk ð11Þ

Similarly, we observe the maximal job processing time in classk on machine i (Pmax

ki ), and define an upper bound on theminimum of these maximal processing times (on all the machines

E. Gerstl, G. Mosheiov / Computers & Operations Research 39 (2012) 1927–1932 1929

for a given class):

min1r irm

Pmaxki

� �r

1

Smi ¼ 1si

Xm

i ¼ 1

Pmaxki � Pmax

k ð12Þ

By dealing with average values, we solve identical problems onall m machines. We thus have to solve a single machine problem.Let SLB

k denote the starting time of class k in this single machineproblem. (Note that SLB

k is a decision variable in the non-linearprogram below.) Due to the monotonicity of Fk and Gk, we clearlyobtain the following inequalities:

max1r irm

fFkðdk�Ski�Pmaxki ÞgZFkðdk�SLB

k �Pmaxk Þ ð13Þ

max1r irm

fGkðSkiþTLmaxki �dkÞgZGkðS

LBk þTLk�dkÞ ð14Þ

As mentioned, by averaging we obtain identical schedules onall the machines, leading to a single machine problem. A lowerbound on the optimal cost for the case of Y1 is obtained by solvingthe following non-linear program (Y3) based on the aboveaverages:

minZ

S:T :

ZZFkðdk�SLBk �Pmax

k Þ, k¼ 1,. . .,K ð15Þ

ZZGkðSLBk þTLk�dkÞ, k¼ 1,. . .,K ð16Þ

SLB1 Z0 ð17Þ

SLBk ZSLB

k�1þTLk�1 , k¼ 1,. . .,K ð18Þ

ZZ0, SLBk Z0, k¼ 1,. . .,K

A lower bound on the optimal cost for the minsum–minmax

case (Y2) is obtained by solving the following non-linear program(Y4):

minXK

k ¼ 1

Zk

S:T :

ZkZFkðdk�SLBk �Pmax

k Þ, k¼ 1,. . .,K ð19Þ

ZkZGkðSLBk þTLk�dkÞ, k¼ 1,. . .,K ð20Þ

SLB1 Z0 ð21Þ

SLBk ZSLB

k�1þTLk�1 , k¼ 1,. . .,K ð22Þ

ZZ0, SLBk Z0, k¼ 1,. . .,K

We thus introduce two formal algorithms for the determina-tion the above lower bounds in both cases:

Algorithm 3 (Minmax_LB). Step 1: Calculate TLk and Pmaxk for

each k, k¼1,y,K, using Eqs. (11) and (12).


Algorithm 4 (Minsum_Minmax_LB). Step 1: Calculate TLk andPmax

k for each k, k¼1,y,K, using Eqs. (11) and (12).


Running time: The running times required for the calculation of

TLk and Pmaxk are O(nþm) and Oðn lognþmnÞ, respectively. There-

fore, the complexity of Step 1 is Oðn lognþmnÞ. As before, the

running time of Step 2 is dependent on the relevant non-linear

problem (Y3 or Y4).

Worst case behavior: The worst case behavior of the heuristics is

heavily dependent on the actual Fk and Gk functions. Focus for

example on the minmax problem with a single job-class, and F1

and G1 representing the earliness and tardiness cost functions. Let

Z(Y1) denote the minmax cost obtained by solving problem Y1, and

let LB(Y3) denote the lower bound obtained by the solution

of problem Y3. Recall the classical result (see Dobson [18]) on

the worst case optimality gap obtained by the LPT heuristic

for makespan minimization on parallel uniform machines:

CðLPTÞmax =Cn

maxr19=12. In the very special case that F1(X)¼G1(X)¼X,

clearly ðZðY1ÞÞ=ðLBðY3ÞÞr19=12.

Assume now that both F1 and G1 are general non-decreasinglinear functions. In a single-class problem, the minmax cost isobtained on each machine by the most tardy job on this machine(and in the case of a non-restrictive due-date, also by the most earlyjob). Thus, let G1(X)¼aXþb. Again, we are looking for an upperbound on ðZðY1ÞÞ=ðLBðY3ÞÞ, i.e. on ðaXðY1ÞþbÞ=ðaXðY3ÞþbÞ, whereX(Y1) is the maximum tardiness obtained by Y1, and X(Y3) is the(average) tardiness obtained by Y3. Since ðXðY1ÞÞ=ðXðY3ÞÞr19=12, itfollows that:

Case 1 (bZ0).

ZðY1Þ

LBðY3Þ¼

aXðY1Þþb

aXðY3Þþbrðða19Þ=12ÞXðY3Þþb

aXðY3Þþbr

19

12

aXðY3Þþb

aXðY3Þþb

� �

¼19

12¼ 1:583

Case 2 (bo0).

ZðY1Þ

LBðY3Þ¼

aXðY1Þþb

aXðY3Þþbrðða19Þ=12ÞXðY3Þþb

aXðY3Þþb¼

a1912 XðY3Þþ

1912 b� 7

12 b

aXðY3Þþb

¼19

12

aXðY3Þþb

aXðY3Þþb

� ��

7

19

b

aXðY3Þþbr

19

12�

7

19

b

aXðY3Þ

Since bo0 and aX(Y3)Z�b, then

19

12�

7

19

b

aXðY3Þr

19

12þ

7

19

aXðY3Þ

aXðY3Þ¼

445

228¼ 1:952

Assume now that F1 and G1 are quadratic functions. Let

G1(X)¼aX2. In this case, an upper bound on Z Y1ð Þ

LB Y3ð Þ¼

a X Y1ð Þ½ �2

a X Y3ð Þ½ �2 r

a 1912X Y3ð Þ½ �

2

a X Y3ð Þ½ �2 ¼

1912

� �2¼ 2:507

Similar bounds on the worst case optimality gaps can beobtained for various tardiness functions. Note however, that forsome functions (e.g. exponential: G1(X)¼2X), the worst casebehavior is arbitrarily bad, i.e. there is no constant bound onthe optimality gap.

Asymptotic optimality: It is well known that LPT is asymptoti-cally optimal for makespan minimization on parallel uniformmachines under very general assumptions; see Frenk and RinnooyKan [19]. Specifically, we have to assume that the process-ing times are independent and identically distributed randomvariables, generated from a discrete bounded distribution.Under these assumptions, it is clear that for the case of a

minmax objective and a single job-class: max1r irmfTLkig -n-1

TLk

and min1r irmfPmaxki g -n-1

Pmaxk . (The first limit reflects the fact that

the maximum total load on all machines converges to the averageload per machine, and the second means that the m-th largestprocessing time converges to the average processing time of thelargest m jobs.) These clearly hold for all classes, implying thatunder the above assumptions, the heuristic for the minmax case isasymptotically optimal. This result is verified in our numericaltests (presented below): the average optimality gaps for the2-machine problems are consistently smaller than those of the


3-machine problems (where the average number of jobs permachine is smaller).

In order to demonstrate the procedure for solving a minmax

and a minsum–minmax problem, and for calculating the relevantlower bounds, we solve the following numerical example.

Example 1. We solve a 16-job, 2-machine, 3-class problem. Thejob processing times (sorted in LPT for each class) are given inTable 3.1. The machine speed factors are: s1¼1, s2¼1.5. The classdue-dates are: d1 ¼ 30, d2 ¼ 70, d3 ¼ 80.

Algorithm 1 (Minmax): We first solve makespan minimizationproblem for each class on 2 uniform machines. The LPT-basedsolution provides for each class: (i) the maximum completiontime on each machine and (ii) the maximum job processing time(i.e. the processing time of the first scheduled job) on eachmachine. The results are summarized in Tables 3.2 and 3.3,respectively. We substitute these values (TLki and Pmax

ki ) in theMinmax program (constraints (3)–(6)) and solve using an appro-priate NLP solver. (This small size example is easily solved by theSolver of Excel.) One optimal schedule (for this job allocation tomachines based on LPT) is demonstrated in Fig. 1. The optimalstarting times of the job classes on the machines are given inTable 3.4. The minmax value (54.083) is obtained by both theearliness of the first job in class 2 on machine 2, and the tardinessof the last job in class 3 on machine 2. (Clearly there is no idletime between these two classes on machine 2, but there are(possible) idle times between all other classes.)

Algorithm 3 (Minmax_LB): For each class, we calculate theaverage load per machine ðTLk Þ, and the average maximal processingtime ðPmax

k Þ; see (11) and (12). The resulting values are presented inTable 3.5. We substitute these values in the Minmax_LB program(constraints (15)–(18)). The solution (starting times of the ‘‘average’’classes) are presented in Table 3.6. The lower bound on the optimalminmax cost is 45.76.

Algorithm 2 (Minsum_Minmax): We repeat the first step of thesolution of the Minmax problem, i.e. we solve makespan minimiza-tion problem by the LPT procedure. As mentioned, the relevantresults are summarized in Tables 3.2 and 3.3. We substitute theseresults in the Minsum_Minmax program (constraints (7)–(10)) andsolve. An optimal schedule (for this job allocation to machines) isshown in Fig. 2. The optimal starting times of the job classes on the

Job 1

Machine 1

Machine 2

d1

Job 2

Job 3

Job 4

Job

7

Fig. 1. Example 1: Solution

Job 1

Machine 1

Machine 2

d1

Job 2

Job 3

Job 4

Job 5 Job 6

7

Fig. 2. Example 1: Solution of th

machines for this case are given in Table 3.7. The optimal value ofthe objective function (102.167) is obtained again by both theearliness of the first job in class 2 on machine 2, and the tardinessof the last job in class 3 on machine 2.

Algorithm 4 (Minsum_Minmax_LB): We use the averages of loadper class ðTLk Þ, and of the maximal processing time per class ðPmax

k Þ,calculated earlier; see Table 3.5. We substitute these numbers in theMinsum_Minmax_LB program (constraints (19)–(22)). The solution (asbefore, the starting times of the ‘‘average’’ classes) are provided inTable 3.8. The lower bound on the optimal minsum_minmax costis 88.83.

4. Numerical study

Our goal was to evaluate the efficiency and accuracy of theheuristic algorithms described above. We performed a significantnumber of computational tests under different conditions. Twoand three machine settings were considered, with the followingspeed factors: s1¼0.7, s2¼0.8, and s3¼1.0. We assumed four jobclasses. The number of jobs per class (nk) and their processingtime (Pkj) were generated uniformly in the intervals [10,120] and[1,100], respectively. Linear and quadratic earliness/tardinesscost functions were considered. Specifically, we focused on thefollowing four combinations: ðfkðxÞ,gkðxÞÞ ¼ ðakx,bkxÞ; ðakx,bkx2Þ;ðakx2,bkx2Þ, and ðakx2,bkxÞ, where both coefficients ak and bk weregenerated uniformly in the interval [1,5]. The due-dates weregenerated uniformly in the interval 0,aððSkSjPkjÞ=ðS

mi ¼ 1siÞÞ

� ,

where SjPkj=Smi ¼ 1si reflects the average load per class per

machine, ðSkSjPkjÞ=ðSmi ¼ 1siÞ is the average load per machine, and

a is the tightness factor. Three values of a were assumed:a¼ 0:7, 1,1:3. For each combination of the number of machines(2 values), the earliness/tardiness cost functions (4 values), andthe tightness factor (3 values), 25 instances were generated andsolved. Since there are 24 such combinations (problem sets), atotal of 1200 problems were solved. For each problem set, theaverage and the worst case optimality gap (ratio of the heuristicresult and the lower bound) were calculated. [All C programswere executed on a Macintosh with a 2.8 GHz Intel Core i7processor. The programs utilized the NLOP libraries developedby Johnson [20], in particular the Constrained Optimization BY

5 Job 6 Job 1

Job 2

Job 3

4

Job 1

Job 2

Job 3

4

5

d2 d3

of the Minmax problem.

Job 1

Job 2

Job 3

4

Job 1

Job 2

Job 3

4

5

d2 d3

e Minsum_Minmax problem.

Table 1Mean and worst case optimality gap: the minmax case.

a¼0.7 a¼1.0 a¼1.3

M¼2

fkðxÞ ¼ akx; gkðxÞ ¼ bkx

Mean 1.0018 1.0040 1.0033

Worst case 1.0181 1.0390 1.0085

fkðxÞ ¼ akx2; gkðxÞ ¼ bkx

Mean 1.0043 1.0065 1.0056

Worst case 1.0166 1.0178 1.0124

fkðxÞ ¼ akx2; gkðxÞ ¼ bkx2

Mean 1.0031 1.0039 1.0065

Worst case 1.0366 1.0168 1.0171

fkðxÞ ¼ akx; gkðxÞ ¼ bkx2

Mean 1.0022 1.0025 1.0050

Worst case 1.0185 1.0180 1.0427

M¼3


Mean 1.0030 1.0041 1.0056

Worst case 1.0112 1.0181 1.0129


Mean 1.0079 1.0093 1.0115

Worst case 1.0217 1.0252 1.0251


Mean 1.0055 1.0059 1.0106

Worst case 1.0346 1.0238 1.0346


Mean 1.0050 1.0059 1.0070

Worst case 1.0225 1.0238 1.0225

Table 2Mean and worst case optimality gap: the minsum–minmax case.

a¼0.7 a¼1.0 a¼1.3

M¼2


Mean 1.0034 1.0061 1.0053

Worst case 1.0080 1.0218 1.0137


Mean 1.0058 1.0051 1.0071

Worst case 1.0127 1.0351 1.0151


Mean 1.0118 1.0037 1.0014

Worst case 1.0411 1.0122 1.0064


Mean 1.0105 1.0016 1.0106

Worst case 1.0016 1.0105 1.0220

M¼3


Mean 1.0076 1.0093 1.0084

Worst case 1.0342 1.0214 1.0160


Mean 1.0089 1.0100 1.0092

Worst case 1.0299 1.0214 1.0275


Mean 1.0107 1.0116 1.0140

Worst case 1.0500 1.0322 1.0346


Mean 1.0044 1.0040 1.0027

Worst case 1.0283 1.0246 1.0073

Table 3.1Job processing times for Example 1.

Job Class 1 Class 2 Class 3

1 17 15 18

2 15 14 12

3 10 9 7

4 9 2 4

y 7 3

6 6

7 2

Table 3.2Results of the LPT procedure: maximum completion time on the machines/classes.

Class 1 Class 2 Class 3

Machine 1 26 16 16

Machine 2 26.667 16 18.667

Table 3.7Solution of the Minsum_Minmax problem: starting times of the classes on the

machines.


Machine 1 11.08 48.90 64.90

Machine 2 14.74 48.90 64.90

Table 3.3Results of the LPT procedure: maximal job processing time on the machines/

classes.


Machine 1 15 14 12

Machine 2 11.333 10 12

Table 3.4Solution of the Minmax problem: starting times of the classes on the machines.


Machine 1 11.55 51.35 71.35

Machine 2 26.02 52.69 68.69

Table 3.5Average values of total load and maximal job completion time per class.


TLk26.4 16 17.6

Pmaxk

12.8 11.6 12

Table 3.6Solution of the Minmax_LB problem:

starting times of the classes.


13.31 53.16 69.16

E. Gerstl, G. Mosheiov / Computers & Operations Research 39 (2012) 1927–1932 1931

Linear Approximations (COBYLA) algorithm for derivative-freeoptimization (Powell [21,22]), and the Improved Stochastic Rank-

ing Evolution Strategy (ISRES) algorithm for nonlinearly-con-strained global optimization (Runarsson and Yao [23,24]).]

The results for the minmax and for the minsum–minmax

settings are reported in Tables 1 and 2, respectively. We notethat very small optimality gaps are obtained in all problem sets:the average optimality gap did not exceed 1.5%, and the worst

Table 3.8Solution of the Minsum_Minmax_LB problem:

starting times of the classes.


13.48 49.43 65.43


case optimality gap was less than 5%. The longest running timeswere required for solving minsum–minmax problems with quad-ratic earliness and tardiness cost functions. The average runningtime per problem in this setting was 31.4 s. Based on the above,we conclude that our proposed heuristics produce very close-to-optimal schedules in reasonable time (Tables 3.1–3.8).

5. Conclusion

We studied minmax scheduling problems on uniform machineswith job classes. General class-dependent and non-decreasingearliness/tardiness cost functions are assumed. Two problems,(of a minmax and of a minsum–minmax type) are considered. Wedeveloped simple heuristics, based on an LPT procedure for joballocation on the machines, followed by a solution of an appro-priate non-linear program. The heuristics are shown numerically toperform very well. An extension to job-dependent cost functionsseems to be an interesting direction for future research.

Acknowledgement

This paper was supported in part by The Recanati Fund ofThe School of Business Administration, and by The Charles RosenChair of Management, The Hebrew University, Jerusalem, Israel.

References

[1] Sidney JB. Optimal single-machine scheduling with earliness and tardinesspenalties. Oper Res 1977;25:62–9.

[2] Lakshminarayan S, Lakshmanan R, Papineau RL, Rochette R. Optimal single-machine scheduling with earliness and tardiness penalties. Oper Res1978;26:1079–82.

[3] Cheng TCE. Optimal total-work-content-power due-date determination andsequencing. Comput Math Appl 1987;14:579–82.

[4] Li C-L, Cheng TCE. The parallel machine min–max weighted absolute latenessscheduling problems. Nav Res Logistics 1994;41:33–46.

[5] Cheng R, Gen M, Tozawa T. Minmax earliness/tardiness scheduling inidentical parallel machine system using genetic algorithms. Comput IndEng 1995;29:513–7.

[6] Federgruen A, Mosheiov G. Heuristics for multi-machine minmax schedulingproblems with general earliness and tardiness costs. Nav Res Logistics1997;44:287–99.

[7] Mosheiov G. A common due-date assignment problem on parallel identicalmachines. Comput Oper Res 2001;28:719–32.

[8] Mosheiov G, Shadmon M. Minmax earliness-tardiness costs with unitprocessing time jobs. Eur J Oper Res 2001;130:638–52.

[9] Mosheiov G. Due-date assignment with asymmetric earliness-tardiness cost.J Oper Res Soc 2003;54:1222–4.

[10] Mosheiov G, Oron D. Minmax scheduling with job-classes and earliness-tardiness costs. Eur J Oper Res 2007;177:612–22.

[11] Lauff V, Werner F. Scheduling with common due date, earliness and tardinesspenalties for multi-machine problems: a survey. Math Comput Model2004;40:637–55.

[12] Janiak A, Kovalyov MY, Marek M. Soft due window assignment and schedul-ing on parallel machines. IEEE Trans Syst Man Cybern A 2007;37:614–20.

[13] Emmons H. Scheduling to a common due-date on parallel uniform proces-sors. Nav Res Logistics 1987;34:803–10.

[14] Balakrishnan N, Kanet J, Sridharan S. Early/tardy scheduling with sequencedependent setups on uniform machines. Comput Oper Res 1999;29:127–41.

[15] Raja K, Selladurai V, Arumugan C. Earliness–tardiness scheduling on uniformparallel machines using simulated annealing and fuzzy logic approach. ProcInst Mech Eng B: J Eng 2008;222:333–46.

[16] Mosheiov G, Sarig A. Due-date assignment on uniform machines. Eur J OperRes 2009;193:49–58.

[17] Mosheiov G, Sarig A. Scheduling identical jobs and due-window on uniformmachines. Eur J Oper Res 2010;201:712–9.

[18] Dobson G. Scheduling independent tasks on uniform processors. SIAM JComput 1984;13:705–16.

[19] Frenk JBG, Rinnooy Kan AHG. The asymptotic optimality of the LPT rule. MathOper Res 1987;12:241–54.

[20] Johnson SG. The NLopt nonlinear-optimization package. /http://ab-initio.mit.edu/nloptS; 2011.

[21] Powell MJD. A direct search optimization method that models the objectiveand constraint functions by linear interpolation. in: Gomez S, Hennart J-P,editors. Mathematics and its Applications. Dordrecht: Kluwer Academic;1994. p. 51–67.

[22] Powell MJD. Direct search algorithms for optimization calculations. ActaNumer 1998;7:287–336.

[23] Runarsson TP, Yao X. Stochastic ranking for constrained evolutionary opti-mization. IEEE Trans Evol Comput 2000;4:284–94.

[24] Runarsson TP, Yao X. Search biases in constrained evolutionary optimization.IEEE Trans Syst Man Cybern C 2005;35:233–43.

http://ab-initio.mit.edu/nlopt

http://ab-initio.mit.edu/nlopt

Documents

Scheduling job classes on uniform machines