A Server-based Approach for Overrun Management in Multi-Core Real-Time Systems

Transcription

1 A Server-based Approach for verrun Management n Mult-Core Real-Tme Systems Meng Lu 1, Mors Behnam 1, Shnpe Kato 2, Thomas Nolte 1 1 Mälardalen Unversty, Västerås, Sweden 2 Nagoya Unversty, Nagoya, Japan Emal: 1 {meng.lu, mors.behnam, thomas.nolte}@mdh.se 2 shnpe@s.nagoya-u.ac.jp Abstract Ths paper presents a server-based framework for task overrun management n mult-core real-tme systems. Unlke most exstng schedulng methods whch usually assume a sngle upper bound of the Worst-Case Executon Tme (WCET) for each task, our approach targets scenaros wth task overruns. The man dea of our framework s to employ Synchronzed Deferrable Servers (SDS) to deal wth globally scheduled task overruns, whle a parttoned schedulng approach s appled on regular task executons. Moreover, we provde a determnstc Worst-Case Response Tme (WCRT) analyss focusng on hard tmng constrants, along wth a probablstc analyss of Deadlne Mss Rato (DMR) for soft real-tme applcatons. In the evaluaton phase, we have mplemented two types of experments evaluatng dfferent tmng constrants. I. INTRDUCTIN A. Motvaton The motvaton of ths paper orgnates from the overrun problem n some ndustral real-tme embedded systems. For some applcatons the estmated Worst-Case Executon Tme (WCET) may be volated durng runtme. For example, path plannng and percepton tasks n moblty robots have dversty n ther executon tmes. As a result, f we do not handle task overruns n a proper way, the relablty of a system can be serously mpacted. Ths knd of problem has been addressed n [1], where a resource reservaton methodology s proposed. Due to the usage of resource reservaton mechansms, systems can adapt themselves to runtme changes. Under resource reservaton mechansms, each task (or task set) can have a reserved processor bandwdth, such that t wll not be nfluenced by emergent ncdents (e.g. overruns from other tasks). Nevertheless, as far as we know, for most exstng resource reservaton mechansms, the scenaro that the executon of a certan task exceeds ts reserved bandwdth has not been well concerned from the schedulablty pont of vew, especally lookng at the context of mult-core realtme systems. In other words, due to the task solaton by resource reservaton mechansms, the overrun of a task may not mpact the executon of other tasks. However, the actual overrun of ths partcular task s not well managed n most Ths work s supported by the Swedsh Research Councl, va the research project START. exstng approaches, and as a result the schedulablty for the task wth overruns may be very low. n another hand, n many real-tme control applcatons, the executon tme of a task may vary greatly [2]. For those applcatons, a task usually has a short executon tme durng most of the tme, whle the WCET rarely occurs. As a result, the use of the WCET can obvously affect the performance optmzaton of a system. Ths problem can be even worse n soft real-tme systems. Therefore, we need a schedulng framework whch can handle the above problem and at the same tme guarantee system schedulablty. Some works targetng a smlar problem have been proposed (e.g. [2][3]). In those works, each task gets a reserved bandwdth based on ther mostly occurred executon tme, whle the executons exceedng the reserved capacty (e.g. when the WCET occurs) are handled by an overrun management. Unfortunately, those works only focus on sngle-core systems. In order to tackle the overrun problem n the settng of mult-core systems, n ths paper, we present a new Synchronzed Deferrable Server (SDS) based herarchcal schedulng framework to handle task overruns. Moreover, schedulablty analyss s provded targetng both hard and soft real-tme applcatons. B. Contrbutons We propose an SDS-based schedulng approach for multcore real-tme systems, whch, we beleve, s the frst framework concernng the holstc schedulablty of both regular task executons and overruns n mult-core realtme systems. In our framework, task overruns are only processed n the globally shared servers. By solatng overruns from regular task executons, each task can get a guaranteed servce for ts regular executon, and overruns can be processed by the spare slacks n the system va SDSs. As a result, our framework can spare many tasks from mssng ther deadlnes due to the occurrence of overruns n the system. Ths framework can be utlzed n dfferent ways. For example, the concept of task overruns n ths paper can be consdered as extra fault recoverng executons from a fault-tolerant perspectve, or another crtcal level of executons from a mxed-crtcalty pont of vew.

