t of Stics, T
ne 5 Jd by M
We address a single-machine batch scheduling problem. The setup times (incurred whenever starting a new batch) are assumed
to be a function of the number of batches processed previously, i.e., batch-dependent. The objective is minimum total flow-time.We focus on the case of identical processing time jobs. Given the number of jobs and the setup times, we have to determine theoptimal number of batches and their (integer) size. An efficient (O(n)) solution procedure is introduced. 2005 Elsevier B.V. All rights reserved.
Keywords: Scheduling; Single machine; Flow-time; Setup times
This paper addresses a classical single machine batchscheduling problem. Jobs are assumed to have identi-cal processing times. The objective is minimum totalflow-time. Given the number of jobs and the setup times(incurred whenever starting a new batch), we have to de-termine the optimal number of batches, their size, andtheir schedule.
Santos and Magazine , Dobson et al. , Naddefand Santos , Coffman et al. , Shallcross , andMosheiov et al. , introduced different polynomial-time (in the number of jobs n) solutions for the problem(in particular for obtaining integer batch sizes). In thesestudies, all batch setup times are assumed to be identi-cal. In their recent survey Scheduling with batching:
* Corresponding author: Tel.: +972 2 588 3790, fax: +972 2 5881341.
E-mail address: email@example.com (G. Mosheiov).
A review, Potts and Kovalyov  mention several gen-eralizations of this basic case: They allow the setup to bemachine-dependent (in a multi-machine setting), and/orsequence-dependent. Indeed, in many real-life applica-tions, the setup may change. In particular, the setup maybe batch-dependent. Such applications include, e.g., thevery common case where the first setup time is largerthan the following ones because it contains several ini-tialization procedures required for the entire productionprocess. Some setups may be larger due to periodicmaintenance procedures. In some cases, the setup timesare arranged in non-increasing order to reflect a learn-ing effect. In other cases the setup times are arrangedin non-decreasing order to reflect deterioration of theprocessor.
In this paper we allow the setup time to be batch-dependent in order to reflect the above applications. Thesetup time prior to the processing of a given batch isa function of the number of batches processed previ-ously, i.e., the setup of the ith batch depends solely onInformation Processing Le
Single machine scheduling w
Gur Mosheiova School of Business Administration and Departmen
b Econometrics and Business Statis
Received 22 September 2004; rece
Abstract0020-0190/$ see front matter 2005 Elsevier B.V. All rights reserved.doi:10.1016/j.ipl.2005.12.0038 (2006) 7378www.elsevier.com/locate/ipl
batch-dependent setup times
Daniel Oron b
tatistics, The Hebrew University, Jerusalem, Israelhe University of Sydney, Australia
n revised form 13 September 2005anuary 2006
on Pr74 G. Mosheiov, D. Oron / Informati
its index i. The solution technique used here is quitesimilar to the one used in  for the case of constantsetup times. Note, however, that the problem studied in is simpler, and the optimal number of batches therecan be expressed in closed form, whereas in our (batchdependent setups) case, a closed-form expression doesnot seem to exist, and the optimal number of batchesis found by search. We show that this more general(and possibly more realistic) case remains polynomiallysolvable.
A set of n jobs has to be processed on a single ma-chine. All the jobs are available at time zero and pre-emption is not allowed. The processing times of thejobs are assumed to be identical and, without loss ofgenerality, we assume unit processing time jobs. Jobshave to be grouped in batches whose size is to be deter-mined. For a given schedule, let k denote the number ofbatches, and let ni denote the number of jobs assigned tobatch i, i = 1, . . . , k. (Clearly, n1 + n2 + + nk = n.)A positive setup time is incurred whenever a batch isformed. The setup time of the ith batch is denoted bysi , i = 1, . . . , k.
We assume batch availability (see Potts and Kova-lyov ), i.e., a job is completed and released only whenits batch is finished. Cj denotes the completion time ofjob j , j = 1, . . . , n (that is, the completion time of thebatch to which it is assigned). The objective assumed istotal flow-time minimization:
j=1Cj = (s1 + n1)n1 + (s1 + s2 + n1 + n2)n2
+ + (s1 + s2 + + sk + n1 + n2+ + nk)nk. (1)
Using the conventional notation, the problem studied inthis note is 1/pj = 1, si/Cj .3. Optimal integer batch sizes
Our goal is to find the number (k) and size (ni ) of thebatches, so as to minimize the total flow-time. It shouldbe emphasized that k denotes the number of batcheswith positive size, thus, k is a positive number (its small-est value is 1, reflecting the case that all n jobs createa single batch; clearly, the largest value k can assumeis n, which is the case where each job belongs to adifferent batch). The problem can be formulated as fol-
lows:ocessing Letters 98 (2006) 7378
(P) minf (2)
i=1ni = n, (3)
ni 0, i = 1, . . . , k, (4)ni integer, i = 1, . . . , k.
First, we ignore the integrality constraints, and focuson solving the relaxed problem. Note that the objec-tive function is quadratic and the constraints are lin-ear, implying that a local optimum is the global op-timum (see, e.g., Luenberger, ). Note that problem(P) contains a single equality constraint and n inequal-ity (non-negativity) constraints. We add n slack vari-ables in order to convert the inequality to equality con-straints. (Thus, each ni 0 is replaced by ni a2i = 0,i = 1, . . . , k.) The problem becomes:(P1) minf
i=1ni = n,
ni a2i = 0, i = 1, . . . , k. (5)The Lagrangian of this 2k variable problem is
L = f + (
By taking first derivatives we obtainL
n1= n + n1 + s1 + + 1 = 0,
n2= n + n2 + s1 + s2 + + 2 = 0,...
nk= n + nk +
si + + k = 0.
The general expression for the above partial derivativesis:
ni= n + ni +
st + + i = 0, (6)
i = 1, . . . , k,L
ni n = 0, (7)
i= ni a2i = 0, i = 1, . . . , k, (8)L
ai= 2iai = 0, i = 1, . . . , k. (9)
on PrG. Mosheiov, D. Oron / Informati
Since k is a positive number (i.e., n1, n2, . . . , nk > 0),we obtain from (8) that a1, a2, . . . , ak > 0, and from (9)that 1, 2, . . . , k = 0.
By substituting the latter (i = 0) in (6), we obtain:n2 = n1 s2, n3 = n2 s3, . . . , (10)ni+1 = ni si+1, . . . , nk = nk1 sk.Equivalently,
n2 = n1 s2,n3 = n1 s2 s3,
ni = n1 s2 s3 si , (11)...
nk = n1 s2 s3 sk.The total left-hand side of these k 1 equalities is equalto their total right-hand side:
n n1 = (k 1)n1 (k 1)s2 (k 2)s3 2sk1 sk,
n n1 = (k 1)n1 k
i=2(k i + 1)si .
It follows that
kn1 = n +k
i=2(k i + 1)si .
The size of the first batch is thus given by
n1 = nk
+ k + 1k
isi . (12)
From (12) and (10) we obtain the size of the k batches.Note that similar to the case of constant setup times (see,e.g., Santos and Magazine ), batch sizes are arrangedin decreasing order. In our case, however, the differencebetween sizes of consecutive batches is not constant.[Note that in the case of a constant setup time (i.e., si =s, i = 1, . . . , k), the size of the first batch is reduced to
n1 = nk
+ k + 1k
+ (k + 1)(k 1)k
s (k 1)(k + 2)2k
+ (k 1)(2k + 2 k 2)2k
+ k 12
s,ocessing Letters 98 (2006) 7378 75
which is the expression obtained by Santos and Mag-azine  and Naddef and Santos . Also, the size ofthe remaining batches is reduced from ni+1 = ni si+1(see (10)) to ni+1 = ni s, i = 1, . . . , k 1, as in thesepapers.
The size of the kth batch (the smallest one) is givenby
nk = nk
+ k + 1k
isi . (13)
Since k defines the number of batches with positive size,it follows that nk > 0 and that nk+1 0. This require-ment leads to the conditionk+1i=2
(i 1)si n >k
i=2(i 1)si (from (13)).
The optimal number of batches is thus, the k-value sat-isfying these inequalities. [Note again that in the caseof a constant setup time (si = s, i = 1, . . . , k), this in-equality is easily solved, and a closed form expressionis obtained for the optimal number of batches:
An equivalent expression (k = ( 14 + 2n/s)1/2 12)has been introduced in the literature, see, e.g., Naddefand Santos .] It is worth mentioning that the optimalnumber of batches k is independent of the first setup.The reason for this is that at least one batch must beformed, implying that at least the first setup must be per-formed.
We introduced an efficient solution for the relaxedproblem. In order to obtain the optimal solution for theoriginal problem, i.e., with integer batch sizes, we pro-vide below a rounding procedure, based on the optimalsolution for the relaxed problem. The rounding proce-dure is similar to the one introduced by Mosheiov etal.  for the special case of constant setups. However,the proof of optimality of the procedure for the moregeneral case of batch-dependent setups is different inseveral points. We, therefore, provide a complete proofof optimality in Appendix A.
As in Mosheiov et al. , we denote the non-integerpart of the batch size by
i = ni ni, i = 1,2, . . . , k. (14)(Note that if the s values are defined to be integers, theni(from (11)) i = for all i.)
on Pr76 G. Mosheiov, D. Oron / Informati
i=1i = a, (15)
where a is clearly an integer, strictly smaller than k(since the i values are strictly smaller than 1).
The following rounding algorithm (AlgorithmRounding) is based on these definitions:
Algorithm Rounding (Mosheiov et al. )
Input: k,n1, n2, . . . , nk, s1, s2, . . . , sk .Step 1: Calculate i, i = 1, . . . , k, and a by (14) and
(15), respectively.Step 2: Let A denote the set of a batches with the
largest i values. Round up all batches in set A.Round down all the remaining batches.
(The proof of optimality of Algorithm Rounding isgiven in Appendix A.)
Complexity. Solving the relaxed problem (i.e., findingthe optimal number of batches and their non-integersize) requires an effort of O(n) time. Algorithm Round-ing clearly requires an effort of O(n) as well. Hence,the total running time is O(n). [Note that the complex-ity of the special case of constant setups is known tobe solved in polynomial time in the logarithm of n (seeShallcross ). However, in this case the input containstwo numbers only (n and s), and, therefore, the totalcomplexity is not polynomial in the input. In the case ofbatch-dependent setups studied here, the input containsthe vector s1, s2, . . . , sn. Thus, our proposed solution ispolynomial in the size of the input.]
We demonstrate the solution procedure by solvingthe following numerical example: Assume that n = 100unit processing time jobs. The first setup time containsan initialization procedure and is therefore longer thanthe others: s1 = 5. The setup time of a batch with aneven index contains some maintenance procedure, thussi = 3, i = 2,4, . . . . The remaining setup times are of aregular size: si = 2, i = 3,5, . . . . The optimal number ofbatches is the largest k-value that satisfies the inequalityn >
ki=2(i 1)si . We obtain k = 9. Based on (12) and
(10) we find the optimal set of (non-integer) batch sizes:n1 = 21 13 , n2 = 18 13 , n3 = 16 13 , n4 = 13 13 , n5 = 11 13 ,n6 = 8 13 , n7 = 6 13 , n8 = 3 13 , n9 = 1 13 .
The associate flow-time value is 6890.We then perform Algorithm Rounding:i = 13 , i = 1, . . . ,9.ocessing Letters 98 (2006) 7378
(As mentioned earlier, when all the si values are inte-gers, all i values are identical.)
i=1i = 3.
Since a = 3 we have to round up the size of the threebatches with the largest i values, and round down thesize of the remaining six batches. In this case we maychoose to round up any three batches. An optimal inte-ger solution is:
n1 = 22, n2 = 19, n3 = 17, n4 = 13, n5 = 11,n6 = 8, n7 = 6, n8 = 3, n9 = 1.The optimal flow-time value is 6891.
Note that there are multiple optimal solutions forthe integer problem, since any three batches maybe rounded up, while rounding down the remainingbatches. In the general case, in which setup times arenot necessarily integers, there may exist a single opti-mal solution to the problem.
We introduced an O(n) solution to the single ma-chine batch scheduling problem with identical jobs andbatch-dependent setup times. Future research may focuson the extension of the problem to sequence-dependentsetups, i.e., when setup times are dependent on both theprevious and the current batch.
This paper was supported in part by the RecanatiFund of the School of Business Administration, the He-brew University, Jerusalem, Israel.
Appendix A. Proof of optimality of AlgorithmRounding
Recall (1) that
j=1Cj = (s1 + n1)n1 + (s1 + s2 + n1 + n2)n2
+ + (s1 + s2 + + sk + n1 + n2+ + nk)nk.
f can be expressed as
1 2 1k
2k if =2n +
ni +i=1 j=1
on PrG. Mosheiov, D. Oron / Informati
Letn = (n1, n2, . . . , nk,0,0, . . .): an (infinite) vector of
optimal non-integer batches, = (1,2, . . . ,k,0,0, . . .): an (infinite) vector of
the non-integer part of n (i = ni ni),q = (q1, q2, . . . , qm,0,0, . . .): an (infinite) vector of
optimal integer batches.Define = (1, 2, 3, . . .), such that q = n+
is the optimal integer solution. Note that
i=1 i =ki=1 i = a (in order to maintain a total of n jobs) and
i is integer for all i. Recall that a is an integer strictlysmaller than k. Let f = f (q)f (n) denote the differ-ence between the flow time of the integer solution andthat of the relaxed solution. Thus,
f (q) = f (n + )
= 12n2 + 1
(ni i + i)2
sj (ni i + i),
f = f (q) f (n) = f (n + ) f (n)
nii + 12k
= C +i=1
(ni i +
)i + 12
(A.1)where C is a constant (independent of ).
Our problem becomes
i = a,
i integer, i = 1,2, . . . .When substituting the value of ni (from (10)) in (A.1),we obtain:
f = C +i=1
bii + 12i=1
2i , (A.2)
where b = n + s for i = 1, . . . , k, and b =i 1 1 i iij=1 sj for i = k + 1, k + 2, . . . .ocessing Letters 98 (2006) 7378 77
In order to complete the proof, we introduce the fol-lowing four facts:
Fact 1. |bi bj | < 1 for any i, j k.
This is true since |bi bj | = |(n1 + s1 i) (n1 +s1 j)| = |i + j |.
Fact 2. bi < bj for any i k and j k + 1.
Recall that nk = n1 kj=2 sj is the size of thesmallest batch. The size of the next batch must be nega-tive:
nk+1 = n1 k+1j=2
sj = n1 + s1 k+1j=1
sj < 0.
Thus, n1 +s1 1 for some j . Since
i=1 i = a,then
k a, and, clearly, there exists some i (1i=1 i
i k), such that i = 0.
78 G. Mosheio...