An improved on-line algorithm for scheduling on two unrestrictive parallel batch processing machines
Q.Q. Nong1, T.C.E. Cheng2, C.T. Ng2∗
1Department of Mathematics, Ocean University of China, Qingdao, Shandong 266071, People’s Republic of China
2Department of Logistics, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kong, People’s Republic of China
Abstract. We consider the problem of on-line scheduling a set of n jobs on two parallel batch processing machines. Each machine can handle an infinite number of jobs as a batch simultaneously. The processing time of a batch is the time required for processing the longest job in the batch. Each job becomes available at its release date, which is not known in advance, and its processing time only becomes known at its arrival. We deal with the problem of minimizing the makespan. We provide an algorithm for the problem that is better than one given in the literature, improving the competitive ratio from 32 to√
2.
Keywords: on-line scheduling; parallel machines; batch; worst-case analysis; competitive ratio
1 Introduction
We consider the problem of on-line scheduling on two parallel batch processing machines. A parallel batch processing machine is modeled as a system that can handle up to b jobs simul- taneously as a batch. The processing time of a batch is the time required for processing the longest job in the batch, and all the jobs in a batch start and complete at the same time. We are given a set of n independent jobs. Each job Jj (1 ≤ j ≤ n) becomes available at its release date rj, which is not known in advance, and its processing time pj only becomes known at its arrival. The problem involves assigning all the jobs to batches and machines and determining the starting times of the resulting batches in such a way that the makespan, i.e., max
1≤j≤nCj, is min- imized, where Cj is the completion of job Jj. According to the scheduling notation introduced by Graham et al. [4], this model is expressed as
P 2|b = ∞, rj, on-line|Cmax.
Scheduling of batch processing machines has been extensively studied in the last decade [1, 2, 3, 6, 7, 9, 10, 11, 12]. According to the limit on the size of each batch, there are two distinct models. One is the restrictive model in which the bound b on each batch size is effective, i.e., b < n. Problems of this model is motivated by the burn-in operations in semiconductor manufacturing, in which a batch of integrated circuits are placed in an oven and then exposed to a high temperature. Each circuit has a prespecified minimum burn-in time and the burn-in
∗Corresponding author. E-mail address:[email protected] (Daniel Ng).
This is the Pre-Published Version.
oven has a limited capacity. The other is the unrestrictive model in which there is effectively no limit on the sizes of batches, i.e., b = ∞. Scheduling problems of this model arise in situations where compositions need to be hardened in kilns and the kiln is sufficiently large that it does not restrict batch sizes. According to the characteristics of the information known before scheduling, scheduling research can be divided into two categories. The first category is off-line, in which there is a basic assumption that the scheduler has full information on the problem instance, such as the total number of jobs to be scheduled, their release dates and their processing times, before solution algorithms are applied. The second category is on-line, in which, contrary to the off-line case, at any point in time, the scheduler only knows the jobs that have already arrived and has no information at all on whether any more jobs will come. In this situation, the scheduler has to schedule jobs irrevocably.
For many on-line scheduling problems, because of a lack of information, it is normally not possible to have on-line algorithms that guarantee to deliver optimal solutions. Researchers therefore turn to studying approximation on-line algorithms for this kind of problems. The quality of an on-line algorithm is typically assessed by its competitive ratio: the nearer the ratio is to 1, the better the algorithm is. We say that an algorithm has a competitive ratio ρ (or is a ρ-competitive algorithm) if for any input instance, it always returns a feasible solution with an objective value not greater than ρ times of the optimal (off-line) solution.
Let us survey the previous related results. Lee and Uzsoy [5] provided a number of heuristics for the off-line scheduling problem 1|rj, b < n|Cmax. Liu and Yu [8] proved that the problem is N P -hard even if there are only two release dates and derived a pseudo-polynomial time algorithm for the case where the number of release dates is fixed. Zhang et al. [13] considered the on-line version of the problem. They dealt with both the unrestrictive and restrictive models. For the unrestrictive model, they derived an optimal on-line algorithm with a competitive ratio of
√ 5+1
2 . For the restrictive model, they provided a 2-competitive algorithm and a lower bound of
√ 5+1
2 on the competitive ratio of any on-line algorithm. In the same paper, they considered the problem P m|b = ∞, rj, on-line|Cmaxand developed an 1 + βm-competitive on-line algorithm, where m is the number of machines, and 0 < βm< 1 is a solution of the equation βm= (1 − βm)m−1, which yields β2 = 12. In a recent paper, Zhang et al. [14] addressed the problems P |b < n, rj, pj = p, on-line|Cmax and P |b = ∞, rj, pj = p, on-line|Cmax, in both of which there is an assumption that the processing times of the jobs to be scheduled are identical. They first proved that there is no on-line algorithm with a competitive ratio smaller than
√ 5+1
2 (1 + γm resp.) for P |b < n, rj, pj = p, on-line|Cmax (for P m|b = ∞, rj, pj = p, on-line|Cmax, where 0 < γm< 1 is a solution of the equation (1 + γm)m+1 = γm+ 2). They then provided on-line algorithms with competitive ratios matching the lower bounds.
In this paper we study the problem P 2|b = ∞, rj, on-line|Cmax. According to the results of [14], there does not exist any on-line algorithm for the problem with a competitive ratio smaller than 1 + γ2, where γ2 ≈ 0.325 is a solution of the equation (1 + γ2)3 = γ2+ 2. We provide an on-line algorithm for the problem that is better than the one given in [13]. In fact, our algorithm improves the competitive ratio from 32 to
√ 2.
2 Main results
Before designing an algorithm, let us consider a simple instance I in which each job has a processing time of 1. Let A be an arbitrary on-line algorithm. The first job J1 in I arrives at time 0. If J1 is processed at or after time
√
2 − 1, no more job comes in I. Then it results in a schedule with a makespan of at least √
2, while the optimal makespan is 1. If A starts J1 before time γ2 ≈ 0.325, say at time t1, the second job J2 is released at time t1+ , where is a sufficiently small positive number. Assume that A starts J2 at time t2. If 1+t1+t2
1 ≥ 1 + γ2, no more job comes in I. Then A returns a schedule with a makespan of 1 + t2 and the optimal makespan is 1 + t1+ , which means that, when tend to 0, the competitive ratio of A is at least
1 + t2
1 + t1+ → 1 + t2
1 + t1 ≥ 1 + γ2. If 1+t1+t2
1 < 1 + γ2, the third job J3 arrives at time t2+ . Then A returns a schedule with a makespan of at least 2 + t1 and the optimal makespan is 1 + t2+ . Thus, when tend to 0, the competitive ratio of A is at least
2 + t1
1 + t2+ → 2 + t1
1 + t2 > 2 + t1
(1 + γ2)(1 + t1) > 2 + γ2
(1 + γ2)2 = 1 + γ2, where the last inequality holds from the fact that the function (1+γ2+t1
2)(1+t1)is a decreasing function and t1< γ2, and the equation follows from the fact that (1 + γ2)3 = γ2+ 2. From this instance we realize that, in order to get a better competitive ratio, jobs in an instance should wait for some reasonable time before they are processed.
Let J (t) be the job with the largest processing time among the jobs that are available but not yet scheduled at time t; if there are two or more candidates, define J (t) to be the one with the largest release date. Denote by p(t) and r(t) the processing time and the release date of job J (t), respectively. Let α =
√
2 − 1, which is a solution of the equation α2+ 2α = 1. Our algorithm runs as follows.
Algorithm A2(α)
At time t, if a machine is idle and there are jobs available but not yet scheduled, and t ≥ (1 + α)r(t) + αp(t),
then start all the available jobs as a single batch on the machine with the minimum completion time so far; otherwise, do nothing but wait.
Note that the basic idea of Algorithm A2(α) is to apply the delay and greedy tactic, and all the batch starting times in the schedule produced are different. Given an instance, denote by σ the schedule produced by Algorithm A2(α) and by π the optimal schedule. For a schedule x, let Cmax(x) denote its makespan and let sj denote the starting time of job Jj. For any two jobs Ji and Jj in two different batches in σ, if si > sj, then, by the description of Algorithm A2(α), all the jobs in the batch to which job Ji is assigned are released after sj, implying that (1) si > (1 + α)sj + αpi and thus si− sj > αpi; and (2) Cmax(π) > sj+ pi. Consider a batch starting at time s. We say that the batch is regular if it starts at (1 + α)r(s) + αp(s). Clearly, if the batch is not regular, then s > (1 + α)r(s) + αp(s), which means that both machines are processing jobs at time (1 + α)r(s) + αp(s).
Consider the structures of π and σ. The following three lemmas provide some useful insights into π and σ.
Lemma 1 Without increasing the makespan of π, we can assume that the jobs in π are scheduled in decreasing order of their processing times.
Proof. Consider an arbitrary pair of jobs Ji and Jj in two different batches. If pi ≤ pj and job Ji starts before job Jj in π, then by moving job Ji to the batch to which job Jj is assigned, we get a new schedule with a makespan not greater than Cmax(π). This procedure can be repeated until a schedule satisfying the property stated in the lemma is obtained. 2 Lemma 1 indicates that for any two jobs Ji and Jj in π, if job Ji starts before job Jj, then pi > pj. The lemma below will simplify the structure of σ significantly.
Lemma 2 Without decreasing the ratio of Cmax(σ)/Cmax(π), we can assume that there is only one job in each batch of σ.
Proof. From each batch in σ, pick the job with the largest processing time; if there are two or more candidates, pick the one with the largest release date. Let I0 be the instance that consists of the jobs being picked only. Apply A2(α) to I0. Then we obtain a schedule that is identical to σ in the sense that the processing times and the starting times of the batches in the schedule are the same as those in σ. Thus, the makespan of the resulting schedule is not smaller than Cmax(σ). On the other hand, it is evident that the optimal makespan of I0 is not greater than Cmax(π). Thus, we can assume that there is only one job in each batch of σ and this assumption does not decrease the ratio of Cmax(σ)/Cmax(π). 2 We thus assume in the sequel that there is only one job in each batch of σ and we can refer to a batch by only referring to the job in it. For convenience, we index the jobs in σ in the order so that C1 ≤ C2 ≤ · · · ≤ Cn.
Lemma 3 Without decreasing the ratio of Cmax(σ)/Cmax(π), we can assume that, in σ, except Jn there is no job starting at or after sn.
Proof. Let I0 be the instance consisting of Jn and the jobs that start before sn in σ only.
Apply A2(α) to I0. Then it results in a schedule with a makespan equal to Cmax(σ). Clearly, the optimal makespan of I0 is not greater than Cmax(π). Thus the lemma follows. 2
We will eventually show that
Cmax(σ)/Cmax(π) ≤ 1 + α, (1)
which yields the following theorem.
Theorem 4 Algorithm A2(α) has a competitive ratio of
√ 2.
Clearly, if job Jn is regular, then
Cmax(σ) = sn+ pn= (1 + α)(rn+ pn) ≤ (1 + α)Cmax(π),
and hence inequality (1) holds. Thus, in the rest of this section, we assume that job Jn is not regular. Consider the last three jobs, Jn−2, Jn−1 and Jn in σ. From the fact that Cn−2 ≤ Cn−1≤ Cn and Lemma 3, one can easily see that job Jn−2and job Jn are on the same machine and job Jn−1 is on the other. Since job Jn is not regular, there is no idle time between sn and
Cn−2, i.e., sn = Cn−2. To show Theorem 4, we distinguish two cases depending on whether or not sn−1 > sn−2. We will show that inequality (1) holds in each case. We first consider the case where sn−1> sn−2 and start with establishing upper bounds on Cmax(σ) − Cmax(π).
Observation 5 If sn−1> sn−2, then Cmax(σ) − Cmax(π) < sn− sn−1≤ (1 − α)pn−2. Proof. Since sn = Cn−2 ≤ Cn−1 = sn−1+ pn−1, we have sn− sn−1 ≤ pn−1. Furthermore, since Cmax(π) > sn−1+ pn and Cmax(σ) = sn+ pn, we have
Cmax(σ) − Cmax(π) < sn− sn−1≤ pn−1. (2) If pn−1≤ (1 − α)pn−2, then the result follows. If pn−1> (1 − α)pn−2, then by inequality (2) and the property of Algorithm A2(α), we have
Cmax(σ) − Cmax(π) < sn− sn−1
= sn−2+ pn−2− sn−1
< sn−2+ pn−2− [(1 + α)sn−2+ αpn−1]
= pn−2− αsn−2− αpn−1
≤ pn−2− α · αpn−2− αpn−1
< (1 − α)pn−2,
as required. 2
Lemma 6 If sn−1> sn−2, then Cmax(σ)/Cmax(π) ≤ 1 + α.
Proof. Consider the optimal schedule π. If job Jn−1 and job Jnare in the same batch, then Cmax(π) ≥ rn+ pn−1 > sn−1+ pn−1≥ Cn−2; if job Jn−2 and job Jn are in the same batch, then Cmax(π) ≥ rn+ pn−2 > sn−2+ pn−2 = Cn−2; if job Jn−2 and job Jn−1 are in the same batch, then Cmax(π) ≥ rn−1+ pn−2> sn−2+ pn−2 = Cn−2. Together with Observation 5 and the fact that Cn−2≥ (1 + α)pn−2, this implies that in all the cases
Cmax(σ)
Cmax(π) < 1 + (1 − α)pn−2
(1 + α)pn−2 = 1 + α.
We thus assume that in π each of the jobs Jn−2, Jn−1 and Jn is in a different batch. We can further assume that, in π, jobs Jn−2, Jn−1 and Jn are processed in the order so that sn−2(π) < sn−1(π) < sn(π), where sj(π) is the starting time of Jj in π. This is because if the order is violated, then from the fact that rn−1 > sn−2, rn > sn−1 and Cn−1 ≥ Cn−2, one can deduce that Cmax(π) ≥ Cn−2 ≥ (1 + α)pn−2 and thus Cmax(σ)/Cmax(π) ≤ 1 + α. By Lemma 1, a consequence of this assumption is pn−2 > pn−1 > pn. Clearly, there is one machine that processes at least two of the jobs Jn−2, Jn−1 and Jn. We distinguish two cases in the following analysis.
Case 1. In π, either jobs Jn−2 and Jn−1, or jobs Jn−2 and Jn are processed on the same machine. Then
Cmax(π) ≥ max{rn−2+ pn−2+ pn, sn−2+ pn−1},
where the second term of the inequality is from the fact that rn−1 > sn−2. Consider σ, the schedule produced by A2(α). If job Jn−2 is regular in σ, then sn−2= (1 + α)rn−2+ αpn−2 and
thus
Cmax(σ) = sn−2+ pn−2+ pn
= (1 + α)rn−2+ αpn−2+ pn−2+ pn
≤ (1 + α)(rn−2+ pn−2+ pn)
≤ (1 + α)Cmax(π).
Otherwise, on each machine there is one job being processed exactly before sn−2. For conve- nience, we denote the two jobs by Jband Jb0, respectively, where job Jb is the one on the machine to which job Jn−2 is assigned and job Jb0 is the other.
• If sb0 < sb, then
sb > (1 + α)sb0+ αpb
≥ (1 + α) · αpb0+ αpb
> (1 + α) · α(sn−2− sb) + α(sn−2− sb)
= α(2 + α)(sn−2− sb)
≥ α2(2 + α)pn−2
= αpn−2,
where the third inequality holds from the fact that pb = sn−2−sband pb0 ≥ sn−2−sb0 > sn−2−sb in this case. Furthermore, noting that rn−2> sb, we have the following:
Cmax(π) > sb+ pn−2+ pn> (1 + α)pn−2. Thus,
Cmax(σ)
Cmax(π) < 1 + (1 − α)pn−2
(1 + α)pn−2 = 1 + α.
• Consider the subcase with sb0 > sb. If pb≤ α(pn−2+pn)
1−α2 , then Cmax(σ)
Cmax(π) < sb+ pb+ pn−2+ pn
sb+ pn−2+ pn = 1 + pb
sb+ pn−2+ pn ≤ 1 + pb
αpb+ pn−2+ pn ≤ 1 + α.
If pb> α(pn−21−α+p2 n), then
sn−2= sb+ pb ≥ (1 + α)pb > (1 + α)α(pn−2+ pn) 1 − α2 = α
1 − α(pn−2+ pn) ≥ α
1 − αpn−2. Together with inequalities (2), this implies that
Cmax(σ) − Cmax(π) < sn− sn−1
< (sn−2+ pn−2) − [(1 + α)sn−2+ αpn−1]
= pn−2− αsn−2− αpn−1
< pn−2− α ·1−αα pn−2− αpn−1
= 1−αα pn−2− αpn−1,
(3)
and
Cmax(π) > sn−1+ pn
> (1 + α)sn−2+ αpn−1+ pn
> (1 + α) ·1−αα pn−2+ αpn−1+ pn,
≥ pn−2+ αpn−1.
(4)
If pn−1≥ pn−2
2 then, by (3) and (4), Cmax(σ)
Cmax(π) < 1 +
α
1−αpn−2− αpn−1 pn−2+ αpn−1 ≤ 1 +
α
1−αpn−2− α ·pn−22
pn−2+ α ·pn−22 = 1 + α.
Recall that Cmax(σ) − Cmax(π) < sn− sn−1≤ pn−1. If pn−1< pn−22 , then Cmax(σ)
Cmax(π) < 1 + pn−1 pn−2+ αpn−1
≤ 1 +
pn−2 2
pn−2+ α ·pn−22 = 1 + α.
Case 2. In π, jobs Jn−1and Jnare processed on the same machine. Then, Cmax(π) ≥ rn−1+ pn−1+pn> sn−2+pn−1+pn. Thus, Cmax(σ)−Cmax(π) < (sn−2+pn−2+pn)−(sn−2+pn−1+pn) = pn−2− pn−1. If pn−1≥ (1 − α)pn−2, then Cmax(σ) − Cmax(π) < pn−2− pn−1 ≤ αpn−2, and thus
Cmax(σ)
Cmax(π) < 1 +αppn−2
n−2 = 1 + α. In the following, we discuss the case where pn−1 < (1 − α)pn−2. Note that if job Jn−1 is regular in σ, then the result can be easily observed. We assume that job Jn−1 is not regular in σ, and, therefore, there is one job, denoted by Jb, being processed exactly before job Jn−1.
• If sb > sn−2, then Cmax(π) > sb+ pn−1+ pnand Cmax(σ) ≤ Cn−1+ pn= sb+ pb+ pn−1+ pn. If pb≤ α
1−α2[(1 + α)sn−2+ pn−1+ pn], then Cmax(σ)
Cmax(π) < sb+ pb+ pn−1+ pn sb+ pn−1+ pn
= 1+ pb
sb+ pn−1+ pn
< 1+ pb
(1 + α)sn−2+ αpb+ pn−1+ pn
≤ 1+α.
Otherwise, by (2) and the fact that pn−1< (1 − α)pn−2, we have Cmax(π) > sb+ pn−1+ pn
> (1 + α)sn−2+ αpb+ pn−1+ pn
> (1 + α)sn−2+ α · 1−αα2[(1 + α)sn−2+ pn−1+ pn] + pn−1+ pn
= 1−α1 sn−2+1−α1 2(pn−1+ pn)
≥ 1
1−α · αpn−2+ 1
1−α2(pn−1+ pn)
> 1−α1 · α · 1−α1 pn−1+ 1−α1 2pn−1
= (2 + α)pn−1, implying that CCmax(σ)
max(π) < 1 +(2+α)ppn−1
n−1 = 1 + α.
• Consider the subcase with sb < sn−2. We claim that pb > α1pn−1− 1
1+αpn−2. Otherwise, sn−2− sb = (sn−2+ pn−2) − (sb+ pn−2)
≤ Cn−1− (sb+ pn−2)
= (sb+ pb+ pn−1) − (sb+ pn−2)
= pb+ pn−1− pn−2
≤ α1pn−1−1+α1 pn−2+ pn−1− pn−2
< α1(1 − α)pn−2−1+α1 pn−2+ (1 − α)pn−2− pn−2
= 1+αα pn−2
< αpn−2,
contradicting the fact that sn−2− sb> αpn−2. Thus, the claim holds and we can deduce that Cmax(π) > sn−2+ pn−1
> (1 + α)sb+ αpn−2+ pn−1
≥ (1 + α) · αpb+ αpn−2+ pn−1
> (1 + α)α[α1pn−1− 1
1+αpn−2] + αpn−2+ pn−1
= (2 + α)pn−1. Thus CCmax(σ)
max(π) ≤ 1 + (2+α)ppn−1
n−1 = 1 + α. This completes the proof the lemma. 2 We now consider the case with sn−1< sn−2. As before, we first establish some upper bounds on Cmax(σ) − Cmax(π).
Observation 7 If sn−1< sn−2, then Cmax(σ) − Cmax(π) < pn−2< (1 − α)pn−1. Proof. Since rn> sn−2 and sn= Cn−2= sn−2+ pn−2, we have
Cmax(σ) − Cmax(π) < pn−2. (5)
We claim that pn−2 < (1 − α)pn−1. In fact, (1 + α)sn−1 + αpn−2+ pn−2 < sn−2 + pn−2 ≤ sn−1+ pn−1. Therefore, (1 + α)pn−2 < pn−1− αsn−1≤ pn−1− α · αpn−1= (1 − α2)pn−1, implying that pn−2< (1 − α)pn−1. This implies the claim and hence the observation holds. 2
A consequence of the fact that pn−2< (1 − α)pn−1 is the following lower bound on sn−2. sn−2 > (1 + α)sn−1+ αpn−2
≥ (1 + α) · αpn−1+ αpn−2
> (1 + α)αp1−αn−2 + αpn−2
= (1 + α)pn−2.
(6)
Lemma 8 If sn−1< sn−2, then Cmax(σ)/Cmax(π) ≤ 1 + α.
Proof. Note that rn > sn−2 > sn−1, rn−2 > sn−1 and Cn−1 ≥ Cn−2. We can deduce that if two of the jobs Jn−2, Jn−1 and Jn are in the same batch in π, then Cmax(π) ≥ Cn−2 = sn−2 + pn−2 > (2 + α)pn−2, where the last inequality holds from (6). This indicates that
Cmax(σ)
Cmax(π) < 1 +(2+α)ppn−2
n−2 = 1 + α. We thus assume in the sequel that, in π, each of the jobs Jn−2, Jn−1 and Jn is in a different batch. It is evident that at least two of the jobs are on the same machine. Recall that pn−2< (1 − α)pn−1. If jobs Jn−2 and Jn−1are on the same machine, then Cmax(π) ≥ pn−1+ pn−2> 2−α1−αpn−2 and thus
Cmax(σ)
Cmax(π) < 1 + pn−2
2−α
1−αpn−2 < 1 + α.
Case 1. Jobs Jn−2and Jn are on the same machine in π. It is easy to see that if job Jn−2is regular in σ, then CCmax(σ)
max(π) ≤ 1+α. Thus, we assume that there is one job being processed exactly before Jn−2. As before, we denote the job by Jb. Then, rn−2 > sb and Cmax(σ) − Cmax(π) < pb.
• If sb > sn−1, then
Cmax(π) > sb+ pn−2+ pn
> (1 + α)sn−1+ αpb+ pn−2+ pn
≥ (1 + α) · αpn−1+ αpb+ pn−2+ pn
> (1 + α)αp1−αn−2 + αpb+ pn−2+ pn
= 2pn−2+ αpb+ pn.
(7)
If pb ≤ α
1−α2(2pn−2+ pn), then CCmax(σ)
max(π) < 1 +2p pb
n−2+αpb+pn ≤ 1 + α. Otherwise, by (7), Cmax(π) is bounded below by 2pn−2 + α · 1−αα2(2pn−2 + pn) + pn ≥ 2
1−α2pn−2, and thus CCmax(σ)
max(π) <
1 + 2pn−2
1−α2pn−2 = 1 + α.
• If sb < sn−1, then sb ≥ αpb
= α(sn−2− sb)
= α[(sn−2− sn−1) + (sn−1− sb)]
> α{[(1 + α)sn−1+ αpn−2− sn−1] + [(1 + α)sb+ αpn−1− sb]}
≥ α2(sn−1+ pn−2+ pn−1)
≥ α2[(1 + α)pn−1+ pn−2],
where the last inequality follows from the fact that sn−1≥ αpn−1. Thus, Cmax(π) > sn−1+ pn−2+ pn
> (1 + α)sb+ αpn−1+ pn−2+ pn
> (1 + α) · α2[(1 + α)pn−1+ pn−2] + αpn−1+ pn−2+ pn
> (1 + α) · α2[(1 + α)p1−αn−2 + pn−2] + αp1−αn−2 + pn−2+ pn
> 1+α1−αpn−2,
and hence CCmax(σ)
max(π) < 1 + 1+αpn−2
1−αpn−2 = 1 + α.
Case 2. Jobs Jn−1 and Jnare on the same machine in π. Similarly, if job Jn−1 is regular in σ, then CCmax(σ)
max(π) ≤ 1 + α. Thus, we assume that on each machine there is exactly one job being processed before sn−1. We denote the two jobs by Jb and Jb0, respectively, where job Jb is the one on the machine to which job Jn−2 is assigned and job Jb0 is the other. Clearly, Cmax(π) >
max{sb, sb0} + pn−1+ pn and Cmax(σ) − Cmax(π) < min{pn−2, pb0}. If pb0 ≤ α
1−α2(pn−1+ pn), then
Cmax(σ)
Cmax(π) < 1 + pb
sb0 + pn−1+ pn ≤ 1 + pb0
αpb0 + pn−1+ pn ≤ 1 + α.
Otherwise, pb0 > 1−αα2(pn−1+ pn) and we consider the following two cases.
• If sb0 < sb, then
sb > (1 + α)sb0+ αpb ≥ (1 + α) · αpb0 > (1 + α)α · α
1 − α2(pn−1+ pn) ≥ α2 1 − αpn−1, and hence
Cmax(π) > sn−1+ pn−2
> (1 + α)sb+ αpn−1+ pn−2
> (1 + α) ·1−αα2 pn−1+ αpn−1+ pn−2
= 2αpn−1+ pn−2
> 1+α1−αpn−2,
implying that CCmax(σ)
max(π) < 1 + 1+αpn−2
1−αpn−2 = 1 + α.
• If sb0 > sb, then pb ≥ sn−1− sb > sn−1− sb0 = pb0. Recall that pb0 > 1−αα2(pn−1+ pn). We have
sn−1 = Cb0
= sb0 + pb0
> (1 + α)sb+ αpb0+ pb0
≥ (1 + α) · αpb+ (1 + α)pb0
> (1 + α) · αpb0+ (1 + α)pb0
> (1 + α)2· α
1−α2(pn−1+ pn)
≥ pn−1.
Thus, CCmax(σ)
max(π) < 1 +s pn−2
n−1+pn−2 < 1 + p pn−2
n−1+pn−2 < 1 + 1 pn−2
1−αpn−2+pn−2 < 1 + α, and we complete
the proof of the lemma. 2
Combining Lemma 6 and Lemma 8, we can obtain inequality (1), and Theorem 4 follows.
3 Concluding Remarks
In this paper we designed a√
2-competitive algorithm for the problem P 2|b = ∞, rj, on-line|Cmax. The algorithm performs better than the one given in [13], which has a competitive ratio of 32. It would be interesting to find out whether for the problem under study there is an on-line algorithm with a competitive ratio matching the lower bound 1 + γ2 ≈ 1.325 provided in [14], or whether the lower bound can be improved. It will be interesting to extend the problem to a general set of m machines and to the variant where the capacity on each batch is restrictive.
Further research is required, and it seems that improvement is possible.
Acknowledgements
We are grateful for an anonymous referee for his/her helpful comments on an earlier version of the paper. This research was supported in part by The Hong Kong Polytechnic University under grant number G-U060 and by the National Natural Science Foundation of China under grant number 10771200.
References
[1] P. Brucker, A. Gladky, H. Hoogeveen, M.Y. Kovalyvov, C.N. Potts, T. Tautehahn and S.L. van de Velde, Scheduling a batching machine. Journal of Scheduling, 1(1998), 31-54.
[2] B. Chen, X. Deng and W. Zang , On-line scheduling a batch processing system to minimize total weighted job completion time, Lecture Notes in Computer Science, 2223(2001), 380-389.
[3] T.C.E. Cheng, C.T. Ng, J.J. Yuan and Z.H. Liu, Single machine parallel batch scheduling subject to precedence constraints, Naval Research Logistics, 51(2004), 949-958.
[4] R.L. Graham, E.L. Lawler, J.K. Lenstra, and A.H. G Rinnooy Kan, Optimization and approximation in deterministic sequencing and scheduling: a survey, Annals Discrete Mathematics, 5(1979), 287-326.
[5] C.Y. Lee and R. Uzsoy, Minimizing makespan on a single batch processing machine with dynamic job arrivals, International Journal of Production Research, 37(1999), 219-236.
[6] C.Y. Lee, R. Uzsoy and L.A. Martin Vega, Efficient algorithms for scheduling semiconductor burn-in opera- tions, Operations Research, 40(1992), 764-775.
[7] S. Li, G. Li, X. Wang and Q. Liu, Minimizing makespan on a single batching machine with release times and non-identical job sizes, Operations Research Letters, 33(2005), 157-164.
[8] Z. Liu and W. Yu, Scheduling one batch processor subject to job release dates, Discrete Applied Mathematics, 105(2000), 129-136.
[9] C.T. Ng, T.C.E. Cheng and J.J. Yuan, A note on the single machine serial batching scheduling problem to minimize maximum lateness with precedence constraints, Operations Research Letters, 30(2002), 66-68.
[10] C.T. Ng, T.C.E. Cheng and J.J. Yuan, The single machine batching problem with family setup times to minimize maximum lateness is strongly N P -hard, Journal of scheduling, 6(2003), 483-490.
[11] R. Uzsoy, A single batch processing machine with non-identical job sizes, International Journal of Production Research, 32(1994), 1615-1635.
[12] J.J. Yuan, Z.H. Liu, C.T. Ng and T.C.E. Cheng, The unbounded single machine parallel batch scheduling problem with family jobs and release dates to minnimize makespan, Theoretical Computer Science, 320(2004), 199-212.
[13] G. Zhang, X. Cai and C.K. Wong, On-line algorithms for minimizing makespan on batch processing machines, Naval Research Logistics, 48(2001), 241-258.
[14] G. Zhang, X. Cai and C.K. Wong, Optimal on-line algorithms for scheduling on parallel batch processing machines, IIE Transactions, 35(2003), 175-181.