Lower Bounds for Scheduling on Identical Parallel Machines with

Heads and Tails

Mohamed Haouari and Anis GharbiLaboratory of Mathematical Engineering

Ecole Polytechnique de Tunisie, BP 743, 2078, La Marsa. Tunisia.

Abstract

In this paper, we investigate new lower bounds for the P=rj; qj=Cmax schedulingproblem. A new bin packing based lower bound, as well as several new lifting proce-dures are derived for this strongly NP-hard problem. Extensive numerical experimentsshow that the proposed lower bounds consistently outperform the best existing ones.

Keywords : Scheduling, Identical Parallel Machines, Release Dates, DeliveryTimes, Makespan, Lower Bound.

1 IntroductionIn this paper, we investigate lower bounding strategies for the problem of scheduling identicalparallel machines with release dates and delivery times. This problem is formally describedas follows: A set J of n jobs has to be scheduled on m identical parallel machines (withn > m ¸ 2). Each job j has a release date or head rj; a processing time or body pj and adelivery time or tail qj: All data are assumed to be deterministic and integer. Each machineprocesses at most one job at one time and each job cannot be processed by more than onemachine at one time. We assume that preemption is not allowed and that all machinesare available from time zero onwards. Let tj ¸ rj denote the start time of job j, then thecompletion time of j is de…ned as Cj = tj + pj + qj: The objective is to …nd a schedule thatminimizes the maximum completion time (or makespan) Cmax = max

j2JCj. Following Lawler

et al. [11], this problem is denoted by P=rj ; qj=Cmax.

The P=rj ; qj=Cmax is NP-hard in the strong sense since it generalizes the well studiedP==Cmax which is strongly NP-hard (Garey and Johnson [7]). However, unlike this latterproblem for which there exist very e¢cient exact algorithms (Dell’Amico and Martello [6]),

1

computational experiments with optimization algorithms developed by Carlier [3] and Gharbiand Haouari [8] provide evidence that only small or medium-sized instances could be solvedwithin a reasonable computing time. The objective of this paper is to derive several newlower bounds for the P=rj; qj=Cmax: These bounds might be useful both to improve thee¤ectiveness of branch and bound algorithms and to benchmark heuristic solutions.

Our motivation for the study of the P=rj; qj=Cmax stems from the fact that it constitutes afundamental model encompassing several well studied parallel machine scheduling problems,including P==Cmax, P=rj=Cmax; P==Lmax; and the parallel machine problem with machineavailabilities denoted by P;NCinc==Cmax. Hence, many of the results presented in this papermight be applicable for all these problems. Also, the P=rj; qj=Cmax has many interestingtheoretical applications. In particular, it arises as a strong relaxation of the MultiprocessorFlow Shop problem (Hoogeveen et al. [9]) and it plays a central role in some exact algorithmsfor the Resource Constrained Project Scheduling Problem (Carlier and Latapie [4]).

The paper is organized as follows: In Section 2, we survey lower bounds from the lit-erature. In Section 3, a new lower bound based on the bin packing problem is proposed.In Sections 4-6 several strategies aimed at enhancing lower bounds are introduced. Thesestrategies are based on considering subset of jobs, machines, or both. In Section 7, we presentthe results of an extensive computational analysis of the di¤erent lower bounds. Finally, weconclude by providing a summary of our results and indicating some directions for futureresearch.

For convenience, we assume hereafter that the release dates, processing times, and deliv-ery times are sorted according to the non-decreasing order. The values ¹rj(J); ¹pj(J) and ¹qj(J)denote the jth smallest release date, processing time and delivery time in J; respectively. Wedenote by dxe the smallest integer that is larger than or equal to x; and by bxc the largestinteger that is smaller than or equal to x:

2 Lower bounds from the literature

2.1 Simple lower bounds

Obviously, no job j can …nish its processing earlier than rj + pj + qj: Thus, a simple lowerbound is:

LB0(J) = maxj2J

(rj + pj + qj)

LB0 can be computed in O(n) time. A second simple O(n) lower bound given by Carlier [3]is:

LB1(J) = minj2J

rj +

26661

m

X

j2Jpj

3777+ min

j2Jqj

2

This bound is based on the fact that all release dates and delivery times are assumed to beequal to min

j2Jrj and min

j2Jqj ; respectively.

2.2 A lower bound based on machine idle times

In any feasible schedule, a machine is necessary idle from time zero to r1(J); a second onefrom time zero to r2(J), ..., and an mth one from time zero to rm(J). Similarly, a machine isidle from time C¤max(J)¡ q1(J) to C¤max(J), ..., and an mth one from time C¤max(J)¡ qm(J)to C¤max(J). Moreover, the total amount of activity of the m machines is equal to

X

j2Jpj: By

adding the minimal amounts of activity to those of inactivity, we obtain:

r1(J) + r2(J) + ¢ ¢ ¢+ rm(J)+X

j2Jpj + q1(J) + q2(J) + ¢ ¢ ¢+ qm(J) · mC¤max(J)

This yields the following O(n) lower bound proposed by Carlier [3]:

LB2(J) =

26661

m

0@r1(J) + r2(J) + ¢ ¢ ¢+ rm(J)+

X

j2Jpj + q1(J) + q2(J) + ¢ ¢ ¢+ qm(J)

1A

3777

Clearly, LB2(J) dominates LB1(J):

2.3 A lower bound based on machine availability times

In a parallel machine scheduling problem with availability constraints; a machineMi is avail-able from time ui ¸ 0 onwards (1 · i · m). A strong lower bound for the P;NCinc==Cmax;denoted by the General Bound (GB), has been proposed by Webster [13]. Its descriptionis rather long and may a¤ect the clarity of the present paper, so we refer the reader tothe original paper. Gharbi and Haouari [8] used GB to construct a new lower bound forthe P=rj; qj=Cmax, referred to as the Modi…ed General Bound (MGB), that was proven todominate LB2: The MGB is computed as follows: First, a subset ¹J µ J is computed usingan O(n logn) preprocessing algorithm. Let D( ¹J) be the set of dummy jobs j1; j2; :::; jm¡1such that:

