Multiprocessor scheduling with rejection

Transcription

1 Multiprocessor scheduling with rejection Citation for published version (APA): Bartal, Y., Leonardi, S., Marchetti Spaccaela, A., Sgall, J., & Stougie, L. (1999). Multiprocessor scheduling with rejection. (Meorandu COSOR; Vol. 9906). Eindhoven: Technische Universiteit Eindhoven. Docuent status and date: Published: 01/01/1999 Docuent Version: Publisher s PDF, also known as Version of Record (includes final page, issue and volue nubers) Please check the docuent version of this publication: A subitted anuscript is the version of the article upon subission and before peer-review. There can be iportant differences between the subitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher's website. The final author version and the galley proof are versions of the publication after peer review. The final published version features the final layout of the paper including the volue, issue and page nubers. Link to publication General rights Copyright and oral rights for the publications ade accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requireents associated with these rights. Users ay download and print one copy of any publication fro the public portal for the purpose of private study or research. You ay not further distribute the aterial or use it for any profit-aking activity or coercial gain You ay freely distribute the URL identifying the publication in the public portal. If the publication is distributed under the ters of Article 25fa of the Dutch Copyright Act, indicated by the Taverne license above, please follow below link for the End User Agreeent: Take down policy If you believe that this docuent breaches copyright please contact us at: openaccess@tue.nl providing details and we will investigate your clai. Download date: 23. Feb. 2019

2 tlb Eindhoven University of Technology Departent of Matheatics and Coputing Sciences Meorandu COS OR Multiprocessor scheduling with rejection Y. Bartal S. Leonardi A. Marchetti-Spaccaela J. SgaU L. Stougie Eindhoven, April 1999 The Netherlands

3 Multiprocessor Scheduling with.rejection * Yair Bartal t Stefano Leonardi+ Jifi Sgall Alberto Marchetti-Spaccaela t Leen Stougie'l Abstract We consider a version of ultiprocessor scheduling with the special feature that jobs ay be rejected at a certain penalty. An instance of the proble is given by identical parallel achines and a set of n jobs, each job characterized by a processing tie and a penalty. In the on-line version the jobs becoe available one by one and we have to schedule or reject a job before we have any inforation about future jobs. The objective is to iniize the akespan of the schedule for accepted jobs plus the su of the penalties of rejected jobs. The ain result is a 1 + ~ copetitive algorith for the on-line version of the proble, where is the golden ratio. A atching lower bound shows that this is the best possible algorith working for all. For fixed we give iproved bounds, in particular for = 2 we give a ~ copetitive algorith, which is best possible. For the off-line proble we present a fully polynoial approxiation schee for fixed and a polynoial approxiation schee for arbitrary. Moreover we present an approxiation algorith which runs in tie O(nlogn) for arbitrary and guarantees a 2 - ~ approxiation ratio. A preliinary version of this work appeared in the Proceedings of the 7th Annual ACM-SIAM Syposiu on Discrete Algoriths (1996), pp te-aii yairb<oath.tau.ac.il. Departent of Coputer Science, Tel-Aviv University, Tel-Aviv 69978, Israel. Research supported in part by Ben Gurion Fellowship, the Ministry of Science and Arts. ~E-ail {leonardi.archetti}cdis.uniroa1.it. Dipartiento di Inforatica Sisteistica, Universita di Roa "La Sapienza", via Salaria 113, Roa, Italia. This work was partly supported by ESPRIT BRA Alco II under contract No.7141, and by Italian Ministry of Scientific Research Project 40% "Algoriti, Modelli di Calcolo e Strutture Inforative". E-ail: sgallcath. cas. cz Praha 1, Czech Republic and Dept. of Applied Matheatics, Faculty of Matheatics and Physics, Charles University, Prague. Partially supported by grants A and AI of GA AV CR, postdoctoral grant 201/97/P038 of GA CR, and cooperative research grant INT /ME-103 fro the NSF (USA) and the M8MT (Czech republic). Part of this work was done at Institute of Coputer Science, Hebrew University, Jerusale, Israel; supported in part by Golda Meir Postgraduate Fellowship. 'I E-ail leencwin.tue.nl. Departent of Matheatics, Eindhoven University of Technology, PO Box 513, 5600 MB Eindhoven, The Netherlands. Supported by the Huan Capital Mobility Network DONET of the European Counity 1

