Single machine scheduling with controllable processing times: a parametric study

International Journal of Production Economics, 22 ( 1991 ) 105-110 105 Elsevier

Single machine scheduling with controllable processing times: a parametric study

In-Soo Lee Management Science, Korea Advanced lnstitute of Science and Technology, 373-1, Kusung-dong, Yusung-gu, Taejon, 305- 701, Korea

(Received June 18, 1990; accepted in revised form June 10, 1991 )

Abstract

Most scheduling research has treated individual job processing times as fixed parameters. In many practical situations, however, jobs can be compressed at extra cost through the allocation of a limited resource. This paper considers the problem of minimizing the total job processing cost plus the average flow cost. The tolerance ranges of job processing times are determined so that the optimal sequence remains unchanged. An application of such sequence-independent tolerance ranges is presented to demonstrate their potential usefulness in practice.

1. Introduction

Most scheduling research has treated individual job processing times as fixed parameters. In many practical situations, however, jobs can be compressed at extra cost through the allocation of a limited resource such as overtime shifts. Al- though t ime/cost tradeoffs have been studied thoroughly in the project management context [ 1,2 ], similar concepts are still wide open to ex- ploitation in the "sequencing" portion of the scheduling research.

Vickson [3 ] has analyzed the problem of job sequence and processing time selection when the scheduling criterion of interest is the total job processing cost plus a weighted total flow cost. His argument leads us to conjecture that the pro- posed problem is NP-complete, but its actual computational complexity is yet to be determined [ 4]. A potentially explosive enumerative solution scheme has been presented along with extensive computational experiments. In a sub- sequent paper [ 5 ], Vickson has demonstrated that the case of equal unit flow cost can be for- mulated as an assignment problem which is eas- ily solvable. The same paper also has analyzed the problem of minimizing the total job process-

ing cost plus the maximum tardiness cost. Van Wassenhove and Baker [6] have con-

structed all efficient sequences for the bicriterion of maximum tardiness and job processing costs. Most recently, Daniels and Sarin [ 7] have pro- vided theoretical results that aid in developing the tradeoff curve between the number of tardy jobs and the total amount of resource allocated to reduce job processing times. For related bicriterion work, see Van Wassenhove and Gelders [ 8 ] and Nelson et al. [ 9 ].

This paper considers the same problem of minimizing the total job processing cost plus the average flow cost as in Vickson [ 5]. It has been shown that each job is either processed normally or maximally compressed in the optimal schedule. Since the existence of imperfect and/or manageable data prevails in reality, it would be nice if we have some flexibility or tolerance in the optimal processing time of a job while maintaining the current optimal sequence. Prior knowledge of such sequence-independent tolerance ranges would be informative for circumstances in which any modification of the sequence is expensive.

As an application of the tolerance ranges, we may conceive a scenario in which an uncertain

0925-5273/91/$03.50 © 1991 Elsevier Science Publishers B.V. All rights reserved.

106

amount of overtime is available; the overtime crew is multi-skilled but the crashing rates may differ among jobs. An interesting question then would be how much fluctuation in the overtime requirement may be absorbed by adjusting the processing time of a crashed job while maintaining the current optimal sequence. Since the limit of a resource is manageable as well as uncertain in general, such information on the overtime requirement would be helpful in practice.

In Section 2, the scheduling problem is for- mulated as an assignment problem [ 4 ] under the following assumptions: ( 1 ) the scheduling criterion of interest is the total job processing cost plus the average flow cost, (2) job processing costs are decreasing linear functions of processing times, (3) all jobs are simultaneously ready at time zero, (4) no precedence constraints are in force, and (5) only one job at a time can be processed (no preemptive priorities). Section 3 determines the tolerance ranges of processing times based on the final reduced cost matrix of (Kuhn's) Hungar- ian algorithm. An illustrative example is pro- vided. Section 4 presents an application of the tolerance ranges in which an uncertain amount of multi-skilled overtime is available. Finally, in Section 5, we discuss the possible contribution of this study.

2. Problem formulation

Let J={1,2 ..... N} denote the set of jobs to be scheduled on a single machine. For each jeJ, Pj denotes the normal and pj the minimum possible processing time, while mj=Pj-p&O and xj ( 0 ~< xj ~< mj ) denote the maximum and actual job compression, respectively. The job compression costs are assumed to be linear functions c~xj, where cj>O VjeJ.

For any sequence, or permutation of J, [j] e J denotes the jth job in the sequence [4,5 ]. Since all jobs are assumed to be simultaneously ready at time zero, the flow time of job [j] is its completion time Ctn = Y.~= ~ (Ptq -x[~] ), and the average flow time is the average completion time C = N - 1 E N j=lC[s ]. The total schedule cost is Z = wC+ E~v= i c H x[/l, where w> 0 is the cost per unit of average flow time. Without loss of gener- ality, cost units are chosen such that w=N. Then

N j N

Z= E E (&i]--Xti]) + E CvjXtj 1 j = l i = 1 j = l