8>><>>:

rjh = rm( ¹J)

pjh = qh+1( ¹J)¡ q1( ¹J)

qjh = q1( ¹J)

for h = 1; :::;m¡ 1

One can prove that adding the set D( ¹J) to the jobset ¹J keeps the value of the optimalmakespan unchanged. Hence, the “extended” P=rj; qj=Cmax instance de…ned on ¹J [ D( ¹J)is relaxed as a parallel machine problem with machine availability times by assuming that

3

all release dates and delivery times are set equal to zero, and that each machine Mi has anavailability time ui = ri( ¹J [D( ¹J)) (i = 1; :::;m): The bound MGB is de…ned by:

MGB(J) = GB( ¹J [D( ¹J))+ minj2 ¹J

qj

MGB is obtained in O(n logn) time. For convenience, in the sequel, we refer to MGB byLB3:

2.4 The preemptive bound

If we relax the non-preemption constraint, then we obtain a preemptive parallel machineproblem denoted by P=rj ; qj; pmtn=Cmax: Obviously, the makespan of an optimal preemptiveschedule constitutes a strong lower bound for P=rj; qj=Cmax: Horn [10] proposed a polyno-mial optimization algorithm for the P=rj; qj; pmtn=Cmax. Basically, it consists in checkingthe existence of a preemptive schedule with makespan equal to a trial value C through atransformation into a maximum ‡ow problem. If LB and UB denote a lower and upperbound on the trial value C; then the optimal preemptive makespan is computed using abisection search on the interval [LB;UB]: Its computation requires O(n3(logn + log pmax))time where pmax denotes the largest processing time. In the sequel, we de…ne the preemptivelower bound, denoted by PLB(J); as the optimal preemptive makespan:

2.5 The Jackson’s pseudo-preemptive bound

In a pseudo-preemptive schedule, any operation is allowed to be preempted, and each machinecan handle several jobs at one time. Moreover, each job can be processed by more than onemachine at one time. The Jackson’s Pseudo-Preemptive Schedule (JPPS) was introducedby Carlier and Pinson [5]. It was shown that it provides an O(n log n+nm logm) lower boundfor the P=rj; qj=Cmax. The JPPS is a generalization of Jackson’s preemptive schedule whosemakespan is a tight lower bound for 1=rj; qj=Cmax: The Jackson’s pseudo-preemptive lowerbound, denoted hereafter by JPPB; is equal to dCmax(JPPS)e ; where Cmax(JPPS) denotesthe makespan of JPPS:

3 A bin packing based bound

A simple way to relax the P=rj; qj=Cmax is to assume that all the heads and tails areequal to min

j2Jrj and min

j2Jqj; respectively. Let C¤max(J) denote the optimal makespan of

the P=rj; qj=Cmax de…ned on J: The following result clearly holds:

minj2J

rj + LBP==Cmax(J) + minj2J

qj · C¤max(J)

4

where LBP==Cmax(J) denotes a lower bound for the P==Cmax de…ned on J: The P==Cmax is afundamental scheduling problem that has been extensively investigated by many researchers,and several lower bounds have been proposed in the literature (Dell’Amico and Martello [6]).

These bounds include maxj2J

pj ;

26661

m

X

j2Jpj

3777, and ¹pn¡m(J) + ¹pn¡m+1(J) to quote just a few.

Therefore, any of these bounds can be used to derive a lower bound for P=rj ; qj=Cmax.

For instance, taking LBP==Cmax(J) =

26661

m

X

j2Jpj

3777

yields LB1(J): However, a much more

interesting lower bound can be derived from the optimal solution of a Bin Packing Problem(BPP ): The BPP is an NP-hard optimization problem which can be described as follows:Given a set of weighted items and a set of bins, each item has to be assigned to one binso that the total weight of the items in each bin does not exceed a given capacity C. Theobjective is to minimize the number of used bins (Martello and Toth [12]). The P==Cmax isrelated to the BPP in the following way. Given a trial value C of the optimal makespan,consider the decision problem which consists in checking whether the n jobs can be processedon the m machines such that the maximum completion time does not exceed C: A positiveanswer to this feasibility problem is provided if the minimal number of bins (machines) doesnot exceed m in the BPP de…ned for the n items (jobs) with weights pj and bins’ capacityC: Otherwise, we conclude that a valid lower bound for the P==Cmax is C + 1:

Dell’Amico and Martello [6] proposed a strong BPP based lower bound for the P==Cmax

which can be described as follows: For each integer p = ¹p1(J); ¹p2(J); :::;min½¹pn¡m¡1(J);

C

2

¾,

the subsets J1; J2 and J3 are de…ned by:

J1 = fj 2 J; C ¡ p < pjgJ2 =

½j 2 J ; C

2< pj · C ¡ p

¾

J3 =½j 2 J ; p · pj · C

2

¾

The two proposed lower bounds of the minimal number of used bins are:

BPP1(C; p) = jJ1j+ jJ2j+max

0BBB@0;

2666666

X

j2J3pj ¡ C jJ2j+

X

j2J2pj

C

3777777

1CCCA

BPP2(C; p) = jJ1j+ jJ2j+max

0BBBBB@0;

266666666

jJ3j ¡X

j2J2

$C ¡ pjp

%

$C

p

%

377777777

1CCCCCA

5

Clearly, if maxp

fmax(BPP1(C; p);BPP2(C; p))g > m then C + 1 is a valid lower bound

for the P==Cmax: Therefore, an enhanced lower bound for the P==Cmax can be computedthrough a bisection search on the interval [L;U ]; where L and U denote a lower and upperbound on the optimal makespan, respectively. The lower bound is:

L = max

8<:maxj2J

pj;

26661

m

X

j2Jpj

3777; ¹pn¡m(J) + ¹pn¡m+1(J)

9=;

The upper bound U is the makespan of the schedule constructed according to the Longest

Processing Time (LPT) rule. This consists in scheduling the available job with the longestprocessing time on the …rst available machine. The computation of L and U requires O(n)and O(n logn) time, respectively. Let BPP (J) denote the resulting lower bound. Then,BPP (J) can be computed in O(n2 logU ).

Consequently, a valid lower bound for the P=rj ; qj=Cmax is:

minj2J

rj +BPP (J)+ minj2J

qj

This bound can be further improved in the following way: Consider the sets D(J) and D0(J)of dummy jobs de…ned by:

D(J) =njh(h = 1; :::;m¡ 1)=rjh = rm(J); pjh = qh+1(J)¡ q1(J) and qjh = q1(J)

o

D0(J) = fjh(h = 1; :::;m¡ 1)=rjh = r1(J); pjh = rh+1(J)¡ r1(J) and qjh = qm(J)g

Gharbi and Haouari [8] proved that adding the sets D(J) and D0(J) to the jobset J hasno e¤ect on the value of the optimal makespan. Let Jext = J [ D(J) [ D0(J) denote theextended set of jobs. Clearly, we have:

BPP (J) · BPP (Jext)

Therefore, an improved O(n2 logU) lower bound for the P=rj ; qj=Cmax is:

LB4(J) = minj2Jext

rj +BPP (Jext)+ minj2Jext

qj

Obviously, any progress that would be made in the design of an improved lower bound forthe bin packing problem could be advantageously used to improve LB4:

6

Proposition 1:

LB4(J) ¸ LB2(J)

Proof. Clearly, LB4(J) ¸ LB1(Jext): Note that

LB1(Jext) = minj2Jext

rj +

26661

m

X

j2Jextpj

3777+ min

j2Jextqj

= minj2J

rj +

26661

m

0@ X

j2D0(J)

pj+X

j2Jpj+

X

j2D(J)pj

1A

3777+ min

j2Jqj

= ¹r1(J) +

26661

m

0@

mX

h=2

rh(J)+X

j2Jpj+

mX

h=2

qh(J)¡ (m¡ 1)(r1(J) + q1(J))1A

3777+ ¹q1(J)

=

26661

m

0@

mX

h=1

rh(J)+X

j2Jpj+

mX

h=1

qh(J)

1A

3777

= LB2(J)

Example 1: Consider the 10 job -2 machine instance de…ned by Table 1.

j 1 2 3 4 5 6 7 8 9 10rj 2 8 3 6 5 3 9 6 3 7pj 92 92 97 93 92 4 4 5 3 4qj 2 2 10 4 7 7 8 2 10 10

Table 1 - Data of the 10 job - 2 machine instance of example 1

We have D(J) = ; and D0(J) = fj1 : rj1 = 2; pj1 = 1; qj1 = 2g: The lower andupper bounds computed for the corresponding P==Cmax de…ned on Jext = J [ fj1g are

L = max½97;

»487

2

¼; 93 + 92

¾= 244 and U = 277; respectively.

Consider the trial value C = 275: For p = 92; we have J1 = J2 = ® and J3 = f1; 2; 3; 4; 5g:

Thus, BPP2(C; p) = max

8<:0;

26665j27592

k

3777

9=; = 3 > m: Consequently, C + 1 = 276 is a lower

bound for the considered P==Cmax: Therefore, a valid lower bound for the P=rj; qj=Cmaxinstance is LB4(J) = 2 + 276 + 2 = 280 (Note that LB1(J) = 247 and LB2(J) = 248):

7

4 Job subset based lower boundsIn this section as well as in the two following ones, we introduce some lifting procedures thataims at enhancing a given lower bound. Perhaps the simplest example of a lifting procedureis based on the observation that a valid lower bound on the optimal makespan of an instancede…ned on a jobset J is still valid when de…ned on a restricted subset S of jobs. Therefore,we can lift a given lower bound by taking its maximal value over all of the subsets.

For instance, by applying the job based lifting procedure to LB1; we obtain the followingvalid bound:

JLB1(J) = maxSµJ

LB1(S)

Carlier [3] proved that JLB1 can be computed in O(n logn) time. Indeed, JLB1 is equal tothe optimal makespan of the preemptive one machine problem 1=rj ; qj; pmtn=Cmax, obtainedby replacing the m machines by a single one and dividing all the processing times by m.This problem is solved using Jackson’s preemptive algorithm (see Carlier [2]).

Also, it is worth noting that applying this lifting procedure to the bound LB2 wouldyield, at best, the value of JPPB: Indeed, Carlier and Pinson [5] proved that:

JPPB(J) = max½LB0(J);max

SµJLB2(S)

¾

Unfortunately, for several bounds it is not known if their maximal value over all of thesubsets can be computed in polynomial time. In these cases, for a given lower bound LBrequiring O(g(n)) time, we propose to use a simple O(n2g(n)) greedy algorithm for …ndinga subset S¤ which is an approximate solution of JLB(J) = max

SµJLB(S). This algorithm is

referred to as the Approximate Subset Procedure (ASP). It consists in initializing S¤ to Jand iteratively removing a job j0 from S¤: The job j0 that is chosen to be removed is the onethat yields the largest improvement to LB(S¤): Clearly, if jS¤j = m+1; then removing a jobfrom S¤ yields a bound dominated by LB0(J): The algorithm stops when no improvementis possible or jS¤j = m+ 1. Formally, ASP can be described as follows:

Approximate Subset Procedure (ASP)

Step 0. Set S¤ = J and JLB(J) = LB(J)Step 1. For all j 2 S¤ do

If LB(S¤nfjg) > LB(S¤) set j0 = j and LB(S¤) = LB(S¤nfjg):Step 2. If LB(S¤) · JLB(J) or jS¤j = m+1 then Stop. Otherwise, set JLB(J) = LB(S¤);S¤ = S¤nfj0g and go to step 1.

8

Gharbi and Haouari [8] used ASP to compute an approximate value of maxSµJ

LB3(S): The

resulting value, denoted hereafter by JLB3(J), requires O(n3 log n) time.

Also, an approximation of maxSµJ

LB4(S) can be obtained using ASP. The resulting

O(n4 logU) lower bound will be denoted by JLB4(J):

It is worth noting that, due to its approximate computation, the bound JLB3(J) doesnot dominate max

SµJLB2(S): However, if we consider the subset J¤ µ J such that LB2(J¤) =

maxSµJ

LB2(S); then the bound maxSµJ

LB2(S) is dominated by JLB3(J¤). The set J¤ can be

computed in O(n log n+ nm logm) time (Carlier and Pinson [5]). Thus, JLB3(J¤) requiresO(n3 logn) time. With no loss of generality, the lower bound maxfJLB3(J), JLB3(J¤)g isdenoted by JLB3(J): Similarly, Proposition 1 proves that JLB4(J¤) ¸ max

SµJLB2(S): In the

sequel, the bound JLB4(J) denotes maxfJLB4(J), JLB4(J¤)g:

5 Machine subset based lower bounds

In this section, we introduce a second basic lifting procedure which consists in consideringonly a restricted subset of machines. First, we state a lemma provided, with no formal proof,by Blocher and Chand [1] and then we prove it.

Lemma 1: (Blocher and Chand [1])

In any feasible schedule of a parallel machine problem with n jobs and m machines such

that n =¹n

m

ºm + ½; there is at least a set of ½ machines ( 1 · ½ · m ¡ 1) which must

process at least ½µ¹n

m

º+ 1

¶jobs.

Proof. The result is shown by induction on ½:

i) Firstly, we consider ½ = 1: Assume that n =¹n

m

ºm+ 1 and that each machine processes

at most¹n

m

ºjobs. Thus, the m machines process at most m

¹n

m

º< n jobs which is absurd.

Therefore, there is at least one machine processing at least¹n

m

º+ 1 jobs. Hence, the result

holds for ½ = 1:

ii) Now, assume that the result holds for a given ½ (½ = 1; :::;m¡ 2): Then, there is at least

a set S of ½ machines processing ½µ¹n

m

º+ 1

¶+® jobs (® ¸ 0). Assume that each machine

9

of the m¡ ½ remaining ones processes at most¹n

m

º¡ ® jobs. That is, an upper bound on

the total number of jobs processed on the m machines is:

n0 = ½µ¹n

m

º+ 1

¶+ ®+ (m¡ ½)

µ¹n

m

º¡ ®

¶= m

¹n

m

º+ ½+ ®(1¡m+ ½)

which is strictly smaller than n. Therefore, there is at least one machine among them¡½ ones

processing at least¹n

m

º¡®+1 jobs. By adding this machine to the set S; we obtain a set of

½+1machines processing at least ½µ¹n

m

º+ 1

¶+®+

¹n

m

º¡®+1 = (½+1)

µ¹n

m

º+ 1

¶jobs.

In fact, we can go a step further and propose the following more general result.

Lemma 2:

In any feasible schedule of a parallel machine problem with n jobs and m machines, there is

at least a set of k machines ( 1 · k · m) which must process at least ¸k = k¹n

m

º+min(k; ½)

jobs, where ½ = n¡¹n

m

ºm:

Proof. Two cases have to be considered:

i) If k · ½ : Using Lemma 1, the result holds if the number of jobs is equal to¹n

m

ºm + k:

Clearly, the result remains true if the number of jobs is increased to¹n

m

ºm+ ½:

ii) If k > ½ : First, we check that the result holds for k = ½+1. Lemma 1 ensures that there

is a set S of ½ machines processing ½µ¹n

m

º+ 1

¶+ ® jobs (® ¸ 0): Assume that each of the

remainder m¡ ½ machines processes at most¹n

m

º¡®¡ 1 jobs. That is the total number of

jobs processed by the m machines is less than or equal to:

n0 = ½µ¹n

m

º+ 1

¶+ ® + (m¡ ½)

µ¹n

m

º¡ ®¡ 1

¶= m

¹n

m

º+ ½+ ®¡ (m¡ ½)(®+ 1):

Clearly, n0 < n for ® = 0: Assume that n0 = n for ® > 0: That is, ®¡ (m¡½)(®+1) = 0: So,m =

®

®+ 1+ ½ which is impossible since

®

®+ 1is not integer for ® > 0: Therefore, n0 < n

for all ® ¸ 0 which is absurd. Consequently, there is one machine among the m ¡ ½ ones

10

processing at least¹n

m

º¡ ® jobs. By adding this machine to the set S; we obtain a set of

½+ 1 machines processing at least ½µ¹n

m

º+ 1

¶+ ®+

¹n

m

º¡ ® = (½+ 1)

¹n

m

º+ ½ jobs.

Using similar arguments, we can prove that if the result holds for a given k (½+1 · k · m¡1);then there is a set of k + 1 machines processing at least (k + 1)

¹n

m

º+ ½ jobs.

An immediate consequence of Lemma 2 is that a relaxed instance can be obtained byassuming that there is a subset of k machines (k = 1; :::;m) processing ¸k jobs having thesmallest release dates, processing times and delivery times. The latter P=rj; qj=Cmax instancewill be denoted hereafter by Pk: Clearly, a whole family of lifted lower bounds is derived byconsidering each Pk (k = 1; :::;m): Let MLBk1(J); MLB

k2 (J); MLB

k3 (J) and MLBk4 (J)

denote the respective values of LB1; LB2; LB3 and LB4 computed for the instance Pk: Thisyields the following valid lower bounds:

MLB1(J) = max1·k·m

MLBk1 (J)

MLB2(J) = max1·k·m

MLBk2 (J)

MLB3(J) = max1·k·m

MLBk3 (J)

MLB4(J) = max1·k·m

MLBk4 (J)

Clearly, the computation of MLB1; MLB2; MLB3 and MLB4 requires O(mn); O(mn);O(mn logn) and O(mn2 logU) time, respectively.

The following example illustrates how LB1 and LB2 can be lifted using the machinesubset lifting procedure.

Example 2: Consider the 10 job - 4 machine instance de…ned by Table 2.

j 1 2 3 4 5 6 7 8 9 10rj 9 6 2 9 8 2 2 5 7 8pj 95 96 90 99 97 91 97 92 97 93qj 9 4 8 8 8 6 7 5 1 2

Table 2 - Data of the 10 job - 4 machine instance of example 2

We have LB1(J) = 2 +»947

4

¼+ 1 = 240 and LB2(J) =

»11 + 947 + 12

4

¼= 243:

For k = 1; we have ¸k = 3 and

MLBk1 (J) =MLBk2 (J) = 2 + (90 + 91 + 92) + 1 = 276

11

For k = 2; we have ¸k = 6 and

MLBk1 (J) = 2 +»90 + 91 + 92 + 93 + 95 + 96

2

¼+ 1 = 282

MLBk2 (J) =

&(2 + 2) + (90 + 91 + 92 + 93 + 95 + 96) + (1 + 2)

2

'= 282

For k = 3; we have ¸k = 8 and

MLBk1 (J) = 2 +»90 + 91 + 92 + 93 + 95 + 96 + 97 + 97

3

¼+ 1 = 254

MLBk2 (J) =

&(2 + 2 + 2) + (90 + 91 + 92 + 93 + 95 + 96 + 97 + 97) + (1 + 2 + 4)

3

'= 255

For k = 4; we have clearly MLBk1 (J) = LB1(J) = 240 and MLBk2 (J) = LB2(J) = 243:

Consequently, the resulting machine subset based bounds are:

MLB1(J) = maxf276; 282; 254; 240g = 282

MLB2(J) = maxf276; 282; 255; 243g = 282

6 Job-machine based lower bounds

The lower bounds derived with the machine based lifting procedure can be further improvedif they are computed for every subset of J: In this section, we propose for each lower boundcomputed in the previous section, a speci…c method to compute (exactly or approximately)its maximal value over all the subsets of jobs.

Lemma 2 provides the minimal number of jobs ¸k processed by at least one subset of k

machines. We recall that ¸k = k¹n

m

º+ min(k; ½) jobs, where ½ = n ¡

¹n

m

ºm: Note that,

for …xed k and m; di¤erent values of n may yield the same value of ¸k. Given an integer ¸;let n¸ denote the minimal number of jobs yielding ¸k = ¸: Consider the subset J¸ of the n¸jobs having the largest processing times. We make the following observation:

Observation 1:

1) MLB1(J¸) ¸ MLB1(J)2) MLB2(J¸) ¸ MLB2(J)

