On-line Scheduling of Two Parallel Machines. with a Single Server

Transcription

1 On-line Scheduling of Two Parallel Machines with a Single Server Lele Zhang, Andrew Wirth Department of Mechanical and Manufacturing Engineering, The University of Melbourne, VIC 3010, Australia Abstract In this paper, we consider the on-line scheduling of two parallel identical machines sharing a single server with the objective of minimizing the latest completion time of all jobs. Each job has to be setup by the server before being processed on one of the machines. Three special cases: equal length jobs, equal processing times and regular equal setup times are considered and the asymptotic competitive ratios of list scheduling are determined. Also, a lower bound for the equal length job case is given, and two heuristics with tight asymptotic competitive ratios for the other two cases are proposed. Key words: On-line scheduling; Parallel machines; Server; List scheduling 1 Introduction In many manufacturing situations, some pre-operational work (e.g. loading) needs to be executed before the processing of jobs. We consider the problem Corresponding author. Tel.: ; Fax: address: wirtha@unimelb.edu.au (Andrew Wirth). Preprint submitted to Elsevier 17 August 007

2 of scheduling parallel machines with setups. More specifically, this paper considers the on-line scheduling of two identical parallel machines with a single server, where n jobs must be processed non-preemptively on either of the machines after the completion of their setups on the server. The server can handle at most one job at a time. The objective is to minimize the latest completion time of all jobs. In the standard notation [10], our problem could be denoted by P, S 1 s i C max. One application of the problem, which is mentioned in [8], is a robot system where a robot is shared by two semiautomatic machines. There have been several papers discussing the deterministic (off-line) version of this problem. Koulamas [8] reduced the problem to a smaller one with all consecutive jobs processed on machines alternately and proposed a beam search heuristic with favorable computational performance, based on the reduction. Kravchenko and Werner [10] presented a pseudo-polynomial algorithm for the unit setup time problem and derived the problem s computational complexity for an arbitrary number of machines. They also analyzed a list scheduling heuristic for this problem. In subsequent work, Hall et al. [7] provided a comprehensive study of the computational complexity of the problem for various classical scheduling objectives, as well as some polynomial or pseudo-polynomial algorithms for them. The work of Abdekhodaee et al. [ 4], which is closer to the issues discussed in this paper, resolved the computational complexity of the problem and provided some effective heuristics for some special and general cases. However, all of the above articles have concentrated on the off-line version of the scheduling, where the scheduler must have full access to the information of the problem before the scheduling starts. In fact, in many real life situations, only partial of information is available in advance, while decision-making is required immediately. In this paper, we apply list scheduling (LS) [6], the earliest and simplest on-line algorithm, to three special cases of the two parallel machines with a single server problem - the equal length problem (ELP), the equal processing time problem (EPP) and the regular equal setup time problem (RESP), and establish the asymptotic competitive ratio of LS for each case. Furthermore, we derive a lower bound of any on-line algorithm for ELP and also propose two on-line heuristics for EPP and RESP, which are shown to have better asymptotic performance than LS. The remainder of the paper is organized as follows. Section presents the

3 problem model and recalls some useful notation and propositions from previous work. Section 3 is dedicated to ELP, where an on-line lower bound and the asymptotic competitive ratio of LS are given. In Sections 4 and 5, we propose on-line heuristics for EPP and RESP, respectively, and analyze the asymptotic performance of LS and the new heuristics. Finally, in Section 6 we draw some conclusions and present some suggestions for future work. Model Notation: First we recall some notation from [,3]: M 1 : machine 1 which processes the first job; M : machine ; n: number of jobs; s i : p i : setup time of job i in a sequence; processing time of job i in a sequence; a i : length of job i, a i = s i + p i ; S i : P i : C i : I i : W i : setup time of the ith job in a schedule; processing time of the ith job in a schedule; completion time of the ith scheduled job; the ith machine idle time; server waiting time between the (i + 1)th and (i + )th scheduled jobs; In this paper we shall assume that we have a list of n jobs, available at time zero, such that p i a j i, j. That is, the job set is regular, [], and so any off-line schedule not allowing unnecessary idle time will process the jobs alternately on the two machines. We also assume, for now, that we schedule the jobs on-line, one-by-one (on-line list), Pruhs et al. [9]. That is, we must 3

4 allocate machines and starting times to the jobs, one by one, without any knowledge of the remaining jobs in the list. Two evaluation measures for an on-line algorithm A are its competitive performance ratio R A = inf{r 1 : A(I)/OP T (I) r, for all I}. where OP T denotes the optimal off-line solution, and I is a problem instance and asymptotic performance ratio R A = inf{r 1 : for some N > 0, A(I)/OP T (I) r, for all I with OP T (I) N}. The latter measure may avoid certain small case anomalies. In some of the proofs presented below we make use of jobs with very small processing or setup times. That is, we may have p i = ɛ or s i = ɛ where ɛ is a small positive number and then let ɛ 0. By a slight abuse of language we shall abbreviate this process by saying that we have a set of jobs with zero processing or setup times. We now recall the following propositions from []: Proposition 1 Under the assumption of alternating processing and regular jobs, W i = T i+ T i+1 S i+1 = (P i S i+1 W i 1 ) + for 0 i n, I i = (T i+1 + S i+1 T i S i P i ) + = (P i S i+1 W i 1 ) + for 0 i n + 1, T i+ = T i + I i + S i + P i for 0 i n and W i I i = 0 for 0 i n. Proposition Under the assumption of alternating processing and regular jobs, C max = n s i + n W i = 1/( n a i + n+1 i=0 I i ). Proposition 3 If p j s k for j, k, then W i = 0 for 1 n 1 and W n = P n. 3 Equal length problem (P, S 1 a i = a C max ) 3.1 A lower bound of competitive ratio The off-line version of this problem can be solved optimally with an O(n log n) time algorithm, []. The equal length problem has a close link with classic bin packing. Here we modify slightly an on-line bin packing argument Liang [11] to obtain a lower bound for the asymptotic competitive ratio. Proposition 4 For the problem P, S 1 a i = a C max, no on-line algorithm can 4