N

= ~ { ( N - j + 1)PLi I + [eL/1- (N--j+ 1)]xul } j = l

(1)

The x values which minimize Z in ( 1 ) are

{ m b I ifctj I < ~ N - j + I xH = 0 ifctn > N - j + I (2)

Job [j] is said to be crashed i fxu] = m H and to be uncrashedifxt/] =0. Since the optimal choice of xt/] depends only on which job is placed in position j, the scheduling problem can be for- mulated as an assignment problem, with cost k o for assigning job i to location j given by

k o =P~(N-j+ 1 ) + min{0,mi [ G - ( N - j + 1 ) ]}

o r

mici+ ( N - j + 1)Pi ifj<~jo(i) k°= ( N - j + l)Pi ifj>jo(i) (3)

where

jo(i) = N + 1 -ci (4)

We callj0(i) the critical position of job i. In this way, an optimal choice of job sequence and processing times is obtainable using readily available assignment algorithms such as (Kuhn's Hungarian algorithm [ 10 ].

3. Determination of tolerance ranges

According to eqn. (2), each job is either processed normally or compressed maximally in the optimal schedule. We shall determine the sequence-independent tolerance ranges for individual job processing times.

Suppose that we have solved, via (Kuhn's) Hungarian algorithm, the assignment problem with the cost matrix II kejll as defined in eqn. (3). Let II/co II denote the final reduced cost matrix and j*(i) the optimal position of job i. Further suppose that there is some change 6 in the normal or minimum processing time of job s so that

k,j--, ksj +A~j

for j = 1 ..... n. The following lemma provides a

necessary and sufficient condition for the tolerance of the change &

Lemma 1. K s<.K ° if and only if the current assignment (sequence) remains optimal, where

Ks= max {A~,j.(~)-/~,j-Asj} j~sj*(s)

and

K ° = m i n {/~id*(s)} i ¢ s

Proof. Proof is due to Karush-Kuhn-Tucker conditions for equality constraints [ l 0 ]. In case of Ks~0, Asd.(s) is the minimum among per- turbed elements in row s and thus subtracting Asj.(s) from each element in row s recovers dual feasibility and complementary slackness. In case of Ks> 0, Asj.(s) -Ks is the minimum among per- turbed elements in row s. Thus subtracting A~j.(s) - K , from each element in row s and the Ks from each element in column j*(s) recovers dual feasibility and complementary slackness. []

In the sequel, the necessary and sufficient condition Ks <~ K ° is called the O-tolerance condition, while the sequence-independent tolerance range of 0 is called the O-tolerance range.

3.1 Normal processing times

If we let 5 denote the change in Ps (i.e. P,~Ps+O), then it follows from eqn. (3) that

Asj= j" c,O ifj<~jo(s) (5) ( ( N - j + 1)O ifj>jo(s)

By assumption, P~ + O >i Ps or 5 > / - ms. Two cases, uncrashed and crashed, of job s are considered.

Uncrashed or j* ( s ) >jo (s). The 0-tolerance condition then becomes

{N-j*'(s) + 1 }0- A,j ~<K°+/~sj

for j = 1 ..... N, which are divided into

{jo(s)

for j <<.jo( s ) and

{j--j*(s) }O~ K° +fc~

for j >Jo (s). Hence the O-tolerance range is given by

107

max{-ms,KI,K2} <~ O<~ K3 (6)

where

K t = m a x ~ K°--+/~ j~jo(.) ( j o ( s ) - - j * ( s ) J

K 2= max ~" K ° + / ~ jo(s)

K 3-- min ~" K ° + / ~ j>j*(s) ( j - j * ( s ) J

For convenience, we set m a x { . } = - ~ and rain{.} = ~ if their arguments are empty.

Crashed or j* (s) <<.Jo (s). The 0-tolerance condition now becomes

G O - ( N - j + I )O<,,K°+k~

forj>jo(s) so that the 6-tolerance range is given by

- m s <.O<..K 4 (7)

where

g 4~-~ min ~ K ° + / ~ ~ j>jo(s) (j--jo(S)J

3.2 Minimum processing times

If we let 0 denote the change in Ps (i.e. p:-,ps+O), then it follows from eqn. (3) that

Asj= {; jo(s)- j}O ifj<~jo(s) if j>jo(s) (8)

By assumption, 0 < Ps + 0 ~< 1°, or -p~ ~< 0 < ms. The 0-tolerance ranges of minimum processing times are developed in parallel with those of normal processing times.

Uncrashed orj * (s) >Jo (s). The 6-tolerance range is given by

max{ - p , , K 5 } ~< 0..< m, ( 9 )

where

K 5--- max ~ K ° + / ~ j<jo(s) (j--jo(S)J

Crashed orj*(s) <~jo(s). The 0-tolerance range is given by

108

TABLE 1

i K ° K l K 2 K 3 K 4 K 5 K 6 g 7 K s 0-tolerance ranges

Pi Pi

1 1 - - o o

2 0 3 0 4 0 - 2

- 1 1

re(X) (30

0 Oo

- - 0 0

- 2

- I ~ 0 ~ I - 3 ~ 0 ~ 1 - ~ 1 0 - 2 ~ 0 ~ 0 - 3 ~ f i ~ 0 - 1 0 ~ - l ~ O < ~ - l ~ f i ~ 0

- 2 ~ f i < m - 2 ~ f i ~ 2

max{ - P s , K6} ~< c~< min{ ms,K7,K 8 )

where

K6= max ~ K°+/~ ~ j<j*(s) ( j - - j * ( s ) )

K 7 - = min ~ K° + / ~ j*(~) < j< jo ( s ) ( j - j* ( s ) )

K s - min ~ g°+/~sJ j>jo(s) ( j o ( S ) - - j * ( s ) )

(10)

3.3 An example

We consider the four-job example with the following data [ 5 ]:

i Pi Pi ci

1 4 3 5 2 5 3 3 3 6 5 1 4 7 5 2

The critical positions in eqn. (4) are jo( i )=0,2 ,4 ,3 for i= 1,2,3,4, respectively. The assignment cost matrix Ilkijll and the associated reduced cost matrix II~,j II for this example are

I 1 6 1 2 8 4 1 1 8 1 5 1 0 5 Ilk;ill= 2 1 1 6 1 1 6

2 4 1 9 1 4 7 [!00] 1 0 0 II~ II

"~'J"= 1 0 0 3 2 0

From the reduced cost matrix, the optimal as-

signment is found to be [ 1 ] = 2, [ 2 ] = 1, [ 3 ] = 3, [4] =4. Note that jobs 2 and 3 are crashed, while

jobs 1 and 4 are uncrashed. Various quantities in eqns. 6, 7, 9, 10 are computed to obtain the ~-tolerance ranges of processing times. The re- suits are summarized in Table 1. Notice that the optimal processing time of job 1 (uncrashed) can be anywhere between 3 and 5, while the optimal processing time of job 3 (crashed) can be de- creased by up to 1 time unit but cannot be increased.

4. An application of tolerance ranges

As an application of the tolerance ranges, we consider a scenario in which an uncertain amount of overtime is available; the overtime crew is multi-skilled but the speed-up or crashing rates may differ among jobs. The question is how much fluctuation in the overtime requirement may be absorbed by adjusting the processing time of a crashed job while maintaining the current optimal sequence.

Let K denote the hourly overtime cost and r;, the crashing rate of job i. Then the hourly crashing cost of job i may be expressed in terms of c i = g / r i. The total crashing cost R* of an optimal solution which also becomes the overtime requirement, can be computed as

u ~ X* R*=F,_ c;x*=K - - (11)

i = 1 ri

where x* is the optimal job compression of job i, i= 1,...,N. Note that R * / K represents the over- t ime requirement in hours.

We suppose that R * - , R * + A where A denotes the fluctuation amount to be absorbed without changing the current optimal sequence. There may not exist any crashed job in the solution

( R * = 0 ) . In this case, there is no reason to consider any fluctuation in the requirement, either. Hence we assume that there exists at least one crashed job in the solution (R*> 0).

Suppose job s is crashed in the optimal solution; that is , j*(s) <~jo(s). According to eqn. ( 1 ), the 6-tolerance range ofps is given in the form of

6_s<~6<~ (12)

where 6s-~<0 and 6~ >/0, since 6 = 0 always lies within the range. Let us define

Amax- max c~(--_6~) s, crashed

LJmi,------ rain c~(--6s) (13) s.crashed

An intuitive interpretation of these quantities is as follows. LJmax indicates the maximum amount of overtime that may be added for decreasing further the processing time of a crashed job in the solution, while the negative of Amin indicates the maximum amount of overtime that may be saved by increasing the processing time of a crashed job in the solution. Hence the fluctuation amount A, as long as ZJmi n ~</i ~< Zlmax, may be absorbed by adjusting the processing time of a crashed job within its tolerance range.

It is a simple matter to select a job for the adjustment. Specifically, given A, the selection of a crashed job (s) and its adjustment (6) is made from the following set:

s - { (s,6) I s, crashed; 6_s<~6<~6s, Cs(-6) =A} (14)

The set S is non-empty if Amin ~< 3 ~< Amax. Since the change in the optimal schedule cost associated with each (s,6) ~ S is {Jo (s) - j * (s) }6 by eqn. ( 8 ), the minimal cost change and its correspond- ing element in S can be found by a simple enumeration.

5. Conclusion

This paper presented a parametric study of the problem of minimizing the total job processing cost plus the average flow cost. Although the study is limited to the equal weights case, it would be appropriate for circumstances in which rapid turnaround is required and the objective is to keep low in-process inventory. The sequence-in-

109

dependent tolerance ranges of job processing times were developed based on (Kuhn's) Hun- garian algorithm. As an application of these tolerance ranges, we conceived a scenario in which an uncertain amount of overtime is available; the overtime crew is multi-skilled but the crashing rates may differ among jobs. And we exactly cal- culated the fluctuation range of the overtime requirement that may be absorbed by adjusting the processing time of a crashed job while maintaining the current optimal sequence. Since the limit of a resource is manageable as well as uncertain in general, such information on the overtime requirement would be helpful in practice. This is particularly true if any modification of the sequence is expensive. We hope that more appli- cations of the tolerance ranges would be found in manufacturing systems where the job sequence has to be freezed for a fixed time period.

Acknowledgment

The author is grateful to a referee for suggest- ing an application of the tolerance ranges in Sec- tion 4. Other comments from the referees are also appreciated.

References

1 Elmaghraby, S.E. and Pulat, P.S., 1979. Optimal project compression with due-dated events. Naval Res. Logist. Quart., 26:331-348.

2 Deckro, R.F. and Hebert, J.E., 1990. A multiple objective programming framework for tradeoffs in project scheduling. Eng. Costs Prod. Econ., 18 ( 3 ): 255-264.

3 Vickson, R.G., 1980. Choosing the job sequence and processing times to minimize total processing plus flow cost on a single machine. Oper. Res., 28(5): 1155-1167.

4 Lenstra, J.K., Rinnooy Kan, A.H.G. and Brucker, P., 1977. Complexity of machine scheduling problems. Ann. Discrete Math., 1 : 343-362.

5 Vickson, R.G., 1980. Two single-machine sequencing problems involving controllable job processing times. AIIE Trans., 12(3): 258-262.

6 Van Wassenhove, L.N. and Baker, K.R., 1982. A bicriterion approach to time/cost tradeoffs in sequencing. European J. Oper. Res., 11 ( 1 ): 48-54.

7 Daniels, R.L. and Sarin, S.K., 1989. Single machine scheduling with controllable processing times and number of jobs tardy. Oper. Res., 37 ( 6 ): 981-984.

8 Van Wassenhove, L.N. and Gelders, L.F., 1980. Solving a bicriterion scheduling problem. European J. Oper. Res., 4( 1 ): 42-48.

110

Nelson, R.T., Sarin, R.K. and Daniels, R.L., 1986. Scheduling with multiple performance measures: the one- dimension case. Manage. Sci., 32(4): 464-479.

10 Bazaraa, M.S., Jarvis, J.J. and Sherali, H.D., 1990. Lin- ear Programming and Network Flows. Wiley, New York, pp. 49-508.

Documents

Single machine scheduling with controllable processing times: a parametric study