4 MULTIPROCESSOR SCHEDULING WITH REJECTION 2 1 Introduction Scheduling jobs on parallel achines is a classical proble that has been widely studied for ore than three decades [6, 12]. In this paper we consider a version of the proble that has the special feature that jobs can be rejected at a certain price. We call this proble Multiprocessor Scheduling with Rejection and use the abbreviation MSR. Given are identical achines and n jobs. Each job is characterized by its processing tie and its penalty. A job can either be rejected, in which case its penalty is paid, or scheduled on one of the achines, in which case its processing tie contributes to the copletion tie of that achine. The processing tie is the sae for all the achines, as they are identical. Preeption is not allowed, i.e., each job is assigned to a single achine, and once started is processed without interruption. The objective is to iniize the su of the akespan and the penalties of all rejected jobs. Makespan (the length of the schedule) is defined as the axiu copletion tie taken over all achines. In the on-line version ofmsrjobs becoe available one by one, and the decision to either reject a job or to schedule it on one of the achines has to be ade before any inforation about next jobs is disclosed. In particular, there ay be no other jobs. On-line algoriths are evaluated by the copetitive ratio; an on-line algorith is c-copetitive if for each input the cost of the solution produced by the algorith is at ost c ties the cost of an optial solution (cf. [14]). The ain goal of an on-line MSR algorith is to choose the correct balance between the penalties of the jobs rejected and the increase in the akespan for the accepted jobs. At the beginning it ight have to reject soe jobs, if the penalty for their rejection is sall copared to their processing tie. However, at a certain point it would have been better to schedule soe of the previously rejected jobs since the increase in the akespan due to scheduling those jobs in parallel is less than the total penalty incurred. In this scenario the on-line MSR proble can be seen as a non-trivial generalization of the well-known Rudolph's ski rental proble [11]. (In that proble, a skier has to choose whether to rent skis for the cost of 1 per trip, or to buy the for the cost of c, without knowing the future nuber of trips. The best possible deterinistic strategy is to rent for the first c trips and buy afterwards. In our proble, rejecting jobs is analogous to renting, while scheduling one job is analogous to buying, as it allows to schedule - 1 ore jobs of no bigger processing tie without extra cost.) Our ain result is a best possible, 1 + <P ~ copetitive algorith for the on-line MSR proble, where <p = (1 +.../5)/2 is the golden ratio. We prove that no deterinistic algorith that receives as input can achieve a better~copetitive ratio independent of. '" For sall values of we give better upper and lower bounds. In particular for = 2 we obtain a best possible, <p ~ copetitive algorith. For = 3 we obtain 2-copetitive algoriths and show a lower bound of Our results should be copared with the current knowledge about on-line algoriths for the classical ultiprocessor scheduling proble. In that proble, each job has to be scheduled, hence it is equivalent to a special case of our proble where each penalty is larger than the corresponding

5 MULTIPROCESSOR SCHEDULING WITH REJECTION 3 processing tie. Graha's list scheduling algorith schedules each job on the currently least loaded achine and is 2 - ~ copetitive [7]. It is known that for > 3 list scheduling is not optial [5], and in fact there exist 2 - c copetitive algoriths for sall constant e > 0 [2, 10, 1]. The best POSSIBLE copetitive ratio is known to be between 1.85 and 1.92 (see [1]), but its precise value is unknown. In contrast, for the ore general on-line MSR proble we do find the optial copetitive ratio. More surprisingly, our algoriths achieving the optial copetitive ratio schedule the accepted jobs using list scheduling, which is inferior when rejections are not allowed! Next we consider the off-line MSR proble. We present an approxiation algorith with a 2 - worst-case approxiation ratio running in tie O(nlogn) for arbitrary. We also present a fully polynoial approxiation schee for MSR for any fixed and a polynoial approxiation schee for arbitrary, Le., where is part of the input. More explicitly, the approxiation schees give algoriths with running tie either polynoial in n and lie but exponential in, or polynoial in n and, but exponential in lie, where E is the axial error allowed. This iplies that for the ore general proble with possible rejection of jobs we have algoriths that are essentially as good as those known for the classical proble without rejection. In fact, our algoriths are based on the techniques used for the proble without rejection, naely on the fully polynoial approxiation schee for fixed [9] (based on a dynaic prograing forulation of the proble) and the polynoial approxiation schee for arbitrary (8]. Obviously, the MSR proble on a single achine is easily solved exactly by scheduling every job whose processing tie does not exceed its penalty, and for 2:: 2 it is NP-hard to find the optial solution, siilarly as in the classical case without rejections. The on-line algoriths and lower bounds are presented in Sections 3 and 4. Section 5 contains the results about the off-line proble. 2 Notation An instance of the MSR proble consists of a nuber of achines and a set of jobs J, IJI = n. We abuse the notation and denote the j-th job in the input sequence by j. Each job j E J is characterized by a pair (Pj, Wj), where Pj is its processing tie and Wj is its penalty. For a set of jobs X ~ J, W(X) = L,jEXWj is the total penalty of jobs in X, and M(X) = L,jEX pjl is the su of the loads of the jobs in X, where the load of a job j is defined by pjl. The set B = {j 1 Wj :::; pjl} contains jobs with penalty less than or equal to their load. Given a solution produced by an on-line or approxiation algorith, R denotes the set of all rejected jobs, A denotes the set of all accepted job, T denotes the largest processing tie of all accepted jobs. For their analogs in the optial solution we use R OPT, AOPT, TOPT, respectively. ZOPT denotes the total cost of the optial solution for a given instance of the proble, and ZH is the cost achieved by algorith H. An on-line algorith ON is o-copetitive if ZON :::; C. ZOPT

