EDF. New algorithm. Speed factor. 1.2 Deadline-ordered lower bound 1.1 General lower bound

Transcription

1 Trade-os between Speed and Processor in Hard-deadline Scheduling Tak Wah La Kar Keung To y Abstract This paper revisits the proble of on-line scheduling of sequential jobs with hard deadlines in a preeptive, ultiprocessor setting. An on-line scheduling algorith is said to be optial if it can schedule any set of jobs to eet their deadlines whenever it is feasible in the oline sense. It is known that the earliest-deadline-rst strategy (EDF) is optial in a one-processor setting, and there is no optial on-line algorith in an - processor setting where 2. Recent work [Phillips et al. stoc 97] however reveals that if the on-line algorith is given faster processors, EDF is actually optial for all (e.g., when = 2, it suces to use processors 1:5 ties as fast). This paper initiates the study of the trade-o between increasing the speed and using ore processors in deriving optial on-line scheduling algoriths. Several upper bound and lower bound results are presented. For exaple, the speed requireent of EDF can be reduced to 2? 1+p +p when it is given p 0 extra processors. The ain result is a new on-line algorith which deands less speedy processors so as to attain optiality (e.g., when = 2, the speed requireent is 1 1 ) and adits a better speed-processor trade-o than EDF (e.g., when = 2 and p = 1, the speed requireent is 1:2). In general, no optial palgorith exists when the speed factor is less than 1 (2 2 + p=? 2). 1 Introduction Probles of on-line scheduling have a rich literature (see e.g., [1, 2, 7, 11, 1] for soe recent results). In this paper we consider a classical scheduling proble encountered in a hard-deadline real-tie environent. There is a pool of identical processors. At any tie a job can be released, which is sequential in nature (i.e. to be run on at ost one processor at any tie), and ust be copleted before a certain deadline. The Departent of Coputer Science, The University of Hong Kong. Eail: twla@cs.hku.hk y Departent of Coputer Science, The University of Hong Kong. Eail: kkto@cs.hku.hk release tie of a job, as well as the required aount of work and the deadline, is known only when the job is released. This odel has been considered by any authors (see e.g., [9, 10, 12, 1]) for scheduling with deadlines. Our goal is to devise an on-line algorith to schedule such jobs so that their deadlines can all be et. We allow preeptive scheduling, which is coonly used in coputer systes. Not every set of jobs can be scheduled to eet their deadlines. We expect an on-line algorith to eet the deadline requireents whenever it is feasible in the o-line sense. Such an on-line algorith is said to be optial. When there is only one processor for scheduling, the earliest-deadline-rst strategy (EDF) gives an optial algorith [4]. However, when there are two or ore processors, it is known that no on-line algorith is optial [5]. Recently, there are studies on the eect of giving the on-line algorith faster processors in dierent scheduling probles [, 6, 10, 1]. Intuitively, using faster processors copensates the on-line algorith for the lack of future inforation. In the following, we assue that the o-line algorith is given processors of speed-1 and the on-line algorith is given processors of speed-s for soe s 1 (precisely, a speed-s processor can process x units of work in x=s units of tie). Regarding hard-deadline scheduling in particular, Phillips et al. [1] showed that, when using processors of speed- (2? 1=), EDF is actually optial. 1 That eans, for a two-processor syste, the speed requireent is 1.5. Phillips et al. [1] also showed a lower bound of 1.2 for all 2. Another way to facilitate the on-line algorith is to use ore processors. However, due to the sequential nature of the jobs, ore processors ay not iprove the perforance. It is known that EDF cannot achieve optiality even if it is allowed to use up to O() speed-1 1 Phillips also showed that the least-laxity-rst (LLF) strategy is optial when given speed-(2? 1=) processors. However, LLF ay schedule jobs to igrate aong processors innitely frequently, whereas EDF (as well as our new algorith) requires only O(n) igrations for a set of n jobs. 1