2 A determnstc Worst-Case Response Tme (WCRT) analyss for our framework s provded. Ths analyss can provde a suffcent schedulablty test regardng hard tmng constrants. We also propose a method to compute an upper bound of the Deadlne Mss Rato (DMR) of each task n our framework targetng soft real-tme applcatons. The estmated DMR can be utlzed for varant purposes. For example, t can be used to predct temporal drops of frame rates for path plannng and percepton tasks. Regardng dfferent tmng constrants, we have mplemented a number of experments. We explctly examned the effects of dfferent system parameters. The comparsons between dfferent allocaton algorthms and dfferent server bandwdth selecton schemes are provded along wth dscussons regardng the observatons. Accordng to the expermental results, our global overrun management framework always outperforms the local overrun-handlng solutons. C. Related Work A lot of researchers have been workng on task schedulng problems for mult-core real-tme systems. The tradtonal schedulng methods for mult-core systems can be categorzed nto two types: parttoned and global schedulng. In parttoned schedulng, tasks are statcally allocated on dfferent processors. nce a task s assgned to a certan processor, t cannot mgrate to any other processors. Due to ths feature, the tasks n the same processor can always be scheduled under unprocessor schedulng algorthms (e.g. Rate Monotonc (RM) [4], Deadlne Monotonc (DM) [5], Earlest Deadlne Frst (EDF) [6]). Whle the dsadvantage of parttoned schedulng s that the task allocaton problem can be consdered as a bn packng problem whch s NP-hard [7]. Under global schedulng, tasks are usually controlled n a common queue shared among processors, and a task can mgrate from one processor to another. In ths case, those well developed theores for unprocessors may not be vald any more, because dfferent features of mult-core systems (e.g. parallel executons) need to be taken nto account. Another type of approach whch s known as sem-parttoned schedulng has also been developed (e.g. [8][9]). Ths type of schedulng s a combnaton of the tradtonal parttoned and global schedulng, where some tasks are parttoned on dfferent processors and the other tasks are globally scheduled. Some works have also been proposed regardng herarchcal schedulng approaches (e.g. [10][11][12][1]). Under herarchcal schedulng, a certan processor bandwdth (.e. usually denoted by a server) can be reserved for dfferent purposes (e.g. to handle aperodc tasks), and dfferent schedulers can be ntegrated n one system. Due to the usage of resource reservaton mechansms, systems can adapt themselves to runtme changes. Under resource reservaton mechansms, each task (or task set) can have a reserved processor bandwdth, such that t wll not be nfluenced by emergent ncdents (e.g. overruns from other tasks). In [13], the authors proposed a Synchronzed Deferrable Server (SDS) based herarchcal schedulng method, where the mgratng tasks are processed only n the globally shared servers. ur framework can be consdered as a type of herarchcal schedulng employng SDSs, where both parttoned and global schedulng are nvolved. Several works focusng on the overrun problems have been proposed n lterature. In [2], the authors present an approach to handle task overruns targetng the EDF algorthm. They proposed a rate adapton method based on the Constant Bandwdth Server algorthm [14] to fully utlze a processor. In [3], the authors compared several schedulng algorthms consderng task overruns. These algorthms nclude both classcal prorty based (DM and EDF) and server based schedulng algorthms. However, most of the exstng schedulng frameworks consderng task overruns only focus on sngle core systems, and our framework targets mult-core systems. The rest of ths paper s organzed as follows. Secton II ntroduces the system model and the schedulng polcy of our framework. In Secton III, we propose a determnstc WCRT analyss, as well as a probablstc analyss of DMRs. The results and observatons of our experments are dscussed n Secton IV. Fnally, n Secton V, we conclude the paper and provde some thoughts about future works. A. Task Model II. SYSTEM MDEL In our model, a mult-core system ncludes a set of perodc or sporadc tasks ℸ = {τ 1,τ 2,...,τ N }. Each task can be characterzed as τ = {T, C,P,D }. A perod T denotes the mnmum nter-arrval tmes between successve nstances of a task. A matrx C represents the executon tmes of a task along wth the correspondng probabltes, whch wll be explaned n detal n the next paragraph. Each task owns a fxed prorty P, whch s used for the local schedulng on a processor (.e. the prorty of a task has nothng to do wth any other tasks whch are executed on another processor). The tmng constrant s gven by the relatve deadlne D of a task. A system s consdered to be acceptable when the Deadlne Mss Rato (DMR) (.e. the probablty of the response tme of a random task nstance to exceed ts deadlne) does not exceed a certan bound Pr ˆ DMR. In a vald hard real-tme system, all the tasks are supposed to meet ther respectve deadlnes (.e. the response tmes do not exceed ther deadlnes), whch means that Pr ˆ DMR = 0. In ths paper, we only assume constraned deadlnes (.e. D T ). Due to the fact that n our task model, the regular executon tme of a task s gven by an upper bound nstead of a certan dstrbuton, we can only generate a correspondng upper bound of the response tme of a regular executon. As a result, the DMRs computed n ths paper only focus on the occurrence of overruns, whch s dfferent from the concept of DMR used n some exstng probablstc analyss (e.g [15]). In other words, for each task τ, our analyss provdes an approxmated upper bound of ts DMR rather than an exact DMR. Moreover, we assume that overheads caused by preemptons and mgratons are

3 neglgble or ncluded n the executon tmes (as dscussed n [16]). Instead of usng a sngle upper bound of the executon tme of a task, n our system model, the executon tme of each task τ s characterzed by a 2 2 matrx C = ( C R C ). In most cases, the executon tme of a task s bounded by ts regular WCET C R, whch s assocated wth a probablty PrR (.e. Pr R represents the probablty of that only the regular executon occurs wthout an overrun). However, sometmes because of certan factors (e.g. system errors, hardware effects, etc.), a task may nclude an overrun. Due to ths extra executon, the WCET of τ may be ncreased up to C R+ (C R+ > C R ). The upper bound of the executon tme of the overrun can be acqured accordngly as C = C R+ C R, whch s assocated wth a probablty Pr (Pr = 1 P R). If C and Pr for each task τ equate to 0, ths task model wll be the same as the tradtonal task model wth sngle executon tme bounds. Moreover, we assume that for each task, there can be at most one nstance processed n the system at each tme. In other words, when a job of a task s ready to be released, f the executon of ts prevous nstance from the same task has not been completed, the system should ether dscard the newly arrved nstance or ts prevous nstance (dependng on specfc applcatons). In our future work, we wll further relax ths assumpton. B. Deferrable Servers We employ the concept of Deferrable Servers (DS) n our mult-core system model (smlar to [13]). A DS can be consdered as a perodc task, whch has ts own replenshment perod T s and capacty C s. Wthn each replenshment perod (T s ), a DS can execute pendng workloads untl all of ts capacty (C s ) s consumed. At the begnnng of each replenshment perod, the capacty of a DS wll be replenshed up to C s. In our model, we assume that each processor contans at most one DS, whch has the hghest prorty among all the tasks located n the same processor. In other words, once a DS detects assgned workloads and meanwhle t stll holds avalable capacty wthn the current replenshment perod, ths DS wll preempt the executon of other tasks n the same processor. If a DS has consumed all of ts capacty for a perod, the remanng workloads need to wat untl the arrval of the next replenshment perod. In ths paper, we assume that the deferrable servers on dfferent processors are synchronzed. In other words, all the servers have the same ntal phase (.e. released smultaneously), and share a common replenshment perod. However, dfferent servers may have dfferent capactes, whch depend on the workloads on each processor. Therefore, we employ the same notaton as n [13] to represent an m-sds (.e. Synchronzed Deferrable Servers on m processors) 1, that s (T s, Cs 1, Cs 2,..., Cs m ). We also assume that the capactes n the tuple are sorted n a descendng order (.e. k, Cs k Cs k+1 ). The SDS parameters (T s and Cs) can be selected n many dfferent ways. As dscussed above, we can consder a DS as a task wth the hghest prorty n each processor. Therefore, Pr R Pr usng an optmal fxed-prorty schedulng algorthm (e.g. Rate Monotonc (RM)), a vald T s can be selected based on the perods of other tasks n the same processor. Gven a certan utlzaton Us of a DS, the correspondng capacty can be calculated accordngly (.e. Cs = T s Us). We dvde the whole capacty of a processor nto two parts. The frst part s used to process the regular executons of parttoned tasks, where the executon tme of a task s upper bounded by C R. All the remanng capacty n each processor can be assgned to the SDS. Unlke [13] and [17], the servers n our model are only used to execute the overruns of tasks n a system but not any complete task, where the overrun of a task s upper bounded by C. Moreover, the regular executons of tasks are statcally parttoned on dfferent processors, whle the overruns are processed on the globally shared SDSs. In other words, only the overruns of tasks can mgrate from one processor to another. In ths paper, we assume that the overruns are scheduled employng a stated global Frst-In- Frst-ut (FIF) queue, where each nstance n the queue may have ether a Watng state or a Runnng state. By solatng the overrun of a task from ts contnuaton of the regular executon to globally shared servers, we can n some manner decrease the probablty of that an overrun of a task may cause more overruns of other tasks. In other words, each task s provded a guaranteed bandwdth for ts regular executons, whch may not be much affected by the overruns of other tasks especally when some extremely long overruns occur. C. Schedulng Polcy Regardng the regular executon and the overrun of a task, the schedulng mechansm s separated nto two levels as follows. 1) Schedulng for Regular Executons: The regular executons of all the tasks are allocated on dfferent processors usng a certan allocaton algorthm, such as Frst-Ft, Worst-Ft, Best-Ft, etc ([7][18]). Wthn each processor, all the tasks together wth the local SDS (f there s one) are scheduled usng a fxedprorty unprocessor schedulng algorthm. Note that an SDS always has the hghest local prorty. 2) Schedulng for verruns: nce the executon tme of a task exceeds a certan bound (.e. the upper bound of ts regular executon C R), ths task needs to release the processor mmedately. The remanng executon of ths task τ wll be appended to the end of a stated global FIF queue Q g, τ wll then be marked wth a Watng state. nce there s no job marked wth Watng ahead of τ n Q g (.e. all jobs ahead of τ are n the Runnng state), τ wll be dspatched 2 to an avalable SDS whch has remanng capacty wthn the current replenshment 1 In our framework, the number of SDSs s smaller than or equal to the number of processors n the system (.e. some processors may not contan any SDSs).