6 MULTIPROCESSOR SCHEDULING WITH REJECTION 4 for every input instance. The golden ratio is denoted by if> = (v'5 + 1)/2 ~ We will often use the property of the golden ratio that if> 1 = 1/if>. Using list scheduling, the akespan of a schedule is bounded fro above by the processing tie of the job that finishes last plus the su of the loads of all other scheduled jobs [7]. We denote this bound by C LS (X) for a set X of scheduled jobs. If l is the job in X that finishes last, then CLS(X) = M(X - {l}) +Pe::; M(X) + (1- ~)T. (1) 3 On-line scheduling with rejections In the first part of this section we present an on-line MSR algorith which works for arbitrary and achieves the best possible copetitive ratio in that case. The corresponding lower bound is given in Section 4.2. For fixed 2:: 3 this algorith gives the best copetitive ratio we are able to achieve, however we are not able to prove a atching lower bound. In the second part we present a different algorith which is best possible for the case of two achines. The corresponding lower bound is given in Section Arbitrary nuber of achines Our algorith uses two siple rules. First, all jobs in the set B are rejected, which sees advantageous since their penalty is saller than their load. The second rule is inspired by the relation of MSR to the ski-rental proble and states that a job is rejected unless its penalty added to the total penalty of the hitherto rejected jobs would be higher than soe prescribed fraction of its processing tie. This fraction paraeterizes the algorith, we denote it by a. Algorith RTP (a) (REJECT -TOTAL-PEN ALTY( a» (i) If a job fro B becoes available, reject it. (ii) Let W be the total penalty of all jobs fro J - B rejected so far. If a job j = (Pj, Wj) r;. B becoes available, reject it if W + Wj ::; apj, otherwise accept it and schedule it on a least loaded achine. In Theore 1 we will prove that for given,. the algorith is c-copetitive if c and a > 0 satisfy c 2:: (1--)- a 2 2+a- -. (2) To obtain a best possible algorith for arbitrary, we use a = if> - 1 ~ Then c = 1 + if> satisfies the inequalities above. For a fixed, the best c is obtained if equality is attained in both

7 MULTIPROCESSOR SCHEDULING WITH REJECTION 5 cases. For 2 this leads to a =../2/2 ~ and c = 1 +../2/2 ~ 1.707, and for = 3 we get a = 2/3 and c = 2. For general we obtain a = c = -(1 - ~) + )5 - ~ + ~ 2 (1-2) ~ + ~ 1+ V 2. Theore 1 The algorith RTP(a) for achines is c-copetitive if c and a satisfy {2}. Proof. First we notice that since our algorith uses list scheduling for the accepted jobs, its akespan is bounded by CLS(A) = (1 - ~)T + M(A) (cf. (1». Hence, ZON :5 (1 - ~)T + M(A) + W(R). For any set S ~ R, the right-hand side of this inequality can be rewritten as a su of two ters: ZON S (M(A) + W(R - S) + M(S)) + «1 - ~)T + W(S) - M(S». Now, we fix an off-line optial solution. We use the above inequality for the set S = (R- B) n AOPT, the set of all jobs rejected by the algorith in Step (ii) and accepted in the optial solution. First we bound the first ter in (3). Notice that (3) since no job of the set B is accepted by the algorith, and thus the load of each job accepted by the algorith is saller than its penalty. Next we notice that S ~ AOPT, iplying that M(S) = M(AOPT n S). (5) Since RO PT and AOPT is a partition of the set of all jobs, and B ~ R, we obtain R - S = [(R n RO PT ) U (R n AOPT)] - [(R - B) n AO PT ] (R n ROPT) U (B n AO PT ). (6) Fro (6) and the definition of B we have W(R - S) T,v(B n AOPT) + W(R n RO PT ) :5 M(B n AOPT) + W(R n RO PT ). (7) Inequalities (4), (5), and (7) together iply that M(A) + W(R - S) + M(S) :5 M(Ao PT ) + W(R OPT ) :5 ZOPT. To finish the proof, it is now sufficient to show 1 (1- -)T + W(S) (8)

8 MULTIPROCESSOR SCHEDULING WITH REJECTION 6 and notice that under our conditions (2) on c this is at ost All jobs in S are scheduled in the optial solution and hence have processing tie at ost TOPT. The algorith never rejects such ajob ifthis would increase the penalty above ato PT, and hence (9) For any job j that was rejected by Step (ii) of the algorith we have Wj :5 apj. Suing over all jobs in S we obtain W(S) :5 am(s), and hence W(S) - M(S) :5 (1- _1_)W(S) :5 (1- _1)aTO PT = (a a a (10) Thus, if T :5 TO PT, (8) follows. If T > TOPT, let W be the penalty incurred by the jobs rejected in Step (ii) of the algorith until it schedules the first job with processing tie T, job j say, having penalty Wj' By the condition in Step (ii) of the algorith, at:5 W +Wj. On the other hand, W + Wj :5 W(S) + W(RO PT ), as all jobs rejected in Step (ii) are in S U RO PT, and also the job with processing tie T is in ROPT, since T > TOPT. Thus, (11) using (9). Adding (10) to (11) we obtain (8), which finishes the proof. o Choosing a = tp - 1 and c = tp + 1, both inequalities in (2) are satisfied for any, which yields our ain result. For arbitrarily large these values are the best possible. Theore 2 The algorith RTP(tP - 1) is (1 + tp)-copetitive. For any choice of and a the bounds on c given by the inequalities (2) give a tight analysis of the algorith RTP(a), as shown by the following two exaples. First, consider the sequence of two jobs (1 - a;!n, a - ~) and (1- e, ~) with f > 0 arbitrarily sall. RTP(a) rejects the first job and accepts the second job, while in the optial solution both jobs are rejected. The copetitive ratio attained on this sequence is (1 - e + (a - ~))Ia, which for any a > 0 and can be ade arbitrarily close to the first inequality of (2). Second, consider the sequence fored by one job (1, a), - 2 jobs (1, ~), and one job (1,1). RTP(a) rejects the first - 1 jobs and accepts job (1, 1), while the optial solution accepts all jobs. The copetitive ratio is 2 + a!, leading to the second inequality of (2). 3.2 Two achines To obtain a best possible, <p-copetitive algorith for two achines we use another approach. We siply reject all jobs with penalty at ost a ties their processing tie, where a is again a paraeter of the algorith. Again the optial value is a = tp - 1 ~

9 MULTIPROCESSOR SCHEDULING WITH REJECTION 7 Algorith RP(a) (REJECT-PENALTY(a)) If a job j = (pj, Wj) becoes available, reject it if Wj ~ apj, otherwise accept it and schedule it on a least loaded achine. Theore 3 The algorith RP(4) 1) is </>-copetitive for two achines. Proof. If the algorith does not schedule any job, then and the theore is proved. Otherwise denote by i a job that is finished last by the on-line algorith. Since the algorith uses list scheduling, the akespan is bounded by alsea) = M(A - {i}) + Pe, and therefore we have Notice that ZON ~ W(R) + M(A - {i}) + Pe. (12) by direct application of the rejection rule of algorith RP(</> - 1}. For any job that is accepted by the algorith the rejection rule of RP(4) - 1) iplies that its load is not greater than its penalty. Therefore, M(A-{ }) = M«(A-{i}) nao PT ) +M«A-{i}) nr OPT ) < M(A - {l}) n A OPT ) + W(A - {i}) n RO PT ). (14) Invoking (13) and (14) in (12), yields ZON ~W(ROPT {i})+2(4)-i}m(ao PT -{i})+pe. (15) We distinguish two cases. In the first case the optial solution rejects job i. Since i is scheduled by the algorith, we have Pe ~ 4>we, and therefore In the second case i is accepted in the optial solution. Then, we use the identity Pe = 2(</> -1)M({i}) + (1 (4) -l))pe in (15) to obtain ZON ~ (2-4»Pl + W(RO PT ) + 2(4) -l)m(ao PT ) ~ (2-4»ZOPT + 2(4) -l)zopt = 4>ZOPT,