2 2 processors [1]. As far as we know, no on-line algorith using O() speed-1 processors is optial. This paper initiates the study of the trade-o between increasing the speed and using ore processors so as to attain optiality. Several upper bound and lower bound results are presented, illustrating to what extent using ore processors can reduce the speed requireent. For EDF, we show that the speed requireent is reduced to 2? 1+p +p when there are p 0 additional processors. In general, when is large, we nd that no optial algorith p exists when the processor speed is less than 1=(2 2 + p=?2) (which is roughly equal to 1:207 when p = 0). The ain result in this paper is a new scheduling algorith which deands a saller speed requireent to attain optiality and adits a better speed-processor trade-o than EDF. Precisely, when there are p 0 extra processors, the speed requireent is 2? 2()+p (+1)()+p (i.e. 2? 2 if p = 0). For +1 exaple, when = 2 and there is no extra processor, the speed requireent is 1 1 ; when = 2 and p = 1, the speed requireent is 1:2. The iproveent is rooted at a siple yardstick schedule which results fro an attept to estiate the optial o-line schedule. Like EDF, our new algorith depends on the relative ordering of the deadlines of jobs instead of their actual values. We call such algoriths deadlineordered. In this paper we also show iproved lower bounds on the speed and processor requireents of such kind of algoriths. When p extra processors are available, the speed requireent is at least 1? 1? ( ) + p ( ). When = 2 and p = 0, this lower bound is equal to 1 1 ; therefore, our algorith is actually the best possible deadline-ordered algorith in this case. Our work also iplies that using speed-1 processors, any algorith requires at least? 1 extra processors to achieve optiality. This result should be copared with the previously known lower bound for general algoriths [1], which states that at least =4 extra processors ust be used to achieve optiality. As a suary, we illustrate in Figure 1 the speedprocessor trade-o achieved by EDF and our new algorith, as well as the lower bounds for deadline-ordered algoriths and general algoriths. Related work: In the literature, the study of using faster processors to enhance on-line scheduling algoriths covers not only hard-deadline systes, but also soe less stringent requireents. Based on a setting siilar to the one considered in this paper, Speed factor EDF New algorith 1.2 Deadline-ordered lower bound 1.1 General lower bound p/ Figure 1: Trade-os between speed and processor when = 5. Kalyanasundara and Pruhs [10] have studied oneprocessor scheduling with an objective to axiize the benets earned fro jobs that eet the deadlines, and Phillips et al. [1] have studied the ultiprocessor scheduling in view of average response tie. There are also a nuber of interesting results based on a singleprocessor syste in which jobs have unknown processing tie [, 10]; the priary concern is again on average response tie. Edonds [6] recently extended these works to a ultiprocessor setting in which jobs are parallelizable (i.e., jobs can be speeded up by using ore processors). Organization: The reainder of this paper is organized as follows. Section 2 serves as a war-up, showing that using ore processors, EDF deands less on processor speed to achieve optiality. Section shows a lower bound on the speed requireent of any optial on-line algorith using + p processors. Section 4 describes a siple way to estiate the optial o-line schedule, which is then used in Section 5 to derive a new on-line algorith attaining the iproved results claied earlier. Section 6 shows new lower bounds for the class of deadline-ordered on-line algoriths. Before we leave this section, let us clarify how an on-line scheduling algorith operates. The algorith is invoked whenever an interrupt occurs. An interrupt is either triggered by the release of a job, or preset by the algorith itself in soe previous invocation. The output of the algorith is a apping fro the jobs to the processors. The algorith is said to be optial if it never isses a deadline for any feasible job set, that is, any job set which adits a schedule which eets all the deadlines using speed-1 processors.