4 perod. If there are more than one avalable server, the one wth the lowest ndex wll be selected. As soon as τ s assgned to an SDS, the state of τ wll be changed to Runnng. nce an SDS receves some workload, t wll mmedately preempt the executons of other local tasks untl all of ts capacty wthn the current replenshment perod s consumed or the workload s completely processed. nce an SDS completes the executon of an overrun τ, τ wll be removed from Q g. If ths SDS stll has some remanng capacty, t wll contnue to process another pendng workload whch s the frst job wth a Watng state n Q g. If the capacty of an SDS s exhausted whle processng τ, the remanng executon wll be suspended. Then the remanng part of τ wll preempt the executon of the last Runnng job whch s queued after τ n Q g, and the state of ths preempted job wll be changed to Watng. If τ s the last Runnng job n Q g (.e. all jobs queued after τ are n the Watng state), τ wll go to the Watng state. If all the servers have already exhausted ther capactes, the remanng workloads of overruns need to wat untl the arrval of the next replenshment perod. III. SCHEDULABILITY ANALYSIS In ths secton, we present a response-tme based schedulablty analyss for the above system model. Frst, we present the calculaton of the determnstc upper bounds of task WCRTs, whch focuses on hard real-tme constrants. In the second subsecton, we propose an approach to calculate an upper bound of the DMR of each task, whch can be utlzed n soft real-tme systems. A. Determnstc Worst-Case Response Tme Analyss As we ntroduced n Secton II, n our task model, the worst-case response tme of a task conssts of two sources: the regular executon and the overrun executon. Therefore, we can compute the WCRT of a task τ as R = R R + R (1) where R R and R represent the response tmes of the regular executon and the overrun executon respectvely. We wll present the calculaton of R R and R n the followng subsectons. In ths paper, the release jtter (.e. the tmng duraton between the arrval and the release of a task nstance) s not consdered for smplcty. Therefore, whle analyzng the schedulablty of a system, we only need to compare R wth D. 2 Note that τ wll stll be kept n Q g at ths phase. 1) WCRT of Regular Executons: As mentoned n our schedulng polcy, the parttoned regular executons of tasks are scheduled usng a fxed-prorty unprocessor schedulng algorthm, where an SDS can be consdered as a perodc task. Therefore, we can smply utlze the exstng approaches (e.g. [19][20]) to compute R R. Consderng that we assume a preemptve mechansm n our model, R R should 3 only consst of the upper bound of the regular executon tme C R and the nterference I R caused by other tasks n the same processor wth hgher prortes (ncludng the SDS). Therefore, we can compute R R as R R (n + 1) = C R + I R = C R R + R (n) C R j + T τ j hp(τ ) j τ j S ( RR (n) C s() + 1) C s () T s where the task set S contans all the regular tasks assgned on the processor where task τ s located, and C s () denotes the maxmum capacty of the SDS on that processor. The task set hp(τ ) ncludes all the regular tasks whose prortes are hgher than or equal to P. If there s no SDS on the processor, C s () = 0 n Eq. 2. Note that whle calculatng the nterference caused by the SDS, we cannot smply consder t as other regular tasks because of the carry-n nstance of an SDS. More detals can be found n [21] or Appendx A. Eq. 2 can be solved usng a fxed pont teraton soluton. We can start the calculaton wth R R (0) = CR + C s (), and teratvely compute R R (n + 1) untl: 1) RR (n + 1) > D, whch means that τ has mssed ts deadlne; 2) or R R (n+1) = RR (n), n whch case R R (n + 1) s consdered as the fnal result. We need to emphasze that the above equaton can only provde an upper bound of R R but not the exact worst-case result due to the pessmsm. Eq. 2 assumes that an SDS s completely occuped all the tme, whch may not be necessary n realty. As a result, the above computaton gves a suffcent but not necessary schedulablty test. 2) WCRT of verruns: As ntroduced n Secton II, the overruns of tasks are scheduled n a global FIF queue and can be processed by the SDSs on dfferent processors 4. Therefore, once the overrun of a task arrves at the global FIF queue Q g, t only needs to wat for the executons of task overruns whch are queued ahead. All the task overruns cannot preempt any other earler arrved task overrun. Note that sometmes the executon of a task overrun τ may be suspended because the current SDS has exhausted ts capacty. Then τ may preempt the executon of the jobs whch are queued after τ. 3 Note that n ths paper the resource sharng problem s not taken nto account for smplcty, therefore, the blockng term s not ncluded n our calculaton. 4 We assume that the overrun of a task cannot be executed on two or more SDSs smultaneously. (2)