5 have an asymptotic ratio less than 4/3. Proof. Suppose, without loss of generality, that a = 1. Consider a sequence σ of n jobs with zero setup time. Suppose an algorithm A completes the sequence at time c. Then a sequence σ of n jobs with zero processing time is presented. At best, A will complete c n of additional jobs by time c. So A(σ + σ ) c + n (c n) = n c. Assume that the asymptotic competitive ratio is ρ. We have that c ρop T (σ) = ρn/ and n c ρop T (σ + σ ) = ρn. Thus, n ρn/ n c ρn and ρ 4/3. The result follows. 3. List Scheduling Graham [6] introduced the classic list scheduling on-line algorithm. Each job is scheduled to the first available machine at the earliest possible time. For ELP, let L represent a job with long setup (s i > a/) and R represent a job with short setup (s i a/). Proposition 5 A sequence in which the first job has equal setup and processing times and the following jobs are all short setup jobs, that is, R 1 R R 3 R n in which S 1 = a/ and S i a/ for i n, has T i+1 T i = a/ for 1 i n. Proof. Since T 1 = 0 and T = S 1 = a/, T T 1 = a/. Assume T k+1 T k = a/ for k n 1. T k+ = max(t k+1 + S k+1, T k + a) = max(t k+1 + S k+1, T k+1 + a/) = T k+1 + a/ since S k+1 a/. Hence the result follows. Lemma 6 If the sequence of Proposition 5 is within another sequence, that is, L i R i+1 R i+ R k L k+1 then T j+1 = T j + a/ for i j k subject to T i+1 = T i + a/. Proof. Since T i+1 T i = a/ and S j a/ for i j k, the proof is similar to Proposition 5 s. The result follows. 5

6 Proposition 7 R LS = 3/ for the equal length problem. Proof. Consider an arbitrary sequence σ of equal length jobs. Its asymptotic competitive ratio can be obtained by following steps. Step: 1 We add a job M, whose setup and processing times are equal, that is S M = a/, and put it at the beginning of the sequence. Denote the new sequence by σ. We will prove that the makespan of sequence σ does not decrease after it is sorted in non-increasing setup time order. Step: If the job following job M is a long setup job, move it to the first position of the sequence. Otherwise, check each successive job until the first long setup job comes up and move it to the first position. Continue the procedure until all long setup jobs after job M are moved. Now let us look on the change of makespan for each move. Suppose there are p 1 long setup jobs in front of job M and q jobs which form a run of purely short setup jobs following job M. If p = 1, it means no long setup job has been moved. The sequence is represented by L 1 L L p 1 R M R p+1 R p+ R p+q L p+q+1 for p 1 and q 0. We show that moving job p + q + 1, whose setup time is greater than a/, to the first position does not reduce the makespan. The move could be separated into two substeps as follows, Fig. 1. Insert Figure 1 here Substep 1: Remove job p + q + 1 from the sequence. Since S i > a/ for 1 i p, by Proposition 3, 0 if p = 1 T p = p 1 S i if p p T p+1 = S i 6

7 p p 1 T p+1 T p = S i S i = S p = S M = a/ By Lemma 6, T p+q+1 T p+q = a/. Thus, before the remove the start times of jobs p + q + and p + q + 3 are given by T p+q+ = max(t p+q+1 + S p+q+1, T p+q + a) = T p+q+1 + S p+q+1 T p+q+3 = max(t p+q+ + S p+q+, T p+q+1 + a) = max(t p+q+1 + S p+q+1 + S p+q+, T p+q+1 + a) since S p+q+1 > a/. After the remove, the start times are given by T p+q+ = T p+q+1 T p+q+3 = max(t p+q+1 + S p+q+, T p+q + a) = max(t p+q+1 + S p+q+, T p+q+1 + a/) Substep : Insert job p + q + 1 to the first position of the sequence. Since the first two jobs after the insert are long setup jobs, the setup time increments of jobs and 3 both equal to S 1, which is equal to S p+q+1. That is to say the whole sequence is shifted right by S p+q+1 without changing the processes of other jobs. Note that, for the first switch, since the setup time of job M (a short setup job) is equal to 1/, the result above is the same. Thus the start times of jobs p + q + and p + q + 3 are given by T p+q+ = T p+q+ + S p+q+1 = T p+q+1 + S p+q+1 T p+q+3 = T p+q+3 + S p+q+1 = max(t p+q+1 + S p+q+ + S p+q+1, T p+q+1 + a/ + S p+q+1 ) Consider the changes of the start times. Since T p+q+ T p+q+ = T p+q+1 + S p+q+1 T p+q+1 S p+q+1 = 0 the start time of job p + q + does not change. As for job p + q + 3, 7