3 2 Speed-processor trade-o for EDF With EDF, job assignent is done only when a job is released or copleted. Basically, whenever the nuber of reaining jobs does not exceed the nuber of processors, every job is assigned to a distinct processor; otherwise, only those with the earliest deadlines are assigned. In this section, we extend the work of Phillips et al. [1] to show that the speed requireent for EDF to achieve optiality can be lowered when ore processors are used. In particular, we prove that EDF is optial if it is given + p speed-(2? 1+p +p ) processors, where p is any nonnegative integer (Corollary 2.1). We also show that this trade-o result is tight at the end of this section (Lea 2.2). The following lea generalizes a property given in [1] about the work done in accordance with EDF, as well as any busy scheduling algorith (i.e. any algorith that produces a schedule satisfying that whenever there is an idling job that is not yet copleted, all processors ust be working on other jobs). Using this property, we obtain the trade-o result for EDF. Lea 2.1. Consider any algorith A using speed-1 processors, and any busy scheduling algorith A 0 using + p speed-s processors, where s 2? 1+p +p. Suppose A and A 0 are each used to schedule a job set L. At any tie t, let A(L; t) denote the total work done on L up to t with A, and siilarly A 0 (L; t) with A 0. Then A 0 (L; t) A(L; t). Proof. We prove the lea by contradiction. Assue that at soe tie t, A 0 (L; t) < A(L; t). Then there ust be a job J such that A 0 (fjg; t) < A(fJg; t). Denote r J as the release tie of J. Without loss of generality, we assue that A 0 (L; r J ) A(L; r J ) (otherwise we replace t by r J ). Consider the period of tie between r J and t. Let x be the aount of tie when A 0 uses all processors available, and let y be the rest of the tie. Since A 0 is a busy algorith, whenever A 0 is not using all processors, J ust be worked on by one processor. Therefore, sy A 0 (fjg; t) < A(fJg; t) x + y: Consider the work done for all jobs during the tie interval (r J ; t). We have s(( + p)x + y) A 0 (L; t)? A 0 (L; r J ) < A(L; t)? A(L; r J ) (x + y): Cobining the above inequalities, we have s( + p)(x + y) < (2 + p? 1)(x + y), which contradicts the bound of s. Corollary 2.1. Let p be any nonnegative integer. EDF, when given + p speed-s processors where s 2? 1+p +p, is optial. Proof. Suppose, for the sake of contradiction, that there exists a feasible job set L for which EDF causes the deadline of a job J to be issed. Denote (J) as the set of jobs in L with deadlines earlier than J. Note that (J) can be scheduled by soe o-line algorith A, and using EDF to schedule (J) would again cause the deadline of J to be issed. At the deadline of J, all jobs are copleted with A but not with EDF. This contradicts Lea 2.1. Lea 2.2. (Tightness) Let p be any nonnegative integer. EDF, when given + p speed-s processors where s < 2? 1+p +p, is not optial. Proof. It suces to show a feasible job set for which EDF fails to schedule all the jobs to eet the deadlines. Consider a set of + p + 1 jobs, all released at tie 0. Aong the, + p jobs are short, with required work? 1 and deadline + p. The last job is long, with required work + p and with deadline + p + for soe > 0. This job set is feasible as all deadlines can be et by a siple schedule: Allocate a processor solely for the long job, and allocate other processors for the sall jobs in a round-robin fashion. With EDF, the + p processors are each allocated to the short jobs until all of the are copleted. The tie for the long job to coplete is (++p)=s. Since s < 2? 1+p +p, (++p)=s > +p+ for soe chosen suitably. So EDF isses the deadline of the long job. A lower bound for trading processor for speed In this section, we derive a lower bound for the speed requireent of any on-line algorith using + p processors. We show that such algoriths need speedk+ 2 k p processors to achieve optiality, where k is any integer between 0 and. In particular, choosing 6 k = =2, we obtain a speed lower bound of 5+4p=. This result iplies the lower bound of 1:2 given in [1] for the case using no extra processor. When is large, we can choose a suitable p k so that the speed requireent approaches 1=(2 2 + p=? 2). In the special

4 4 case when p = 0, the bound is approxiately 1:207, slightly iproving the previous lower bound. Lea.1. No on-line algorith using + p speeds processors is optial when s < k+2 k p, where k is any integer between 0 and. Proof. To show this lower bound, we consider the following repetitive list of jobs. Assue that the tie frae is divided into iterations, each of length 1. At the beginning of each iteration, the following jobs are released. jobsrequired work: 1? k=; deadline: at the end of the iteration; k jobsrequired work: 1; deadline: at the end of the next iteration. The nuber of iterations is deterined by the adversary. In the nal iteration, there are additional jobs. They are released exactly after 1? k= units of tie has elapsed; each job requires k= units of work and has deadline at the end of this iteration. It is easy to see that an o-line algorith (using speed-1 processors) can schedule all the jobs to eet their deadlines. We dene the critical oent of an iteration to be the tie when 1? k= units of tie has elapsed. An on-line algorith (using + p speed-s processors) does not know whether an iteration is the nal one or not until it sees the additional jobs released at the critical oent. Just before the critical oent, let w be the aount of reaining work due to jobs with deadlines at the end of the current iteration. Note that w cannot be too large. Otherwise, if the current iteration is indeed the nal one, the additional jobs cannot be copleted in tie. More precisely, the algorith ust aintain k + w s( + p) k. In each iteration other than the nal one, the aount of work that can be done starting fro the critical oent is at ost w + sk(k=). Thus the axiu aount of work that can be done in each iteration is (1? k )s( + p) + w + sk( k ) (1? k )s( + p) + s( + p) k? k + sk k = s(p + + k 2 =)? k: Suppose the speed of the processors are (1?)(k+ 2 )=(k p) for soe > 0. Then the axiu aount of work that can be done in each iteration is s(p + + k 2 =)? k k + 2 = (1? ) (p + + k 2 =)? k k p =? (k + ): Note that the total aount of work due to the jobs released in each non-nal iteration is exactly. In other words, the on-line algorith fails to schedule at least (k + ) units of work after the rst iteration, and 2(k + ) after the second iteration. At the end of the (bk=((k + ))c + 1)-st iteration, the on-line algorith has accuulated ore than k units of work not yet scheduled. Since the aount of work with deadline later than the end of that iteration is only k, at least one of the jobs with deadline at the end of that iteration isses its deadline. Corollary.1. When is even, no on-line algorith using + p speed-s processors is optial when s < 6=(5 + 4p=). Proof. Putting k = =2 in Lea.1 yields the corollary directly. When is large enough, we can iprove this bound by choosing k ore carefully. That is, when is arbitrarily p large, we can choose k arbitrarily close to p?. This iplies that the speed requireent for an optial algorith using + p p processors is at least 1=(2 2 + p=? 2). 4 Yardstick schedule versus o-line schedule EDF is priarily based on a greedy strategy to drive its speedy processors to eet the deadlines. It does not care how the jobs are actually scheduled using speed- 1 processors. Our new algorith, called FR, perfors better by aking reference to a yardstick schedule using speed-1 processors. This yardstick schedule eets the deadlines of any feasible job set, although it is not a realistic schedule and cannot be used directly. Note that an on-line algorith does not know the jobs in advance. At a particular tie, a natural yardstick it can refer to is the optial o-line schedule (using speed-1 processors) for the jobs released so far. Yet polynoial tie algoriths for coputing the optial o-line schedule is known only in the special

