Task Scheduling with Self-Suspensions in Soft Real-Time Multiprocessor Systems

Transcription

1 ask Schedulng wth Self-Suspensons n Soft Real-me Multprocessor Systems Cong Lu and James H. Anderson Department of Computer Scence, Unversty of North Carolna at Chapel Hll Abstract Job release Job deadlne Executon Suspenson In work on multprocessor real-tme systems, task schedulng wth self-suspensons s a relatvely unexplored topc. In ths paper, soft real-tme sporadc task systems are consdered that nclude self-suspendng tasks. Condtons are presented for guaranteeng bounded deadlne tardness n such systems under global EDF or FIFO multprocessor schedulng. hese condtons enable many soft real-tme task systems wth self-suspendng tasks to be scheduled wth lttle or no utlzaton loss. Introducton In many real-tme systems, tasks nteract wth external devces that ntroduce self-suspenson delays. Examples of such devces nclude sold-state and magnetc dsks and network cards. Delays ntroduced by such devces can be moderate (e.g., roughly µs per read and µs per wrte for NAND Flash) or qute lengthy (e.g., roughly ms for magnetc dsks) [, ]. Unfortunately, such delays qute negatvely mpact schedul n real-tme systems f deadlne msses cannot be tolerated []. In ths paper, we consder whether, on multprocessor platforms, such negatve mpacts can be amelorated f task deadlnes are soft. Our focus on multprocessors s motvated by the advent of multcore platforms. here s currently great nterest n provdng operatng-system support to enable real-tme workloads to be hosted on such platforms. Many such workloads can be expected to nclude self-suspendng tasks. Moreover, n many settngs, such workloads can be expected to have soft tmng constrants. he soft tmng constrant consdered n ths paper pertans to mplct-deadlne sporadc task systems and requres that deadlne tardness be bounded. All multprocessor schedulng algorthms follow ether a parttonng or global-schedulng approach (or some combnaton of the two). Under parttonng, tasks are statcally assgned to processors, whle under global schedulng, they Work supported by A&, IBM, Intel, and Sun Corps.; NSF grants CNS, CNS, and CNS 9; and ARO grant W9NF---. Fgure : Example task system wth low utlzaton. may mgrate. Under parttonng schemes, constrants on overall utlzaton are requred to ensure tmelness even f bounded deadlne tardness can be tolerated. On the other hand, a varety of global-schedulng approaches are capable of ensurng bounded tardness n sporadc systems (wthout self-suspendng tasks), as long as the system s not overutlzed []. Unfortunately, f tasks may self-suspend, then bounded tardness cannot be guaranteed even on unprocessors wthout constranng the system n some way. Consder, for example, the unprocessor task system, scheduled by the earlest-deadlne-frst (EDF) algorthm, shown n Fg.. hs system conssts of two tasks, each of whch releases a new job every tme unts that executes for. tme unt, then suspends for 9 tme unts, and then executes for another. tme unt. ardness grows unboundedly n ths system, even though ts s small. Motvated by the observatons above, we consder n ths paper whether t s possble to specfy reasonable constrants under whch bounded deadlne tardness s guaranteed under global schedulng algorthms, for mplctdeadlne sporadc tasks systems wth self-suspendng tasks. We focus specfcally on two global schedulng algorthms that are capable of ensurng bounded tardness for ordnary (suspenson-less) sporadc systems wth no utlzaton loss [, ], namely, the global earlest-deadlne-frst (GEDF) algorthm and the global frst-n frst-out (GFIFO) algorthm. Related work. o our knowledge, self-suspensons have not been consdered before n the context of global real-tme schedulng algorthms. In work pertanng to unprocessors (and by extenson multprocessors scheduled va parttonng), several schedul tests have been presented for analyzng tasks wth self-suspensons. hese nclude a utlzaton-based test for

2 EDF [] and response-tme-bound tests for fxed-prorty systems [, ] and EDF-scheduled systems []. On a more negatve note, Rdouard et. al have shown that the feasblty problem for hard real-tme, ndependent tasks wth self-suspensons s NP-hard n the strong sense. Rdouard and Rchard [] have also shown that no optmal on-lne algorthm exsts for task systems wth selfsuspensons. In fxed-prorty systems, schedulng penaltes assocated wth self-suspensons can be lessened by usng a technque called the perod enforcer [], whch forces suspensons to occur more predctably. Contrbutons. We show that GEDF s and GFIFO s to guarantee bounded tardness n sporadc systems wth self-suspendng tasks hnges upon a task parameter that we call the maxmum suspenson rato, denoted ξmax, H wth range [,]. We present a general tardness bound, whch s applcable to ether GEDF or GFIFO, that expresses tardness as a functon of ξmax H and other task parameters. hs bound shows that task systems consstng of both self-suspendng tasks and ordnary computatonal tasks that do not suspend can be supported wth bounded tardness f ξmax H < U sum s + UL c, where m s the m number of processors, Usum s s the of selfsuspendng tasks, and UL c s the of the m computatonal tasks of hghest utlzaton. he task model assumed n obtanng ths result s very general and allows self-suspensons wthn a task s jobs to nterleave arbtrarly wth computaton. We show va a counterexample that task systems that volate our utlzaton constrant may have unbounded tardness. o assess the mpact of ths constrant, we present schedul experments that compare our analyss to a common approach for analyzng systems wth self-suspensons wheren suspensons are merely treated as computaton. In these experments, our approach proved to be superor (.e., could guarantee bounded tardness for more systems) n most of the tested scenaros. Organzaton. he rest of ths paper s organzed as follows. Sec. descrbes our system model. In Sec., our tardness bound s derved and evaluated. Sec. concludes. System Model We consder the problem of schedulng a set τ = {,..., n } of n ndependent sporadc tasks on m dentcal processors. Each task s released repeatedly, wth each such nvocaton called a job. Jobs alternate between computaton and suspenson phases. We assume that each job of l executes for at most e l tme unts (across all of ts executon phases) and suspends for at most s l tme unts (across all of ts suspenson phases). We place no restrctons on how these phases nterleave (a job can even begn or end wth a suspenson phase). he j th job of l, denoted l,j, s released at tme r l,j and has a deadlne at tme d l,j. Assocated wth each task l s a perod p l, whch specfes both the mnmum tme between two consecutve job releases of l and the relatve deadlne of each such job,.e., d l,j = r l,j + p l. he utlzaton of a task l s defned as u l = e l /p l, and the utlzaton of the task system τ as U sum = u τ. We requre e l + s l p l, u l, and U sum m; otherwse, tardness can grow unboundedly (f e l + s l > p l or u l >, then l s tardness grows unboundedly; f U sum > m, then the system s overloaded, whch mples that tardness grows unboundedly for at least one task). A common case for real-tme workloads s that both selfsuspendng tasks and computatonal tasks (whch do not suspend) co-exst. o reflect ths, we let Usum s denote the of all self-suspendng tasks, and Usum c denote the of all computatonal tasks. Successve jobs of the same task are requred to execute n sequence. If a job,j completes at tme t, then ts response tme s t r,j and ts tardness s max(, t d,j ). A task s tardness s the maxmum tardness of any of ts jobs. Note that, when a job of a task msses ts deadlne, the release tme of the next job of that task s not altered. Unless stated otherwse, we henceforth assume that each job of any task l executes for exactly e l tme unts. By Clam, gven n an appendx, any tardness bound derved for systems that meet ths restrcton apples to other systems as well. So that our analyss can be more accurately appled n settngs where a task s total suspenson tme vares from job to job, we assume that a fxed parameter H (H ) s specfed and that S H denotes the maxmum total selfsuspenson length for any H (H ) consecutve jobs of task. Note that f H =, then a maxmum per-job total suspenson length s beng assumed. Under GEDF (GFIFO), released jobs are prortzed by ther deadlnes (release tmes). So that our results can be appled to both algorthms, we consder a generc schedulng algorthm (GSA) where each job s prortzed by some tme pont between ts release tme and deadlne. Specfcally, for any job,j, we defne a prorty value ρ,j = r,j + κ p, where κ. Lower prorty values denote hgher prortes, and tes are assumed to be broken n favor of tasks wth smaller ndces. Note that GEDF and GFIFO are specal cases of GSA where κ s set to and, respectvely. A ardness Bound for GSA We derve a tardness bound for GSA by comparng the allocatons to a task system τ n a processor sharng (PS) schedule and an actual GSA schedule of nterest for τ, both on m