10 MULTIPROCESSOR SCHEDULING WITH REJECTION 8 which copletes the proof. The sae approach can be used for larger as well. However, for > 3 this is worse than the previous algorith. An interesting situation arises for = 3. Choosing a = 1/2 we obtain a 2-copetitive algorith, which atches the copetitive ratio of the algorith RTP(2/3) for = 3 in the previous subsection. Whereas RP{I/2) rejects all jobs with penalty up to 1/2 of their processing tie, RTP(2/3) rejects all jobs with penalty up to 1/3 of their processing tie and also jobs with larger penalty as long as the total penalty payed (by the jobs with saller or equal processing ties) reains at ost 2/3 ties the processing tie. We can cobine these two approaches and show that for any 1/3 :::; a :::; 1/2, the algorith that rejects each job with penalty at ost a ties its PROCESSING TIME and also if the total penalty is up to 1 - a ties its processing tie, is 2-copetitive, too. However, no such cobined algorith is better. o 4 Lower bounds for on-line algoriths In the first part of this section we give the lower bound for a sall nuber of achines. In particular it shows that the algorith presented in Section 3.2 is best possible for = 2. In the second part we exhibit the lower bound for algoriths working for all. 4.1 Sall nuber of achines Assue that there exists a c-copetitive on-line algorith for achines. We prove that c satisfies c 2 p, where p is the solution of the following equation: For = 2 we get p =, and hence prove that the algorith RP{ -l) is best possible. For = 3 we get p ~ 1.839, and so on. Notice that for arbitrary this only proves that the copetitive ratio is at least 2. Theore 4 For any c-copetitive algorith for MSR on achines, it holds that c 2 p, where p satisfies equation {16}. Proof. Given, let p be the solution of equation (16). Consider an adversary providing a sequence of jobs, all with processing tie 1. The first job given has penalty WI = 1/ p. If the on-line algorith accepts this job the sequence stops and the algorith is p-copetitive. Otherwise, a second job is given by the adversary with penalty W2 = 1/ p2. Again, accepting this job by the on-line algorith akes the sequence stop and the copetitive ratio is p. Rejection akes the sequence continue with a third job. This process is repeated for at ost 1 jobs with penalties Wj = 1/ pi for 1 :::; j = - 1. If the on-line algorith accepts any job in this sequence, job k say, the adversary stops the sequence at that job, yielding a copetitive ratio of the on-line algorith on this sequence (16)