5 5 Job List Yardstick Schedule A B C A 2 B C Current tie Tie copleted is scheduled on a processor and the aount of work done for these jobs ust equal to the aount of tie they had released. In other words, the aount of work done for any job by the real scheduler cannot exceed that by YS, contradicting the proposition that the real scheduler has done ore work over all released jobs. Figure 2: An exaple of yardstick schedule using 2 processors. Crosses in the gure denote deadlines of the jobs. Jobs A and B are released at tie 0, while Job C at tie 1. Note that C runs on both processors for 1 unit of tie in the yardstick schedule. case when = 2 [8]. Moreover, whenever a new job is released, the optial schedule ay change drastically, which then has little value to the on-line algorith since it cannot roll back its decision. To arrive at a good yardstick schedule, we ake an unrealistic assuption that when a job J is underworked (i.e., the work done on J is saller than the period of tie since J is released), J can be speeded up by running on ore than one processor siultaneously. With this assuption, we can extend EDF to obtain an on-line algorith, denoted YS below, that can produce a good yardstick schedule using speed-1 processors. YS is invoked when a job is released or copleted. YS always considers the reaining jobs in ascending order of the deadlines. Before scheduling a job J, YS takes an extra step to exaine whether J is under-worked. If not, YS siply allocates one processor for J; if so, YS allocates all reaining processors to work on J. In the latter case, YS will be invoked again as soon as J becoes no longer under-worked. See Figure 2 for an exaple. Note that YS is not a "real" scheduler as it depends on an unrealistic assuption. Yet YS is optial since processors are kept to be busy as far as possible in the following sense. Lea 4.1. At any tie, the total aount of work scheduled for all released jobs by any real scheduler using speed-1 processors cannot exceed that by YS. Proof. Suppose the contrary holds for soe tie period with respect to a real scheduler. Then within the tie period, there ust be a tie when the real scheduler schedules ore processors to work than YS. At this tie YS ust have soe processors idle. By denition, this can happen only if every released job that is not Lea 4.2. Using speed-1 processors, YS produces a schedule which does not iss any deadline for any feasible job set. Proof. Suppose that there is a feasible job set L in which soe jobs iss their deadlines under the schedule produced by YS. Aong these jobs, let J be the job with the earliest deadline. Denote (J) as the subset of L in which jobs have deadlines earlier than the deadline of J. Consider the scheduling of (J) by YS. Since YS deterines the schedule of a job before exaining any job with later deadline, the scheduling of jobs in (J) is the sae as the scheduling of L. Therefore, J still isses its deadline when YS is used to schedule (J). Also, (J) is feasible since it is a subset of a feasible job set. This however contradicts Lea 4.1 at the deadline of J, since all jobs are copleted in the optial schedule but not by YS. The assuption ade by YS actually does not give it too uch power. In fact, we can prove that EDF using speed-(2? 1 ) processors can atch the progress of YS on every job at any tie. In 5, we see that YS serves as a yardstick for our new algorith FR, which uses less speedy processors to atch the progress of YS and copletes every job no later than YS does. 5 FRa less speed-deanding algorith By siulating the on-line algorith YS, we can odify EDF to adjust dynaically so as to achieve optiality with less speedy processors. The new algorith is called FR. The reduced speed requireent is 2? 2. FR also +1 adits a trade-o between speed and processor. We show that if p 0 extra processors are available, the speed requireent of FR becoes 2? 2()+p (+1)()+p ( 5.2). For exaple, when = 2 and p = 0, the speed requireent is 1 1 ; when = 2 and p = 1, the speed requireent is 1.2. In the full paper we will show that both results are tight, in the sense that FR is not optial with slower processors. The nuber of igrations induced by FR