5 As shown n Fgure 1, the workloads queued ahead of τ s denoted by QW, and the workload of τ s upper bounded by C. latest occurrence of S wll result n the maxmum r H under a gven startng nstant of QW. The proofs of the followng computaton can be found n [13]. C QW r H = ( QW m 1) T s +t res (5) =1 C s Tal τ τ y Q g Fg. 1. A global FIF queue Q g. We use S to denote the tme nstant when τ starts to be executed. The response tme of τ may consst of the processng tme for the workloads whch are queued ahead of τ (.e. the tme duraton from the begnnng of QW to S, denoted by r H ), and the processng tme of τ tself (.e. the tme nterval from S to the end of τ, denoted by rb ). We compute R as τ x Head R = T s C m s + r H + r B (3) where T s Cs m represents the maxmum watng tme before the start of QW (.e. denoted as the crtcal head ĤC k n [13]). Ths upper bound may nclude pessmsm unless all the SDSs have the same capacty (.e. Cs 1 = Cs 2 =... = Cs m ). The proof of ĤC k can be found n Lemma 1 n [13]. Before computng r H, we need to fnd an upper bound of the queueng workloads QW. Lemma 1. Whle computng QW, we only need to consder the queueng workloads QW ahead of a task overrun τ whch s upper bounded by QW = C j (4) τ j ℸ τ j τ Proof: As mentoned n Secton II, we assume that each nstance of a task cannot be released unless the executon of ts prevous nstance s fnshed. Due to the feature of a FIF queue, a later arrved job cannot preempt the executons of the jobs whch are queued ahead n the queue. If the analyzed nstance τ gets nterference from two or more jobs of another task overrun τ j, these nstances of τ j must be queued ahead of τ together n Q g. Ths wll apparently cause a contradcton of the above assumpton. Therefore, whle computng the workloads ahead of τ n Q g, we only need to consder at most one nstance of overrun for each other task n the system. nce we have acqured the upper bound of QW, we can utlze part of the analyss presented n [13] to compute r H. Both our schedulng polcy and the schedulng algorthm presented n [13] can satsfy the work-conservng property (.e. a processor wll always be occuped whenever there s pendng workload on t). The basc dea of the followng computaton s that the SDSs n the analyzed system are always busy wthn the tme nterval from the begnnng of QW to S, and the where t res = QW res m Cs k+1 + QW res δ(k) = QW res δ(k + 1) k f QW res δ(m) f δ(k + 1) < QW res k [1,m 1] = QW ( QW m 1) =1 C s m j=k m =1 δ(k), (6) C s (7) C j s +C k s (k 1), k [1,m] (8) In Eq. 7, QW m 1 denotes the number of complete =1 C s replenshment perods that QW may consume. Consequently, t res represents the processng tme of the resdual workloads of QW n the last replenshment perod (.e. the capactes wthn ths perod are not exhausted). Based on t res, we can compute r B. Lemma 2. An upper bound of r B r B = where can be computed as { C f C C 1 s t res T s t res +CRP T s +C res therwse (9) C res = C (C 1 s t res ) CRP C 1 s (10) CRP = C (Cs 1 t res ) Cs 1 1 (11) Proof: As we dscussed above, whle τ s executng on a server, the jobs whch are queued after τ may occupy other servers at the same tme, that wll defntely ncrease the response tme of τ. In the worst case, we can assume that when τ s beng processed on a server, there are always some jobs consumng all the other servers smultaneously. Under ths assumpton, we can compute the upper bound of r B accordng to dfferent szes of C. The proof s gven n Appendx B. 3) Calculaton of WCRT: Based on the upper bounds of R R (Eq. 2) and R (Eq. 3) computed above, we can derve an upper bound of R usng Eq. 1. We need to confess that our analyss provdes a suffcent but not necessary schedulablty test due to the pessmsm nvolved n the computaton. We wll further mprove the analyss by decreasng pessmsm n our future work.

6 B. Deadlne Mss Rato Calculaton In our task model, the regular WCET of a task s gven by a sngle upper bound nstead of a certan dstrbuton. Moreover, the regular executon of each task s assumed to be mandatory, whch means that the occurrence probablty of τ R s 100% for any task τ. Therefore, no matter f a task nstance experences an overrun or not, the regular WCRT s determnstcally upper bounded by R R. In other words, the probabltes n C are not nvolved whle computng the response tmes of regular executons. n the other hand, whle computng R, the occurrence probablty of a task overrun (.e. Pr ) can be taken nto account. For smplcty, n ths paper, we only consder the probabltes n QW -related computatons, whle the other parts of R stll use the upper bounds computed n the prevous subsectons 5. Lemma 1 mples that at most only one nstance of each task overrun (except τ ) needs to be ncluded n QW. As descrbed n our task model, the occurrence probablty of a task overrun τ s gven by Pr. Therefore, we can derve a dscrete probablty dstrbuton of QW by where F QW = ϒ (12) τ j ℸ τ j τ ϒ = ( 0, C Pr R ) (13),Pr n = ϒ 1 ϒ 2... ϒ n (14) k=1 ϒ x ϒ y = ( 0, C x, Cy, Cx +Cy Prx R Pry R, Prx Pry R, Prx R Pry, Prx Pry ) (15) As defned above, F QW can also be consdered as a twodmensonal matrx (.e. F QW = ( c 1 QW... c N QW pr 1 QW... pr N QW ), and the sze s (N,2)). Apparently, n Eq. 5, QW s the only effectve factor, snce all the other factors are fxed or based on QW. Therefore, we can defne Eq. 5 as a sngle varable functon, r H (X) = ( X m =1 C s 1) T s +t res (16) Ths functon returns the result of r H along wth the t res computed by the sub-equaton (Eq. 6). In the same manner, Eq. 9 can be defned as a functon of t res, and Eq. 3 can be defned as a functon of r H and r B. Then we can use Algorthm 1 to compute an upper bound of the DMR of τ. Accordng to dfferent possble quantles of QW, we can respectvely compute the correspondng response tmes of τ (Algorthm 1 lne 6-10). The quantles of QW only make sense 5 Consderng the probabltes n the whole computaton of R may result n an exponentally ncreased computng tme. Therefore, we leave the further nvestgaton to our future work. 6 Note that f the response tme of the regular task executon of the analyzed task has already exceeded ts deadlne, we drectly set ts DMR to 1 and termnate the algorthm mmedately. Algorthm 1 Calculaton of DMR 1: Intalze τ, pd f null,dmr 0 2: R R Eq : F QW Eq. 12 4: (N,2) szeo f (F QW ) 5: for all k n [1,N] do 6: r H 0,t res 0,r B 0,r 0 7: r H,t res Eq. 5(c k QW ) 8: r B Eq. 9(t res ) 9: R Eq. 3(r H,r B ) 10: R R R + R o 11: append (R, pr k QW Pr ) to pd f 12: end for 13: (q,2) szeo f (pd f ) 14: for all j n [1,q] do 15: f pd f [ j 1][0] > D then 16: DMR + = pd f [ j 1][1] 17: end f 18: end for 19: return DMR when the overrun of τ ndeed occurs. therwse R s always 0 and R s constantly equal to R R. Therefore, we also need to take Pr nto account whle dervng the dstrbuton of R (Algorthm 1 lne 11). Based on the dstrbuton of R, we can compute an upper bound of DMR (Algorthm 1 lne 14-18, where pd f denotes the created probablty densty functon of the response tmes of τ ). Smlar to our determnstc WCRT calculaton, the DMR may also nclude pessmsm because some parts of the response tme stll use upper bounds (e.g. T s Cs m n Eq. 3). IV. EVALUATIN In ths secton, we present some results and observatons from our experments. We have mplemented two types of experments regardng hard and soft tmng constrants respectvely. A. Experment Settngs 1) Task Generatons: In ths paper, we use the UUnFast- Dscard [16] algorthm to generate task sets for a 4-core system. Each task set conssts of n tasks (n [5,30] wth a granularty of 5) wth a total utlzaton 4 U t, where U t (.e. the average utlzaton bound of each processor) s selected from [0.1, 0.6] wth a granularty of 0.1. The perod of each task s randomly selected from a unform dstrbuton wth the range of [50000, ]. The deadlne of each task s assumed to equate to ts perod. The executon tme of a task overrun (C ) s selected based on a certan percentage of ts regular executon tme (C R ). Ths percentage s unformly selected wthn the range of (0, 150%). Moreover, we assume that all the tasks n our experments can have overruns. 2) Allocaton of Regular Executons: In the followng experments, for the regular task executons, we employ the RM schedulng algorthm wthn each processor. When we partton