8 T p+q+3 T p+q+3 T p+q+1 + S p+q+1 + S p+q+ if S p+q+ > a/ (T p+q+1 + S p+q+1 + S p+q+ ) T p+q+1 + S p+q+1 + a/ = (T p+q+1 + S p+q+1 + S p+q+ ) T p+q+1 + S p+q+1 + a/ if S p+q+ a/ and S p+q+1 + S p+q+ > a if S p+q+ a/ and (T p+q+1 + a) S p+q+1 + S p+q+ a 0 if S p+q+ > a/ = a/ S p+q+ 0 if S p+q+ a/ and S p+q+1 + S p+q+ > a S p+q+1 a/ 0 if S p+q+ a/ and S p+q+1 + S p+q+ a since S p+q+1 > a/. Hence the makespan of the sequence is not reduced after each move of long setup jobs. Obviously, the makespan does not decrease after all moves. Step: 3 Suppose there are l long setup jobs and r short setup jobs in the sequence, excluding job M which is in the l + 1th position. Sort all long setup jobs before job M in non-increasing setup time order. Since S i > a/ for 1 i l, by Proposition 3, T l+1 = l S i and T l+ = l+1 S i. The makespan does not change after the sort. Then sort all short setup jobs after job M in non-increasing setup time order. By Lemma 6, we have that the makespan does not change either. The sequence is finally sorted in non-increasing setup time order, since S 1 S S l > S M S l+1 S l+r+1, without changing the makespan. Denote the sequence in non-increasing setup time order by σ. Delete the added job M from the sequence σ. The final sequence denoted by σ s is presented by L 1 L L l S l+1 R l+ R l+r 8

9 where S i S i+1 for 1 i l + r 1. Obviously, σ and σ s have the same job composition. Thus OP T (σ) = OP T (σ s ). Besides, C max (σ ) C max (σ) + a/ and C max (σ s )+a C max (σ ) as well as C max (σ ) C max (σ ), which is proved in step. It can be concluded that C max (σ) C max (σ s ) + a/ Step 4: Find the maximum value of C max (σ)/op T (σ). Case (i): l r First we consider the makespans of long setup and short setup jobs, respectively. For long setup jobs, a/ < S i a for 1 i l, by Proposition 3, l C max (L) = S i + P l la + a/ For short setup jobs, 0 S i a/ for l + 1 i l + r, by Lemma 6 C max (R) = T l+r+ T l+1 r + 1 a Then, as to the makespan of the whole sequence σ s, C max (σ s ) C max (L) + C max (R) la + a + r + 1 a C max (σ) C max (σ s ) + a/ la + 3a + r a OP T (σ) = OP T (σ s ) = 1 C max (σ) OP T (σ) ( l+r (l + r/ + 3/)a (l + r)a/ l/r + 1 = l/r l/r + 1 = a i + as r l+r+1 i=0 I i ) l/r /r l/r + 1 l + r a 9

10 Now l/r 1, so by simple calculus, the fraction is maximized when l/r = 1. Thus, C max (σ)/op T (σ) 3/. Hence we have the asymptotic competitive ratio equals to 3/ for l r. Case (ii): l r In order to simplify the following proof we consider the l long setup jobs as two parts: the first r + 1 jobs and the following l r 1 jobs. Then we have r+1 C max (L) = S i + l i=r+ l S i + P l (r + 1)a + S i + a i=r+ C max (σ s ) C max (L) + C max (R) (r + 1)a + a + = C max (σ) 3a(r + 1) 3a(r + 1) Recall the Lemma 9 in []. + a + l + a + S i i=r+ l S i i=r+ l i=r+ S i + r + 1 a C max s j + (s j+1 + s j 1 a) (s j 1 + s 1 a) + + ja where the sequence is s 1 s s j s j+1 s j and subject to s i s i+1 for 1 i j 1. Without loss of generality, we assume l + r is even, that is, l + r = j. Since l r and l j, the sequence is given by L 1 L L j l 1 L j L j+1 L l R l+1 R l+r where S i S i+1 for 1 i l + r 1 and S i a/ for 1 i l. So we have S l + S j l+ a,, and S j + S j+ a, as Fig. shows. Thus Insert Figure here OP T (σ) = OP T (σ s ) 10

11 S j+1 + (S j+ + S j a) + + (S j l+ + S l a) + ja l (l r )a (l + r)a l = S i + = S i + (r + 1)a i=r+ i=r+ Then C max (σ) OP T (σ) 3a(r + 1)/ + a + li=r+ S i (r + 1)a + l i=r+ S i Denote (r + 1)a and l i=r+ S i by α and β, respectively. Thus, C max (σ) OP T (σ) 3α/ + a + β α + β 3α/ + β as l, α + β = 1 + 1/ 1 + β/α 3 So R LS 3/. a 0 α+β Consider the following sequence: the first n jobs, with even n, have P i = ɛ, s i = 1 ɛ and the next n jobs have p i = 1 ɛ, s i = ɛ. The list scheduling as well as its corresponding optimal solution are shown in Fig. 3. Clearly, C max (LS) 3n/ and OP T n/ as ɛ 0. The sequence achieves the upper bound of asymptotic competitive ratio for the equal length problem. Insert Figure 3 here 4 EPP (P, S 1 p i = p C max ) We note that the off-line version of this problem is NP-hard, Abdekhodaee et al. [3]. Now we introduce some new notation within this section: Job subsets: L = {job i : s i > p} and R = {job i : s i p}. Let an index (1 or ) indicates the number of the machine which processes the jobs in the subset. Let lower cases represent the numbers of jobs in each subset, thus L = l and R = r. 11

12 4.1 LS Rearrange a list schedule σ in following way: If S i 1 < S i, swap jobs i 1 and i for 1 i n/. Denote the new schedule after the rearrangement by σ and the setup time of the ith processed job in σ by S i. Clearly, S i 1 S i for 1 i n/. Firstly, we consider the short setup problem. Lemma 8 T i+1 = C i 1 = T i 1 + S i 1 + p, for 1 i n/, for the short setup problem. Proof. For 1 i n/, T i+1 = max(t i + S i, T i 1 + S i 1 + p) = max(t i 1 + S i 1 + S i, T i + S i + S i + p, T i 1 + S i 1 + p) = max(t i + S i + S i + p, T i 1 + S i 1 + p) = T i 1 + S i 1 + p since p S i 1 S i and T i 1 T i + S i. Hence the result follows. Lemma 9 C max (σ) C max (σ ) + p Proof. We start by showing, by induction, that T i 1 T i 1 for 1 i n/ +1. The start times of the first three jobs of σ and σ are listed in Table 1. Clearly, the result holds for i = 1 and i =. Insert Table 1 here Now suppose that i = m+1 for 1 m n/. The start times of job m+1 in σ and σ are given by T m+1 = max(t m + S m, T m 1 + S m 1 + p) = max(t m 1 + S m 1 + S m, T m + S m + S m + p, T m 1 + S m 1 + p) = max(t m + S m + S m + p, T m 1 + S m 1 + p) T m+1 = T m 1 + S m 1 + p by Lemma 8 1