11 MULTIPROCESSOR SCHEDULING WITH REJECTION 9 of k jobs of Z ON 1 + ~~-1..l L...J=l pj o Corollary 5 For two achines, no on-line algorith has copetitive ratio less than cp. 4.2 Arbitrary nuber of achines Now we prove the lower bound on algoriths working for arbitrary. The sequence of jobs starts as in the previous section, but additional ideas are necessary. Theore 6 There exists no on-line algorith that is /3-copetitive for soe constant /3 < 1 + cp and all. Proof. All jobs in the proof have processing tie 1. All logariths are base 2. For contradiction, we assue that the on-line algorith is /3-copetitive for a constant /3 < 1 + cp, and is a sufficiently large power of two. Let ai (log)i+1, and let k be the largest integer such that log + L:~=1 ai <. Calculation gives k = Llog/loglogJ 1. Consider again an adversary that intends to provide the following sequence of at ost jobs (all with processing tie 1): 1 job with penalty 1/(1 + cp) 1 job with penalty 1/(1 + cp)2 1 job with penalty 1/(1 + cp)log al jobs with penalty l/al ak jobs with penalty l/ak' As in the proof of Theore 4 we argue that if the on-line algorith accepts one of the first log jobs, the adversary stops the sequence and the copetitive ratio is 1 + cp. Therefore, any /3-copetitive algorith has to reject the first log jobs. Now, let bi be the nuber of jobs with

12 MULTIPROCESSOR SCHEDULING WITH REJECTION 10 penalty 1/ai that are rejected by the l1-copetitive algorith. The penalty the algorith pays on those jobs is bil ai. Since there are less than jobs, the optial cost is at ost 1. Thus the total penalty incurred by the on-line algorith has to be at ost 11, and in particular there has to exist is k such that b!ae S I1lk < 31k. Fix such i. Now consider the following odified sequence of at ost 2 jobs (again all with processing tie 1): 1 job with penalty 1/(1 + ) 1 job with penalty 1/(1 + )2 1 job with penalty 1/(1 + )log al jobs with penalty 11a l al jobs with penalty 11al M jobs with penalty 6, where M = Ef=l (ai - bi). The sequence is identical up to the jobs with penalty 1/ae, and hence the on-line algorith behaves identically on this initial subsequence. In particular, it also rejects all first log jobs paying a penalty of at least E;~;n(1 + )-j = (1 (1 + )-log)/ ~ -I-11 for the. Then it also rejects bi jobs with penalty 1/ai, for is i, paying penalty Ef=l bdai for the. The on-line algorith has to accept all jobs with penalty 6, since the adversary will present at ost 2 jobs, and hence scheduling the all would lead to a cost of at ost 2. By suing the nubers, it follows that the on-line algorith schedules exactly + 1 jobs. Thus, its akespan is at least 2, and its total cost is at least To finish the proof, it is sufficient to present a solution with cost 1 +0(1). Consider the solution that rejects 1 +log jobs with penalty 11a l, b l jobs with penalty l/a 2, b2 jobs with penalty 1/a 3, bl-2 jobs with penalty 1/al-I, bl-1 + bl jobs with penalty 1/aL, and schedules all reaining jobs optially. First we verify that this description is legal,i.e. there are always sufficiently any jobs with given penalty. By definition, bi S ai S ai+!. For sufficiently large, we have 1 + log < all and due to our choice off, we also have bl- 1 +bl S a -l +3atJ k S ai. In the presented schedule one ore job is rejected than in the solution produced by the on-line algorith, and hence there are only jobs to be scheduled. Thus, the akespan is 1. The penalty