12

Hence, we can systematically use the above observation to further lift the bounds MLB1and MLB2. The number of jobs n¸ can be computed using the following proposition.

Proposition 2:

Let ¸k(n) = k¹n

m

º+minfk; ½(n)g, where ½(n) = n¡

¹n

m

ºm: Given the integers m; k and

¸; the smallest number of jobs satisfying ¸k(n) = ¸ is:

n¸ =

8>>>><>>>>:

m

ø

k¡ 1

!+ k if k divides ¸

(m¡ k)$¸

k

%+ ¸ otherwise

Proof. It su¢ces to prove that ¸k(n¸) = ¸, and ¸k(n) < ¸ for all n < n¸: The result clearlyholds if k = m: For k = 1; :::;m¡ 1; two cases have to be considered:

i) If k divides ¸ : We have¹n¸m

º=¸

k¡1+

$k

m

%=¸

k¡1: Thus, ½(n¸) = n¸¡

¹n¸m

ºm = k:

That is, ¸k(n¸) = k

ø

k¡ 1

!+k = ¸: Now, we prove that if n < n¸ then ¸k(n) < ¸: Clearly,

n < n¸ yieldsn

m<¸

k¡ 1 + k

m: That is,

¹n

m

º· ¸

k¡ 1:

The result clearly holds if ½(n) < k since ¸k(n) = k¹n

