9
Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors Author(s): Thomas Kämpke Source: Operations Research, Vol. 37, No. 1 (Jan. - Feb., 1989), pp. 126-133 Published by: INFORMS Stable URL: http://www.jstor.org/stable/171153 . Accessed: 08/05/2014 13:54 Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at . http://www.jstor.org/page/info/about/policies/terms.jsp . JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range of content in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new forms of scholarship. For more information about JSTOR, please contact [email protected]. . INFORMS is collaborating with JSTOR to digitize, preserve and extend access to Operations Research. http://www.jstor.org This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PM All use subject to JSTOR Terms and Conditions

Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Embed Size (px)

Citation preview

Page 1: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel ProcessorsAuthor(s): Thomas KämpkeSource: Operations Research, Vol. 37, No. 1 (Jan. - Feb., 1989), pp. 126-133Published by: INFORMSStable URL: http://www.jstor.org/stable/171153 .

Accessed: 08/05/2014 13:54

Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .http://www.jstor.org/page/info/about/policies/terms.jsp

.JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range ofcontent in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new formsof scholarship. For more information about JSTOR, please contact [email protected].

.

INFORMS is collaborating with JSTOR to digitize, preserve and extend access to Operations Research.

http://www.jstor.org

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 2: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

OPTIMAL SCHEDULING OF JOBS WITH EXPONENTIAL SERVICE TIMES ON IDENTICAL PARALLEL PROCESSORS

THOMAS KAMPKE FA W. Universitat Ulm, Ulm, West Germany

(Received March 1986; revisions received September 1986, March 1987; accepted August 1987)

The scheduling of jobs with stochastically independent, exponentially distributed service times on identical parallel processors is considered. General sufficient conditions for optimality in expectation of priority policies for certain cost functions are given, including cases of the weighted flow time. The priority policies under consideration may be more general than the longest expected processing time (LEPT) or the shortest expected processing time (SEPT) policy. We deal with a fixed number of processors as well as certain more general resource constraints. Finally, precedence relations between jobs given by strict interval orders are admitted and an optimality result for LEPT is stated for this situation.

M any planning situations, such as those consid- ered here, consist of allocating scarce re-

sources. Moreover, information about the planning problem may be incomplete. We will model such a scheduling situation giving special emphasis to the latter aspect by allowing processing times of problem tasks to vary stochastically. Though the problem may look difficult at the outset, some easy solutions are given.