3 r, v, v preempted d, v r, v s actve, v suspended ,v s pendng d, v,v s enabled Fgure : Illustraton of Defs. -. he last executon phase of,v completes suspended fnte job set J at tme t n the schedule S s defned by LAG(J, t, S) =,j J lag(,j, t, S) =,j J (A(,j,, t, P S) A(,j,, t, S)). () Our tardness-bound dervaton follows a format orgnally presented n [] and focuses on a gven task system τ. We order the jobs n τ based on ther prortes:,v a,b ff ρ,v < ρ a,b or (ρ,v = ρ a,b ) ( < a). Let l,j be a job of a task l n τ, t d = d l,j, and S be a GSA schedule for τ wth the followng property. processors, and quantfyng the dfference between the two. We analyze task allocatons on a per-task bass. he tme nterval [t, t ), where t > t, conssts of all tme nstances t, where t t < t, and s of length t t. For any tme t >, the notaton t s used to denote the tme t ε n the lmt ε +, and the notaton t + s used to denote the tme t + ε n the lmt ε +. Defnton. A task s actve at tme t f there exsts a job,v such that r,v t < d,v. Defnton. Job,v s pendng at tme t f t r,v and,v has not completed all of ts executon phases by t. Note that,v s not pendng at t f t has completed all ts executon phases by t but not all of ts suspenson phases. Defnton. Job,v s enabled at t f t r,v,,v has not completed by t, and ts predecessor (f any) has completed by t. A job s consdered to be completed f t has fnshed ts last phase (be t suspenson or computaton). he above three defntons are llustrated n Fg.. Let A(,j, t, t, S) denote the total allocaton to the job,j n an arbtrary schedule S n [t, t ). hen, the total tme allocated to all jobs of n [t, t ) n S s gven by A(, t, t, S) = j A(,j, t, t, S). Consder a PS schedule PS. In such a schedule, executes wth the rate u when t s actve. (Note that suspensons are not consdered n the PS schedule.) hus, f s actve throughout [t, t ), then A(,j, t, t, P S) = (t t )u. () he dfference between the allocaton to a job,j up to tme t n a PS schedule and an arbtrary schedule S, denoted the lag of job,j at tme t n schedule S, s defned by lag(,j, t, S) = A(,j,, t, P S) A(,j,, t, S). () he concept of lag s mportant because, f lags reman bounded, then tardness s bounded as well. he LAG for a (P) he tardness of every job,k such that,k l,j s at most x + e + s n S, where x. Our objectve s to determne the smallest x such that the tardness of l,j s at most x + e l + s l. hs would by nducton mply a tardness of at most x + e + s for all jobs of every task, where τ. We assume that l,j fnshes after t d, for otherwse, ts tardness s trvally zero. he steps for determnng the value for x are as follows.. Determne an upper bound on the work pendng for tasks n τ that can compete wth l,j after t d. hs s dealt wth n Lemmas n Sec.... Determne a lower bound on the amount of work pendng for tasks n τ that can compete wth l,j after t d, requred for the tardness of l,j to exceed x + e l + s l. hs s dealt wth n Lemma n Sec.... Determne the smallest x such that the tardness of l,j s at most x + e l + s l, usng the above upper and lower bounds. hs s dealt wth n heorem n Sec... Defnton. We categorze jobs based on the relatonshp between ther prortes and deadlnes and those of l,j : d = {,v : (,v l,j ) (d,v t d )}; D = {,v : (,v l,j ) (d,v > t d )}. d s the set of jobs wth deadlnes at most t d wth prorty at least that of l,j. hese jobs do not execute beyond t d n the PS schedule. Note that l,j s n d. D s the set of jobs that have hgher prortes than l,j and deadlnes greater than t d. Note that jobs not n d D have lower prorty than those n d D and thus do not affect the schedulng of jobs n d D. For smplcty, we wll henceforth assume that no job not n d D executes n ether the PS or GSA schedule. Let D CI be the set of tasks wth jobs n D. D conssts of carryn jobs, whch have a release tme before t d and a deadlne after t d. Exactly one such job exsts for each task n D CI. (Note that D s empty under GEDF because jobs wth later deadlnes have lower prortes.)