m

º+ ½(n) · k

ø

k¡ 1

!+ ½(n) < ¸: If

½(n) ¸ k then ¸k(n) = k¹n

m

º+ k · ¸: Assume that ¸k(n) = ¸: Then,

¹n

m

º=¸

k¡ 1: Note

that n < m

ø

k¡ 1

!+ k: That is, n < m

¹n

m

º+ k. Therefore ½(n) < k which is absurd.

Consequently, ¸k(n) < ¸.

ii) If k does not divide ¸ : We have n¸ = m

$¸

k

%+ ¸ ¡

$¸

k

%k: Then,

¹n¸m

º=

$¸

k

%+

66666664

¸¡$¸

k

%k

m

77777775: But, 0 · ¸ ¡

$¸

k

%k < k: That is, 0 ·

66666664

¸¡$¸

k

%k

m

77777775·

$k

m

%= 0: Thus,

¹n¸m

º=

$¸

k

%: Therefore, ½(n¸) = n¸ ¡ m

¹n¸m

º= ¸ ¡

$¸

k

%k < k: Consequently, we have

¸k(n¸) = k

$¸

k

%+ ¸¡

$¸

k

%k = ¸:

13

Now, we prove that if n < n¸ then ¸k(n) < ¸: Clearly, n < n¸ yields