7 regular task executons, we take nto account both the Frst-Ft (FF) and Worst-Ft (WF) bn-packng algorthms. Under the FF allocaton algorthm, a new task τ s frst assgned to an unfull processor wth the lowest ndex. Then we check the schedulablty of all the tasks (based on ther regular executon tmes) n ths processor. If all the tasks can meet ther deadlnes, then τ wll be kept n ths processor, and we start to allocate another unassgned task. therwse, we need to remove τ from ths processor, and try to assgn t to the next processor. If at the end τ cannot be assgned to any processor, the system s consdered to be unschedulable. Due to the feature of the FF algorthm, the processors are usually unevenly utlzed (.e. the processors wth lower ndexes are usually hghly occuped, whle the others may contan much less workload). In ths case, the response tme of a task n a heavy-loaded processor may be very close to ts deadlne. As a result, f the overruns of all the tasks are stll executed n the processors where ther regular executons are located (whch s called No verrun Management (NM) schedulng herenafter), they are qute lkely to mss ther deadlnes. Under the WF algorthm, a new task τ wll be assgned to the processor on whch can leave the most capacty left over after ths allocaton. In other words, f τ can ft n several processors (.e. all the regular task executons on these processors are schedulable after the allocaton), we choose the processor wth the lowest task utlzaton to allocate τ. If τ cannot ft n any processor, the system wll be consdered as unschedulable. For most cases, the loads of the whole system are almost evenly dstrbuted on all processors. 3) SDS Parameters Selecton: The replenshment perod of a set of SDS s randomly selected n the range [1000, 10000] wth a granularty of 1000 (same as [13]). In our experments, we examne three bandwdth selecton schemes. In [13], the bandwdth of an SDS s chosen from (0.15, 0.3, and 0.5). Based on randomly selected replenshment perods, SDSs wth dfferent capactes are generated. The work n [13] provdes a combnaton of global and parttoned schedulng, where the servers are used to process globally scheduled tasks. However, n our framework, the servers are only used to execute the overruns of parttoned tasks. We want to provde a guaranteed servce to each task regardng ts regular executon, so that the overrun of a task may mpact other regular task executons as lttle as possble. Therefore, we select the parameters of an SDS (.e. replenshment perod and capacty) based on the slack remanng on each processor after the task allocaton process. Ths s smlar to the dea of the Slack Stealer whch s presented n [22]. The detals of the selecton process are llustrated n Appendx C. In Appendx C, the SDS capacty selecton s based on response tme analyss, therefore, we call t Response Tme based Slack Stealer (RTSS) herenafter. Besdes the RTSS, we also consder an Utlzaton based Slack Stealer (USS). Under the USS scheme, the bandwdth of an SDS s also selected based on the remanng capacty of the correspondng processor, but the calculaton s based on utlzatons rather than response tmes. The Lu & Layland utlzaton bound [4] mples that as the number of tasks goes up, the affordable total task utlzaton wll be decreased from 1. n another hand, f we use most remanng capacty, the response tme of some regular task executons may be very close to ther deadlne. As a result, these tasks cannot afford any overruns. Therefore, we can only partally utlze the remanng capacty. In our experments, the SDS bandwdth selecton s based on some percentage (wthn the range of [0.1, 0.6]) of the remanng capacty. Smlar to [13], we also consder an even SDS bandwdth allocaton scheme (denoted by EVEN). Under ths scheme, all the SDSs have the same bandwdth, whch s randomly chosen from [0.1, 0.3] wth a granularty of B. Experments for Hard Real-Tme Applcatons In the frst set of experments, we focus on the determnstc WCRT analyss whch s utlzed under hard tmng constrants. For each task set, we respectvely apply our global SDS-based framework wth dfferent bandwdth selecton schemes, as well as some local overrun management solutons presented n [3]. In [3], the authors used a Sporadc Server [23] based overrun management scheme for fxed prorty systems wth sngle core, whch can be consdered as a local overrun management soluton n a mult-core system. Under the local overrun management scheme, the overruns of tasks are handled by the local servers (.e. no mgratons). Regardng dfferent server bandwdth selecton schemes, the results of the local management soluton are marked as Local-RTSS, Local-USS and Local-EVEN. The comparson results are provded along wth some observatons. 1) Effects of System Parameters: Frst, we try to examne how parttonng algorthms and SDS bandwdth selecton schemes can affect the schedulablty of ths framework. We mplement several separate sets of experments to nvestgate the mpact of dfferent effectve factors (e.g. the number of tasks, the total task utlzaton, etc.). Wthn each experment set, the observed factor s fxed for each sub experment set, whle all the other parameters are randomly selected as mentoned n the above subsectons. a) Number of Tasks: The frst experment set s regardng the number of tasks n the whole system. Gven the total utlzaton of a task set, f the number of tasks s low, the utlzaton of each task wll be hgh. In ths case, the number of overruns s also low, but the executon tmes of overruns can become longer snce we set the overrun tme of each task based on ts regular executon tme. n another hand, when the number of tasks s hgh, the utlzaton of each task s mostly low. As a result, the executon tme of each overrun s usually small, but the number of overruns becomes hgh. When we ncrease the number of tasks, we cannot clearly observe a trend of the schedulablty changes, because the number of overruns and the executon tmes of overruns are balancng each other all the tme. As shown n Fgure 2.a, under the FF allocaton algorthm, the RTSS and USS server bandwdth selecton scheme have very close performance, whch are always much better than the