13 If T m+1 = T m + S m + S m + p, then T m+1 = T m + S m + S m + p T m 1 + S m + p since T m 1 T m + S m T m 1 + S m + p by assumption T m 1 + S m 1 + p since S m 1 = max(s m 1, S m ) = T m+1 Otherwise, T m+1 = T m 1 + S m 1 + p T m 1 + S m 1 + p = T m+1. Consequently, T i 1 T i 1 for 1 i n/ + 1. If n is odd, then n/ + 1 = (n + 1)/ and T n T n. Since S n = S n when n is odd, C max (σ) = T n + S n + p T n + S n + p = C max (σ ) If n is even, then and C max (σ) = T n + S n + p = max(t n 1 + S n 1 + S n + p, T n + S n + S n + p) C max (σ ) = T n + S n + p T n 1 + S n 1 + S n + p If C max (σ) = T n 1 + S n 1 + S n + p, then, obviously, C max (σ) C max (σ ). Otherwise, C max (σ) = T n + S n + S n + p T n 1 + S n + p T n 1 + S n + p T n 1 + S n 1 + S n + p C max (σ ) + p Proposition 10 R LS 4/3 for the short setup problem. Proof. From the proof of Lemma 9, it is clear that we may assume, without loss of generality, that n is even. Now 13

14 C max (σ) C max (σ ) + p by Lemma 9 = T n + S n + p + p T n+1 + p n/ = For an optimal solution, since T n+1 T n + S n a i 1 + p by Lemma 8 OP T (σ) = OP T (σ ) 1 n a i = 1 n/ n/ ( a i 1 + a i) Since np n/ a i 1 n/ a i np/, thus n/ a i n/ a i 1 1 So C max (σ) OP T (σ) C max(σ ) + p OP T (σ ) = Hereby, the result follows. n/ a i 1 n/ a i 1 + n/ a i n/ a i 3 n/ a i 1 ( n/ a i 1 + p) n/ a i 1 + n/ a i as n Next we consider the general case of equal processing time problem. Proposition 11 For an equal processing time schedule, decrease the setup times of all long setup jobs to p (s i = p), respectively. The total server waiting time does not change, while the makespan is reduced by the sum of long setup times minus lp, that is, i L(s i p). Proof. Suppose job i is a long setup job. Before and after the reduction, the server waiting times are given by W i 1 = (p S i W i ) + = 0; W s i 1 = (p p W i ) + = 0 14