4 Defnton. A tme nstant t s busy for a job set J f all m processors execute a job n J at t. A tme nterval s busy for J f each nstant wthn t s busy for J. he followng clam follows from the defnton of LAG. Clam. If LAG(d, t, S) > LAG(d, t, S), where t > t, then [t, t ) s non-busy for d. In other words, LAG for d can ncrease only throughout a non-busy nterval. An nterval could be non-busy for d for two reasons:. here are not enough enabled non-suspended jobs n d to occupy all avalable processors. Such an nterval s called non-busy non-dsplacng.. here are enabled non-suspended jobs n d that are not scheduled (because jobs n D occupy one or more processors). Defnton. Let δ k be the amount of executon tme consumed by a carry-n job k,v by tme t d. Defnton. Let B(D, t d, S) be the amount of work due to jobs n D that can compete wth l,j after t d. Snce d D ncludes all jobs of hgher prorty than l,j, the competng work for l,j s gven by the sum of () the amount of work pendng at t d for jobs n d, and () the amount of work B(D, t d, S) demanded by jobs n D that competes wth l,j after t d. Snce jobs from d have deadlnes at most t d, they do not execute n the PS schedule beyond t d. hus, the work pendng for them s gven by LAG(d, t d, S). herefore, the competng work for l,j after t d s gven by LAG(d, t d, S) + B(D, t d, S). Let Z = LAG(d, t d, S) + B(D, t d, S). () A summary of the terms defned so far, as well as some addtonal terms defned later, s presented n able.. Upper Bound In ths secton, we determne an upper bound on Z. Defnton. Let t n be the end of the latest non-busy nondsplacng nterval for d before t d, f any; otherwse, t n =. he followng two lemmas have been proved prevously for both GEDF [] and GFIFO [] for ordnary sporadc task systems wthout self-suspensons. Note that the value of LAG(d, t d, S)+B(D, t d, S) depends only on allocatons n the PS schedule P S and allocatons to jobs n d D n the actual schedule S by tme t d. he PS schedule s not mpacted by self-suspensons. Also, Property (P) alone s suffcent for determnng how much work any job n d D other than l,j completes before t d. For these reasons, Lemmas and contnue to hold for task systems wth selfsuspensons. For completeness, proofs are gven n the appendx. m Number of processors n Number of tasks S( l,j ) Start tme of job l,j F ( l,j ) Fnsh tme of job l,j t d Deadlne of job l,j Esum s otal executon cost of all selfsuspendng tasks n τ E sum otal executon cost of all tasks n τ Ssum s otal suspenson length of all tasks n τ u s max Maxmum utlzaton of any selfsuspendng task n τ UL c Sum of the mn(m, c) largest computatonal task utlzatons, where c s the number of computatonal tasks EL c Sum of the mn(m, c) largest computatonal task executon costs S H Maxmum total self-suspenson length for any H (H > ) consecutve jobs of task Smax H Maxmum total self-suspenson length for any H (H > ) consecutve jobs of any task n τ ξ H Suspenson rato of ξmax H Maxmum suspenson rato δ k Amount of executon tme consumed by a carry-n job k,v by tme t d B(D, t d, S) Amount of work due to jobs n D that can compete wth l,j after t d W Amount of work due to jobs n d D that can compete wth l,j at or after t d + y, ncludng the work due for l,j Z Amount of competng work for l,j after t d t s Earlest non-busy nstant n [t d, t d + y) t p Fnsh tme of l,j s predecessor, f t exsts; otherwse (j = ), t p = able : Summary of notaton. Lemma. LAG(d, t d, S) LAG(d, t n, S) + k D CI δ k ( u k ), where t [, t d ]. Lemma. lag(, t, S) u x + e + u s for any task and t [, t d ]. Lemma below upper bounds LAG(d, t n, S). Defnton 9. Let E s sum be the total executon cost of all self-suspendng tasks n τ. Let E sum be the total executon cost of all tasks n τ. Let S s sum be the total suspenson length of all tasks n τ. Let u s max be the maxmum utlzaton of any self-suspendng task n τ. Defnton. Let UL c be the sum of the mn(m, c) largest computatonal task utlzatons, where c s the num-

5 ber of computatonal tasks. Let EL c be the sum of the mn(m, c) largest computatonal task executon costs. Lemma. LAG(d, t n, S) (U s sum + U c L ) x + Es sum + E c L + us max S s sum. Proof. By summng ndvdual task lags at t n, we can bound LAG(d, t n, S). If t n =, then LAG(d, t n, S) =, so assume t n >. Consder the set of tasks β = { :,v n d such that,v s enabled at t n }. Gven that the nstant t n s non-busy non-dsplacng, at most m computatonal tasks n β have jobs executng at t n. Due to suspensons, however, β may contan more than m tasks. In the worst case, all suspendng tasks n τ have a suspended enabled job at t n and mn(m, c) computatonal tasks have an enabled job executng at t n. If task does not have an enabled job at t n, then lag(, t n, S). herefore, by (), we have LAG(d, t n, S) = lag(, t n, S) :,v w d β lag(, t n, S) {by Lemma } β(u x + e + u s ) (U s sum + U c L) x + E s sum + E c L + u s max S s sum. he demand placed by jobs n D after t d s B(D, t d, S) = k D CI (e k δ k ). hus, by () and Lemmas and, we have the followng upper bound: Z (U s sum + U c L) x + E s sum + E c L + u s max S s sum + k D CI (δ ( u k ) + (e k δ k )) (U s sum + U c L) x + E s sum + E c L + u s max S s sum + E sum. (). Lower Bound Lemma, gven below, establshes a lower bound on Z that s necessary for the tardness of l,j to exceed x + e l + s l. Defnton. If job,v s enabled and not suspended at tme t but does not execute at t, then t s preempted at t. Defnton. If,v s frst phase s an executon (suspenson) phase and t begns executng (a suspenson) for the frst tme at t, then t s called ts start tme, denoted S(,v ). If,v s last phase (be t executon or suspenson) completes at tme t, then t s called ts fnsh tme, denoted F (,v ). Defnton. Let S H max = max{s H, S H,..., S H n }. (S H was defned earler n Sec..) Defnton. Let ξ H Smax H = Smax H be the suspenson + H e rato of. Let ξmax H = max{ξ, ξ,..., ξ n } be the maxmum suspenson rato. Lemma. If the tardness of l,j exceeds x + e l + s l, then Z > ( ξ H max) mx (m )e l m s l n (S H max+s max). Proof. We prove the contrapostve: we assume that Z ( ξ H max) mx (m )e l m s l n (S H max + S max) () holds and show that the tardness of l,j cannot exceed x + e l + s l. Let η l be the amount of work l,j performs by tme t d n S. Defne y as follows. y = ( ξ H max) x + η l m Let W be the amount of work due to jobs n d D that can compete wth l,j at or after t d + y, ncludng the work due for l,j. We consder two cases. Case. [t d, t d + y) s a busy nterval for d D. In ths case, the amount of work due to jobs n d D performed wthn [t d, t d + y] s my, and hence, W = Z my. hus, by () and (), W ( ξmax) mx (m )e H l m s l n H +Smax) my = ( ξmax) mx (m )e H l m s l n (Smax+S H max) ( ξ max) mx η H l <. Snce l,j can suspend for at most s l tme unts after t d +y (and at least one task executes whle t s not suspended), the amount of work performed by the system for jobs n d D durng the nterval [t d + y, F ( l,j )) s at least F ( l,j ) t d y s l. Hence, F ( l,j ) t d y s l W <. herefore, the tardness of l,j s F ( l,j ) t d < y + s l = ( ξmax) H x + η l m + s l x + e l + s l. Case. [t d, t d + y) s a non-busy nterval for d D. Let t s t d be the earlest non-busy nstant n [t d, t d + y). Job l,j cannot become enabled untl ts predecessor (f t exsts) completes. Let t p be the fnsh tme of l,j s predecessor (.e.,,j ), f t exsts; otherwse (j = ), let t p =. We consder three subcases. Subcase.. t p t s and l,j s not preempted after t s. In ths case, l,j performs ts remanng executon and suspenson phases n sequence wthout preempton after t s (note that, by Def., l,j s not consdered to be preempted when t s suspended). hus, because t s < t d +y, by (), the tardness of l,j s at most t s +e l η l +s l t d < t d +y+e l η l +s l t d = ( ξmax) x+ H η l m +e l η l +s l x+e l +s l. he clam below wll be used n the next two subcases. Clam. he amount of work due to d D performed wthn [t, t ), where S( l,j ) t < t F ( l,j ), s at least m(t t ) (m )e l m s l. ()