8 4 35,00% 3 25,00% 15,00% 1 5,00% 45,00% 4 35,00% 3 25,00% 15,00% 1 5,00% 35,00% ,00% 8 15,00% ,00% ,3 0,6 0,9 1,2 1,5 0,1 0,2 0,3 0,4 0,5 0,6 (a) (b) (c) ,3 0,6 0,9 1,2 1,5 0,1 0,2 0,3 0,4 0,5 0,6 (d) (e) (f) RTSS EVEN USS Local-RTSS Local-EVEN Local-USS Fg. 2. Comparson between the FF (Fgure a&b&c) and WF (Fgure d&e&f) based framework regardng dfferent system parameters. The y axs n these fgures denotes the schedulablty rato per 1000 expermental observatons. The x axs n Fgure a&d denotes the number of tasks. The x axs n Fgure b&e denotes the overrun percentage regardng regular executons. The x axs n Fgure c&f denotes the average total task utlzaton for each core. EVEN bandwdth selecton. Because these two schemes take nto account the actual remanng capacty on each core more precsely. n another hand, the local overrun management soluton performs qute bad here. The man reason s that under the FF algorthm, there s always a heavy loaded core whch has a very weak capablty to handle overruns due to the qute lmted server bandwdth. Therefore, n ths case, our global overrun management framework performs much better. As shown n Fgure 2.d, under the WF partton algorthm, the RTSS and USS bandwdth selecton schemes are stll better than the EVEN scheme. Under the WF algorthm, all the cores may provde much server bandwdth snce the workloads are almost evenly dstrbuted. Therefore, t s not common to see an extremely heavy loaded core n ths case. That s why the local overrun management solutons are much better comparng to under the FF algorthm. However, the local overrun management stll cannot outperform our method, snce they do not utlze the capactes from other cores. Accordng to our server bandwdth selecton schemes, f a core s totally free, we use the whole core for overruns; f a core has been assgned some regular task executons, we partally use the remanng capactes. In other words, under the FF algorthm, the total capacty for SDSs s usually larger than under the WF algorthm; however, the FF algorthm s strongly affected by the heavy loaded core. Under the FF algorthm, when the number of tasks s low, there s a hgh probablty that some cores can be completely used to handle overruns (.e. workloads are dstrbuted n the cores wth lower ndexes). However, under the WF algorthm, once the number of tasks s greater than the number of cores, there wll be no free core whch can be totally used for overruns. Therefore, as shown n the results, when the number of tasks s low, the FF algorthm outperforms the WF algorthm. However, when we ncrease the number of tasks, the occurrence of free cores under the FF algorthm becomes less frequent, but a heavy loaded core stll usually exsts. As a result, the WF algorthm becomes better than the FF algorthm. b) verrun Executon Tme: Ths set of experments focus on the executon tmes of task overruns. As shown n Fgure 2.b, under the FF algorthm, as the overrun tme goes up, the schedulablty of the global schemes decreases slghtly. However, the performance of the local overrun management methods goes down sharply (.e. almost non-schedulable when the overrun percentage exceeds 1.2). Under the WF algorthm (as shown n Fgure 2.e), the local overrun management methods become much better, but stll lmted by the local capacty on each core. We notce that as the overrun tme ncreases, the performance under the WF algorthm drops faster than under the FF algorthm. Under the FF algorthm, for the tasks on the heavy loaded cores whose response tmes are close to ther deadlnes, they have very weak capablty to afford any

9 overrun. Therefore, those tasks are not very senstve to the changes of overrun tmes (.e. they may always mss ther deadlnes no matter the overrun percentage s 0.3 or 1.2). n another hand, under the WF algorthm, heavy loaded cores do not frequently appear. As a result, the man effectve factor for the performance changes n Fgure 2.b&e s the total overrun-handlng capacty of a system. As we mentoned n the prevous subsecton, the WF algorthm has a hgh probablty to provde less capacty than the FF algorthm, therefore, t s more senstve to the ncrease of overrun tmes. However, when the overrun percentage s not very large (e.g. less than 0.9), the WF algorthm can always provde better performance because t can avod the nfluence of heavy loaded cores. c) Task Utlzaton: In ths set of experments, we try to examne the effect caused by the average total utlzaton of regular tasks executons per core. The results are shown n Fgure 2.c&f. As the system utlzaton goes up, the schedulablty of all these methods decreases. When the average total utlzaton of regular executons exceeds 0.5 on each core, t s always non-schedulable. When the utlzaton s very low (.e. 0.1 per core), the global overrun management framework under the FF algorthm performs better than the WF algorthm. Smlar to the prevous dscusson, under the FF algorthm, when the system utlzaton s low, there s a very hgh probablty that some cores are totally free whch can be utlzed to handle overruns. However, under the WF algorthm, once the number of tasks s greater than the number of cores, there wll be no empty cores n the system. 2) General Comparson: A general comparson s shown n Fgure 3. Here we summarze some key observatons from the above dscussons. Apparently, our framework s always better than the local overrun management solutons. Under the FF algorthm, the RTSS server bandwdth selecton scheme s better than the USS approach. Whle under the WF algorthm, the USS scheme becomes slghtly better than the RTSS approach. We need to pont out that the RTSS algorthm may nclude more overhead than the USS scheme due to the computaton of response tmes. Moreover, the FF algorthm has a hgher probablty to provde larger total overrun-handlng capacty than the WF algorthm, because free cores are fully utlzed. However, the WF algorthm can avod heavy loaded cores on whch the tasks may have weak capabltes to afford overruns. 3) Comparson wth NM schedulng: We also produced some experments to compare our framework wth the NM schedulng (.e. no overrun management). The results are shown n Fgure 4. Apparently, our framework always performs better. We need to pont out that, the experments are produced by analyss-based smulatons. As we mentoned n Secton III, n order to reduce the computaton tme, our schedulablty analyss (both the determnstc and probablstc analyss) ncludes some approxmatons whch can lead to pessmsm. Therefore, the actual performance of our framework can be even better. In our future work, we wll 35,00% 3 25,00% 15,00% 1 5,00% FF RTSS EVEN USS Local-RTSS Local-EVEN Local-USS Fg. 3. FF VS. WF. further remove the pessmsm n the analyss, and examne our framework from real mplementatons. 35,00% 3 25,00% 15,00% 1 5,00% 0,6 0,9 1,2 1,5 SDS-based NM schedulng (a) 35,00% 3 25,00% 15,00% 1 5,00% WF SDS-based NM schedulng Fg. 4. Global overrun management VS. No overrun management. The y axs n these fgures denotes the schedulablty rato per 1000 expermental observatons. The x axs n Fgure a denotes the overrun percentage regardng regular executons. The x axs n Fgure b denotes the number of tasks. Note that the connecton lnes n all the fgures are just used for the convenence of vsualzaton. C. Experments for Soft Real-Tme Applcatons The second type of experments take the probabltes of overrun occurrences nto account, whch focus on soft tmng constrants. The systems are randomly generated n the same ways as presented n Secton IV-A. The occurrence probabltes of task overruns are unformly selected from the range [0, 5%]. As we know, the determnstc WCRT analyss assumes a guaranteed worst-case scenaro where the task overruns always occur. However, the probablty of that case may be very low n realty. Therefore, for soft real-tme applcatons, we can set a DMR bound for the system under analyss. If the DMRs of all the tasks n a system do not exceed the gven bound, we can stll consder ths system as acceptable. Due to the page lmtaton, here we just show some of the results. In ths experment set, we focus on the changes of the total task utlzaton. The regular tasks allocaton s based on the FF algorthm, and the server bandwdth s selected wth the USS approach. As shown n Fgure 5, when we ncrease the DMR bound, the average schedulablty rato of the system gans an (b)