15 since S i > p. The server waiting times do not change, but the total setup time decreases by i L(s i p). Hence the result follows. Proposition 1 R LS = 4/3 for the equal processing time problem. Proof. Assume that n = l+r is even. Decrease the setup times of all long setup jobs to p and denote the new schedule by σ s. From the proof of Proposition 10, we have C max (σ s ) C max (σ s ) + p So, by Proposition 11 (l+r)/ a s i 1 + p C max (σ) = C max (σ s ) + i L(s i p) (l+r)/ a s i 1 + p + i L(s i p) By Proposition 4 in Abdekhodaee et al. [3], there is an optimal schedule with a single run of purely long setup jobs. So OP T (σ) = C max (L) + C max (R) s i + 1 i L = s i + 1 i L i R s i + rp a i i R Case (i): l > r C max (σ) (l+r)/ a s i 1 + p + (s i p) (l + r)p + p + i p) i L i L(s = (r + )p + i L s i OP T (σ) = s i + 1 i L C max (σ) OP T (σ) s i + rp i R s i + rp i L (r + )p + i L s 1 p i i L s i + rp = rp i L s i as n i L s i rp i L s i 15

16 Since i L s i lp and l > r, rp rp i L s i lp < 1 Thus C max (σ)/op T (σ) < 4/3. Case (ii): l r Recall that L 1 = {job i : s i > p, i is processed on M 1 } and R 1 = {job i : s i p, i is processed on M 1 }. (l+r)/ C max (σ) a s i 1 + p + i p) i L(s = since l 1 + r 1 = (l + r)/. a i + a i + p + (s i p) i L 1 i R 1 i L (l 1 l + r 1 + )p + s i + s i i R 1 i L (l + r + 4)p = (l 1 l)p + + s i + i R 1 i L (l + r + 4)p + s i + s i i R 1 i L s i OP T (σ) s i + 1 i L s i + rp i R s i + 1 s i + rp i L i R 1 The case in which l + r is odd can be solved similarly. Denote i L s i and i R 1 s i by α and β, respectively. C max (σ) α + β + (l + r + 4)p OP T (σ) α + β + rp α + β + rp and 4p α+β+rp 0, as n. So C max (σ) OP T (σ) 1 + = β + lp α + β + rp 1 + lp + rp lp + β + rp β + lp lp + β + rp lp + rp lp + rp since α lp 16

17 1 = r/l 4 3 since r/l 1 When β = 0 and l = r, the ratio is maximized. Hence R LS 4/3. To demonstrate that the bound is tight, consider the following instance: there are n jobs of which s i 1 = p and s i = ɛ for 1 i n/, and n is divisible by 4. The makespan of list scheduling is essentially np. An optimal solution has an ɛ setup time job scheduled first, following by all p setup time jobs, and the remaining ɛ setup time jobs processed last. Now let ɛ 0. The latest completion time of the optimal solution is 3np/4. Thus C max (LS)/OP T = 4/3, which shows that the bound is best possible. 4. New Heuristic According to Sgall [13], for a one by one job scheduling model, an on-line algorithm needs to assign each job of some sequence to a particular machine and time slot. However, in order to obtain better asymptotic performance, and under the general assumption in this paper that all jobs are processed alternately on two machines, we propose a definition of weak on-line algorithms, one that just specifies the positions of each job in a schedule. The final starting time of a job in position i is fixed once we know which jobs are in position 1,, i 1. Let us define two subsets, G and H, before introducing the new heuristic. G = {job i : s i > p/} and H = {job i : s i p/}, while g and h indicate the numbers of jobs in subsets G and H, respectively. Let a superscript ( ) represent the same parameters in σ, where σ is the schedule after the arrangement indicated in the previous subsection. Heuristic E: Always assign M 1 to current job i unless both of the following conditions are satisfied. (1) There is an idle place on M (for some j), that is, no job has been assigned to the position, and () The job scheduled at position j 1 and the current job i are both from G or both from H. If both of the conditions are satisfied, then schedule job i in position j. 17

18 Example: An instance of equal processing time jobs: s 1 = 0.6p (G), s = 0.3p (H), s 3 = 0.p (H), s 4 = 0.7p (G), s 5 = 0.8p (G), s 6 = 0.6p (G), s 7 = 0.p (H), s 8 = 0.9p (G). The schedule of E have all jobs processed in the sequence: 1,4,,3,5,6,7,8 (GGHHGGH G), where jobs 4,3 and 6 are processed on M. Observations: We make the following observations about an arbitrary E schedule σ. (1) If g (h) is odd and h (g) is even, there is one and only one idle position j in σ for some j, while the job scheduled in position j 1 is from G (or H). () If g and h are both even, there are no idle positions. (3) If g and h are both odd, there are two idle positions, one of which is at the end of σ. From the observations above, there is at most one idle position, excluding the last one, in an E schedule. Suppose there is an idle position j in a schedule δ and its neighbor job j 1 is from subset G (or H). Add an extra job d with setup time of p/ + ɛ (or p/), where positive number ɛ 0. Then the scheduler will assign it to position j. Let δ d be the schedule with the extra job. C max (δ) C max (δ d ) OP T (δ d ) 3p/ ɛ OP T (δ) OP T (δ d ) 3p/ job j 1 G job j 1 H So C max (δ) OP T (δ) C max (δ d ) OP T (δ d ) 3p/ ɛ C max (δ d ) OP T (δ d ) 3p/ job j 1 G job j 1 H 18

19 C max(δ d ) OP T (δ d ) as n Similarly, if there is an idle position at the end of a schedule, a similar argument shows that this has an insignificant impact on the asymptotic competitive performance. So to find the asymptotic competitive ratio of E, we may assume that g and h are both even, that is, there is no idle position in an E schedule. Under this assumption, E schedules have similar properties to those of LS schedules, except that the difference between the setup times of two neighborhood jobs (job j 1 and job j) is at most p/ for an E schedule, while it is at most p for an LS schedule. These properties together with Lemmas 8 and 9 yield the following proposition. Proposition 13 R E = 6/5 for the short setup problem. Proof. Let G 1 and G (H 1 and H ) denote the subsets of jobs in σ, in which G (H) jobs are processed by M 1 and M, respectively. C max (σ) C max (σ ) + p = T n + S n + p + p T n+1 + p n/ = = since T n+1 T n + S n a i 1 + p by Lemma 8 a i + a i + p i G 1 i H 1 OP T (σ) = OP T (σ ) 1 n a i = 1 a i + a i + a i + a i i G 1 i G i H 1 i H Let α = i G a i + 1 i H a i and β = 1 i G a i + i H a i. Since S i > p/ when job i G 1 G, and S i p/ when job i H 1 H, g 3p + h p β α g p + h 3p Besides, we have n = g + h. So 19

20 3gp β α + hp 4 pg + 3hp 4 = 3g + h 4g + 3h 3(n h) + h = 4(n h) + 3h = 3n h 4n h Since 3n h 4n h h = n (4n h) < 0, β/α achieves its minimum of /3, when h = n. C max (σ) OP T (σ) C max(σ ) + p OP T (σ ) = (α + p) α + β 1 + β/α 1 + /3 = 6 5 α α + β as n The instance I of EPP, in which s i 1 = p/ and s i = ɛ for 1 i n/ where n is divisible by 8, achieves the bound, since by an argument similar to that in Proposition 1 we have C max (I) = n 3 p = 3np 4 OP T (I) = 1 n a i = 1 [ ] n i=0 (p + p + p) C max (I) OP T (I) = 3np/4 5np/8 = 6 5 = 5np 8 The conclusion follows. Proposition 11 is also applicable for E schedules. Furthermore, we can obtain the same upper bound of E for the general case of the equal processing time problem with the analogous process to that in Proposition 1. Therefore, RE = 6/5 for EPP. 5 RESP (P, S 1 p i a j, s i = s i, j C max ) For a regular set of jobs, p i a j i, j. A necessary and sufficient condition for regularity for equal setup time jobs is that max p i min p j s where s i = s i [3], that is, p i v + s i. As for the previous special case Abdekhodaee et al. [3] showed that the off-line version of this problem is NP-hard. We now introduce the following definitions. v = min i p i, L = {job i : p i > s} and R = {job i : p i s}. Let the machine number which processes the jobs in a subset be represented by an index and let lower cases represent the numbers of jobs in each subset. Then, n = l + r = l 1 + l + r. 0

21 5.1 LS We rearrange an arbitrary schedule σ of equal setup time jobs in following way: If P i 1 < P i, swap jobs i 1 and i for 1 i (n 1)/. Denote the new schedule after the rearrangement by σ and the processing time of the ith job of σ by i. Clearly, i 1 i for 1 i (n 1)/. Lemma 14 T i 1 = [ i 1 j=1 s + (P j 1 s) +] and T i i (n + 1)/ for σ. = T i 1 + s, where Proof. The proof is by induction. For i =, we have that T 1 = 0 T = s T 3 = max(s + s, s + P 1) = s + ( 1 s) + T 4 = max(t 3 + s, T + s + P ) = max(3s, s + P 1, s + P ) = max(3s, s + P 1) since 1 = T 3 + s So the result is valid for i =. For i = m, assume that T m 1 = m 1 j=1 T m = T m 1 + s [ s + (P j 1 s) +] Consider the case that i = m + 1 for m (n 1)/. We have that and T m+1 = max(t m + s, T m 1 + s + m 1) = max(t m 1 + s + s, T m 1 + s + P m 1) m 1 [ = max s + (P j 1 s) +] + s, j=1 m 1 [ s + (P j 1 s) +] + s + m 1 j=1 m [ = s + (P j 1 s) +] j=1 1

22 T m+ = max(t m+1 + s, T m + s + m) = max(t m+1 + s, T m 1 + s + m) Since T m+1 T m 1 + s + m 1 T m 1 + s + P m, T m+ = T m+1 + s. Hence, the result follows. Lemma 15 C max (σ) C max (σ ) Proof. First, we will demonstrate that T i 1 T i 1 and T i T i for 0 i (n + 1)/. Once again the proof is by induction. For i = 1 and i =, the start times of the first four jobs of σ and σ are listed in Table, respectively. So the result is true for i = 0 and i = 1, since 1 = max(p 1, P ). Now suppose that i = m + 1 for 1 m (n 1)/. The start times of jobs m + 1 and m + are given in Table 3. Insert Tabel here Insert Tabel 3 here By inductive assumption, T m 1 T m 1 and T m T m. As m 1 = max(p m 1, P m ) P m 1, it is obvious that T m+1 T m+1. As for job m +, if T m+ = T m+1 + s, then T m+ = T m+1 + s T m+1 + s = T m+. If T m+ = T m + s + P m, then T m+ = T m+1 + s = max(t m + s, T m 1 + s + m 1) + s T m 1 + m 1 + s T m 1 + P m + s since m 1 P m = T m + P m + s since T m = T m 1 + s by Lemma 14 T m + P m + s by assumption = T m+ So we conclude that T i 1 T i 1 and T i T i for 1 i (n + 1)/. Since job n remains in place after the rearrangement, that is, P n = n, we have C max (σ) = T n + s + P n C max (σ ) = T n + s + n = T n + s + P n Note that, if n is even and i = n/, T i T i, that is, T n T n. On the

23 other hand if n is odd and i = (n + 1)/, T i 1 T i 1, that is, T n T n. Consequently, C max (σ) C max (σ ). Proposition 16 R LS = 6/5 for the regular equal setup time problem. Proof. The makespan of σ is bounded above thus, C max (σ) C max (σ ) = T n + s + n [ n/ 1 s + (P i 1 s) +] + s + n if n is even = [ (n 1)/ s + (P i 1 s) +] + s + n if n is odd Case (i): v s Then C max (σ) n/ 1 (s + i 1) + s + n if n is even (n+1)/ (s + i 1) if n is odd For the optimal solution, OP T (σ) = OP T (σ ) 1 n a i = 1 n (s + i ) [ 1 n/ (s + P i) + n/ (s + P i 1) ] = 1 if n is even [ (n 1)/ (s + i) + (n+1)/ (s + i 1) ] if n is odd From the result above, and from the fact that we are considering the asymptotic competitive ratio, we may assume that n is even. Then C max (σ) OP T (σ) C max(σ ) OP T (σ ) n/ 1 (s + P i 1) + 4s + n n/ 1 (s + P i) + n/ 1 (s + P i 1) + s + n + n 1 (1) 3

24 Denote n/ 1 (s + i 1) + s + n and n/ 1 (s + i) + s + n 1 by α and β, respectively. Then the asymptotic competitive ratio is given by C max (σ) α + s OP T (σ) α + β = + s/α 1 + β/α As α, s/α is neglected. Since v i v + s i, (s + v)n β (s + v)n and (s + v)n α (s + v)n Thus, β s+v (s+v)/(s+v). Since > 0, s + v/s + v is minimized when v α s+v v achieves its minimal value s. Therefore, β/α /3. The competitive ratio is maximized when β/α achieves the minimum. So C max (σ)/op T (σ) 6/5. Case (ii): 0 v < s Assume that n is even. By Lemma 14, C max (σ ) = n/ 1 n/ 1 = = ( i L 1 = i L 1 [ s + (P i 1 s) +] + s + n ( i 1 s) + + (n/ 1)s + s + n i s) + ns + n i + (n l 1 )s + n () By Proposition 5 in [3], there exists an optimal solution in which all long jobs form a single run. The makespan of an optimal solution consists of two parts: the makespans of long jobs and short jobs, respectively. For the short jobs, since W i = ( i S i+1 W i 1) + = 0, C max (R) i k s i + v. As for the long jobs, their makespan lower bound is 1 i L 1 L a i. Hence, we have that OP T (σ ) = C max (L) + C max (R) 1 a i + s i + v i L 1 L i R = ( 1 l l + r)s + 1 i + 1 i + v i L 1 i L 4

25 ( 1 l 1 + l + r)s + 1 i + v i L 1 since i s, i L = (n 1 l 1)s + 1 i + v i L 1 since l 1 + l + r = n So i L 1 C max (σ) OP T (σ) C max(σ ) OP T (σ ) i + (n l 1 )s + P n (n 1l 1)s + 1 i L 1 i + v = i L 1 i + (n l 1 )s + P n (n l 1 )s + i L 1 i + v ns n + 4v = (n l 1 )s + i L 1 i + v By assumption, l 1 n/ and l 1 s i L 1 i l 1 (s + v). Thus, C max (σ) OP T (σ) ns n + 4v (n l 1 )s + l 1 (s + v) + v = ns n + 4v ns + l 1 v + v ns n + 4v ns + nv/ + v (3) To find the maximum of C max (σ)/op T (σ), consider ns n+4v ns+nv/+v v = 4(ns + nv/ + v) (n/ + )(ns n + 4v) (ns + nv/ + v) = 4ns n s + n n + 4 n (ns + nv/ + v) < 0 for sufficiently large n, since n < s. Consequently, the ratio is maximized when v achieves its maximum. Hence, for 0 < v < s, C max (σ) OP T (σ) ns n + 4s 5ns/ + s = 6 5 as n The upper bound obtained in Proposition 16 is achieved by the sequence in which min p 1 = s, p i 1 = s and p i = s for 1 i n/, where n is 5

26 divisible by 4. The makespan of list scheduling is 3ns/. An optimal solution has jobs processed in the following order: p 1 p 3 p n 3 p n 1 p p 4 p n p n and the optimal makespan is (s + s)n/4 + sn/4 + s = 5ns/4 + s. Thus C max (LS)/OP T 6/5 when n. 5. New Heuristic We slightly modify some definitions for heuristic EP to obtain the following heuristic for RESP. Define the following job subsets: G = {job i : p i > v + s/} and H = {job i : p i v + s/}, where v = min i p i. H 1 = H 1 L 1 ; H = H L. Heuristic F : Always assign M 1 to current job i unless both of the following conditions are satisfied. (1) There is an idle place on M (for some j), that is, no job has been assigned to the position, and () The job scheduled at position j 1 and the current job i are both from G or both from H. If both conditions are satisfied, then schedule the job i in position j. Observations: The observations made earlier about E also apply to F schedules. So we may assume that g and h are both even. By utilizing the properties of F schedules, and applying Lemmas 14 and 15 we derive the following proposition. Proposition 17 R F = 10/9 for the regular equal setup problem. Proof. In terms of the values of v, there are three cases to consider. Case (i): v s Inequality (1) holds here as well, that is, 6

27 C max (σ) OP T (σ) C max(σ ) OP T (σ ) n/ 1 (s + i 1) + 4s + n n/ 1 (s + i) + n/ 1 (s + i 1) + s + n + n 1 = + s/α 1 + β/α 1 + β/α n where α = n/ 1 (s + i 1) + s + n and β = n/ 1 (s + i) + s + n 1. Since g (3s + v) + h (s + v) β α g (s + v) + h (3s + v) and g + h = n, g β α ( 3s + v) + h (s + v) (3s + v)(n h) + h(s + v) g (s + v) + h( 3s = + v) (4s + v)(n h) + h(3s + v) 3ns + nv sh = 4ns + vn sh Let x = nv sh and 3ns+x 4ns+x x = ns (4ns+x) > 0. So 3ns+nv sh 4ns+nv sh is minimized when x is minimized. As v s and h n, min{x} = ns when v = s and h = n. Hence C max (σ)/op T (σ) 10/9. Case (ii): v s/ By inequality (3), that is, C max (σ) OP T (σ) ns n + 4v ns + nv/ + v we have that C max (σ) OP T (σ) ns n + 4v ns + ns/4 + v 10 9 as n Case (iii): s/ v s We recall the definitions of sets L, G and H. Thus, p i > s for i L, p i > v + s/ for i G, p i v + s/ for i H and H = L H. Since v s/, all 7

28 jobs in G are long jobs jobs, that is, G L. Thus, L 1 = G 1 H 1, L = G H and l 1 + l g. From equality (), Then C max (σ ) = i + (n l 1 ) + n i L 1 OP T (σ ) ( 1 l l + r)s + 1 i + 1 i + v i L 1 i L ( 1 l l + r)s + 1 i + 1 i + v i L 1 i G H ( 1 l l + r)s + 1 i + g i L 1 4 (v + s ) + 1 i + v i H ( 1 l l + r)s + 1 i + g i L 1 4 (v + s ) + s (l g ) + v = (n l 1 )s + 1 i + g i L 1 4 (v s ) + v Since C max (σ) OP T (σ) C max(σ ) OP T (σ ) = i L 1 i + (n l 1 )s + n (n l 1 )s + 1 i L 1 i + g (v s) + v 4 ns n + g(v s ) + 4v (n l 1 )s + i L 1 i + g (v s ) + v i g i L 1 (v + s) + (l 1 g )(v + s ) as p i v + s i we have that C max (σ) OP T (σ) ns n + g(v s) + 4v (n l 1 )s + g (v + s) + (l 1 g )(v + s) + g (v s) + v = gs ns + gv + 4v n ns + l 1 v l 1s + gv + v ns + gv gs ns + l 1 v l 1s + gv 8ns + 4gv gs 7ns + nv + gv 6ns + 4nv + gs = 7ns + nv + gv as n since l 1 n/ 8

29 6ns+4nv+gs 7ns+nv+gv g 6ns+4nv+gs 7ns+nv+gv v = s(7ns + nv + gv) v(6ns + 4nv + gs) (7ns + nv + gv) = 14ns 8nvs 8nv (7ns + nv + 4gv) = 0 when v = ( 1/)s = 4n(7ns + nv + gv) (g + n)(6ns + 4nv + gs) (7ns + nv + gv) = 16n s 4g s 16ngs (7ns + nv + gv) = 0 when g = ( )n Since s/ v s and 0 g n, the possible extrema of the bounded region are listed in Table 4. However, maxima may only be achieved at the points with asterisk (*). So 6ns+4nv+gs 7ns+nv+gv n. Insert Tabel 4 here achieves its maximum 10/9 when v = s, g = 0 or v = s/, g = Consider the following instance: p i 1 = 3/s and p i = s for 1 i n/ and n is divisible by 4. C max (I) = n (3s + s) + s OP T (I) = n 4 (s + s) + n 4 (3s + s) + s 5ns C max (I) OP T (I) = + s 4 9ns + s 10 as n 9 8 Hence the result follows. 6 Conclusions and future work In this paper, we dealt with three special cases of the on-line scheduling of P, S 1 s i C max. We applied the simply on-line algorithm List Scheduling to the cases and found the asymptotic competitive ratio of LS for each case. A lower bound for any on-line algorithm was provided for the equal length job problem. For the other two cases equal processing and equal setup time 9

30 problems, we developed two simple but effective on-line heuristics, which were shown to beat LS in terms of asymptotic performance. Table 5 concludes these results. The future work may be dedicated to the tighter lower bounds for the problems, as well as some new heuristics, which lead to better competitive ratios. Additionally, the on-line scheduling study may be extended to the general case of the problem and the situation with an arbitrary number of machines. Insert Tabel 5 here References [1] Amir H. Abdekhodaee. Scheduling Jobs with Setup Times on Parallel Machines with a Single Server. PhD thesis, The University of Melbourne, Australia, [] Amir H. Abdekhodaee and Andrew Wirth. Scheduling parallel machines with a single server: some solvable cases and heuristics. Computers & Operations Research, 00, 9: [3] Amir H. Abdekhodaee, Andrew Wirth, and Heng Soon Gan. Equal processing and equal setup time cases of scheduling parallel machines with a single server. Computers & Operations Research, 004, 31: [4] Amir H. Abdekhodaee, Andrew Wirth, and Heng Soon Gan. Scheduling parallel machines with a single server: the general case. Computers & Operations Research, 006, 33: [5] Jr. E. G. Coffman, M. R. Garey, and D. S. Johnson. Appoximation algorithm for bin packing: A survey. PWS, 1996, 9: [6] R. L. Graham. Bounds for certain multiprocessing anomalies. Bell System Technical Journal, 1966, 45: [7] Nicholas G. Hall, Chris N. Potts, and Chelliah Sriskandarajah. Parallel 30

31 machine scheduling with a common server. Discrete Applied Mathematics, 000, 10:3 43. [8] Christos P. Koulamas. Scheduling two parallel semiautomatic machines to minimize machine interference. Computers & Operations Research, 1996, 3(10): [9] K.Pruhs, J.Sgall, and E. Torng, Handbook of Scheduling: Algorithms, Models, and Performance Analysis, chapter Online scheduling, 004, pages [10] S. A. Kravchenko and F. Werner. Parallel machine scheduling problems with a single server. Mathematical and Computer Modelling, 1997, 6:1 11. [11] Frank M. Liang. A lower bound for on-line bin packing. Information Processing Letters, 1980, 10: [1] Vinod K. Sahney. Single-server, two-machine sequencing with switching time. Operations Research, 197, 0(1):4 36. [13] J. Sgall. On-line scheduling - a survey. Lecture Notes in Computer Science 144, 1998, pages

32 Fig. 1. Move of job p + q + 1 Fig.. Optimal solution for l r 3

33 Table 1 Fig. 3. Worst case of list scheduling and optimal schedule i = 1 and i = σ σ T 1 = 0 T 1 = 0 T = S 1 T = S 1 = max(s 1, S ) T 3 = max(s 1 + S, S 1 + p) T 3 = max(s 1 + S, S 1 + p) = S 1 + p = max(s 1 + p, S + p) 33

34 Table i = 1 and i = σ σ T 1 = 0 T 1 = 0 T = s T = s T 3 = max(s + s, s + P 1 ) T 3 = max(s, s + 1 ) T 4 = max(t 3 + s, T + s + P ) T 4 = max(t 3 + s, T + s + ) = max(3s, s + P 1, s + P ) = max(3s, s + 1 ) Table 3 i = m + 1 σ σ T m+1 = max(t m +s, T m 1 +s+p m 1 ) T m+1 = max(t m +s, T m 1 +s+ m 1 ) T m+ = max(t m+1 + s, T m + s + P m ) T m+ = max(t m+1 + s, T m + s + m ) = T m+1 + s (by Lemma 14) 34

35 Table 4 Possible Extrema v g 6ns+4nv+gs 7ns+nv+gv *( 1/)s ( )n *s/ n 10/9 s/ 0 1 *s 0 10/9 s n 1/11 Table 5 Current asymptotic bounds for P, S 1 p i a j i, j C max lower bound LS new heuristic ELP 4/3 3/ EPP 4/3 6/5 RESP 6/5 10/9 35

36 Title: On-line Scheduling of Two Parallel Machines with a Single Server Abstract: In this paper, we consider the on-line scheduling of two parallel identical machines sharing a single server with the objective of minimizing the latest completion time of all jobs. Each job has to be setup by the server before being processed on one of the machines. Three special cases: equal length jobs, equal processing times and regular equal setup times are considered and the asymptotic competitive ratios of list scheduling are determined. Also, a lower bound for the equal length job case is given, and two heuristics with tight asymptotic competitive ratios for the other two cases are proposed. 36