n · m

$¸

k

%+ ¸¡

$¸

k

%k ¡ 1:

That is,¹n

m

º·

$¸

k

%+

66666664

¸¡$¸

k

%k

m

77777775¡

»1

m

¼=

$¸

k

%¡ 1: Therefore,

¸k(n) = k¹n

m

º+minfk; ½(n)g · k

Ã$¸

k

%¡ 1

!+ k < ¸:

We describe how to compute the lifted lower bound JMLB1(J) = maxSµJ

MLB1(S). It

su¢ces to compute JMLBk1 (J) = maxSµJ

MLBk1 (S) for a given k (1 · k · m). Let fk(J) =26661

k

¸kX

j=1

¹pj(J)

3777: Clearly, if max

SµJfk(S) can be computed in O(g(n)) time, then JMLBk1 (J)

can be computed in O(n2g(n)) using the following exact algorithm:

Computation of JMLBk1 (J)

Rank rj and qj in increasing order and set JMLBk1 (J) = 0:For all pairs of heads and tails (r; q) do

Compute the jobset Sr;q = fj 2 J : rj ¸ r and qj ¸ qgSet JMLBk1 (J) = max

½JMLBk1 (J); r+ max

SµSr;qfk(S) + q

¾

End (for)

Now; we describe how to compute the subset S¤r;q µ Sr;q such that fk(S¤r;q) = maxSµSr;q