10 obvous ncrease. That s why we beleve that a probablstc task model s very mportant for soft real-tme systems ,1 0,2 0,3 0,4 0,5 Hard (SDS-based) Hard (NM schedulng) Soft (DMR bound = 3%) Soft (DMR bound = 5%) Fg. 5. Global overrun management (determnstc and probablstc) VS. No overrun management. The y axs denotes the schedulablty rato per 1000 expermental observatons. The x axs denotes the average total task utlzaton for each core. V. CNCLUSIN AND FUTURE WRKS In ths paper, we present a Synchronzed Deferrable Server (SDS) based schedulng framework for mult-core real-tme systems, where task overruns are taken nto account. In our framework, task overruns are solated from regular task executons by mgraton of overruns to globally shared servers. Consequently, many tasks can be saved from mssng ther deadlnes due to the occurrence of overruns n the system. A determnstc Worst-Case Response Tme (WCRT) analyss and a probablstc Deadlne Mss Rato (DMR) computaton are provded. Some systematc experments regardng dfferent parameters have also been mplemented. Accordng to the results of our experments, our framework can always provde a better performance than the local overrun management schemes. When task overruns occur, our soluton also always outperform the schedulng method wthout overrun management. As mentoned above, both the determnstc WCRT analyss and the probablstc DMR computaton presented n ths paper may nclude pessmsm, because we utlze some guaranteed approxmatons n our analyss to decrease the complexty. Therefore, we need to further nvestgate some more explct analyss to reduce the pessmsm. Moreover, the experments n ths paper are produced by smulatons. We wll evaluate further usng real mplementatons where the schedulng overhead wll be nvestgated. In our framework, the overruns are scheduled by a stated global Frst-In-Frst-ut (FIF) queue. In our future work, we may utlze some other global schedulng mechansms for task overruns. Then we can try to fnd out the optmal solutons under dfferent system condtons. Moreover, we wll also further nvestgate other approaches to select server bandwdth. REFERENCES [1] R. Rajkumar, K. Juvva, A. Molano, and S. kawa, Resource kernels: A resource-centrc approach to real-tme and multmeda systems, n Photoncs West 98 Electronc Imagng. Internatonal Socety for ptcs and Photoncs, 1997, pp [2] M. Caccamo, G. Buttazzo, and L. Sha, Handlng executon overruns n hard real-tme control systems, Computers, IEEE Transactons on, vol. 51, no. 7, pp , [3] M. K. Gardner and J. W.-S. Lu, Performance of algorthms for schedulng real-tme systems wth overrun and overload, n the 11th Euromcro Conference on Real-Tme Systems, ECRTS 99. IEEE, 1999, pp [4] C. L. Lu and J. W. Layland, Schedulng algorthms for multprogrammng n a hard-real-tme envronment, J. ACM, vol. 20, no. 1, pp , Jan [5] J. Y.-T. Leung and J. Whtehead, n the complexty of fxed-prorty schedulng of perodc, real-tme tasks, Performance evaluaton, vol. 2, no. 4, pp , [6] M. L. Dertouzos, Control robotcs: The procedural control of physcal processes, n IFIP Congress, Proceedngs., 1974, pp [7] R. I. Davs and A. Burns, A survey of hard real-tme schedulng for multprocessor systems, ACM Computng Surveys, vol. 43, no. 4, [8] J. H. Anderson, V. Bud, and U. C. Dev, An edf-based schedulng algorthm for multprocessor soft real-tme systems, n 17th Euromcro Conference on Real-Tme Systems, ECRTS 05, Proceedngs. IEEE, 2005, pp [9] S. Kato and N. Yamasak, Sem-parttoned fxed-prorty schedulng on multprocessors, n 15th IEEE Real-Tme and Embedded Technology and Applcatons Symposum, RTAS 09. IEEE, 2009, pp [10] R. I. Davs and A. Burns, Herarchcal fxed prorty pre-emptve schedulng, n Real-Tme Systems Symposum, RTSS 05, 26th IEEE Internatonal. IEEE, 2005, pp. 10 pp. [11] P. J. Cujpers and R. J. Brl, Towards budgetng n real-tme calculus: Deferrable servers, n Formal Modelng and Analyss of Tmed Systems. Sprnger, 2007, pp [12] G. Lpar and E. Bn, A framework for herarchcal schedulng on multprocessors: from applcaton requrements to run-tme allocaton, n Real-Tme Systems Symposum, RTSS 10, IEEE 31st. IEEE, 2010, pp [13] H. Zhu, S. Goddard, and M. B. Dwyer, Response tme analyss of herarchcal schedulng: The synchronzed deferrable servers approach, n Real-Tme Systems Symposum, RTSS 11, IEEE 32nd. IEEE, 2011, pp [14] L. Aben and G. Buttazzo, Integratng multmeda applcatons n hard real-tme systems, n The 19th IEEE Real-Tme Systems Symposum, RTSS 98. IEEE, 1998, pp [15] J. Daz, D. Garca, K. Km, C. Lee, L. Lo Bello, J. Lopez, S. L. Mn, and. Mrabella, Stochastc analyss of perodc real-tme systems, n 23rd IEEE Real-Tme Systems Symposum, RTSS 02, 2002, pp [16] R. I. Davs and A. Burns, Prorty assgnment for global fxed prorty pre-emptve schedulng n multprocessor real-tme systems, n Real- Tme Systems Symposum, RTSS 09, 30th IEEE. IEEE, 2009, pp [17] J. K. Strosnder, J. P. Lehoczky, and L. Sha, The deferrable server algorthm for enhanced aperodc responsveness n hard real-tme envronments, Computers, IEEE Transactons on, vol. 44, no. 1, pp , [18] J. Carpenter, S. Funk, P. Holman, A. Srnvasan, J. Anderson, and S. Baruah, A categorzaton of real-tme multprocessor schedulng problems and algorthms, Handbook on Schedulng Algorthms, Methods, and Models, pages, pp. 30 1, [19] M. Joseph and P. Pandya, Fndng response tmes n a real-tme system, n Computer Journal 29(5), ct. 1986, pp [20] N. Audsley, A. Burns, M.Rchardson, K. Tndell, and A. Wellngs, Applyng new schedulng theory to statc prorty pre-emptve schedulng, Software Engneerng Journal, vol. 8, no. 5, pp , Sep [21] J. W. S. W. Lu, Real-Tme Systems, 1st ed. Upper Saddle Rver, NJ, USA: Prentce Hall PTR, [22] J. Lehoczky and S. Ramos-Thuel, An optmal algorthm for schedulng soft-aperodc tasks n fxed-prorty preemptve systems, n Real-Tme Systems Symposum, RTSS 92, 1992, pp [23] B. Sprunt, L. Sha, and J. Lehoczky, Aperodc task schedulng for hardreal-tme systems, Real-Tme Systems, vol. 1, no. 1, pp , 1989.