13 MULTIPROCESSOR SCHEDULING WITH REJECTION 11 paid is 1 + log ~ bi bi 1 + log 1 ~ b i bi -----''''-- + L..J = + --L..J al i=l ai+l ai (log)2 log i=l ai al The su in the second ter is less than the penalty paid by the on-line algorith, and hence this ter is bounded by O(1/log). The last ter is bounded due to our choice of I!, naely it is O(1/k) = O(loglog/log). Thus, the total penalty paid is O(loglog/log) = 0(1), and the total cost is 1 + 0(1). 0 5 Off-line scheduling with rejection 5.1 An approxiation algorith for arbitrary nuber of achines In this section we give a (2 - ~)-approxiation algorith for MSR on achines. Our lower bounds iply that such a ratio cannot be achieved by an on-line algorith. The algorith rejects all jobs in the set B = {j I Wj ::; pj/}. Fro all other jobs it accepts soe nuber of jobs with the sallest processing tie, and chooses the best aong such solutions. Algorith APPROX (i) Sort all jobs in J - B according to their processing ties in non-decreasing order. (ii) Let Si, 0::; i ::; IJ BI, be the solution that schedules the first i jobs fro J - B using list scheduling and rejects all other jobs. Choose the solution Si with the sallest cost. Note that Step (ii) of the algorith takes tie O(nlog) (or O(n) in case ;::: n), as we can build the schedules increentally and the bookkeeping of penalties for rejected jobs is siple. Thus, the whole algorith runs in tie O( n log n), independent of. A perforance analysis leads to the following worst-case ratio. Theore 7 The algorith APPROX achieves ZH ::; (2 solution found by the algorith. ~)ZOPT, where ZH is the cost of the Proof. We assue that the jobs fro J - B are ordered 1, 2,..., IJ - BI, according to the ordering given by Step (i) of the algorith. If the optial solution rejects all jobs fro J - B, by the definition of B it is optial to reject all jobs fro B as well. Thus the solution So that rejects all jobs is optial and ZH = ZOPT, Otherwise let I! be the last job fro J - B accepted in the optial solution. Consider the solution Sll which schedules all jobs up to I!. Let A = {1, '..,I!} be the set of all jobs scheduled in Sl Job I! has the largest running tie of all scheduled jobs, and since we use list scheduling, the akespan of Se is at ost c LS (A) = M(A) + (1 - ~ )Pl ::; M(A) + (1 - ~ )ZOPT.

14 MULTIPROCESSOR SCHEDULING WITH REJECTION 12 Since the cost of the algorith is at ost the cost of St., we have ZH < W(J - A) +M(A) + (1- ~)ZOPT - W(AO PT n (J - A)) + W(RO PT n (J - A)) + M(RO PT n A) + M(Ao PT n A) + (1 _ ~ )ZOPT. By the choice of, AOPT n (J - A) ~ B, and thus W(AOPT n (J - A)) ~ M(AOPT n (J A)). Moreover, since A does not contain any job of B, M(ROPTnA) ~ W(ROPTnA). Theseobservations inserted in the above inequality yield ZH ~ W(R OPT ) + M(A opt ) + (1- ~ )ZOPT ~ (2 _ ~ )ZOPT o That the ratio is tight is shown by the following instance with jobs (and achines): PI... = P = 1, WI = 1 - to, and W2 =... = W = ~(1 - to). The heuristic will reject all jobs resulting in ZH = (1 +,;;1 )(1- E). In the optial solution all jobs are accepted, hence ZOPT = 1. Therefore, ZH /ZOPT can be ade arbitrarily close to 2 - ~. This exaple also shows that any heuristic that rejects all jobs in the set B, has a worst-case ratio no better than 2 - ~, since there is no scheduling at all involved in it. Thus, the only way in which an iproveent ight be obtained is by accepting possibly also jobs in the set B. 5.2 A fully polynoial approxiation schee fixed For the off-line MSR proble there exists a fully polynoial approxiation schee for fixed. The proof uses a rounding technique based on dynaic prograing as was developed in [9], for the classical akespan proble. Lea 8 The MSR proble with integer processing ties and penalties can be solved in tie polynoial in nand (zopt). Proof. We use dynaic prograing. Let Mi represent the current load of achine i, i = 1,...,. We copute for each Ml,...,M ~ ZOPT the inial value of total penalty to be paid that can be achieved with these loads. We denote this value after the first j jobs are rejected or scheduled by Wj(MI"'" M) and define it to be 00 whenever Mi < 0 for soe i. At the sae tie we copute the inial cost of a schedule that can: be achieved with given loads M 1,.., M, denoted Z(M I,...,M). For MI,..., M 2: 0 these values can be coputed recursively as follows: Wo(Ml,...,M) = 0, Wj(M1,...,M) = Z(Ml,..., M) in{wj+wj-i(mt,...,m), ~n Wj-I(M!,...,Mi-I,Mi - pj,mhb'",m)}, 1 = Wn(Ml,...,M) + 11XMi t

15 MULTIPROCESSOR SCHEDULING WITH REJECTION 13 We copute the values in the order of increasing axi Mi. As soon as axi Mi reaches the cost of the current optial solution, which is the sallest value of Z coputed so far, we stop, as we know it is a global optiu. 0 Theore 9 For any c. 2:: 0, there exists an c.-approxiation algorith for the MSR proble that runs in tie polynoial in the size of the input instance, n and l/c. Proof. Given an instance I of the MSR proble with n jobs and achines, we first use the approxiation aigorith fro Section 5.1 to obtain the cost ZH. Now we define an instance I' by rounding the processing ties and the penalties of the jobs in I. Naely the processing tie pj and the penalty wj of job j in I' are pj = lpj/kj and wj = LWj/kJ where k = c.z H /2n. We obtain the optial solution of l' by the dynaic prograing algorith presented in the proof of Lea 8, and derive an approxiate solution for I by scheduling the respective jobs on the sae achines as in the optial solution for 1'. The cost ZA(k) of the approxiate solution deviates fro the optial solution for I by at ost nk = cz H /2. Therefore, by applying the lower bound ZOPT 2:: ZH /2 we obtain IZA(k) - ZOPTI 2nk ZOPT :5 ZH = c. By Lea 8 it follows that the running tie of the approxiation algorith is polynoial in nand (ZOPT(I')). The theore follows since ZOPT(I') :5 ZOPT(I)/k :5 2ZH /k and hence ZOPT(Il) :5 4n/c A polynoial approxiation schee for arbitrary For arbitrary we will design a polynoial approxiation schee (PAS) based on the PAS for the akespan proble in [8]. Given an instance with n jobs, achines, and > 0, we are to find an -approxiate solution. As an upper bound U on the solution value we use the outcoe Z H of the heuristic presented in Section 5.1. Notice that all jobs with Pj > U will be rejected. Thus, all jobs that are possibly scheduled have processing ties in the interval [0, U]. Fro Theore 7 we have a lower bound on the optial solution that we denote by L = ZH /2 = U /2. We define the set S = {j I Pj E [0, L/3]}, a set of jobs with relatively sall processing ties. Let D = {j I j tfi S}. The reaining interval ( L/3, U] is partitioned into 8 :5 lsrt/ 21 subintervals (Lt,12], (1 2,13],., (ls) Is+l] of length 2 L/9 each, with II = L/3 and ls+l 2:: U. Let Di be the set of jobs with processing tie in the interval (li,li+l], and let the jobs in each such set be ordered so that the penalties are non-increasing. As before define the set B = {j I Wj :5 pj/}. First we will describe how for any subset.6. of D we generate an approxiate solution with value ZH(c} (.6.). For any such a set.6. we deterine a schedule for all the jobs in.6. with an /3-approxiate akespan using the PAS in [S]. All other jobs in D, i.e., all jobs in D -.6., are rejected. Jobs in the set S that have Wj 2:: ~Pj, i.e., jobs in the set S - B, are scheduled in any

16 MULTIPROCESSOR SCHEDULING WITH REJECTION 14 order according to the list scheduling rule starting fro the E/3-approxiate schedule deterined before. The reaining jobs, j E S n B, are considered in any order. Each next job is rejected if its assignent to a least loaded achine would cause an increase of the akespan, otherwise it is assigned to a least loaded achine as indicated by list scheduling. This procedure is applied to every set D(Yl,..., Ys) ~ D, where D(y!,..., Ys) denotes the set that is coposed of the first Yi eleents in the ordered set Di, i = 1,...,8. In this way an approxiate solution ZH(f)(D(Yl,''''Ys)) is found for each set D(Yl,...,Ys)' The iniu value over all these sets, ZH(f) = in(yl....,ys) zh(e)(d(y!,...,ys)), is taken as the output of our procedure. Theore 10 For any E > 0 the algorith H(E) described above runs in tie polynoial in nand, and yields Proof. The proof consists of two steps. First, consider the set AOPT n D of jobs in D that are accepted in the optial solution. Applying the heuristic procedure described above to this set of jobs yields the approxiate solution zh(e) (AO PT n D). We will prove that (17) In the second step we analyze how uch the set AOPT n D ay differ fro D(Yb"" Ys). Assue that for i = 1,...,8, AOPT n D consists of yppt jobs fro the set Di. These yppt jobs are not necessarily the first yppt jobs in the ordered set Di, but we will show that Inequalities (17) and (18) iply that zh(e) (D(y?PT,...,y~PT)) S zh(e) (A OPT n D) + ~EL. (18) zh{e} (D(yPPT,..., y?pt)) 1 ZOPT S +E. Since, obviously, zh(e) S ZH(E) (D(yP PT,...,y?PT)) the theore follows. In order to prove inequality (17) two cases are distinguished. (1) The copletion ties of the various achines (in the 'heuristic solution corresponding to ZH(E)(AOPT n D)) differ by no ore than ELI3. The resulting akespan is the sae as the akespan after scheduling the jobs in AOPT nd and S - B, and due to our assuption it is at ost M(A OPT nd)+m(s-b)+elj3. The weight of all rejected jobs is at ost W(SnB)+W(D-AOPT). Thus ZH(E) (A OPT n D) S M(Ao PT n D) + M(S - B) + E~ + W(S n B) + WeD - AOPT).

17 MULTIPROCESSOR SCHEDULING WITH REJECTION 15 Using the definition of the set B, we have for the optial solution ZOPT 2:: M(Ao PT n D) + M(S - B) + W(S n B) + W(D - AO PT ). Fro these two inequalities (17) follows iediately. (2) The copletion ties of the achines differ by ore than el/3. Since the processing tie of each job in S is less than el/3, we know that no job in the set Sn B is rejected, and scheduling all jobs in S has not increased the akespan coputed for the set AOPTnD. Let CH(c)(AOPTnD) and COPT (AOPT n D) denote, respectively, the /3-approxiate and the optial akespan for the jobs in AOPT n D. In this case and Moreover, since we have used an /3-approxiate algorith for scheduling the jobs in AO PT n D, we have CH(f) (A OPT n D) ::; (1 + i)copt(ao PT n D). Inequality (17) results fro the above three inequalities. In order to prove (18) we need to bound the extra error that ight occur due to the fact that AOPT n D :f= D(y?PT,..., y~pt). Notice that, for any Di, i = 1,...,B, the difference in processing tie between any two jobs in Di is at ost 2 L/9, and that D(y?PT,..., y~pt) contains the jobs with larger penalties in Di. The latter iplies that the extra error can only be due to the fact that the first y?pt jobs in Di have longer processing ties than those in AOPT n Di. Since the processing tie of a job in D is at least el/3 and U ::; 2L, no ore than 6/e jobs fro Dare scheduled on any achine. Therefore the overall extra contribution to the akespan due to the fact that AOPT n D :f= D(y?PT,..., y~pt) can be no pre than (6/f)(e 2 L/9) = 2eL/3, which iplies inequality (18).. This copletes the proof of correctness of the approxiation. The running tie of the algorith is doinated by the tie required to copute the heuristic ZH(f)(D(Yl,'",Ys) for each possible set of values Yh...,'Us, such that 0::; Yi::; IDil, i = 1,...,B. Since Yi, i = 1,.. " B, satisfies 1 ::; Yi ::; n, there are at ostn S = O(nlSrl/c 21 ) possible sets of values YI,,ys I For each of these sets an e-approxiate schedule is coputed using the algorith in [8], taking O((n/e)r 9 / f2 1); attaching the jobs in the set S just adds O(n 2 ) tie to each of these coputations. Hence, the overall running tie of the algorith is O((n 3 /e)r 9 / c2 1). This establishes that the algorith is a polynoial approxiation schee for the proble with arbitrary. 0

18 MULTIPROCESSOR SCHEDULING WITH REJECTION 16 6 Open probles and recent developents Soe open probles reain. For the on-line proble tight algoriths for the case of fixed other than = 2 are still to be established. For the off-line proble perhaps better heuristics ay be found by iproving the rejection strategy proposed in the algorith in Section 5.1. Seiden [13] has proved new results related to our proble. For the variant of deterinistic preeptive scheduling with rejection he gives a (4 + J1O) /3 ~ copetitive algorith for any nuber of achines, thus showing that allowing preeption can provably be exploited. Interestingly, this yields yet another 2-copetitive algorith for three achines. Also, Seiden notes that our Theore 4 yields a lower bound for preeptive scheduling as well, and hence yields a lower bound of 2 for general nuber of achines. For two achines, this shows that our algorith RP ( <P - 1) is best possible even aong all preeptive algoriths. For 3 achines, an interesting open proble is to establish if preeption allows a better copetitive ratio. The best upper bound of 2 and the best lower bound of for preeptive algoriths still coincide with those shown in this paper for non-preeptive algoriths. Seiden [13] also studies randoized scheduling with rejection, preeptive and non-preeptive. He gives algoriths which are better than deterinistic for sall nuber of achines, and in particular are 1.5-copetitive for 2 achines, both preeptive and non-preeptivej this is best possible for 2 achines. In both cases it is still open if randoized algoriths for any nuber of achines can be better than their deterinistic counterparts. Epstein and SgaU [4] presented polynoial tie approxiation schees for related achines for various objectives, including MSR, thus generalizing the polynoial tie approxiation schee given in this paper. Engels et al [3] study scheduling with rejection where in the objective the akespan is replaced by the su of the copletions ties. Acknowledgeents. We thank Giorgio Gallo for having drawn our attention to this scheduling proble. We thank anonyous referees for nuerous helpful coents. References [1] S. Albers. Better bounds for online scheduling. In Proc. of the 29th Ann. ACM Syp. on Theory of Coputing, pages ACM, [2] Y. Bartal, A. Fiat, H. Karloff, and R. Vohra. New algoriths for an ~nci~nt scheduling proble. J. Coput. Syst. Sci., 51(3): , [3] D. W. Engels, D. R. Karger, S. G. Kolliopoulos, S. Sengupta, R. N. Ua, and J. Wein. Techniques for scheduling with rejection. In Proc. of the 6th Ann. European Syp. on Algoriths, Lecture Notes in Coput. Sci. 1461, pages Springer-Verlag, 1998.

19 MULTIPROCESSOR SCHEDULING WITH REJECTION 17 [4] L. Epstein and J. Sgall. Approxiation schees for scheduling on uniforly related and identical parallel achines. Technical Report KAM-DIMATIA Series , Charles University, Prague, [5] G. Galabos and G. J. Woeginger. An on-line scheduling heuristic with better worst case ratio than Graha's list scheduling. SIAM J. Coput., 22(2): , [6] M. R. Garey and D. S. Johnson. Coputers and Intractability: A Guide to the Theory oj NP-copleteness. Freean, [7] R. L. Graha. Bounds for certain ultiprocessor anoalies. Bell Syste Technical J., 45: , Nov [8] D. S. Hochbau and D. B. Shoys. Using dual approxiation algoriths for scheduling probles: Theoretical and practical results. J. Assoc. Coput. Mach., 34: , [9] E. Horowitz and S. Sahni. Exact and approxiate algoriths for scheduling non-identical processors. J. Assoc. Coput. Mach., 23: , [10] D. R. Karger, S. J. Phillips, and E. Torng. A better algorith for an ancient scheduling proble. J. oj Algoriths, 20: , [11] R. M. Karp. On-line algoriths versus off-line algoriths: How uch is it worth to know the future? In J. van Leeuwen, editor, Pc. of the IFIP 12th World Coputer Congress. Volue 1: Algoriths, Software, Architecture, pages Elsevier Science Publishers, Asterda, [12] E. L. Lawler, J. K. Lenstra, A. H. G. Rinnooy Kan, and D. B. Shoys. Sequencing and scheduling: Algoriths and coplexity. In S. C. Graves, A. H. G. Rinnooy Kan, and P. Zipkin, editors, Handbooks in Operations Research and Manageent Science, Vol. 4: Logistics oj Production and Inventory, pages North-Holland, [13] S. S. Seiden~ More ultiprocessor scheduling with rejection. Technical Report Woe-16, Departent of Matheatics, TU Graz, Austria, [14] D. D. Sleator and R. E. Tarjan. Aortized efficiency of list update and paging rules. Co. Assoc. Coput. Mach., 28(2): , 1985.