6 l, j executes Busy or suspends Busy nterval where l, j gets preempted l, j executes or suspends Busy l, j executes or suspends Work performed durng [ S( l, j ), F( l, j )) s at least: m F( ) S( )) ( m ) e m s ( l, j l, j l l t d t s t y+t d Work performed durng [t d,t d +y) s at least: my - (m-)e l -m s l Fgure : Subcase.. t F( l,j ) Proof. Wthn [t, t ), all ntervals durng whch l,j s preempted are busy, and l,j can execute for at most e l tme. Wthn ntervals where l,j executes, at least one processor s occuped by l,j. hus, at most m processors are dle whle l,j executes (for at most e l tme unts) n [t, t ). Also, all processors can be dle whle l,j s suspended and ths happens for at most s l tme unts n [t, t ). Subcase.. t p t s and l,j s preempted after t s. Let t be the earlest tme when l,j s preempted after t s, and let t be the last tme l,j resumes executon after beng preempted. (A fnte number of jobs have hgher prorty than l,j, so t exsts.) hen, as shown n Fg., l,j executes or suspends wthn [t s, t ). Also, because l,j s preempted at t, t s busy wth respect to d D. Wthn [t, t ), l,j could be repeatedly preempted. All such ntervals durng whch l,j s preempted must be busy n order for the preempton to happen. Note that F ( l,j ) t + e l η l + s l. hus, f t y + t d, then F ( l,j ) y + t d + e l η l + s l, whch by () mples that l,j s tardness s F ( l,j ) t d y + e l η l + s l ( ξ H max) x + e l + s l x + e l + s l, as requred. If t > t d + y, then by Clam, the amount of work due to d D performed wthn [t s, t d + y) s at least m(t d + y t s ) (m )e l m s l. Because [t d, t s ) s busy, the work due to d D performed wthn [t d, t d + y) s thus at least my (m )e l m s l. Hence, the amount of work that can compete wth l,j (ncludng work due to l,j ) at or after t d + y s W Z (my (m )e l m s l ) {by ()} ( ξ H max) mx (m )e l m s l n (S H max+s max) (my (m )e l m s l ) = ( ξ H max) mx n (S H max+s max) my {by ()} = n (S H max+s max) η l. herefore, the tardness of l,j s F ( l,j ) t d y + W y = ( ξ H max) x + η l m < x + e l + s l. Subcase.: t p > t s. he earlest tme l,j can commence ts frst phase (be t an executon or suspenson Busy t d t s t p Busy: l, js preempted l, j executes or suspends Busy due to preem pton l, j Busy due to preem pton l, j S ( l, j ) F( l, j ) Fgure : Subcase.. phase) s t p, as shown n Fg.. If fewer than m tasks have enabled jobs n d D at any tme nstant wthn [t s, t p ), then l,j wll begn ts frst phase at t p and fnsh by tme t p + e l + s l. (Note that the number of enabled jobs n d D does not ncrease after t d.) By Property (P) (appled to l,j s predecessor), t p t d p l + x + e l + s l t d + x. hus, the tardness of l,j s F ( l,j ) t d t p + e l + s l t d x + e l + s l. he remanng possblty (whch requres a much lengther argument) s: t p > t s and at least m tasks have enabled jobs n d D at each tme nstant wthn [t s, t p ). In ths case, gven that at least m tasks have enabled jobs n d D at t s, t s s non-busy due to suspensons. Let W be the amount of work due to d D performed durng [t s, t p ). Let I be the total dle tme n [t s, t p ), where the dle tme at each nstant s the number of dle processors at that nstant. hen, W + I = m (t p t s ). he followng clam wll be used to complete the proof of Subcase.. Clam. W ( ξ H max) m(t p t s ) n (S H max+s max). Proof. We begn by dvdng the nterval [t s, t p ) nto subntervals on a per-processor bass. he subntervals on processor k are denoted [I (k), E (k) ), where q k, I (k) = t s, I (k) (k) + = E, and E q (k) k = t p, as llustrated n Fg. Wth each such subnterval [I (k), E (k) ), we assocate a unque task, denoted (k). We assume that durng [I (k), E (k) ), (k) executes only on processor k, and E (k) s the last tme (k) s enabled wthn [t s, t p ). hus, f E (k) < t p, then the last job of (k) to be enabled wthn [t s, t p ) fnshes ts last phase (be t executon or suspenson) at tme E (k) ; f E (k) has enabled jobs throughout [I (k) = t p, then (k), t p ). Note that t s possble that (k) I (k). We call the subnterval [I (k) nterval of (k) executes or suspends wthn [t s, t p ) pror to, E (k) ) the presence. he fact that a unque task can be assocated wth each subnterval follows from the assumpton that at least m tasks have jobs n d D that are enabled

7 k I ( ) = ts ( k ) ( k ) ( k )... E = I E = I... ( k ) q k E = I qk qk Fgure : Presence ntervals wthn [t s, t p ]. (k ) qk E k = t q at each tme nstant n [t s, t p ). (Note that multple jobs of (k) may execute durng ts presence nterval.) We let λ (k) denote the set of all tasks that have presence ntervals on processor k. We now upper-bound the dleness on processor k by boundng ts dleness wthn one of ts presence ntervals. For concseness, we denote ths nterval and ts correspondng task as [I ( ), E ( )) and, respectvely. If processor k s dle at any tme n [I ( ), E ( )), then some job of s suspended at that tme. hus, the total suspenson tme of jobs of n [I ( ), E ( )), denoted I( ), upperbounds the dle tme on processor k n [I ( ), E ( )). ask may have multple jobs that are enabled wthn ts presence nterval. Such a job s sad to fully execute n the presence nterval f t starts ts frst phase (be t executon or suspenson) wthn the presence nterval and also completes all of ts executon phases n that nterval (note that t may not complete all of ts suspenson phases). A job s sad to partally execute n the presence nterval f t starts ts frst phase (be t executon or suspenson) before the presence nterval or completes ts last executon phase after the presence nterval. Note that at most two jobs of could partally execute n ts presence nterval (namely, the frst and last jobs to be enabled n that nterval). We now prove that I( ), and hence the dleness wthn [I ( ), E ( )) on processor k, s at most ξmax H (E ( ) I ( ))+Smax H +Smax (see Def. ). Dependng on the number of jobs of that execute durng s presence nterval, we have two cases. Case. has at most H jobs that fully execute n ts presence nterval. (Addtonally, may have at most two jobs that partally execute n ts presence nterval.) In ths case, I( ) s clearly at most Smax H + Smax. Case. has more than H jobs that fully execute n ts presence nterval. (Agan, may have at most two jobs that partally execute n ts presence nterval.) In ths case, the jobs of that are enabled n ts presence nterval can be dvded nto n sets, where one set contans fewer than H fully executed jobs plus at most two partally-executed jobs and each of the remanng n sets contans exactly H fully-executed jobs. Let θ denote the unon of the latter n job sets. Wthout loss of generalty, we assume that As tme ncreases from t s to t p, whenever a presence nterval ends on processor k, a task exsts that can be used to defne the next presence nterval on processor k. It can also be assumed, wthout loss of generalty, that ths task executes only on processor k durng ts presence nterval. p θ contans jobs that are enabled consecutvely. he total suspenson tme for the frst job set defned above s clearly at most Smax H + Smax. We complete ths case by showng that the total suspenson tme for all jobs n θ s at most ξmax H (E ( ) I ( )). o ease the analyss, let I ( ) be the start tme of the frst enabled job n θ, and E ( ) = mn(e ( ), F ), where F s the fnsh tme of the last enabled job n θ. hen E ( ) I ( ) E ( ) I ( ). Also, E ( ) I ( ) = I(θ) + (θ) + E(θ), where I(θ) s the total suspenson tme of all jobs n θ wthn [I ( ), E ( )), (θ) s the total preempton tme of all jobs n θ wthn [I ( ), E ( )), and E(θ) s the total executon tme of all jobs n θ wthn [I ( ), E ( )). (Recall that, by Def., a suspended task s not consdered to be preempted.) Gven that θ contans (n ) H fully-executed jobs, I(θ) (n ) S H. Moreover, gven our assumpton that each job executes for the correspondng task s worst-case executon tme, E(θ) = (n ) H e( ), where e( ) s the worst-case executon tme of. hus, I(θ) = = I(θ) E ( ) I ( ) (E ( ) I ( )) I(θ) I(θ) + (θ) + E(θ) (E ( ) I ( )) I(θ) I(θ) + E(θ) (E ( ) I ( )) { because I(θ) (n ) S H } (n ) S H (n ) S H + E(θ) (E ( ) I ( )) { because E(θ) = (n ) H e( )} (n ) S H (E ( ) I ( )) (n ) S H + (n ) H e( ) = S H S H + H e( ) (E ( ) I ( )) {by Def. } S H max S H max + H e( ) (E ( ) I ( )) {by Def. } = ξ H max (E ( ) I ( )) ξ H max (E ( ) I ( )). hs concludes the proof of Case of Clam. Gven that a task can be dentfed wth only one presence nterval and there are at most n tasks, the dleness wthn [t s, t p ) on m processor satsfes I n (Smax H + Smax) + ξmax H (E ( ) I ( )) λ ()... λ (k) = ξ H max m(t p t s ) + n (S H max + S max).

8 hus, W = m(t p t s ) I ( ξ H max) m(t p t s ) n (S H max +S max). hs completes the proof of Clam. We now complete the proof of Subcase. (and thereby Lemma ). As shown n Fg., [t d, t s ) and [t p, S( l,j )) are busy for d D. By Clam, the amount of work due to d D performed n [S( l,j ), F ( l,j )) s at least m(f ( l,j ) S( l,j )) (m )e l m s l. By Clam, the amount of work due to d D performed n [t s, t p ) s at least ( ξ H max) m(t p t s ) n (S H max S max). By summng over all of these subntervals, we can lower-bound the amount of work due to d D performed n [t d, F ( l,j )),.e., Z: Z m(t s t d ) + ( ξ H max) m(t p t s ) n (S H max + S max) + m(s( l,j ) t p ) + m(f ( l,j ) S( l,j )) (m )e l m s l. By () and (), we therefore have ( ξ H max) mx (m )e l m s l n (S H max + S max) m(t s t d ) + ( ξ H max) m(t p t s ) whch gves, n (S H max + S max) + m(s( l,j ) t p ) + m(f ( l,j ) S( l,j )) (m )e l m s l, F ( l,j ) t d ( ξ H max) x + ξ H max (t p t s ). Accordng to Property (P) (appled to l,j s predecessor), t p t s t p t d x p l + e l + s l x. herefore, F ( l,j ) t d ( ξ H max) x + ξ H max x < x + e l + s l.. Determnng x Settng the upper bound on LAG(d, t d, S) + B(D, t d, S) n () to be at most the lower bound n Lemma wll ensure that the tardness of l,j s at most x+e l +s l. he resultng nequalty can be used to determne a value for x. By () and Lemma, ths nequalty s (U s sum + U c L ) x + Es sum + E c L + us max S s sum + E sum ( ξ H max) mx (m )e l m s l n (S H max + S max). Let V = E s sum + E c L + us max S s sum + E sum + (m )e l + m s l + n (S H max + S max). Solvng for x, we have () V x ( ξmax) H m Usum s UL c. (9) x s well-defned provded U s sum + U c L < ( ξh max) m. If ths condton holds and x equals the rght-hand sde of (9), then the tardness of l,j wll not exceed x + e l + s l. A value for x that s ndependent of the parameters of l can be obtaned by replacng (m )e l +m s l wth max l ((m )e l + m s l ) n V. heorem. Wth x as defned n (9), the tardness of any task l scheduled under GSA s at most x+e l +s l, provded U s sum + U c L < ( ξh max) m. For GFIFO and GEDF, the bound n heorem can be mproved. Corollary. For GFIFO, heorem holds wth V replaced by V E sum + p >p l e n the numerator of (9). Proof. Under GFIFO, D CI conssts of carry-n jobs that are released before r l,j and have deadlnes later than t d, whch mples that these jobs have perods greater than p l. hus, the upper bound n () can be refned to obtan LAG (d, t d, S) + B(D, t d, S) (U s sum+u c L ) x+es sum+ E c L + us max S s sum + p >p l e. Usng ths upper bound to solve for x, the corollary follows. Corollary. For GEDF, heorem holds wth V replaced by V E sum n the numerator of (9). Proof. Under GEDF, the demand placed by jobs n D after t d s zero because D =. hus, under GEDF, LAG (d, t d, S) + B(D, t d, S) (U s sum+u c L ) x+es sum+ E c L + us max S s sum. Usng ths upper bound to solve for x, the corollary follows.. A Counterexample Prevous research has shown that every sporadc task system for whch U sum m wthout self-suspensons has bounded tardness under GEDF and GFIFO [,]. We now show that t s possble for a task system contanng self-suspendng tasks to have unbounded tardness under GEDF or GFIFO f the utlzaton constrant n heorem s volated. Consder a two-processor task set τ that conssts of three self-suspendng tasks: = (((exec.), (susp.)), (perod)), = (((exec.), (susp.), (exec.)), (perod)), and = (((exec.), (susp.), (exec.)), (perod)). For ths system, ξ H max =. (assumng H = ) and U s sum + U c L =.. hus, ( ξ H max) m =. < U s sum + U c L, whch volates the condton stated n heorem. Fg. shows the tardness of each task n ths system under GFIFO/GEDF by job ndex assumng each job s released as early as possble. We have verfed analytcally that the tardness growth rate seen n Fg. contnues ndefntely.. Expermental Evaluaton In ths secton, we descrbe experments conducted usng randomly-generated task sets to evaluate the applc of the tardness bound n heorem. Our goal s to examne how restrctve the theorem s utlzaton cap s, and to compare t wth another commonly-used approach, whch we call SuspoComp, wheren all suspenson phases are treated

9 ardness Case : : s preempted suspended t t t : Δ : task : some computaton phase ranked lower than Δ : ρ t... Case : Job ndex t Fgure : ardness growth rates n counterexample. suspenson length per-task utlzaton lght medum heavy mn: avg: max: mn: avg: max: mn: avg: max: short suspensons ξ max =.. µs 9 µs µs µs 9 µs. ms 9 µs. ms. ms moderate suspensons ξ max =. µs 9 µs. ms. ms. ms. ms. ms. ms ms long suspensons ξ max =. µs. ms ms ms ms ms ms. ms ms able : Per-job suspenson-length ranges. as computaton phases. From [, ], tardness s bounded under SuspoComp provded U sum m and U L m, where U L s the sum of the mn(m, n) largest task utlzatons. (Note that, under SuspoComp, treatng suspensons as computaton causes utlzatons to be hgher.) In our experments, task sets were generated as follows. ask perods were unformly dstrbuted over [ms,ms]. Per-task utlzatons were dstrbuted dfferently for each experment usng three unform dstrbutons: [.,.] (lght), [.,.] (medum), and [.,.] (heavy). ask executon costs were calculated from perods and utlzatons. We vared Usum s as follows: Usum s =. U sum (suspensons are relatvely nfrequent), Usum s =. U sum (suspensons are moderately frequent), and Usum s =. U sum (suspensons are frequent). Moreover, we vared ξ max as follows:. (suspensons are short),. (suspensons are moderate), and. (suspensons are long). able. shows suspenson-length ranges generated by these parameters. We also vared U sum wthn {,,..., }. For each combnaton of (u max, Usum, s U sum ),, task sets were generated for an eght-processor system. For each generated system, soft real-tme schedul (.e., the to ensure bounded tardness) was checked under SuspoComp and usng the condton stated n heorem. In dong so, system overheads were gnored (factorng overheads nto our analyss s beyond the scope of ths paper). he schedul results that were obtaned are shown n Fg. (the organzaton of whch s explaned n the fgure s capton). Each curve plots the fracton of the generated If some processor s dle durng [t,t +ε), then t s scheduled and nothng else s changed. If all processors are busy durng [t,t +ε), then some lower-prorty job must be re-scheduled at t +ε. ardness (n ms) If all processors are busy durng [t,t +ε) and,k s the lowerst-prorty job among all jobs scheduled wthn [t,t ), then the addtonal computaton s scheduled at t. 9 µs Lght utlzaton Medum utlzaton Heavy utlzaton Short suspensons Moderate suspensons Long suspensons Fgure : Average tardness under LA, as computed va heorem. task sets the correspondng approach successfully scheduled, as a functon of. As Fg. shows, our approach proved to be superor, sometmes by a substantal margn, n all tested scenaros summarzed n the frst two rows of graphs. However, n many of the scenaros summarzed n the thrd row of grows, SuspoComp proved to be superor. In these scenaros, task utlzatons are hgh and 9 µs suspensons are long or frequent. Our analyss s negatvely mpacted n such cases because UL c tends to be large when utlzatons are hgh, and ξ max tends to be large when suspensons are long. It s worth notng, however, that our approach allows certan tasks to be desgnated as computatonal tasks. hus, the SuspoComp approach s really a specal case of our approach. It would be nterestng to nvestgate ntermedate choces between the two extremes of modelng all versus no suspensons as computaton. In addton to schedul, the magntude of tardness, as computed usng the bound n heorem, s of mportance. Fg. depcts the average of the computed bounds for each of the tested scenaros n our expermental framework =. U sum (that s, for each scenaro n ths case, an average of all bounds for all tasks n all schedulable task sets s plotted). As can be seen, tardness s reasonable f task utlzatons are low and suspensons are short. However, as ether task utlzatons or suspenson lengths ncrease, tardness ncreases, as an examnaton of the bound n heorem suggests should be the case. Wth large task utlzatons and long suspenson lengths, tardness s qute hgh, perhaps unacceptably so, even though these systems are deemed to be schedulable. for the case where U sum = m and U sum s Concluson We have derved a tardness bound that can be appled to globally-scheduled sporadc task systems that nclude self-

10 [][] % unformly dstrbuted n [.,.] and % are self suspendng tasks unformly dstrbuted n [.,.] and % are self suspendng tasks unformly dstrbuted n [.,.] and % are self suspendng tasks [][] % [][] % % % LA s [] LA % % % % [] LA [[]] LA l % schedul % [] schedul schedul % [] LA s [] LA l (a) % (c) unformly dstrbuted n [.,.] and % are self suspendng tasks unformly dstrbuted n [.,.] and % are self suspendng tasks [][] (b) unformly dstrbuted n [.,.] and % are self suspendng tasks % % % % % % [][] % [] % % % [] LA s [] LA l % % % % [] LA s [[]] LA (d) unformly dstrbuted n [.,.] and % are self suspendng tasks LA % [] [] (f) % [] unformly dstrbuted n [.,.] and % are self suspendng tasks [] '] [ [] % % % % % % % % [] SC s [] [ '] SC [] [] % schedul % [] % [] % % % unformly dstrbuted n [.,.] and % are self suspendng tasks [][] [] (e) % LA s % % [] % schedul % % % % schedul % schedul % schedul schedul % (g) (h) () Fgure : Soft real-tme schedul results. In the frst (respectvely, second and thrd) row of graphs, lght (respectvely, medum and heavy) per-task utlzatons are assumed. In the frst (respectvely, second and thrd) column of graphs, relatvely nfrequent (respectvely, moderately frequent and frequent) suspensons are assumed. Each graph gves three curves per tested approach for the cases of short, moderate, and long suspensons, respectvely. he label LA-s(m/l) ndcates the approach of ths paper assumng short (moderate/long) suspensons. Smlar SC labels are used for SuspoComp. suspendng tasks. hs bound s applcable to a class of global algorthms that ncludes GEDF and GFIFO. he derved tardness bound requres overall utlzaton to be constraned. We have shown va a counterexample that utlzaton constrants are fundamental. We also presented schedul experments that suggest that our constrant s qute lberal n many systems and s often less pessmstc than modelng suspensons as computaton. References [] U. Dev. An mproved schedul test for unprocessor perodc task systems. In Proc. of the th Euromcro Conf. on Real-me Systems, pp. -,. [] U. Dev and J. Anderson. ardness bounds under global EDF schedulng on a multprocessor. In Proc. of the th IEEE Real-me Systems Symp., pp. -,. W. Kang, S. Son, J. Stankovc, and M. Amrjoo. I/Oaware deadlne mss rato management n real-tme embed-