11 APPENDIX A Whle calculatng the nterference caused by the SDS, we cannot smply consder t as other regular tasks because of the carry-n nstance of an SDS. For example, we assume that τ s the task under analyss wth a regular executon tme 2 and a perod 10, and τ j s the SDS n the processor where τ s located wth a capacty 2, and a replenshment perod 5. If we consder τ j as a regular task, accordng to the tradtonal RTA, the crtcal nstance occurs when the jobs of τ and τ j are released at the same tme [19] (.e. tme t 0 n Fgure 6). Then the calculated WCRT wll be 4. However, a deferrable server s dfferent from a regular task, because t s nfluenced by ts own workloads but not the other tasks n the same processor. In other words, the crtcal nstance theory for regular task sets s not vald for task sets wth deferrable servers. As shown n Fgure 6, the crtcal nstance of τ,k occurs when t s released at tme t 1 but not t 0. In ths case, the correct WCRT should be 6. The dfference between the above two crtcal nstances just depends on the begnnng of the busy perod. In order to create the worst-case scenaro, the frst nstance of the SDS should be released as late as possble, and the followng nstances are supposed to be released as early as possble. Therefore, we can upper bound the nterference due to the SDS by takng one more nstance of the SDS nto account [21]. t 1 Fg. 6. τ j,p 1 t 0 τ j,p τ,k WCRT analyss wth deferrable servers. APPENDIX B Proof of Lemma 2: We can dvde r B nto two parts. The frst part s the processng tme n the perod, where QW s just fnshed. The tme nterval t res computed by Eq. 6 denotes the processng tme of QW n ts last replenshment perod. Assume that τ s assgned to the server Cs z (1 y < z m) 7. nce τ has consumed the capacty of Cs, z the processng tme of τ wll be ncreased to Cs z t res. Accordng to our schedulng polcy, τ can preempt any other jobs n Q g at ths moment, snce all the workloads ahead of τ have already left Q g. Then τ wll preempt the executon of another server Cs y wth a larger capacty, because under the worst-case assumpton, all the servers wth lower capactes should have exhausted ther capactes. When the capacty of ths server s also consumed, the processng tme of τ wll be ncreased to Cs z t res +Cs y Cs z = Cs y t res. Then τ wll occupy an even larger SDS, untl the largest one (Cs 1 ) s consumed. Therefore, the frst part of r B can be computed by Cs 1 t res. If C Cs 1 t res, then r B = C, because τ has already fnshed n the frst replenshment perod (.e. the second part s 0). If C > Cs 1 t res, we need to compute the second part of B whch s the processng tme after the frst replenshment perod. If τ o s large enough, the remanng processng tme (.e. C (Cs 1 t res )) may occupy several complete replenshment perods (computed by Eq. 11) and a remanng executon tme C res (computed by Eq. 10). Due to the same manner of the above dscusson, under the worst-case assumpton, the mnmum capacty that τ can consume wthn each replenshment perod s Cs 1. Therefore, the denomnator n Eq. 11 s Cs 1. Based on the above dscusson, the second part of r B can be calculated by CRP T s +C res. Whle addng the above two parts together, we need to nclude the gap between them. That gap s the tme nterval between the tme nstant where all the SDS capactes have been consumed n the frst replenshment perod (.e. the end of the frst part), and the begnnng of the second replenshment perod (.e. the start of the second part). Ths gap can be upper bounded as T s Cs 1. Therefore, when C > Cs 1 t res, we can compute r B as r B = Cs 1 t res + T s Cs 1 +CRP = T s t res +CRP T s +C res APPENDIX C T s +C res (17) A Slack-Stealer based SDS Bandwdth Selecton Scheme: For each processor, we apply Algorthm 2 to generate the capacty of ts own SDS. If the processor s empty, the capacty of the processor wll be fully assgned to the SDS (lne 2-4). therwse, we need to assgn the free capacty of ths processor to the server, so that the created SDS wll not mpact too much on the schedulablty of the regular executons of all the tasks on ths processor. Fgure 7 shows the way that we fnd the slack capacty of each processor. The basc dea s that we try to assgn as much capacty as possble to an SDS, whle keepng that the regular executons of all the tasks stll meet ther deadlnes. In Fgure 7, the broken lne represents the processor demand whch s gven by the followng functon PD(τ,t) = C R + τ j hp(τ ) τ j S t C R j (18) T j The straght sold lne denotes the capacty suppled by a processor regardng tme t. The frst ntersecton pont of these two lnes provdes the WCRT of τ R, whch s the theoretcal base of the tradtonal response tme analyss. If we assgn some processor capactes to an SDS, the suppled capactes for the regular task executons wll certanly be decreased. In other words, whle assgnng capactes to an SDS, we are shftng the straght lne towards the downsde gradually (.e. represented by the dashed lnes). We can keep shftng untl the nstant that a lttle more shftng space may result n no ntersecton pont before D (.e. τ R s about to mss ts deadlne). Ths maxmum shftng space provdes the 7 Here we use C x s to denote the x th SDS as well as ts capacty.