fk(S).

For each integer ¸; let S¸ µ Sr;q denote the job subset which maximizes

26661

k

X̧

j=1

¹pj(Sr;q)

3777:

Clearly, the set S¤r;q is the set which satis…es fk(S¤r;q) = max¸fk(S¸): Using Observation 1,

the set S¸ is the set of n¸ jobs with the largest processing times in Sr;q:

Obviously, for any subset in Sr;q; the value of ¸ cannot exceed ¸max = k

$jSr;qjm

%+min(k; ½);

where ½ = jSr;qj ¡m$jSr;qjm

%. On the other hand, assume that the set S¤r;q corresponds to a

14

value of ¸ which is less than or equal to k: In this case, MLBk1 (S¤r;q) is clearly dominated by

LB0(J). Thus, we set w.n.l.g. JMLBk1 (J) = maxfJMLBk1 (J); LB0(J)g and restricted ourcomputation to ¸ 2 [¸min; ¸max]; where ¸min = k + 1:

If the jobs are sorted according to the non-increasing order of their processing times,then the computation of fk(S¸) requires ¸ operations: Therefore, computing fk(S¤r;q) requires0@¸maxX

¸min

¸

1A operations which is bounded by O(n2). Since JMLBk1 (J) is the maximal value of

MLBk1(S¤r;q) over all pairs (r; q); then JMLBk1 (J) can be computed in O(n4) time. Therefore,

JMLB1(J) requires O(mn4) time.

A second interesting job-machine based lower bound is JMLB2(J) = maxSµJ

MLB2(S):

We propose to compute an approximation of JMLB2: The procedure is similar in spirit tothat of JMLB1: That is, given the integer k (1 · k · m); we compute for each integer¸ 2 [¸min; ¸max] the corresponding subset S¸ µ J of n¸ jobs maximizing the value of MLBk2 ;

where ¸min = k + 1 and ¸max = k¹n

m

º+min(k; ½).

The set S¸ is obtained using a greedy algorithm starting from the global set J: At eachiteration, a particular job is removed such that the value of MLBk2 is maximized. Thealgorithm stops when jS¸j = n¸: Let Sr; Sp and Sq denote the subsets of jobs with the ksmallest release dates, ¸ smallest processing times, and k smallest delivery times, respectively.

Let1

k±j(S¸) denote the increase of MLBk2 that is achieved when the job j is removed from

the current set S¸: We have:

±j(S¸) =

8>>>>>>>>>>>>><>>>>>>>>>>>>>:

¹rk+1(S¸)¡ rj for j 2 Sr n (Sp [ Sq)¹p¸+1(S¸)¡ pj for j 2 Sp n (Sr [ Sq) ( ¹pn+1 = 0)¹qk+1(S¸)¡ qj for j 2 Sq n (Sr [ Sp)¹rk+1(S¸)¡ rj + ¹p¸+1(S¸)¡ pj for j 2 (Sr \ Sp)nSq¹p¸+1(S¸)¡ pj + ¹qk+1(S¸)¡ qj for j 2 (Sp \ Sq)nSr¹rk+1(S¸)¡ rj + ¹qk+1(S¸)¡ qj for j 2 (Sr \ Sq)nSp¹rk+1(S¸)¡ rj + ¹p¸+1(S¸)¡ pj + ¹qk+1(S¸)¡ qj for j 2 Sr \ Sp \ Sq0 otherwise

It is worth noting that MLB12(J) =MLB11(J): Thus, for k = 1; the bound JMLBk2 (J) can

be computed exactly by using the above procedure devoted for JMLBk1 (J): Formally, thebound JMLB2 can be computed using the following algorithm:

15

Computation of JMLB2(J)

Set JMLB2(J) = JMLB11(J):For all k = 2; :::;m do

Set ¸ = ¸max and JMLB2(J) = maxnJMLB2(J);MLB

k2 (J)

o

While ¸ ¸ ¸min doCompute n¸ and set S¸ = JWhile jS¸j > n¸ do

Select the job j0 2 S¸ with maximal ±j(S¸)Set S¸ = S¸nfj0g and update ±j(S¸) for all j 2 S¸

End (while)Set JMLB2(J) = max

nJMLB2(J);MLBk2 (S¸)

o

Set ¸ = ¸¡ 1End (while)

End (for)

If the release dates, processing times, and delivery times are sorted in the non-decreasingorder, then computing ±j(S¸) for all j 2 S¸ requires O(n) time. Thus, the set S¸ can be com-

puted in O(n2): Since JMLB2(J) = max1·k·m

½max

¸min·¸·¸maxMLBk2 (S¸)

¾; then the computation

of JMLB2(J) requires O(mn3) time.

The bounds JMLB3(J) = maxSµJ

MLB3(S) and JMLB4(J) = maxSµJ

MLB4(S) can be

computed approximately using the algorithm ASP. Their computation requires O(mn3 log n)and O(mn4 logU), respectively.

Let J¤ denote the subset of jobs such that LB2(J¤) = maxSµJ

LB2(S): In the sequel, we set:

JMLB2(J) = maxfJMLB2(J); JMLB2(J¤)g

JMLB3(J) = maxfJMLB3(J); JMLB3(J¤)gJMLB4(J) = maxfJMLB4(J); JMLB4(J¤)g

7 Computational experimentsIn order to assess the quality of the di¤erent lower bounds, we have generated 6 di¤erentrandom problem sets. The test problems have been designed with the aim of providing agood picture of the relative performance of the di¤erent lower bounds. The heads and tailsof all jobs are drawn from the discrete uniform distribution on [1,10]. Each problem setis characterized by a number ® 2 f0; 20; 40; 60; 80; 100g which speci…es that the processing

16

times of ®% of the jobs of each instance of the set are drawn from the discrete uniformdistribution on [90,100], and the processing times of the remaining jobs are drawn fromthe discrete uniform distribution on [1,5]. This type of processing times leads to di¤erentcombinations of long/short processing times, and heads and tails. Each problem set contains250 test problems corresponding to 10 instances for di¤erent combinations of n and m withn 2 f20; 40; 60; 80; 100g andm 2 f2; 3; 5; 7; 9g: Therefore, 1500 test problems were generated.All the computational experiments were carried out on a PentiumIII 733 MHz PersonalComputer with 64 MB RAM.

In Table 3, we report for each basic (i.e. non-lifted) lower bound the percentage of timesit yields the maximal value over all of the bounds discussed in this paper (Max), and theCPU time (in sec.) required for processing all of the 1500 instances (T ime). We observethat the highest percentages (60:13%) are obtained for PLB and JPPB: Besides, we foundthat these two bounds are equal in all the generated instances, which is consistent with thepreliminary results of Carlier and Pinson [5]. Obviously, the high percentages indicate thatthese bounds outperform the remaining ones. However, we observe that LB2; LB3;and LB4perform quite well but require much less CPU time.

LB0 LB1 LB2 LB3 PLB JPPB LB4Max 6.93 45.93 53.00 57.73 60.13 60.13 55.60Time 0.10 0.10 0.05 1.66 15.80 11.79 0.22

Table 3 - Performance of the basic bounds

In Tables 4-6, we report the performance results of the lifted lower bounds. We see fromTable 4 that the job subset lifting procedure improves the quality of all these bounds. Theimprovement is negligible for LB1 but more signi…cant for LB3 and LB4: Not surprisingly,these improvements caused a high increase of the CPU time. Table 5 shows that the machinesubset lifting procedure is more e¤ective, since the quality improvements are comparablebut the required CPU time is much less. Interestingly, we observe that this lifting proceduremade MLB2; MLB3, and MLB4 to outperform the best existing lower bound (JPPB).Indeed, MLB4 requires less than one second and yields for 63.53% of the instances the bestvalue, whereas JPPB requires 11.79 seconds and is the best one for 60.13% of the instances.Table 6, provides evidence that combining the two lifting procedures yields the most e¤ectivelower bounds. Hence, JMLB2 reached the maximal value over all the bounds for almost allinstances (95:66%), and even the lifted version of the (simple) lower bound LB1 yields theremarkable percentage of 82.86% and requires just 5.15 seconds. We observe that althoughLB3 and LB4 dominate LB2 and LB1; the lifted bounds JMLB2 and JMLB1 outperformJMLB3 and JMLB4: The (relatively) disappointing behavior of these two latter bounds

17

could be explained by the fact that the optimal subsets are computed using a simple greedyalgorithm.

JLB1 JLB3 JLB4Max 46.46 61.86 63.60Time 0.33 226.71 40.09

Table 4 - Performance of the job subset based bounds

MLB1 MLB2 MLB3 MLB4Max 52.13 61.00 65.73 63.53T ime 0.24 0.23 3.64 0.99

Table 5 - Performance of the machine subset based bounds

JMLB1 JMLB2 JMLB3 JMLB4Max 82.86 95.66 70.33 71.80T ime 5.15 266.68 471.97 141.72

Table 6 - Performance of the job-machine subset based bounds

A more accurate picture of the respective performance of the di¤erent lower bounds is pro-

vided in Tables 7-9, where the detailed results are reported with respect to ®; n; and m: Weobserve that our global analysis is generally consistent with the results displayed in thesetables. However, we can emphasize the following points:

² The bound LB4 is very competitive with the best existing (non-lifted) bounds for largenumber of jobs (n ¸ 60), small number of machines (m = 2; 3), and in the presence ofmore jobs with large processing times (® ¸ 40).

² The e¤ectiveness of the job subset lifting procedure decreases when there are more jobswith large processing times (® ¸ 60) and when the number of jobs increases (n ¸ 60).Though, this lifting procedure performs much better on instances with a large numberof machines (m ¸ 7):

² The machine subset lifting procedure is e¤ective when all the jobs have large processingtimes (® = 100). Moreover, we observe that large improvements are achieved forinstances with large number of machines.

18

² The relative e¤ectiveness of JMLB2 seems to be little sensitive to the variation of theparameters ®; n and m: On the contrary, we observe that the bounds JMLB3 andJMLB4 exhibit better performance for instances with homogeneous processing times(® = 0 or 100).

® = 0 ® = 20 ® = 40 ® = 60 ® = 80 ® = 100LB0 21.60 16.00 4.00 0.00 0.00 0.00LB1 61.20 43.60 41.60 45.60 42.00 41.60LB2 77.60 46.00 44.40 54.40 43.60 52.00LB3 87.60 54.80 48.40 56.40 46.80 52.40PLB 100.00 62.00 48.40 54.80 43.60 52.00JPPB 100.00 62.00 48.40 54.80 43.60 52.00LB4 77.60 51.60 49.20 56.00 46.80 52.40JLB1 63.60 43.60 42.00 46.00 42.00 41.60JLB3 100.00 64.80 50.80 56.40 46.80 52.40JLB4 100.00 69.60 56.00 56.80 46.80 52.40MLB1 61.20 43.60 41.60 45.60 42.00 78.80MLB2 77.60 46.00 44.40 54.40 43.60 100.00MLB3 87.60 54.80 48.40 56.80 46.80 100.00MLB4 77.60 51.60 49.20 56.00 46.80 100.00JMLB1 84.00 94.80 86.00 70.80 82.80 78.80JMLB2 100.00 86.00 88.00 100.00 100.00 100.00JMLB3 100.00 64.80 50.80 57.60 48.80 100.00JMLB4 100.00 69.60 56.00 57.20 48.00 100.00

Table 7 - Performance of the lower bounds with respect to ®

19

n = 20 n = 40 n = 60 n = 80 n = 100LB0 23.66 10.00 1.00 0.00 0.00LB1 15.66 29.00 50.33 60.66 74.00LB2 28.00 36.00 59.66 65.00 76.33LB3 46.33 37.33 61.00 67.33 76.66PLB 53.33 46.00 60.00 65.00 76.33JPPB 53.33 46.00 60.00 65.00 76.33LB4 32.66 38.66 62.66 67.33 76.66JLB1 17.33 30.00 50.33 60.66 74.00JLB3 57.33 47.00 61.00 67.33 76.66JLB4 61.00 49.66 63.33 67.33 76.66MLB1 21.00 36.66 56.33 66.00 80.66MLB2 38.00 46.00 66.33 71.66 83.00MLB3 56.66 47.33 67.66 74.00 83.00MLB4 42.66 48.66 69.33 74.00 83.00JMLB1 68.00 72.66 85.66 91.33 96.66JMLB2 98.66 95.66 93.00 93.66 97.33JMLB3 70.00 57.00 67.66 74.00 83.00JMLB4 72.33 59.66 70.00 74.00 83.00

Table 8 - Performance of the lower bounds with respect to n

20

m = 2 m = 3 m = 5 m = 7 m = 9LB0 0.00 0.33 6.66 10.00 17.66LB1 92.33 67.66 43.66 16.33 9.66LB2 99.00 75.00 52.66 20.00 18.33LB3 99.66 76.33 54.00 28.66 30.00PLB 100.00 76.00 59.33 30.00 35.33JPPB 100.00 76.00 59.33 30.00 35.33LB4 99.00 75.33 54.33 25.66 23.66JLB1 93.33 68.00 44.33 17.00 9.66JLB3 100.00 76.66 60.66 34.00 38.00JLB4 100.00 77.00 62.66 36.66 41.66MLB1 92.33 73.33 43.66 29.33 22.00MLB2 99.00 81.66 52.66 36.66 35.00MLB3 99.66 83.00 54.00 45.33 46.66MLB4 99.00 82.00 54.33 42.33 40.00JMLB1 93.33 89.33 81.66 81.33 68.66JMLB2 100.00 99.00 95.66 91.33 92.33JMLB3 100.00 83.33 60.66 51.33 56.33JMLB4 100.00 83.66 62.66 53.66 59.00

Table 9 - Performance of the lower bounds with respect to m

8 ConclusionIn this paper, we have investigated lower bounding strategies for the identical parallel ma-chine scheduling problem with heads and tails. Despite its theoretical importance, thisproblem has received scant attention in the scheduling literature. We surveyed the existinglower bounds and we introduced a new lower bound based on the bin packing problem.Also, we devised several lifting procedures which are based on considering subset of jobs,machines, or both. These lifting procedures could be systematically used to enhance thequality of lower bounds. The e¤ectiveness of the proposed bounds has been demonstratedby the results of the computational experiments which show that the lifting procedures con-sistently improve the existing bounds. In particular, new lower bounds based on subset ofjobs and machines were proven to outperform the best existing ones (PLB and JPPB).

An interesting issue that is worthy of future research is to embed the best newly derivedbounds in a branch and bound algorithm for the exact solution of large P=rj; qj=Cmax. Also,a second issue that deserves further investigation, is the generalization of the proposed lifting

21

procedures to other scheduling problems, such as the uniform parallel machine schedulingproblem with heads and tails.

References

[1] J.D. Blocher and S. Chand, Scheduling of parallel processors: A posteriori bound onLPT sequencing and a two-step algorithm, Naval Research Logistics 38 (1991) 273-287.

[2] J. Carlier, The one machine sequencing problem, European Journal of OperationalResearch 11 (1982) 42-47.

[3] J. Carlier, Scheduling jobs with release dates and tails on identical machines to minimizethe makespan, European Journal of Operational Research 29 (1987) 298-306.

[4] J. Carlier and B. Latapie, Une méthode arborescente pour résoudre les problèmes cu-mulatifs, RAIRO 25 (1991) 311-340.

[5] J. Carlier and E. Pinson, Jackson’s pseudo preemptive schedule for the Pm=rj; qj=Cmaxscheduling problem, Annals of Operations Research 83 (1998) 41-58.

[6] M. Dell’Amico and S. Martello, Optimal scheduling of tasks on identical parallel proces-sors, ORSA Journal on Computing 7 (1995) 191-200.

[7] M.R. Garey and D.S Johnson, Strong NP-completeness results : Motivation, examplesand implications, Journal of the Association of Computer Machinery 25 (1978) 499-508.

[8] A. Gharbi and M. Haouari, Minimizing Makespan on Parallel Machines Subject toRelease Dates and Delivery Times, to appear in Journal of Scheduling (2002).

[9] H. Hoogeveen, C. Hurkens, J.K. Lenstra, A. Vandevelde, Lower bounds for the multi-processor ‡ow shop, in: Second Workshop on Models and Algorithms for Planning andScheduling, Wernigerode, 1995.

[10] W.A. Horn, Some simple scheduling algorithms, Naval Research Logistics Quarterly 21(1974) 177-185.

[11] E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan and D. Shmoys, Sequencing andScheduling : Algorithms and Complexity, Handbooks in Operations Research and Man-agement Science 4 (1993) 445-522.

[12] S. Martello and P. Toth, Knapsack problems: Algorithms and computer implementa-tions, John Wiley & Sons, 1990.

[13] S.T. Webster, A general lower bound for the makespan problem, European Journal ofOperational Research 89 (1996) 516-524.

22