11 ded databases. In Proc. of the th IEEE Real-me Systems Symp., pp. -,. [] I. Km, K. Cho, S. Park, D. Km, and M. Hong. Real-tme schedulng of tasks that contan the external blockng ntervals. In Proc. of the nd Int l Workshop on Real-me Computng Systems and Applcatons, pp. -9, 99. [] S. Lee and B. Moon. Desgn of flash-based DBMS: An npage loggng approach. In Proc. of the ACM SIGMOD Conf. on Management of Data, pp. -,. [] H. Leontyev and J. Anderson. Generalzed tardness bounds for global multprocessor schedulng. In Proc. of the th IEEE Real-me Systems Symp., pp. -,. [] H. Leontyev and J. Anderson. ardness bounds for FIFO schedulng on multprocessors. In Proc. of the 9th Euromcro Conf. on Real-me Systems, pp. -,. [] J. W. S. Lu. Real-me Systems. Prentce Hall,. [9] J. C. Palenca and M. Gonzlez Harbour. Schedul analyss for tasks wth statc and dynamc offsets. In Proc. of the 9th IEEE Real-me Systems Symp., pp. -, 99. [] J. C. Palenca and M. Gonzlez Harbour. Response tme analyss of EDF dstrbuted real-tme systems. In J. Embedded Comput., Vol., pp. -,. [] R. Rajkumar. Dealng wth Suspendng Perodc asks. IBM homas J. Watson Research Center, 99. [] F. Rdouard and P. Rchard. Worst-case analyss of feasblty tests for self-suspendng tasks. In Proc. of the th Real-me and Network Systems, pp. -,. F. Rdouard, P. Rchard, and F. Cottet. Negatve results for schedulng ndependent hard real-tme tasks wth selfsuspensons. In Proc. of the th IEEE Real-me Systems Symp., pp. -,. Appendx In ths appendx, we prove Clam and Lemmas and. In provng Clam, we lft the restrcton, gven earler n Sec., that each job executes for the correspondng task s worst-case executon tme. o state ths clam, some addtonal termnology s requred. We say that a sporadc task system τ s concrete f the release tme (and hence deadlne) and actual executon cost and suspenson tme of every job of each task s fxed. wo concrete task systems are compatble f they have the same jobs wth the same release tmes (they can have dfferent actual executon and suspenson tmes). A concrete task system τ s maxmal f the actual executon tme of any job equals the correspondng task s worst-case executon tme. Clam. For any concrete task system τ, there exsts a compatble maxmal concrete task system τ such that, for any job,k, ts response tme n the GSA schedule for τ s at least ts response tme n the GSA schedule for τ. Proof. he exstence of the desred maxmal concrete system s demonstrated va a constructon method n whch computaton phases are ranked as follows: () f,k x,y, then all computaton phases of,k are ranked before all computaton phases of x,y ; () earler computaton phases of,k are ranked before later computaton phases of,k. Let ɛ be a postve value that s small enough so that wthn any nterval [t, t + ɛ), each processor schedules exactly one job or no job, and the actual and worst-case executon cost of any computaton phase s a multple of ɛ. Consder a computaton phase C of a job,k that s not maxmal. We show that the length of C can be ncreased by ɛ by addng to the end of C a pece of computaton ρ of length ɛ. In so dong, t may be necessary to reduce the length of a lower-ranked computaton phase by ɛ and to reduce the length of a subsequent suspenson phase (f any) of,k. By nductng over all computaton phases n rank order, and by teratvely ncreasng any non-maxmal executon tme by ɛ, we can obtan a compatble concrete task system that s maxmal. he constructon method wll ensure that no job s response tme s reduced. Let [t, t + ɛ) denote the tme nterval where ρ should be added to the schedule (accordng to GSA). If, before addng ρ, task s scheduled wthn [t, t + ɛ), then the computaton phase of executng at that tme, call t C, s ranked lower than C. In ths case, we can accommodate ρ by reducng C n length by ɛ. If C and C are separated by a suspenson phase, then the length of that suspenson phase must be defned to be zero. In the rest of the proof, we consder the other possblty: before addng ρ, s not scheduled wthn [t, t + ɛ) (and hence, t s not scheduled n [t, t + ɛ), where t s the completon tme of C). In ths case, f there s an dle processor n [t, t + ɛ), then ρ can be scheduled there wthout modfyng the length of any lower-ranked computaton phase. On the other hand, f there s no dle processor, then, as ρ should be scheduled n [t, t + ɛ), there must be a computaton phase ranked lower than C scheduled then. We can accommodate ρ and allow t to be scheduled n [t, t + ɛ) by reducng the length of that lower-ranked computaton phase by ɛ. If C s followed by a suspenson phase, then, once ρ has been added to the schedule, t may be necessary to reduce the length of that suspenson phase. In partcular, f, before addng ρ,,k was suspended n [t, t + ɛ), then the length of that suspenson phase must be reduced so that t starts as t + ɛ. Note that the constructon method used n ths proof strongly explots the fact that, n our task model, suspenson phases are upper-bounded, and hence, can be reduced. If C s of length ɛ and s followed by a suspenson phase, then we can avod alterng the length of that suspenson phase by assumng that C executes for zero tme at tme t + ɛ. Note that C s executon tme wll be ncreased n a subsequent nducton step. A smlar comment apples to the argument n the next paragraph.