A set, A = { 1, . . ., n }, of jobs is to be processed on identical parallel processors (also called machines). Each processor can work only on one job at any moment and any job can be worked on by just one machine at any moment. In the case of m machines, it is not possible to work on a set of m + 1 or more jobs simultaneously. Such a set of jobs will be called forbidden, and the forbidden sets will be denoted by X. Because each set that contains a forbidden set is itself forbidden, one may restrict the minimal forbid- den sets. In the m machine case, X = {B 5 A I I B I = m + 1 I (I I denotes the number of elements of a finite set). Set X will be the means to state resource con- straints that are assumed to be independent of time.

The precedence relation between jobs is given by a partial order 0 on A. Let sO = 0 - {(a, a) a E AI denote the strict order of 0, (a, A) E sO implies that job a has to be completed before job A can be started, and sO = 0 indicates the absence of precedence relations.

The service times Xi of jobs i- 1 ..., n are stochastically independent, exponentially distributed random variables. They may have different parame- ters Xi.

To describe which jobs are scheduled on machines at any moment in time, we use policies that respect all precedence relations and forbidden sets; jobs are not removed from machines until completion (the nonpreemptive case). Assignments of unscheduled jobs to free processors can be made at time t = 0 and at any further moment. To minimize costs (see below) in expectation, which is our objective, it is sufficient to restrict to policy making decisions only at time t =

0 and at the completion times of jobs. This has been shown by Mohring, Radermacher and Weiss (1985a) for cost functions even more general than those con- sidered here. Priority policies are of special interest: jobs are arranged in a linear order (by a priority rule). At any decision moment, as many unscheduled jobs as possible are assigned to machines in decreasing priority, respecting the precedence relations and the resource constraints. If the priority order remains fixed during processing, the policy is static; otherwise it is dynamic. We denote a static priority policy by 1 < 2 < ... < n, giving the highest priority to job 1 and the lowest priority to job n. Examples of static priority rules are the shortest expected processing time first (SEPT) and the longest expected processing time (LEPT), where shorter expected processing times cor- respond to higher priorities.

For the m machine case, Glazebrook (1979) has shown that SEPT minimizes expected flow time, which is the sum of all completion times. Bruno, Downey and Frederickson (1981) provide another proof of that result and also show that LEPT mini- mizes the expected makespan, which is the maximum of all completion times. Weiss and Pinedo (1980),

Subject classification: Production/scheduling: stochastic. Project management: resource constraints.

Operations Research 0030-364X/89/3701-0126 $01.25 Vol. 37, No. 1, January-February 1989 126 ? 1989 Operations Research Society of America

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 3: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Scheduling Jobs with Exponential Service Times / 127

whose approach we follow in this paper, extend these results to slightly more general regular measures and to processors of different speeds using preemptive versions of LEPT and SEPT. In Section 2, optimality results for static priority rules, different than and including LEPT and SEPT, will be presented for the case of identical processors. These results also hold in the case of processors with different speeds (Kampke 1987). However, in the present work, only identical processors will be considered for the following reasons: 1) It is much easier to derive an optimality criterion for static priority policies (Theorem 1). The introduc- tion of an unlimited number of additional decision points and asymptotic expansions are not required. 2) Verification of the optimality conditions (Theo- rem 2) is simplified; only a twofold, rather than a threefold, induction is required. Above all, in contrast to the case of different speeds, the results from Sec- tion 2 can be shown to carry over to models with more general resource constraints and precedence relations (Section 3). By giving a complete proof of Theorem 1, and by omitting the obvious steps in the proof of Theorem 2, this paper is essentially self- contained and comparatively easier to follow.

Results involving service time distributions other than the exponential are given by Weber (1979, 1982, 1986) and by Weber, Varaiya and Walrand (1986). Results involving precedence relations and resource constraints, other than those of Section 3, are given by Pinedo and Weiss (1984, 1985). These results are neither more nor less general than those in Section 3, and they hold only for the case of two machines.

1. Optimality Criterion for Static Priority Policies

The costs of a scheduling problem depend on the completion times ti of all the jobs, and they will be given by a regular measure (or Markovian cost func- tion), K. A regular measure is given by a (Markovian) cost rate g: P(A) -- [0, oo), where P(A) denotes the power set of A. We will assume throughout this paper that g(0) = 0. For increasingly ordered completion times, t,(l) - . ta(n), where a is some permutation of the jobs, the costs are given by

K(ti, . . . , tn) = g(A)ta(l) + g(A - {(l)D)(t,(2) - t,(l))

+ . . . + g(Ja(n)})(t(n) - t,(n-1)).

For any set U of uncompleted jobs, g(U) denotes the additional costs that are incurred in unit time. We will assume that g(U) > g(V), if U D V, which

implies