6 6 is linear in ters of the nuber of jobs, coparable to that of EDF ( 5.). As entioned in the previous section, EDF using speed-(2? 1 ) processors can atch the progress of YS which uses speed-1 processors. In fact, in ost cases, EDF schedules a job to work uch faster than YS, and copletes the job earlier. Notice that YS eets the deadlines of all jobs and there is no need to work faster than YS. The key idea of FR is to use a less greedy strategy for jobs whenever these jobs have been overscheduled, as copared with the yardstick schedule. Roughly speaking, FR attepts to apply EDF to schedule the jobs. This allows FR, using speed-s processors for soe s 2? 2, to outperfor any speed+1 1 algorith (and YS) on jobs with earlier deadlines as quickly as possible. However, when the reaining work of such a job J, denoted by W FR (J), becoes only a sall fraction (precisely, s=) of the reaining work of J in the yardstick schedule, FR deliberately slows down its execution as follows. Whenever YS allocates k 1 processors to J, FR allocates k= of a processor for it. Thus, the ratio between W FR (J) and W YS (J) reains to be s= until J copletes. As a result of this slowdown, jobs with later deadlines can be started earlier than in EDF, and they can eventually be copleted by FR using less speedy processors. The algorith FR is illustrated in Algorith 1. Once a job is released, it is said to be in full ode. At the tie when W FR (J) = (s=)w YS (J), the job is said to be in reduced ode. Jobs in reduced ode are always allocated in a specic processor, which is denoted by P l. In 5.1 we see that speed-(2? 2 +1 ) processors are sucient to guarantee that each job eventually switches to reduced ode, and copletes exactly when it copletes in the yardstick schedule. It is worth-entioning that FR, like soe other well-known scheduling algoriths such as Balance and Equi-partition (see e.g., [, 6, 10]), takes advantage of the tie-sharing capability of processors. Yet FR only needs tie-sharing in at ost one processor (i.e., P l ). For convenience, the discussion in Algorith 1 allows P l to be tie-shared by up to jobs. In the full paper, we will give a sall odication to FR, with which at ost two jobs are scheduled to tie-share P l. This odication is not only of theoretical interest. In practice, tie-sharing aong any jobs causes a lot of overheads. 5.1 Optiality In the reainder of this section we show that FR is optial when given speed-s processors, where s 2? 2. With the optiality +1 of YS (Lea 4.2), it suces to prove the following lea: Lea 5.1. Consider the scheduling of any feasible job set L using FR, as well as that using YS. At any tie t, for any job J 2 L, W FR (J) W YS (J). Proof. We prove this lea by contradiction. Without loss of generality, suppose the job J 0 with the latest deadline in L is the only job failing to satisfy the lea (otherwise we nd the job J with the earliest deadline violating the lea, and replace L with the subset of L with deadlines no later than J). Let r denote the release tie of J 0. Let t be the rst tie such that W FR (J 0 ) = W YS (J 0 ) at t, and W FR (J 0 ) > W YS (J 0 ) right after t. That is, YS akes ore progress on J 0 than FR starting fro t. Note that J 0 ust be in full ode at tie t (because once a job J has switched to reduced ode, W FR (J) = (s=)w YS (J)). The only way YS akes ore progress on J 0 fro t onward is to use ultiple ( 2) processors for J 0 at t. Therefore, J 0 is under-worked by YS at t. We observe a nuber of interesting properties: h1i The aount of work YS has scheduled on J 0 up to t, which is equal to the aount of work FR has scheduled on J 0, is strictly less than t? r. h2i At t, every job other than J 0 is either already copleted by YS (as well as by FR), or not under-worked and selected for execution by YS. Otherwise, YS cannot selects J 0 the job with the latest deadlinefor execution. We call these two categories of jobs C and R respectively. Note that jrj? 2. hi Let t 0 be any tie before t. Consider the aount of work scheduled for J 0, as well as any job in C, during the period of tie (t 0 ; t). The aount of work scheduled with YS is at least that with FR. This is because at t, W YS (J 0 ) = W FR (J 0 ) and W YS (J) = W FR (J) = 0 for every job J in C; and at t 0, W YS (J) W FR (J) for every job J. We partition the tie period fro r to t according to the processor share FR allocates to J 0. For each 0 i, we denote x i as the total length of tie periods during which FR allocates i= of a processor