12 heorem shows that, for any maxmal concrete task system, the tardness of any task l scheduled under GSA s at most x + e l + s l, wth x as defned n (9). By Clam, the same s true for any non-maxmal concrete task system. Let A(J, t, t, S) denote the total tme allocated to all jobs n the job set J n [t, t ) n the schedule S. Lemma. LAG(d, t d, S) LAG(d, t n, S) + k D CI δ k ( u k ), where t [, t d ]. Proof. By (), we have LAG (d, t d, S) LAG(d, t n, S) + A (d, t n, t d, P S) A (d, t n, t d, S). () We splt [t n, t d ) nto z non-overlappng ntervals [t p, t q ), z, such that t n = t p, t q = t p, and t qz = t d. Each nterval [t p, t q ) s ether busy or nonbusy dsplacng for d, by the selecton of t n. We assume that the ntervals are defned so that for each non-busy dsplacng nterval [t p, t q ), f a task n D CI executes n [t p, t q ) then t executes contnuously throughout [t p, t q ); we let α denote the set of such tasks. We now bound the dfference between the work performed n the PS schedule and the GSA schedule S across each of these ntervals [t p, t q ). he sum of these bounds wll gve us a bound on the total allocaton dfference throughout [t n, t d ). Dependng on the nature of the nterval [t p, t q ), two cases are possble. Case. [t p, t q ) s busy. Snce n S all processors are occuped by jobs n d, we have A(d, t p, t q, P S) A(d, t p, t q, S) U sum (t q, t p ) m(t q t p ). Case. [t p, t q ) s non-busy dsplacng. he cumulatve utlzaton of all tasks k α s k α u k. he carry-n jobs of these tasks do not belong to d, by the defnton of d. herefore, the allocaton of jobs n d durng [t p, t q ) n P S s A(d, t p, t q, P S) (t q t p )(m k α u k ). All processors are occuped at every tme nstant n the nterval [t p, t q ), because t s dsplacng. hus, A(d, t p, t q, S) = (t q t p )(m α ). herefore, the allocaton dfference for jobs n d throughout the nterval s A(d, t p, t q, P S) A(d, t p, t q, S) (t q t p ) ((m u k ) (m α )) k α = (t q t p ) ( u k ). k α () For each task k n D CI, the sum of the lengths of the ntervals [t p, t q ) n whch the carry-n job of k executes contnuously s at most δ k. hus, summng the allocaton dfferences for all the ntervals [t p, t q ) gven by (), we have A(d, t n, t d, P S) A(d, t n, t d, S) z (t q t p )( u k ) = k D CI δ k ( u k ). () k D CI Settng ths value nto (), we get LAG(d, t d, S) LAG(d, t n, S) + A(d, t n, t d, P S) A(d, t n, t d, S) LAG(d, t n, S) + k D CI δ k ( u k ). Lemma. lag(, t, S) u x + e + u s for any task and t [, t d ]. Proof. Let d,k be the deadlne of the earlest pendng job of,,k, n the schedule S at tme t. If such a job does not exst, then lag(, t, S) =, and the lemma holds trvally. Let γ be the amount of work,k performs before t. By the selecton of,k, we have lag(, t, S) = h k lag(,h, t, S) = h k(a(,h,, t, P S) A(,h,, t, S)). Gven that no job executes before ts release tme, A(,h,, t, S) = A(,h, r,h, t, S). hus, lag(, t, S) = A(,k, r,h, t, P S) A(,k, r,k, t, S) + h>(a(,h, r,h, t, P S) A(,h, r,h, t, S)). () By the defnton of P S, A(,k, r,h, t, P S) e, and h>k A(,h, r,h, t, P S) u max(, t d,k ). By the selecton of,k, A(,k, r,k, t, S) = γ, and h>k A(,h, r,h, t, S) =. By settng these values nto (), we have lag(, t, S) e γ + u max(, t d,k ). () here are two cases to consder. Case. d,k t. In ths case, () mples lag(, t, S) e γ, whch mples lag(, t, S) u x + e + u s. Case. d,k < t. In ths case, because t t d and d l,j = t d,,k s not the job l,j. hus, by Property (P),,k has tardness at most x+e +s, so t+e γ d,k +x+e +s. hus, t d,k x + γ + s. Settng ths value nto (), we have lag(, t, S) u x + e + u s.