K(tl, tn) < K(tl', ***Xtn)

for ti ti= , ...,n

(see Mohring, Radermacher and Weiss 1 985a). Examples of regular measures are makespan K(tl, . . ., tn) = maxfti, . . ., tnJ (with g(U) = 1 if U $ 0), flow time

n

K(tl, X . . . tn) = E ti i= 1

(with g(U) = I U I), and weighted flow time n

K(tli . . . , tn = E witiI Wi > 0 i= 1

(with g(U) = - u wi, where Z0 is set to 0). In this section, we consider exponential scheduling

models without precedence relations and m > 2 iden- tical parallel processors (m > 2 avoids trivial compli- cations). Let G = Gil(U) and Gk = Gn (U - {kD), denote the expected cost of a scheduling problem when policy II is applied, and we consider the problem from the moment when the set of uncompleted jobs is U or U- {k}, k E U 5 A. Assume that jobs 1, .... r E U are started at some common time. Because Xi are exponential, min{X1, ..., X4 is exponentially distributed with parameter X = X1 + ... + Xr, and the probability that job i is the first to complete is P(min{X1, . .. , Xr = Xi) = Xi/X, i = 1, . . ., r. Hence, the memoryless property of the exponential distribu- tion leads to the recursive formula

r G(U) = g(U)/X + X i1/XG11(U - 18).

i=l1

Set I1, . . ., r} will be called the set of started jobs. Uncompleted jobs currently under operation will also be called started, because the memoryless property allows us to neglect processing times that uncompleted jobs have received so far.

The following theorem gives sufficient conditions for the optimality of a static priority policy. (Compare with the formulation of the optimality criterion of Weiss and Pinedo; and Bruno, Downey and Frederickson. The proof given here follows Bruno, Downey and Frederickson in parts.)

Theorem 1. A static priority policy II is optimal, iffor any UCA, U$0

keU G-Gk?O (1)

k, l E U with k < /

k(G - Gk) 2 (G - GO). (2)

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 4: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

128 / KAMPKE

Proof. We now allow preemptions at completion times, and we will show that II is optimal in the class of preemptive policies. Since II is nonpreemptive, the optimality of II in the class of nonpreemptive policies follows. The proof is by induction on I U 1, where U denotes an arbitrary set of uncompleted jobs. The idea behind the proof is to show that any policy r that allows preemption at job completion times does not become worse when it changes to II on the "tail" U of the problem. The tail can be enlarged to be the whole set, A (see the induction step), which would complete the proof. More formally, with Gr(A) de- noting the expected cost of the problem when r is applied, and with Gr/nN(A) denoting the expected cost when r is applied first, and II is applied whenever I U I < N, we will show Gr(A) : Gr/nN(A) for N = 2, 3, ..., n. From G11(A) = Gr1n,n(A), Theorem 1 follows.

I U I = 2. Since there are at least two processors, r will not become worse when an arbitrary priority policy is applied whenever I UI = 2. So, Gr(A) >

Grln,2(A). I U I N. From the induction hypothesis, we have

Gr(A) > Gr/nN-1I (A). Hence, it remains to show that Gr/riN- (A) > GrI11N(A). Since the policies r/il, N and P/Ri, N - 1 differ only when I U I = N, the last inequality is equivalent to G11, (U) > Gil(U), where II' is the policy that makes the same decisions as r/il, N - 1 when I U I = N, and which makes the same decisions as HI when I U I < N - 1. So

G = Gr(U) = g(U) + E -k Gk A kES A

and

g(U) Xi G, ( U) = U) + E k Gk

A' ce-S' A'

where S, and S' denote the set of jobs that are started by II and II', respectively when I U I = N, A =

EkES Xk, and A = EkeS' Xk. With C = S n S (C may be empty), we obtain

A'(G11'(U) - G11(U))

= A'G1i'(U) - AGn(U) + (A - A')G11(U)

= g(MU + Y, Xk Gk - g( U) keS'

- XkGk + ( Xk XkG keS keS keS /

= ~ Xk(G - GO) -E X k(G - Gk) kES keS'

- IAk(G-GGk)- Z Xk' (G-GGk'). (A) keS\C k' eS'\C

Remember that the jobs are numbered according to II (see the Introduction). Thus, for any job k' in S'\C there is a job k in S\C, with k' > k, where different jobs from S'\C correspond to different jobs in S\C. Note that IS'\CI < IS\CI and IS'\CI < IS\CI if and only if II' does not make use of all the processors when I Ul =N.

For corresponding jobs k and k; we have Xk(G - Gk) : Xk'(G - Gk') by (2), while for jobs in S\C with no corresponding job in S'\C, we have G - Gk > 0 for any of these jobs by (1). Hence, the difference in the sums in (A) is not negative, which completes the proof.

To simplify the notation, we use the following abbreviations.

g= g(U)

gk= g(U- {Ak) for k E U

gkl = g(U- {k, 1D

and

Gk= GH(U- {k, l}) fork, lE U

Gjk/ = Gn (U - {j, k, I)) for j, k, 1 E U.

Condition 1 of Theorem 1 will be shown to hold for an arbitrary priority policy (compare to Lemma 1 and its proof in Weiss and Pinedo 1980).

Lemma 1. For any static priority policy II and for all UCA, U$0,andkE U

G - Gk 3 0

holds.

Proof. By induction on I U 1:

I UI = 1. From Gk =0, G - Gk > 0 follows immedi- ately for I U I = 1.

I Ul N. We have

G = 1 + E ,1 Gi with A xi A iesA iES

Gk = -+ - Gki with Ak= Xi Ak iES' Ak iES'

where S and S' denote the corresponding starting set of jobs. Because II is a static priority policy, there are three cases: S' = S, S' = S - {k} or S' = S - {k} + {I with 1 4 S and I > k. Case S' = S occurs when I U I = m. (Instead of S - Ik} we will write S - k, etc.)

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 5: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Scheduling Jobs with Exponential Service Times / 129

From

Ask Nj -k Gk = -+E - Gk A A cs, A

we obtain

Gk + A Gk + Gk A A is

and hence,

G - Gk

g - gk

= + G. A iES-k A

1i Ak- A + k -

,gk + A

g -gk + Z xi (Gi -Gki) if S' =S A ies A

g -gk N1

g k+ l i(Gi-Gki) if S'=S-k A ies-kA g -gk N1

_ -k+ -(Gi-Gki) A iES-k A

+- (Gk-Gkl) if S' =S-k+1. A

In all cases, we have G - Gk 1 0 from g - gk 3 0 and the induction hypothesis. This completes the proof.

3. The Main Result

The main result that generalizes Theorem 3 of Weiss and Pinedo (1980) for identical processors and Theo- rem 1 of Bruno, Downey and Frederickson is as follows.

Theorem 2. Let II be a static priority policy. If the corresponding numbering of the jobs satisfies U S A, U$ 0for all k,le Uwithk<I

Nk(g - gk) > N1(g - gl) (3)

k, / e U with k < I

gk < g1 (4)

k, I E U

g gk -g + gkl > 0 (5)

then II is an optimal policy.

Proof. By Lemma 1, condition 1 of Theorem 1 is satisfied, and it remains to show condition 2. Also, the following condition will be considered for all U C A and k, / E U, where at least one of the jobs k and / belongs to the starting set

G-Gk-GI + Gkl >-O. (6)

Equations 2 and 6 are shown by a twofold induction on I U I (modifying a proof technique from Weiss and Pinedo), where the induction is nested as follows.

I. (2) and (6) hold for I U I = 2; without loss of generality (w.l.o.g.) U = 1, 2} will be considered.

II. If (2) and (6) hold for I U = N - 1, then (6) holds for I UI = N.

III. If (2) holds for I U I = N - 1 and (6) holds for I UI = N, then (2) holds for I UI =N.

1. (2) holds for I U I = 2

x1(G- G1)- X2(G- G2)

XI + X2 XI + X2

+ X G2j- XG1 +X2G2 X I+ X2

1 [(XI - X2)g + 2(X2g2 - X1g1)] > 0, XI + X2

since

(XI - X2)g + 2(X2g2 - X1g1)

= X1(g - g1) - X2(g - g2) + X2g2 - X1g1 > 0

in the case X2 > X1 because of (3) and (4). Also,

(X1 - X2)g + 2(X2g2 - X1g1)

= (XI-X2)(g-g1 -g2) + (X1 + X2)(g2-g1) ? O

in the case X2 < X1 because of (5) (note that g12 = 0)

and (4). Hence, we have shown (2) for I U I = 2.

1. (6) holds for I U I = 2

Noting that G12 = 2= 0 we obtain

G - G1 - G2

= I g X X I + X G1-G1 + X 2

- ~ + X2 [g gi - g2] > O by (5).

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 6: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

130 / KAMPKE

In II and III, we use the following expressions.

G = g + E A'j Gj A jes A

Gk = J Gkj Ak jES(k) Ak

G, = Jl+f -Gl A, jES(l) Al

Gk1 = " Gklj Ak, jeS(kl) Ak,

A= xiAj jES

Ak= E X jE S(k)

A 1 Y xi jES(l)

Ak1= E Aj. jES(kl)

S, S(k), S(l), and S(k, 1) S U denote the set of jobs started by II.

II. (6) holds for U =N

W.l.o.g. let k < 1. Then, there are 6 cases of the starting sets S(k), S(l) and S(k, 1).

1. kE S.l SwithS(k)=S-k+hS(l)=Sand S(k, 1) = S - k + h with h < 1.

2. kE S, l Swith S(k) = S-k + 1, S(l) = Sand S(k,/ ) = S- k. (Inthiscase, IUI = m + 1.)

3. k E S. I fl S with S(k) = S - k + 1, S(l) = S and S(k, 1) = S- k + h with h > 1.

4. k, I E S with S(k) = S - k, S(l) = S - I and S(k, 1) = S - k - 1. (In this case, I UI im.)

5. kl E S with S(k) = S-k + h, S(l) = S-I + h and S(k, 1) = S - k - I + h with h > 1. (In this case, I UI = m + 1.)

6. k, / E S with S(k) = S - k + h, S(l) = S - I + h and S(k, I) = S- k - I + h + iwith i> h > 1.

Since all cases are treated in the same way, detailed calculations will only be given for the first case.

Case 1. Noting that Al = A (since S(l) = S), we obtain

A(G- Gk- Gi+ Gk,)

= AG - AkGk - AG, + AklGkl

+ (Ak- A)Gk + (A - Akl)Gkl

= g + AjXGj-gk - E XjGJk jES jES-k+h

-gl- jGjl+ gkl + E XjGj jES jES-k+h

+ XhGk - XkGk + XkGkl - XhGkl

= g - k gl + gkl

+ Z Xj(Gj - Gjk- Gji + Gjkl) jES-k

+ Xh(Gk - Gkh - Gkl + Gkhl) : 0

since (5) and (6) for I U I = N - 1. (Note that either k or h belong to the corresponding set of started jobs in those situations where (6) is applied to I U I = N - 1.)

Case 2.

A(G - Gk- G, + Gk1)

= g k - gl + gkl

+ >a Xj(Gj - Gj, - Gjk+ Gjk,) jES-k

+ X, (Gk- Gk,) 2 0

since(5)and(6)for I UI =N- 1 and(l).

Case 3.

A(G - Gk- G, + Gk,)

= g gk - gl + gkl

+ Z Xj(Gj - Gji - Gjk+ Gjkl) jES-k

+ Xl(Gk - Gkl) - XA(Gk - Gkf)

+ Xf(Gk - Gkf - Gkl + Gkf) 2 0

since (5) and (6) for I U =N - 1 and (2) for UI =

N-1.

Case 4.

A(G - Gk- G, + Gk,)

= g gk - gl + gkl

+ E XGj(Gj - Gjk- Gji + Gjkl) 2 0 iES-k-1

since (5) and (6) for I Ul =N- 1.

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 7: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Schedulings Jobs with Exvonential Service Times / 131

Case 5.

A(G - Gk- G, + Gkl)

= g gk - gl + gkl

+ Z Xj(Gj - Gkj-Glj + Gklj) jES-k-1

+ Xk(GI - Gik - Gh + Glkk) + Xk(Gk- Gkk) 2 0

since (5) and (6) for I UI = N- 1 and(1).

Case 6.

A(G - Gk- G, + Gk1)

= g 1 - gk + gkl

+ Z Xj(Gj - Gjk- Gjl + Gjkl) jES-k-1

+ Xk(GI - Gik - Gh + Glkk)

+ Xk(Gk - Gkh - Gk, + Gklh )

+ Xk(Glk - Glkh) - XAz(Glk- Glki) a 0

since (5) and (6) for I UI = N- 1 and (2) for I UI =

N- 1.

Ill. (2) holds for I U I = N

There are 4 cases of starting sets S(k) and S(l)

1. k, 1 ( S with S(k) = S(I) = S. 2. k E S, 1 4 S with S(k) = S - k + h, where h / I

and S(l) = S. 3. k, I E S with S(k) = S - k + h and S(l) =

S - I + h, where h > 1. 4. k, I E S with S(k) = S - k and S(l) = S - 1. (In

this case, I UI = m.)

Case 1.

A[Xk(G - Gk) - X(G- G)]

= Xk(g - gk) - X(g 1g)

+ Z Xj[Xk(Gi - Gki) - X1(Gj- Gi)] 2 0 jES

by (3) and (2) for I UI = N - 1.

Case 2.

A[Xk(G - Gk) - X1(G - G)]

= XkAG - XkAkGk - XIAG

+ XIAG, + Xk(Ak - A)Gk

= Xk(g - gk) - X1(g - g1)

+ Z Xj[Xk(G1 - Gkj) - X,(Gj - Gjl)] jEiS-k

+ Xk[Xh(Gk- Gkh) - Xl(Gk- GkO)] 0 0

by (3) and (2) for I U =N - 1 (if h = I the last term becomes 0).

Case 3.

A,[Xk(G - Gk) - X(G- G)]

= XkAG-XkAkGk-XiAG + XA/G,

+ Xk(Ai - A)G + Xk(Ak-A,)Gk + X,(A - A,)G

= Xk(g-gk) - X1(g-g )

+ E Xi [Xk(GJ - Gki) - X(G -Gil) jES-k-l+h

+ (Xi - Xk)[X,(G - Gl)- Xh(G - Gh)].

The first two terms of the last equation are not negative by (3) and (2) for I UI = N - 1. In Case 2, X,(G - G,) - Xh(G - Gh) is not negative from (2) for I U I = N (which has been shown). So, in the case of X 2 Xk, the required inequality follows. In the case of Xk > Xi, we will show that

Xk(g - gk) - X1(g - g1) - (Xk - X,)

* [Xi(G - G) - Xh(G -G)] 0,

By (4) we have

Xk(g - gk) - X(g- g1) - (Xk - Xi)

* [X,(G-G1)- Xh(G-Gh)]

(Xk - X)[g - - (Xl(G - Gl) - Xh(G - Gh)].

It remains to show that

g - g- [X(G - G,) - Xh(G - Gh)] 3 0.

From the conditions of Case 3 we have

g = AG - XjGj = Z Xj(G - Gj) jEs jEs

= AiGi - jGj= j(Gi - Gj1). jES-l+h jES-I+h

Hence,

g - g- [X(G - G) - XA(G - Gh)]

j(G - Gj) - Z Xj(G,-Gj1) jES jES-l+h

- (G - GO) + Xh(G - Gh)

= E Xj(G - Gj - Gi + Gji) 2 0 jE-S-l+h

from (6) for I U N.

Case 4. This case is treated the same way as Case 3, which completes the proof.

A special case of Theorem 2 is presented next.

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 8: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

132 / KAMPKE

Theorem 3. Let H be a static priority policy for an exponential scheduling problem with K(tI, * *, tn) =

Z1-I witi. If the corresponding numbering of the jobs satisfies

XI WI > ** >1 Xn Wn (7a)

w I1' - ... W n (7b)

simultaneously, then HI is optimal.

Proof. For g(U) = XIEu wi conditions 3 and 4 are satisfied by conditions 7a and 7b, and condition 5 is satisfied because g is additive. Thus, Theorem 2 implies Theorem 3.

For an arbitrary X1, ..., Xn, given a fixed number- ing, the weights wi in the weighted flow time can be chosen in the following way: w, > 0 is arbitrary and wi-1 maxIw iX/Xi1} I = n, . . , 2. Thus, conditions (7a) and (7b) are satisfied and the given numbering of the jobs induces an optimal priority. So, we have the following corollary.

Corollary. For the weighted flow time criterion and for any of the n! static priority policies, there are weights wi for which the static priority under consid- eration is optimal.

So even LEPT may be optimal for the weighted flow time. Also, LEPT and SEPT may be considered as extreme cases of static priority policies which are optimal for exponential scheduling problems. All optimality results, stated in the framework of non- preemptive scheduling, also hold if job preemptions are permitted at the completion times; compare with the proof of Theorem 1.

3. Extensions

Resource constraints more general than the m ma- chine case, and finally, precedence relations given by strict interval orders for the m machine case will now be considered. The results extend Theorems 2 and 3. No proofs will be given because they are basically those of Theorems 2 and 3, but technically are a lot more complicated. The results typically involve some kind of agreeability of the cost function with the resource constraints and the precedence relations.

For the m machine case, single jobs typically com- pete for machines. Instead of this, we now admit certain allowed sets of jobs to compete for the re- sources. A set of jobs is allowed, if all the jobs of the set may be processed simultaneously. Clearly, a subset of an allowed set is also allowed. We now state the next theorem.

Theorem 4. Let sO = 0 and let there be a numbering 1, ..., n of the jobs that satisfies (3)-(5). Let there also be a partition of A into r > 3 sets with J1 = {1, . . . , il - 1}J I2 = {il. . . .,- i2 - I1, * X X , Ir-1

{ir-2 . , ir-I - 1} and Ir =I ir x . ... , n}, so that for any set U of uncompleted jobs it is allowed to process simultaneously at most r - 1 sets M C U. where each M satisfies either M C I n U, where I = Ii with i < r or M = {s}, where s E Ir n U. Then the static priority 1 < 2 < ... < n induces an optimal policy.

The intuitive interpretation of the resource con- straints is that there are r - 1 slots for which the sets Ii, . . ., Ir-I and the single jobs in Ir are competing. For the special choice of r = m + 1 and I, = {}, 1I2 =

12},.. .. Ir-i = im} and Ir = Im + I, ..., n}, Theorem 4 becomes Theorem 2. Condition r 3 3 guarantees the absence of trivial tradeoffs.

Obviously, weighted flow time is a feasible cost function in Theorem 4 with conditions 3-5 reducing to (7a) and (7b). Furthermore, Theorem 4 remains true for LEPT if the cost function is specified to be the makespan. This holds despite the violation of condi- tion 5 by the makespan and the result is similar- though neither more nor less general-to a result for the two machine case of Pinedo and Weiss (1984).

Now,letsO=0andX= {BCAI IBI = m+ 1}. Without further restrictions to the precedence rela- tions, generally, an optimal policy is not induced by a static priority rule although it would be if the problem were changed to sO = 0. Strict interval orders, how- ever, contain enough agreeability between the ability of a job to start early and its effect to set free other jobs (by its completion) so that a static priority may be optimal.

A partial order on set A is called a strict interval order if, for every a E A, there is an interval [Sa, ta] C RO of unit length so that (a, fi) E 0 if and only if ta < sp; see Golumbic (1980) or Fishburn (1985). Orders 0 with sO = 0 as well as the order in the example below are strict interval orders. They may be characterized by the existence of a numbering of the elements with i < j implying S(i) O S(j) and P(i) C P(j), where S(k) and P(k), respectively denote the set of successors or predecessors of element k in order 0 (see Mohring, Radermacher and Weiss 1985b). This leads to the last theorem.

Theorem 5. Let the jobs be numbered according to LEPT (i.e., X1 < . .. .< XAn), and let conditions 3-5 be satisfied. Let there also be a precedence relation be- tween the jobs given by a strict interval order so that

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions

Page 9: Optimal Scheduling of Jobs with Exponential Service Times on Identical Parallel Processors

Scheduling Jobs with Exponential Service Times / 133

P(1) 5 ... 5 P(n) and S(1) D ... . S(n). Then LEPT induces an optimal policy.

Similar to the case of generalized resource con- straints, weighted flow time is a feasible cost function in Theorem 5, and the theorem remains true even if the cost function is taken to be the makespan. In Theorem 5, LEPT appears in connection with weighted flow time. An example shows that a corre- sponding result for SEPT and (ordinary) flow time does not hold.

Example. Given an exponential scheduling problem with A = 11, . . ., 5}, two machines, K(tI, . * *, t5) =

tI + . . + t5, XA = X2 = 2, X3 = X4 = X5 = and sO =

1(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)}, 0 is a strict interval order. SEPT leads to an expected flow time of 255/36, but 3 < 1 < 2 < 4 < 5 (clearly not, SEPT) leads to an expected flow time of 254/36.

Acknowledgment

I would like to thank R. Mohring (Berlin) and F. J. Radermacher (Ulm) for some hints and discussions on the subject as well as the two referees for some helpful hints. This paper includes results from the author's dissertation at the Technical University of Aachen, West Germany.

References

BRUNO, J., P. DOWNEY AND G. N. FREDERICKSON. 1981. Sequencing Tasks with Exponential Service Times to Minimize the Expected Flow Time or Makespan. J. Assoc. Comp. Mach. 28, 100-113.

FISHBURN, P. C. 1985. Interval Orders and Interval Graphs. John Wiley & Sons, New York.

GLAZEBROOK, K. D. 1979. Scheduling Tasks with Expo- nential Service Times on Parallel Processors, J. Appl. Prob. 16, 685-689.

GOLUMBIC, M. C. 1980. Algorithmic Graph Theory and Perfect Graphs. Academic Press, New York.

KAMPKE, T. 1987. On the Optimality of Static Priority Policies in Stochastic Scheduling on Parallel Ma- chines. J. Apple. Prob. 24, 430-448.

MOHRING, R. H., F. J. RADERMACHER AND G. WEISS. 1985a. Stochastic Scheduling Problems II: Set Strat- egies. Z. Opns. Res. Ser. A, 29, 65-104.

MOHRING, R. H., F. J. RADERMACHER AND G. WEISS. 1985b. Stochastic Scheduling Problems III (in prep- aration).

PINEDO, M., AND G. WEISS. 1984. Scheduling Jobs with Exponentially Distributed Processing Times on Two Machines with Resource Constraints, Mgmt. Sci. 30, 883-889.

PINEDO, M., AND G. WEISS. 1985. Scheduling Jobs with Exponentially Distributed Processing Times and Intree Precedence Constraints on Two Parallel Machines, Opns. Res. 33, 1381-1388.

WEBER, R. R. 1979. Optimal Organization of Multi- server Systems. Ph.D. thesis, University of Cam- bridge.

WEBER, R. R. 1982. Scheduling Jobs with Stochastic Processing Requirements on Parallel Machines to Minimize Makespan or Flowtime. J. Appi. Prob. 19, 167-182.

WEBER, R. R. 1986. Stochastic Scheduling on Parallel Processors and Minimization of Concave Functions of Completion Times (preprint).

WEBER, R. R., P. VARAIYA AND J. WALRAND. 1986. Scheduling Jobs with Stochastically Ordered Pro- cessing Times on Parallel Machines to Minimize Expected Flowtime, J. Apple. Prob. 23, 841-847.

WEISS, G., AND M. PINEDO. 1980. Scheduling Tasks with Exponential Service Times on Non-identical Proces- sors to Minimize Various Cost Functions. J. Appl. Prob. 17, 187-202.

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 13:54:35 PMAll use subject to JSTOR Terms and Conditions