7 Algorith 1 FR 1: Update ode(j) for each job J. 2: Siulate YS. : for all jobs J which YS schedules k 1 processors to work on J do 4: if ode(j) = full then 5: Schedule J to one processor, using processors other than P l if possible. 6: else 7: Schedule J to k= of P l. 8: while soe processor other than P l is not used and soe full ode job is not scheduled do 9: Schedule the job with the earliest deadline aong these jobs to that processor. 10: if P l is not fully used and soe full ode job is not scheduled then 11: Schedule the job with the earliest deadline aong these jobs to all reaining share of P l. 12: Preset an interrupt to occur at the earliest of the following: an interrupt preset by YS, the rst tie when a job would coplete, and the rst tie when a job would change ode. 7 to J 0. The P aount of work FR scheduled on J 0 up to tie t is P s(i=)x i. By h1i, this is strictly less than t?r = x i. We thus obtain an upper bound on the aount of tie when FR uses one full processor for J 0. (5.1) (s? 1)x < si 1? x i On the other hand, we observe that FR has a tendency to allocate a full processor to J 0 and thus x has a suciently large lower bound, contradicting the upper bound above. For 0 j jrj, dene r j as the rst tie after r when j or ore jobs have been releases. For jrj + 1 j? 1, we dene r j to be t. Note that r 0 = r. Denote x i;j as the total length of tie periods in (r j ; r j+1 ) during which FR P allocates i= of a processor to J 0. Note that x i = x j=0 i;j. In the following discussion, we inductively show for =? 1 down to 0 a relation concerning the period of tie (r ; t): (5.2) 1? si j= When = 0, (5.2) leads to: x i;j (s? 1) j= 1? si x i (s? 1)x : x ;j : We thus have a contradiction with (5.1). This shows that J 0 does not exist and Lea 5.1 holds. The inductive proof of (5.2) goes fro the trivial case where =? 1, in which all x i; are zero (since jrj? 2). Assuing that (5.2) holds for 0? 1, we consider the case for 0? 1. We add up (5.2) for all 0 to produce (5.) 1? si j= 0?1 (s? 1) (j? 0 + 1)x i;j j= 0?1 (j? 0 + 1)x ;j : We analyze how uch work YS has perfored on all jobs, i.e. fj 0 g [ R [ C, during the tie period (r 0?1; t). With respect to this period of tie, let w 0 and w 1 be the aount of work done for jobs in C with YS when J 0 runs on a partial and full processor respectively according to FR. By hi, the aount of work done for J 0 with YS P j= 0?1 s(i=)x i;j. P is at least that with FR, i.e. The aount of work done with YS for jobs in C is w 0 + w 1. For a job in R released at r j on or after r 0?1, exactly t? r j work is done since the job is not under-worked at t. Siilarly, for a job in R released before r 0?1, at least t? r 0?1 work is done. P This leads to at least j= jx 0?1 i;j work done for jobs in R. On the other hand, YS can do at ost (t? r 0?1) = j= x 0?1 i;j work during the period of tie, producing the following relationship. (5.4) j= 0?1 si x i;j + j= 0?1 + w 0 + w 1 jx i;j j= 0?1 x i;j We obtain another relationship concerning the tie period (r 0?1; t) when we study the work on C with FR. Whenever FR uses less than one processor for J 0,

8 8 no processor can be idle (since J 0 is still in full ode). Between r j and r j+1, only jobs released on or before r j can be scheduled since other jobs are released on or after r j. So only j processors can be used for jobs in R. Exactly i= processors are used for J 0 for a period of length x i;j. All the reaining processors ust be scheduled for executing jobs in C. By denition, FR ensures that whenever k processors is used for a job with YS, at least k= processors are used for that job in FR. Therefore, for the tie when one processor is scheduled for J 0, at least (s=)w 1 work is scheduled for C. On the other hand, we know fro hi that the aount of work done on C by FR does not exceed that by YS (i.e. w 0 + w 1 ). Therefore, (5.5) s w 0 P j= 0?1 (? j? i )x i;j + s w 1 w 0 + w 1 : Together with the fact that s 2? 2 and +1 P j= x 0?1 i, we obtain the following lower P bound for j= x 0?1 ;j after eliinating w 0 and w 1 fro (5.)(5.5). j= 0?1 1? si + 2i(? 2? j) 2 + 1? ( + 1) 0 x i;j (s? 1) j= 0?1 x ;j This copletes the inductive proof of (5.2), since the extra ter on the left of the inequality above is never negative. 5.2 Trade-o between speed and processor In this section we sketch the eect when + p processors are available to the FR algorith (when we know that the job set is feasible using only processors). Note that the algorith is still well dened. Although p extra processors are available to FR, we still use YS without any extra processor as the yardstick. With ore processors, FR achieves optiality with less speedy achines. More precisely, we show that FR is optial when given + p speed-s processors, where 2()+p (+1)()+p s 2?. The proof is siilar to 5.1. In particular, we show Lea 5.1 under this setting, by a contradiction between inequalities (5.1) and (5.2). Note that h1ihi still hold. Since inequalities (5.1), (5.) and (5.4) do not involve the aount of work done by FR for jobs other than J 0, these inequalities also hold under this setting. To coplete the inductive proof of (5.2), we iprove (5.5) as follows. Again we study the work done on C with FR. Whenever FR schedules less than one processor for J 0, no processor can be idle. Since p ore processors are available, this iplies that there are ore processors reaining which ust be scheduled for executing jobs in C. This results in the following inequality: (5.6) s j= 0?1 ( + p? j? i )x i;j + s w 1 Together with the fact that s P w 0 + w 1 : 2()+p (+1)()+p P and the bound w 0 x j=0 i;j, we obtain fro (5.), (5.4) and (5.6) the following lower bound for P j= x 0?1 ;j. j= 0?1 where T = si 1? + T x i;j (s? 1) j= 0?1 (s? 1)(2 + p? 2) (? 0? s + 1)(? 1) 2 ( + p? 1) x ;j (i((? 1)( + p? 2)? j( + p? 1)) + jp) Coparing with (5.2), we have an extra ter T on the left of the inequality. T is never negative, copleting the inductive proof of (5.2) and thus the proof of Lea Nuber of igrations To bound the nuber of igrations, FR need to be ore careful when it chooses a processor for each scheduled job. In the previous discussion, the scheduling of the processor P l is copletely deterined. Jobs allocated to other processors are always allocated a full processor. We show that the following siple allocation strategy for processors other than P l would guarantee that only O(n) igrations are required, where n is the nuber of jobs released. After the algorith is invoked and the set of jobs to be executed is deterined, it copares the jobs

9 9 to be executed in processors other than P l before and after the invocation. For jobs which is allocated a processor both before and after the algorith is invoked, it siply stays in the sae processor. The reaining jobs are allocated arbitrarily in the reaining processors. Now we bound the nuber of igrations required by the algorith for jobs. Jobs in reduced ode always work on the sae processor and thus need no igration. Each job ay change to reduced ode only once, so in total we have at ost n igrations when jobs change ode. For full ode jobs, FR always schedules the? 1 earliest deadline jobs which are in full ode in the processors other than P l. Therefore the schedule in the rst? 1 processors is exactly the sae as an EDF schedule in which? 1 processors are available. The nuber of jobs, release ties and deadlines of all jobs are exactly the sae as that of the input for FR; The processing tie of each job is the aount of work for the job which is scheduled to processors other than P l in FR; The nuber of igrations needed by this EDF schedule is O(n). Therefore, in FR, jobs working in the rst? 1 processors need only O(n) igrations. Finally, full ode jobs ay need to igrate to or fro P l, but there can only be one such igration per release and ode change, aounting to at ost 2n igrations. Adding up all these, the nuber of igrations is O(n). 6 Lower bound result for deadline-ordered algoriths Both EDF and FR are deadline-ordered algoriths, with which the scheduling of jobs depends only on the relative order of job deadlines instead of their exact values. For such kind of algoriths, we obtain new lower bound results on the aount of extra speed and processors to achieve optiality: Theore 6.1. No deadline-ordered algorith is optial if only p extra processors are given and all processors are speed-s, where 1 s < 1? ( ) + p : ( ) L OPT L1 OPT A B C D E A 1111 B C C D E A B C D E A B 1 2 B C D Tie E Figure : Lower bound exaple when =. The job lists L and L 1 are illustrated, together with a possible schedule by an o-line algorith. Proof. Consider a collection of feasible job sets which are identical except the deadlines; the deadlines, though having dierent values, have the sae relative ordering. The behavior of a deadline-ordered algorith is the sae for any of such job sets. Our lower bound arguent exploits the this feature of deadline-ordered algoriths. We construct the following job set denoted L, which is characterized by a sall positive constant. One job for each 0 k? 1; release tie: 0, required work: 1, deadline (=(? 1)) + k; One job for each 1 k? 1; release tie: 0, required work: (=(? 1)) k, deadline (=(? 1)) + (? 1 + k). Since all jobs have the sae release tie and have deadlines before (=(? 1)), an optial o-line algorith ay siply schedule each job in turn, using up the period of tie fro 0 to (=(? 1)) of a processor before considering the P next processor. Since the total aount of work is + (=( k=1? 1))k = (=(? 1)), processors suces to coplete all jobs without issing any deadline. For each 0 j? 1, consider the following job set L j : One job for each 0 k? 1; release tie: 0, required work: 1, deadline (=(? 1)) j + k;

10 10 One job for each 1 k j; release tie: 0, required work: (=(? 1)) k, deadline (=(? 1)) j + (? 1 + k). One job for each j + 1 k? 1; release tie: 0, required work: (=(? 1)) k, deadline 2(=(? 1)) + (? 1 + k). By an arguent siilar to the feasibility of L, the rst + j jobs can all be copleted by (=(? 1)) j by an o-line optial algorith. The reaining jobs can be scheduled exactly as L starting at tie (=(? 1)). Thus L j is feasible. See Figure for an exaple. Note that the collection of two jobs fl; L j g satis- es the requireents set at the beginning of the proof, and thus are scheduled exactly the sae by a deadlineordered on-line algorith. Since the algorith is optial, the rst + j jobs ust all be copleted before the deadline of the ( + j)-th job in L j, i.e. before tie (=(? 1)) j + (? 1 + j). This iplies that, during the execution of the deadline-ordered on-line algorith for L, only?j jobs reain in the syste, and thus at least j processors ust sit idle, after tie (=(? 1)) j + (? 1 + j). By using a sall enough, the su of non-idle tie of all processors can be ade arbitrarily close to p + (? 1) + (=(? 1)). In these tie the algorith ust copletes all jobs, which total work is (=(? 1)). Dividing these two quantities gives the desired lower bound for the speed requireent of a deadline-ordered on-line algorith. Putting s = 1 in Theore 6.1, we obtain a lower bound for the nuber of speed-1 processors to achieve optiality. Corollary 6.1. Using speed-1 processors, a deadlineordered algorith needs at least? 1 extra processors to be optial. [] P. Beran and C. Coulston, Speed is ore powerful than clairvoyance, in Proceedings of the Sixth Scandinavian Workshop on Algorith Theory, To appear. [4] M. L. Dertouzos, Control robotics: the procedural control of physical processes, in Proceedings of IFIP Congress, 1974, pp [5] M. L. Dertouzos and A. K. L. Mok, Multiprocessor online scheduling of hard-real-tie tasks, IEEE Transactions on Software Engineering, 15 (1989), pp [6] J. Edonds, Non-clairvoyant ultiprocessor scheduling of jobs with arbitrary arrival ties and changing execution characteristics. Manuscript. [7] J. Edonds, D. D. Chinn, T. Brecht, and. Deng, Non-clairvoyant ultiprocessor scheduling of jobs with changing execution characteristics (extended abstract), in Proceedings of the Twenty-Ninth Annual ACM Syposiu on Theory of Coputing, 1997, pp [8] M. R. Garey and D. S. Johnson, Coputers and intractability: a guide to the theory of NP-copleteness, W. H. Freean, [9] D. Guseld, Bounds for naive ultiple achine scheduling with release ties and deadlines, Journal of Algoriths, 5 (1984), pp. 16. [10] B. Kalyanasundara and K. R. Pruhs, Speed is as powerful as clairvoyance, in Proceedings of the 6th Annual Syposiu on Foundations of Coputer Science, 1995, pp [11] B. Kalyanasundara and K. R. Pruhs, Miniizing ow tie nonclairvoyantly, in Proceedings of the 8th Annual Syposiu on Foundations of Coputer Science, 1997, pp [12] G. Koren, D. Shasha, and S. C. Huang, MOCA: A ultiprocessor on-line copetitive algorith for real-tie syste scheduling, in Proceedings of the Fourteenth Real-Tie Systes Syposiu, 199, pp [1] C. A. Phillips, C. Stein, E. Torng, and J. Wein, Optial tie-critical scheduling via resource augentation, in Proceedings of the Twenty-Ninth Annual ACM Syposiu on Theory of Coputing, 1997, pp References [1] S. Albers, Better bounds for online scheduling, in Proceedings of the Twenty-Ninth Annual ACM Syposiu on Theory of Coputing, 1997, pp [2] M. A. Bender, S. Chakrabarti, and S. Muthukrishnan, Flow and stretch etrics for scheduling continuous job streas, in Proceedings of the Ninth Annual ACM-SIAM Syposiu on Discrete Algoriths, 1998, pp