Improving Schedulability of Fixed-Priority Real-Time Systems using Shapers

Transcription

1 Improvng Schedulablty of Fxed-Prorty Real-Tme Systems usng Shapers Lnh T.X. Phan Insup Lee Department of Computer and Informaton Scences, Unversty of Pennsylvana Emal: {lnhphan, Abstract In ths paper, we ntroduce a technque for mprovng the schedulablty of real-tme embedded systems wth fxedprorty schedulng. Our technque uses shapers to reduce the resource nterference between hgher-prorty and lower-prorty tasks, and thus enables more lower-prorty tasks to be scheduled. We present a closed-form soluton for the optmal greedy shaper for perodc tasks wth jtter, as well as a schedulablty condton for tasks n the presence of shapers. We also dscuss two applcatons of greedy shapers: In compostonal schedulng frameworks, shapers can help optmze the resource nterfaces of real-tme components, and n mxed-crtcalty systems, they can reduce deadlne msses of low-crtcalty tasks whle preservng schedulablty of hgh-crtcalty tasks, even wth lower prortes. We demonstrate the utlty of our technque through an evaluaton based on randomly generated workloads. I. INTRODUCTION For the past several decades, fxed-prorty (FP) schedulng has been one of the most commonly used schedulng algorthms n safety-crtcal real-tme embedded systems, partly due to ts flexblty, ts smple run-tme mechansm, and ts small overhead [11]. However, n a fxed-prorty system, low-prorty tasks often experence resource nterference from hgherprorty tasks, whch leads to long response tmes (compared to systems that use dynamc schedulers, such as Earlest Deadlne Frst) and requres more resources to guarantee that the system s schedulable. Hence, reducng nterference from hgh-prorty tasks s crtcal to mprovng the schedulablty and optmzng the resource requrements of the system. In fully preemptve FP, mnmzng the nterference due to preempton also helps reduce cache-related overheads and energy consumpton [7]. Several technques for mprovng resource nterference n FP systems have been proposed (see e.g., [5] [7], [13], [23], [24]); however, most of these technques assume a strctly perodc task model. Ths assumpton s overly conservatve for many reactve embedded systems, where tasks often exhbt jtter,.e., devatons from true perodcty. Ths jtter typcally comes from the release-delay overheads nduced by tck-drven schedulng [18], executon of nterrupt servce routnes [4], or I/O overheads. Other sources of jtter nclude delays caused by schedulng, data dependences, and communcaton, especally n a dstrbuted settng. For example, n ARINC avoncs systems [2], tasks n dfferent schedulng parttons are connected over a swtched Ethernet; due to network delay, tasks n a Ths research was supported n part by the ARO grant W911NF , NSF grants CNS and CPS , and MKE (The Mnstry of Knowledge Economy), Korea, under the Global Collaboratve R&D program supervsed by the KIAT (M2389). Ths s the author s verson, whch fxes an error n Example 2 n the offcal IEEE verson. partton are not always released strctly perodcally, but wth a certan jtter. Automotve networks are another example: here, sensor data are sampled at a constant rate, but the results often pass through a seres of electronc control unts (ECUs) and the bus before arrvng at a gven ECU. Snce the resource of each component s often shared among multple tasks, schedulng and task executon wthn a component can delay the nput data for a varable amount of tme, whch results n jttery output. If ths output s then used to actvate the successor task n the next component, ths task wll tself be released n a jttery manner or (when the jtter exceeds the length of a perod) even n bursts. One smple approach to dealng wth jtter s to transform each task wth a jttery release pattern nto a new perodc/sporadc task wth a shorter perod [4]. Exstng nterference reducton technques for perodc tasks (e.g., [5] [7], [13], [23], [24]) can then be appled to the transformed task sets. Whle ths method s safe, the transformaton can lead to overly pessmstc schedulablty analyss results. In addton, the resultng smaller perods (of hgher-prorty tasks) exacerbate the resource nterference wth lower-prorty tasks, whch can dmnsh or even cancel out the benefts of the nterference reducton technques. Further, these technques modfy the behavor of FP to reduce the preempton overheads, whch often requres fne-graned nformaton about the tasks code structure or complex computaton of preempton attrbutes (e.g., [6], [23], [24]). A technque that does not change the FP behavor or tasks attrbutes was proposed n [17]; however, t requres the use of CPU frequency scalng, whch may not be avalable n all systems. In ths paper, we propose a technque based on shapng [3] to mprove the schedulablty of FP systems that contan perodc tasks wth jtter. Our key observaton s that, n settngs where tasks exhbt jtter, the resource nterference of hgher-prorty tasks on the lower-prorty ones s much hgher than n a strctly perodc settng. Typcally, the larger the jtter of a hgher-prorty task, the hgher the resource nterference t mposes on lower-prorty tasks. By usng shapers to reduce the maxmum jtter/burst, we can reduce the nterference, and thus enable more lower-prorty tasks to be scheduled. In ths paper, we focus on the use of greedy shapers, snce they have a smple representaton (as arrval curves [3]), and they preserve the worst-case output arrval patterns and can therefore be combned wth component-based analyss frameworks for dstrbuted archtectures (e.g., [22]). Our technque based on greedy shapng also preserves both the fxed-prorty scheduler and the tasks parameters, so t can be

2 ntegrated nto many exstng fxed-prorty systems (e.g., wth Deadlne Monotonc and (D J)-monotonc [25] schedulers). Greedy shapers were frst ntroduced n the context of communcaton networks [3]. They are commonly used to ensure that packets are sent at regular ntervals rather than n bursts, whch results n lower queueng delays. In ths settng, schedulablty or nterference wth lower-prorty flows are not prmary concerns, so the choce of shapng functons s straght-forward: a greedy shaper can use any functon that s at least equal to the arrval functon of the source flow [3]. In safety-crtcal real-tme embedded systems, however, schedulablty s crucal, so better shapng functons are needed to meet the system s tmng and resource constrants. Contrbutons. Ths paper makes the followng contrbutons: We propose the use of shapng to reduce resource nterference between tasks wth jttery release patterns, whch mproves schedulablty and mnmzes the total resource demands of the system (Secton III). We ntroduce a method for computng the optmal shaper for the perodc-wth-jtter task model (whch mnmzes a task s resource nterference on lower-prorty tasks wthout affectng ts schedulablty), and we ntegrate shapng nto the schedulablty condton (Sectons IV and V). We dscuss two applcatons of shapers. Frst, we show how shapers can be ntegrated wth compostonal schedulng frameworks, and we analyze ther effect on the components nterfaces (Secton VI). Second, we show that n mxed-crtcalty systems, shapers can preserve schedulablty of hgh-crtcalty tasks whle mnmzng deadlne msses of low-crtcalty tasks (Secton VII). We valdate our technque wth an evaluaton usng a varety of real-tme workloads. The results show that our proposed technque can reduce the system s deadlne mss rato by up to 35%, and t reduces components nterface bandwdth by up to 33% compared to a reference system wthout shapers (Secton VIII). Related work. To the best of our knowledge, ths work s the frst to use shapng to reduce resource nterference n FP systems. Shapng was orgnally proposed for traffc shapng n communcaton networks [3]. Wandeler et al. [19], [2] extended t to the real-tme doman but analyzes the end-toend delay and buffer requrements of exstng shapers, rather than desgnng new ones. Other work has desgned shapers for optmzng specfc metrcs; for nstance, Kumar et al. [9] showed how to compute a shaper that optmzes on-chp peak temperature. However, Kumar s approach to shaper desgn s specfc to the EDF schedulng, and s not applcable n an FP settng for two reasons. Frst, optmalty s proven assumng that the processor s fully avalable to the output jobs of the shaper; ths s not the case n FP systems, where lower-prorty tasks do not receve the full capacty of the processor. Second, Kumar uses the shaper to shape the combned demand of all tasks n the system, but there s currently no technque for computng the total demand of tasks wth dfferent deadlnes and WCETs that are scheduled under FP. There s other work that has some smlartes to shapng. Sun and Lu [16] ntroduced the release guard protocol to release subtasks of an end-to-end task perodcally, whch s a specal form of greedy shaper. Rchter et al. [14] proposed an event adaptaton functon (EAF), whch transforms an event stream nto another that conforms to a gven model. If an EAF s gven a perodc model, t effectvely acts as a shaper; the key challenge we solve n ths paper s to desgn the model such that t mproves schedulablty. At a hgh level, shapers are also smlar to servers, whch are commonly used to schedule aperodc tasks together wth perodc tasks [12]. Servers do not guarantee any propertes by themselves, other than a lmt on how much of the resource s used by the tasks they encapsulate; n partcular, they do not consder the schedulablty of the tasks they contan. Servers are a general concept, and n theory one could desgn a server that provdes the same propertes as a shaper, but then the server would effectvely become a shaper, and ts desgn would requre an analyss smlar to the one we propose here. II. BACKGROUND Task model. The system conssts of N ndependent perodc tasks wth jtter (see e.g., [1], [18]), whch are scheduled under preemptve FP on a unprocessor. Each task T s characterzed by (P,J,E,D ), wth < E mn(p,d ), where P,J,E and D are non-negatve real numbers that represent the task s perod, jtter, worst-case executon tme (WCET) and relatve deadlne. The jtter J s the maxmum delay between the vrtual deal perodc release tme of a job (of T ) and ts actual release tme. All tasks have hard deadlnes; the absolute deadlne of a job of T s ts actual release tme plus D. P P J an deal perodc release pont J (jtter wndow) frst release Fg. 1: A sample release pattern of T wth P = 8, J = 6. Fgure 1 llustrates a sample release pattern of a task. We assume that the scheduler mantans a ready queue for each task, whch contans all jobs of the task that are ready for schedulng, and we wrte HP(T ) (resp. LP(T )) to denote the set of all tasks wth a hgher (resp. lower) prorty than T. Modelng resource demands. The release patterns of a task can be modeled as an arrval functon, whch specfes the maxmum number of jobs that are released over any (left-open or rght-open) tme nterval of length t, for all t. Let R + be the set of non-negatve real numbers. The arrval functon of a task T wth perod P and jtter J s α : R + N, where t + J α () =, and α (t) =, t >. (1) The number of executon unts requested by a task over any tme nterval of a gven length can then be modeled by ts request bound functon (RBF). The RBF of a task T wth arrval functon α (t) and WCET E s gven by: P tme rbf (t) = E α (t), t. (2)

3 Smlarly, the mnmum executon unts that must be gven to a task to ensure ts schedulablty s modeled by a demand bound functon (DBF), whch specfes, for each t, the maxmum number of executon unts requred by all jobs that are released and that have deadlnes wthn an nterval of length t. The DBF of a task T wth relatve deadlne D and RBF rbf (t) s: dbf (t) = max {, rbf (t D ) }, t. We note that arrval functons and RBFs of perodc-wthjtter tasks are good functons,.e., they are sub-addtve and equal to zero at t =. Recall that f s sub-addtve ff f (t) f (t s) + f (s) for all s < t. Modelng resource avalablty. The resource suppled by a processor can be modeled by a supply bound functon (SBF), denoted by sbf (t), whch gves the mnmum number of executon unts avalable over any tme nterval of length t, for all t. SBFs are also known as servce functons (possbly, after scalng to a task s WCET) [3]. Consder a task T that s processed by a processor wth SBF f. Suppose g s the RBF of T, then the SBF of the mnmum remanng resource after processng T s gven by [3]: Reman( f,g)(t) def = sup { f (x) g(x) x t }. (3) Further, f f s the SBF of the remanng resource, then the maxmum value for the RBF of T s gven by [21]: RTInverse( f, f )(t) def = f (t + δ t ) f (t + δ t ) (4) where δ t = sup{ε f (t + ε) = f (t)}. Fnally, let F be the set of ncreasng functons f : R + R +. We defne the (mn,+) convoluton, deconvoluton and sub-addtve closure of any f,g F as follows. For all t : ( ) def f g (t) = nf { f (s) + g(t s) s t } ; (5) ( ) def f g (t) = sup { f (t + u) g(u) u } ; (6) closure( f ) = mn{ f, f f, f f f,...}. (7) It follows that closure( f ) s the maxmum good functon upper bounded by f ; ( f f ) s a good functon; and f f f. Fnally, we say f s larger (resp. smaller) than or equal to g ff f (t) g(t) (resp. f (t) g(t)) for all t R +. III. OVERVIEW OF OUR SHAPING APPROACH Basc dea: Recall our assumpton (from Secton II) that the scheduler mantans a separate ready queue for each task. The dea s to optmze the resource usage of the system by controllng these queues n such a way that () the nterference between jobs from dfferent queues s mnmzed, and () the total resource requrements of all jobs wthn the system s reduced wthout volatng the jobs schedulablty. To acheve ths, we nsert a greedy shaper n front of each ready queue to shape the arrval pattern of jobs that are ready to be scheduled. The shaper can delay an already released job for a certan amount of tme so as to bound the resource demands (requests) of the correspondng task to a desred level. Effectvely, each shaper reduces ts task s resource nterference wth the lower-prorty tasks. At the same tme, by postponng the executon of a hgher prorty job just long enough so that t can stll meet ts deadlne, a shaper ndrectly enables the scheduler to gve resources to the lower-prorty jobs, whch mproves ther schedulablty. System archtecture: Fgure 2 llustrates the archtecture of a system that mplements the shapng technque. Each shaper σ has an nput buffer B, whch s used to hold newly released jobs before puttng them nto the ready queue Q. The scheduler does not need to be aware of the shapers t can schedule the jobs n the ready queues exactly as f there were no shapers. We say that a shaper s feasble f t preserves schedulablty of all tasks n the system. shaper released jobs buffer shaper of task T 1 σ 1 B 1 shaper released jobs buffer shaper of task T 2 σ 2 B 2 ready queue Q 1 ready queue Q 2 output data FP output data scheduler Fg. 2: System archtecture for a system wth shapers. Greedy shapers. Informally, a greedy shaper [3] forces ts output jobs to conform to a specfc arrval functon, the shapng functon, and t outputs the jobs as soon as the shapng functon allows t. In Fgure 2, σ s the arrval functon used by T s greedy shaper. For convenence, we also use σ to ndcate the greedy shaper tself, and we use the terms shapng functon and shaper nterchangeably. Thus, the shaper σ delays each released job n the buffer B whenever placng the job to Q would volate the shapng functon σ. Formally, suppose the shaper σ receves job k of T at tme t k (.e., t k s the release tme of job k), where t k t k+1 for all k 1. Then, t wll output job k to Q at tme t k = t k + d k, where d k = f k = 1, and otherwse d k = mn{ 1 j < k : k j + 1 σ (t k + t j + ε)} for an nfntely small postve value of ε. Intutvely, d k s the mnmum tme that the shaper must delay job k to prevent ts ready tme from volatng σ k ; ths s obtaned by ensurng that the number of ready jobs n every nterval [t j,t k ] s no more than σ (t k t j + ε) for all j < k. Example 1: Consder a task T 1 wth perod P 1 = 4 and jtter J 1 = 3, and suppose σ 1 s a perodc arrval functon wth the same perod as the task,.e., σ 1 (t) = t/4, for all t. Then the shaper wll output at most t/4 jobs to the ready queue over any nterval of length t, or at most one ready job every four tme unts. Fgure 3 shows a release pattern of T 1 and the correspondng ready pattern after shapng. (a) Orgnal pattern of released jobs (b) Shaped pattern of ready jobs 1st 2nd 3rd 4th 5th 6th 7th 8th Fg. 3: Effect of the shaper σ 1 (t) = t/4 on T 1 = (4,3,1,4). In ths pattern, due to jtter, jobs 3, 5 and 6 are released less than 4 tme unts after ther predecessors. Snce the shaper cannot allow more than one job to become ready wthn a 4-unt nterval, t delays these jobs; n the fgure, ths s ndcated by the dashed lnes connectng release nstants and tme tme

4 the correspondng (delayed) ready nstants. Note also that the ready pattern s less bursty and closer to a perodc pattern than the orgnal release pattern, and that the delay mposed by the shaper s bounded. In ths paper, we assume that the shaper buffer s empty at tme, and t s s large enough to prevent job loss. In our settng, ths always holds because tasks are not released before tme, and the number of actve jobs per task at any nstant s fnte (otherwse, the task cannot be schedulable). In the rest of the paper, the term shaper refers to greedy shaper. IV. OPTIMAL SHAPER COMPUTATION Our next goal s to compute an optmal greedy shaper for each task T n the system,.e., one that mnmzes the maxmum response tmes of the lower-prorty tasks. We begn by ntroducng some basc propertes of greedy shapers. Theorem 4.1: Let E, α and σ be the WCET, arrval functon and shaper of T, where σ s a good functon. Then, 1) the jobs output by the shapers (.e., the ready jobs of Q ) are bounded by the arrval functon α gs = α σ ; 2) the greedy shaper serves as a vrtual resource that offers a supply-bound functon equal to E σ ; and 3) f sbf (t) s the SBF of the resource avalable to T n the absence of shapng, then the effectve resource avalable to T n the presence of a shaper σ for T s bounded by an SBF sbf gs = (E σ ) sbf. The proof s straghtforward (based on results n [3] (Secton 1.5.2)) and has been omtted due to space lmtatons. Defntons. Next, we formally defne the concepts of feasblty and optmalty for greedy shapers. Let C be the orgnal system wthout shapng, and let C σ be the same system wth the shaper σ appled to T for all 1 N (recall that N s the number of tasks n the system). Further, let R(T j,c) denote the maxmum response tme of task T j n C for all 1 j N. Defnton 1: A functon σ s a feasble shapng functon for T f () t s a good functon 1, and () T s schedulable n C σ f T s schedulable n C. Thus, a feasble shaper always preserves the schedulablty of ts task. Any shapng functon larger than or equal to the arrval functon of a task s trvally feasble but has no effect on the task s ready pattern (.e., as f there were no shaper), so t s not useful for our purposes. Defnton 2: σ s an optmal shaper of T ff () t s a feasble shaper of T, and () for any feasble shapng functon σ of T, R(T j,c σ ) R(T j,c σ ) for every T j LP(T ). It mples that f a lower prorty task of T s schedulable under a feasble shaper σ, then t s also schedulable under an optmal shaper σ. Thus, an optmal shaper of a task not only maxmzes the number of schedulable tasks but also mnmzes the maxmum response tmes of ts lower prorty tasks. When usng a feasble shaper, the effectve RBF of the ready jobs (output from the shaper) can be computed as follows: 1 Snce any functon can be refned nto a good functon (e.g, by takng the sub-addtve closure), we requre ths condton for ease of presentaton. Lemma 4.2: The effectve RBF of (the ready jobs of) T wth arrval functon α and feasble shaper σ gs s gven by rbf gs = E (α σ gs ). Proof: By substtutng the shapng functon nto Theorem 4.1(1), we obtan the arrval functon of the output jobs from the shaper σ gs (.e., nput jobs to the ready queue Q ), whch s gven by α gs = α σ gs. Hence, the effectve RBF = E (α σ gs ). of the ready jobs of T s rbf gs = E α gs The next lemma states the monotoncty between shapers and ther resultng maxmum response tmes of tasks: Lemma 4.3: Suppose σ and σ are two feasble shapers for T. Then, the followng holds: 1) If σ σ, then R(T j,c σ ) R(T j,c σ ) for all T j wth lower prorty than T. 2) σ s optmal ff σ σ for all possble values of σ. Proof: Let rbf gs gs and rbf be the effectve RBFs of the ready jobs of T when usng σ and σ, respectvely. Due to Lemma 4.2, rbf gs = E (α σ gs ) E (α σ gs gs ) = rbf. As a result, the maxmum resource nterference that T mposes on ts lower-prorty tasks when usng σ s always less than or equal to that when usng σ. Snce the resource nterference that T s hgher-prorty tasks mpose on T s lower-prorty tasks does not depend on the shaper that s used for T, we can conclude that R(T j,c σ ) R(T j,c σ ) for all T j wth a lower prorty than T, whch mples (1). Part (2) follows drectly from part (1) and the defnton of optmal shaper. Snce the arrval functons of the tasks are also feasble shapers, t follows from Lemma 4.3 that a system n whch hgh-prorty tasks mplement feasble shapng functons that are smaller than ther respectve arrval functons not only preserves the schedulablty of the system but also reduces the maxmum response tmes, and hence the schedulablty, of lower-prorty tasks. Thus, from a schedulablty and resource-demand perspectve, a system wth feasble shapers s always as good as, f not better than, one wthout shapers. Computng the optmal shaper. Let f be an arrval functon and g be the servce functon of a task,.e., g(t) gves the mnmum number of jobs that can be completed over any nterval of length t. Then, from [3], the maxmum response tme (delay) of the task s the maxmum horzontal dstance between f and g, denoted by dst( f,g), where dst( f,g) = sup t {nf d {d f (t) g(t + d)}}. The next theorem gves the necessary and suffcent condton for feasble shapers. Theorem 4.4: Let α (t) and D be the arrval functon and relatve deadlne of T, respectvely, and let γ (t) = max{,α (t D )}, t. Then σ F s a feasble shapng functon for T ff t s a good functon and σ γ. Proof: ( ) Let sbf (t) be the SBF that bounds the resource avalable to a task T n C and let β = sbf /E. Then, β (t) s the servce functon of T n C. Snce the set of tasks wth hgher prorty than T n C and C σ are the same, β (t) s also the servce functon of T n C σ. Suppose T s schedulable n C. Then, sbf (t) dbf (t) = E γ (t), whch mples β (t) γ (t), for all t (snce γ (t)

5 N). Let a(t) be a release pattern of T,.e., a(t) denotes the number of jobs that are released over (,t] for all t. If none of the jobs n the release pattern a(t) s delayed by the shaper σ, then all jobs of T also meet ther deadlnes n C σ. Otherwse, there exsts a job J k of T that s delayed by the shaper σ. Let t k and tk s be the release tme and the ready tme of J k, respectvely. Fgure 4 llustrates the release and ready patterns wth respect to α, σ and γ. # jobs α Snce σ s a good functon and the shaper outputs σ a(t) J k as soon as the resultng β output pattern does not volate the arrval constrant of 1 γ 2 the shapng functon, the delay of J k at the shaper s the mnmum tme nterval d 1 such that a(t k ) σ (tk s ), wth t k s t k t tk s = t k + d 1. Snce a(t k ) tme nterval length D Fg. 4: Job delay under shapng. α (t k ), we mply d 1 1, where 1 s the horzontal dstance between the arrval functon α and the pont σ (tk s ) (see Fgure 4). Further, the maxmum delay J k experences at the processor s the mnmum nterval 2 such that the number of jobs that can be completed by the processor over an nterval of length tk s + 2 s at least σ (tk s),.e., t s the mnmum tme nterval 2 such that β (tk s + 2) σ (tk s). Ths tme nterval 2 s ndcated by the horzontal dstance between σ (tk s ) and the servce functon β n Fgure 4. From the above, the maxmum response tme of J k s d 1 + def =. There are two cases: If β (tk s + 2) σ (tk s): Then, 2 = and 1 dst(α,σ ). Snce σ γ, we mply dst(α,γ ). Otherwse: Then, s no more than the horzontal dstance between the arrval functon α and β (tk s + 2). Thus, dst(α,β ) dst(α,γ ). Hence, dst(α,γ ). Recall that γ (t) = max{,α(t D )} for all t. Ths mples dst(α,γ ) = D. In other words, the response tme of J k s no more than D. Hence, T s also schedulable n C σ. Because σ s a good functon, we then mply that t s a feasble shapng functon for T. ( ) Reversely, suppose σ (t k ) < γ (t k ) for some t k. Snce γ (t) = for all t D and σ (t) for all t, we have t k > D. Let a(t) be the release pattern that concdes the arrval functon,.e., a(t) = α (t) for all t, where a(t) s the number of jobs that are released over (,t]. Then, a(t k D ) = α (t k D ) = γ (t k ) > σ (t k ). Ths mples that there exsts t k < t k D such that a(t k ) = σ (t k ), and subsequently, there s a job n a(t) that s released at tme t k and ready at tme t k. Ths job has a delay of at least t k t k, whch s larger than D and thus, t msses ts deadlne. In other words, σ s not a feasble shapng functon for T. The next two corollares follow drectly from the above theorem and Lemma 4.3(2) (see also Secton II for the property of the self-deconvoluton). Corollary 4.5: Let f F be such that f (t) = B t/d for all t D and f (t) = α (t D ) otherwse, where B = α ( + ε) for an nfntely small postve value of ε. Then, f f s a feasble shapng functon for T. Corollary 4.6: The smallest good functon σ that s larger than or equal to γ s an optmal shapng functon for T, where γ s defned n Theorem 4.4. Theorem 4.7: Let B = J /P and = mn(j,d ). Defne σ gs : R + N as follows: t R +, σ gs (t) = { B t, f t t+j P, otherwse. Then, σ gs s an optmal shapng functon for the perodc-wthjtter task T = (P,J,E,D ). Proof: Recall that the arrval functon of T = (P,J,E,D ) s gven by α F where α () = and α (t) = (t + J )/P for all t >. Let γ (t) = max{, α (t D )}, t. Then, γ (t) = f t D, and γ (t) = t+j D P otherwse. The proof can be establshed by showng that σ gs s the smallest good functon that s larger than or equal to γ. Intutvely, the second part of σ gs has the same long-term average slope as that of γ, whereas the slope of the frst part must be no less than both B /J and B /D to ensure that the functon s sub-addtve. We also requre that the functon values are ntegers. Due to space constrants, we omt the detals here. The clam then follows va Corollary 4.6. Fgure 5 shows an example that apples the above theorem. Number of jobs arrval functon of released jobs optmal shapng functon (arrval functon of ready jobs) Tme nterval length (tme unts) Fg. 5: Optmal shaper for a task T = (5,16,1.4,5), computed by Theorem 4.7. Note the reducton n the maxmum bursts: n a unt tme nterval, there can be up 4 new jobs that are released but only one new job that wll be ready for executon. V. SCHEDULABILITY ANALYSIS WITH OPTIMAL SHAPING Consder agan the same task and ts optmal shaper shown n Fgure 5. As a result of shapng, the correspondng arrval functon of the ready jobs after shapng s smaller than the orgnal arrval functon of the released jobs before shapng. Ths mples that the effectve RBF of the ready jobs s smaller than the RBF of the released jobs. Lower RBF values mean that the task causes less nterference to lower-prorty tasks, whch we now explot. We denote by C the system wth N tasks T = (P,J,E,D ), where each T uses a feasble shaper σ gs (e.g., the optmal shaper defned n Theorem 4.7). Recall that rbf (t) s the orgnal RBF of T and rbf gs s the effectve RBF of the ready jobs of T n the presence of shapng (c.f. Lemma 4.2). Theorem 5.1: Suppose D P for all 1 N, and let rbf,c = rbf + T j HP(T ) rbf gs j.

6 Then, C s schedulable ff for every T, there exsts t [,D ] such that rbf,c (t ) sbf (t ) where sbf (t) s the SBF of the processor s resource avalable to C. Proof: One can easly prove that a crtcal release pattern of T (.e., a release pattern that generates the maxmum demand from all ts hgher-prorty tasks) n C happens when each hgher-prorty task of T s ready smultaneously wth T, and all future jobs of these hgher-prorty tasks are ready as soon as possble. Snce only the ready jobs of hgher-prorty tasks of T can nterfere wth the executon of T, for any nterval of length t, the maxmum resource nterference of a hgher prorty task T j on T n the system C s rbf gs j (t). Further, rbf (t) s the maxmum number of executon unts requested by T (note that σ does not change the requests of T that must be completed to meet ts deadlne). Hence, rbf,c (t) = rbf (t) + gs T j HP(T ) rbf j (t) s the worst-case cumulatve resource request of T over any nterval of length t. Therefore, the worst-case response tme of T n C s the smallest tme nterval length t such that rbf,c (t ) sbf (t ). Hence, T meets ts deadlne ff t D. It can be observed from the above schedulablty condton that when usng a shapng functon larger than or equal to the arrval functon of the task, the schedulablty analyss of the system wth shapng s reduced to the schedulablty analyss of the orgnal system. The next example llustrates 2 2 the schedulablty mprovement when usng optmal shapers. Number of executon unts d : response tme of T wthout shapng No shapng # rbf 2, C " " rbf 3,C" rbf 2,C" sbf(t)" rbf 1,C" rbf 3, C 18 rbf 1, C d1 d2 d3 d1 d Tme D 1# nterval D 2# Dlength 3# (tme unts) Tme D 1# nterval D 2# Dlength 3# (tme u (a) T 2 and T 3 mss ther deadlnes! Number of executon unts d : response tme of T wthout shapng Wth shapng # rbf 2, C rbf 3,C*" sbf(t)" sbf rbf 2,C*" (b) All tasks are schedulable! rbf 1,C*" Fg. 6: Schedulablty of the system n Example 2. Example 2: Consder a system 51 C wth three tasks T 1 = (6,5,2,6), T 2 = (8,7,2,8) and T 3 = (1,,2,1), whch are scheduled on a fully avalable unt-speed processor. T 1 has the hghest prorty and T 3 has the lowest prorty. The cumulatve RBF of T n C s denoted by rbf,c (t), and the SBF of the processor s denoted by sbf (t). These functons are gven n Fgure 6(a). In ths fgure, the smallest tme nterval t at whch sbf (t) rbf,c (t) s the maxmum response tme of T when there s no shapng. From the fgure, one can observe that both rbf 2,C (t) and rbf 3,C (t) meet sbf (t) after the deadlnes of T 2 and T 3, respectvely. Therefore, T 2 and T 3 mss ther deadlnes. On the other hand, when each task T mplements ts optmal shapng functon (computed by Theorem 4.7), all tasks meet ther deadlnes. Ths s llustrated by Fgure 6(b). As before, rbf,c (t) s the cumulatve RBF of T n the shapng system C. From the fgure, the response tmes of T 1, T 2 and T 3 are 4, 6 and 6, respectvely. Thus, all tasks are schedulable when usng shapng. r VI. INTEGRATING SHAPING INTO COMPOSITIONAL SCHEDULING FRAMEWORKS In ths secton, we demonstrate how shapers can be ntegrated nto a compostonal schedulng framework (e.g., [8], [15]). In ths settng, the system s parttoned nto a tree of components that are scheduled herarchcally as llustrated n Fgure 7(a). There are two types of components: a composte component conssts of a set of chld components or tasks (e.g., component C), and an elementary component conssts of a fnte set of tasks (e.g., C1, C2). Each component has ts own local scheduler for ts chld components/tasks. The schedulablty analyss of the system s done by means of resource nterfaces. An nterface of a component captures the resource supply requred to feasbly schedule ts chld tasks or chld components. The nterface s computed based on the resource demands of the chld tasks, and/or the nterfaces of any subcomponents. The nterface of a component s mplemented as a task, whch s scheduled by the parent component s scheduler (e.g., T C1 ). A component s schedulable f ts nterface s schedulable by the parent s scheduler. An nterface of a component s optmal (resp. bandwdth-optmal) f ts SBF (resp. ts bandwdth) s smaller than, or equal to, that of any other feasble nterface of the component. We llustrate our method usng the explct deadlne perodc (EDP) nterface [8], snce t s effcent and can easly be transformed nto a task. An EDP nterface s characterzed by a perod Π, an executon tme Θ, and a deadlne. It represents a resource that supples Θ executon tme unts durng each perod of length Π, wthn the frst tme unts after the start of each perod. It has a bandwdth of Θ/Π, and t can be transformed nto a perodc task wth perod Π, WCET Θ and deadlne. The SBF of an EDP nterface s gven n [8]. DM: Deadlne Monotonc, RM: Rate Monotonc T 1 root component C T C1 DM C1 T 2 DM T 3 (a) No shapng T C2 RM C2 T 4 σ 1 root component C* σ C1* T C1* DM σ 2 T 1 T 2 C1* DM σ 3 σ C2* T C2* RM σ 4 T 3 T 4 C2* (b) Wth shapng Fg. 7: A two-level compostonal schedulng system. Integraton of shapers: We apply shapng to every component that uses a FP local scheduler (e.g., RM, DM n the above example). Each task T wthn any such component C mplements ts own shaper (.e., ts released jobs wll frst pass through the shaper before they are scheduled by C s scheduler). Fgure 7(b) shows the system wth shapng that corresponds to the orgnal one n Fgure 7(a). We refer to C s counterpart (wth feasble shapng added) as C. If T s a perodc task wth jtter, ts shapng functon s computed by Theorem 4.7. The shapng functon of any other general task model s computed based on the task s arrval functon by usng Corollary 4.5. In Secton V, we have shown that, f a system s schedulable under FP, then the same system wth feasble

7 shapers s also schedulable. Snce ths clam was proven for any general resource characterzed by an SBF, the same result holds for a component wthn the compostonal schedulng framework. That s, f C s schedulable under FP, then C s also schedulable under FP. Hence, the compostonal schedulablty analyss n presence of shapng can be done n the same manner as the conventonal settng, except that the nterface of a component wth shaper s computed based on the schedulablty condton stated n Theorem 5.1. Next, we elaborate ths nterface computaton for any gven C. Interface computaton for a component wth shapng: Let σ gs be the shaper of T as descrbed above, for all T n C. As usual, D denotes the deadlne of T, rbf (t) denotes the RBF of T (c.f. Equaton (2)), and rbf gs denotes the effectve RBF of the ready jobs of T n presence of shapng (c.f. Lemma 4.2). Theorem 6.1: An nterface I can feasbly schedule C ff T C, t [,D ] : rbf,c (t ) sbf I (t ) where rbf,c = rbf + gs T j HP(T ) rbf j s the cumulatve RBF of T n C (whch accounts for nterference of ts hgher prorty tasks), and sbf I (t) s the SBF of I. Proof: The theorem holds due to the schedulablty condton of components wth shapng gven n Theorem 5.1. Corollary 6.2: An nterface I opt s optmal (bandwdthoptmal) for C ff t has the mnmum SBF (mnmum bandwdth) among that of all nterfaces I that satsfy the schedulablty condton gven by Theorem 6.1. Based on Corollary 6.2, we can compute the optmal (bandwdth-optmal) nterface for any shapng component C by followng the same procedure that was used for the component C wthout shapng; the only dfference s that we use the updated cumulatve RBFs rbf,c nstead of rbf,c. The computaton of nterfaces of components that do not use shapers (.e., non FP components), and the transformaton from nterfaces to tasks, can be done exactly as n the conventonal case (see [8] for EDP nterfaces). Snce rbf,c rbf,c for all FP components, the resource needed to schedule the components when usng shapers s always smaller than or equal to the resource requred n the conventonal settng. We end ths secton wth an example to llustrate the effect of shapng on ts nterface. Example 3: Consder an elementary FP component C that conssts of three tasks T = (P,J,E,D ), where T 1 = (1,29,1,1), T 2 = (15,28,1,15), T 3 = (16,,1,16), and the prorty order s T 1 > T 2 > T 3. Our goal s to compute the mnmum-bandwdth EDP nterface for ths component, where the maxmum nterface perod s chosen to be Π max = 32. We frst compute the shaper for each task usng Theorem 4.7, and derve the correspondng cumulatve RBF rbf,c for each task T (c.f. the step functons n Fgure 8(a)). We then vary the nterface perod Π from 1 to Π max, and for each value Π, we fnd the correspondng Θ and that result n a mnmum bandwdth nterface (Π, Θ, ) whose SBF satsfes Theorem 6.1. The mnmum-bandwdth nterface among the nterfaces for all values of Π s gven by (Π = 3,Θ = 1.4, = 1.4), whch has a bandwdth of.4667(= 1.4/3). One can Number of executon unts Θ =1.4 8 rbf 1, C* rbf 2, C* rbf 3, C* sbf EDP gs gs d 2 = d 3 =15 gs d 1 = Π+ 2Θ = = 2Π+ 2Θ Tme nterval length (tme unts) (a) Shapng: BW =.4667, (Π,Θ, ) = (3,1.4,1.4). Number of executon unts rbf 1, C rbf 2, C rbf 3, C d3 = 16 d2 = d1 = 7.6 sbfedp Θ = Π+ 2Θ = = 2Π+ 2Θ Tme nterval length (tme unts) (b) No shapng: BW =.56, (Π,Θ, ) = (1,.56,.56). Fg. 8: Mnmum-bandwdth EDP nterface for Example 3. valdate based on Fgure 8(a) that ths nterface s suffcent to schedule the task set because the maxmum response tme d gs of T s always no more than D. In contrast, as llustrated n Fgure 8(b), the mnmum nterface of the component n the absence of shapng s (Π = 1,Θ =.56, =.56), whch has a bandwdth equal to.56. Hence, shapng reduces the nterface bandwdth by more than 16.6% n ths sngle component alone. Remarks: Snce a feasble shaper for a task can be computed based solely on ts arrval functon (Corollary 4.5), our technque s applcable to any task model that can be characterzed by an arrval functon (e.g., a sporadc task). Further, t can be plugged nto any compostonal schedulng framework that uses supply/demand analyss for nterface computaton. VII. SHAPERS IN MIXED-CRITICALITY SYSTEMS In ths secton, we present an applcaton of shapers to mxedcrtcalty systems. In such systems, each task has n addton to ts conventonal tmng parameters a crtcalty level. There are two schedulng objectves: (1) to guarantee that all hghcrtcalty (HC) tasks meet ther deadlnes; and (2) f objectve (1) s feasble, to mnmze the deadlne mss ratos of lowcrtcalty (LC) tasks, n decreasng order of prorty. Note that (2) s only one possble objectve, whch we follow so as to confrm to the FP scheduler as much as s possble. In general, the crtcalty of a task can change at runtme, dependng on the operatng mode of the system. As a frst step, we present the technque for a sngle-mode scenaro and for two levels of crtcalty. Our goal s to llustrate that shapng s a promsng way to acheve the mxed-crtcalty schedulng objectves. In the settng we consder, a shaper s feasble for a task T ff t preserves the schedulablty of T s lower-prorty HC tasks. A shaper s optmal for T ff t s the smallest feasble shaper for T that preserves the schedulablty of T. We requre shapers are good functons. Basc dea: We wll use a combnaton of shapng and nterface technques. By approprately shapng LC tasks, we can ensure that HC tasks meet ther deadlnes even when they have low prortes whle reducng the deadlne mss ratos of the LC tasks. Intutvely, snce shapers can control the number of tasks that are ready, we can reduce the resource contenton on HC tasks by desgnng shapers wth suffcently small

8 shapng functons for LC tasks. 2 At the same tme, by choosng these functons as large as possble whle stll ensurng schedulablty of HC tasks, we can ncrease the resource utlzaton and mnmze the LC tasks deadlne mss ratos. Towards ths, we compute for each task T an nterface, called the crtcal nterface, that captures the mnmum resource supply needed to feasbly schedule all HC tasks wth a prorty smaller than or equal to T s. We then choose a shapng functon for each LC task such that the remanng resource after processng the task satsfes ts crtcal nterface. From the schedulng perspectve, ths approach offers two man benefts: (1) t does not modfy the scheduler, and thus enables the conventonal FP algorthm to be used n mxedcrtcalty systems wthout volatng the tmng guarantees of HC tasks; and (2) snce the reducton n resource contenton s acheved entrely through shapng (and not by modfyng the scheduler), ths approach can potentally be combned wth other mxed-crtcally schedulng algorthms to further mprove schedulablty. Computng shapers for mxed-crtcalty tasks: Snce the goal of the shaper for an HC task s the same as n systems wthout mxed crtcalty (.e., to ensure the task s schedulablty and to mnmze the resource nterference on lower prorty tasks), the optmal shaper for HC tasks can be computed usng Theorem 4.7. The same theorem can be used for LC tasks wth a prorty below that of all HC tasks, snce such tasks cannot nterfere wth any HC tasks. Let τ LCHP be the set of remanng tasks,.e., LC tasks whose prorty exceeds that of at least one HC task. Let T be a task n τ LCHP. Then T s optmal shaper can be derved from ts crtcal nterface and the SBF of the resource avalable to t. The crtcal nterface of a task s defned by Lemma 7.1, whch holds due to Corollary 6.2: Lemma 7.1: Let C be a vrtual component that conssts of all HC tasks that have a prorty lower than or equal to T s, such that each task n C mplements ts own optmal shaper as descrbed above. Then the crtcal nterface I of T s the mnmum SBF that satsfes the schedulablty condton of C, whch s gven by Theorem 6.1 (Secton VI). From Lemma 7.1, σ s a feasble shaper for T ff the SBF of the remanng resource after processng the output jobs of σ s at least I. Let β be the SBF of the mnmum resource avalable to T. The effectve RBF of the output jobs of σ s rbf gs = E (α σ ), where α and E are the arrval functon and WCET of T (see Lemma 4.2). Combne wth the results n Secton II, σ s feasble for T ff Reman(β,rbf gs ) I (c.f. Equaton (3)). Snce α and σ are good functon, the maxmum soluton for α σ s σ crt def = closure ( RTInverse(I,β ) E ) where closure( f ) s the sub-addtve closure of f (c.f. Equaton 4). Further, let σ gs be the shaper computed usng Theorem 4.7. Recall that σ gs s the smallest shapng functon that ensures that T meets ts deadlne. Also, σ gs α. As a result, the optmal shapng functon for T s mn{σ crt,σ gs }. Based on the above results, we can compute the optmal 2 A smaller shapng functon allows fewer jobs to arrve at the ready queue over any tme nterval of a gven length. shapers for the tasks n a mxed-crtcalty system n decreasng order of prorty based on Theorem 7.2. In ths theorem, β (t) denotes the SBF of the resource avalable to T, and β (t) s the SBF of the total resource gven by the processor. Theorem 7.2: Suppose that, for all 1, j N, where N s the number of tasks n the system, T has hgher prorty than T j f < j. Let α and E be the arrval functon and the WCET of T, respectvely. Then the optmal shaper for T s σ = σ gs f T / τ LCHP ; otherwse, σ = mn { σ gs,closure ( RTInverse(I,β ) E )},where β 1 = β and β = Reman(β 1,rbf gs 1 ) for all 2 N. It can be derved that all the HC tasks are schedulable ff β I 1, and an LC task s schedulable ff ts shapng functon satsfes the feasblty condton n Theorem 4.4 (Secton IV). Snce the system behaves as n the settng wthout mxedcrtcalty after the shapers are fxed, the maxmum response tme of a task can be computed as was done n Secton V. VIII. EVALUATION In ths secton, we evaluate the proposed technque on randomly generated fxed-prorty task systems, n both standard FP schedulng and compostonal schedulng settngs. In the fomer, we quantfy () the degree to whch shapng can mprove the schedulablty of low-prorty tasks under hgh system load stuatons, and () the relatonshp between the tasks jtter values and the schedulablty mprovement acheved by shapng. In the later, we quantfy the amount of resource nterface bandwdth that can be saved by usng shapers n the FP components. Expermental setup: We mplemented the analyss technques from Sectons V and VI n Matlab by extendng the RTC Toolbox [22]. For each schedulng settng, we randomly generated a collecton of perodc-wth-jtter task sets of sze N (specfed below); and each task s deadlne was equal to ts perod. The followng parameters were chosen unformly at random: the task perods (as ntegers from [1, 1]), the task set s total utlzaton (from [U mn,u max ]), the utlzaton values of the ndvdual tasks (from (, 1), scaled by the generated utlzaton of the task set) and each task s jtter-toperod rato (from (, 2)). The tasks prortes were assgned accordng to the Deadlne Monotonc algorthm; tes were broken based on the task ndces. A. Schedulablty evaluaton For ths experment, we generated 1 task sets wth N = 2 tasks per set. Snce we were nterested n the schedulablty of the system, whch s crtcal under hgh system load stuatons for FP, we chose the utlzaton of each task set between U mn =.7 and U max =.9. For each generated task set, we computed the number of tasks that mssed ther deadlnes, based on ther maxmum response tmes. Fgure 9 shows the number of unschedulable tasks (.e., deadlne msses) for each task set wth and wthout shapng. The task sets are sorted by ncreasng utlzaton; the flled and empty crcles correspond to the results for ndvdual task sets wth and wthout shapng, respectvely. The results

9 Number of tasks mssng deadlnes (out of 2 tasks per set) No shapng Utlzaton Wth shapng Fg. 9: Total number of deadlne msses for each task set. show that the number of deadlne msses wthout shapng was strctly above the number of deadlne msses wth shapng, consstently across all utlzaton values. For example, at a utlzaton of.8, approxmately 9 (out of 2) tasks mss ther deadlnes wthout shapng, but only 4 tasks mss ther deadlnes wth shapng. In other words, shapng reduced the number of deadlne msses by 2.25 tmes. Note also that the average reducton for the other utlzaton values s smlar. Deadlne mss rato Improvement (%) Improvement value = MR - MR gs MR (MR gs): Deadlne mss rato wthout (wth) shapng Utlzaton Fg. 1: Effect of shapng on reducng deadlne mss rato. Fgure 1 further llustrates the mprovements when usng shapng wth respect to deadlne mss rato (.e., the rato of the number of unschedulable tasks to the total number of tasks). Each mprovement value s defned as MR MR gs, where MR gs (MR) s the deadlne mss rato wth (wthout) shapng. The results show that shapng can effectvely reduce the deadlne mss rato of the system by 2% to 35%. Under hgh load stuatons, we also observe that, as the utlzaton ncreases, the reducton acheved by shapng tends to decrease slghtly. Ths s expected: ntutvely, f we keep the same number of tasks, an ncrease n the task set s utlzaton mples an ncrease n the tasks WCETs (or a reducton n the tasks perods). Hence, the tasks that used to be schedulable n presence of shapng but unschedulable wthout shapng now also become unschedulable under shapng, due to ther hgher WCETs (or reduced perods). Snce shapng s only effectve when tasks experence jtter, we next nvestgated the relatonshp between jtter and the performance of shapng. We vared the jtter-to-perod rato from to 2, n ncrements of.1. For each rato, we generated 5 task sets, wth N = 1 tasks per set and a utlzaton of.9. The other parameters were chosen as before. Fgure 11 shows the average mprovement for each jtter-toperod rato. Here, the mprovement starts at and ncreases as the jtter-to-perod rato ncreases. Ths trend contnues untl the mprovement reaches a peak (when the jtter s approxmately equal to the perod), and t slowly decreases agan after that. Ths near-bell-shape behavor s expected because when there s no jtter, the system wth shapng behaves exactly as the one wthout shapng, so there s no mprovement. Deadlne mss mprovement (%) Improvement value = MR - MR gs Jtter/Perod rato Fg. 11: Correlaton between deadlne mss rato reducton and jtter. As the jtter values ncrease, more and more tasks become unschedulable wthout shapng but reman schedulable under shapng, so the mprovement ncreases. As was dscussed n the ntroducton, such large jtters happen n many realtme systems, such as dstrbuted automotve networks. Observe also that, as s expected, when the jtter s too large, the task set becomes heavly overloaded, so more and more tasks become unschedulable even wth shapng. B. Interface computaton evaluaton To llustrate the effect of shapng on component nterfaces, we consdered the nterface computaton of a FP elementary component that was part of a compostonal schedulng framework. For our experment, we used the EDP resource model as the nterface representaton, and we appled the technque from Secton VI to compute the optmal nterface. We generated 8 component workloads, wth utlzaton values drawn unformly at random from [.2,.9]. Each component workload had 2 perodc tasks wth jtter; the other parameters were chosen as descrbed under expermental setup, except that the jtter-to-perod raton was chosen from (, 1). For each generated component workload, we computed the optmal EDP nterfaces for the component wth and wthout shapng. The maxmum nterface perod was set to 1. Fgure 12 shows the optmal bandwdths of the EDP nterfaces correspondng to the generated component workloads, sorted by ncreasng workload utlzaton. The correspondng cumulatve dstrbuton functons (CDFs) of the nterface bandwdth are shown n Fgure 13. As expected, when the workload utlzaton ncreases, the nterface bandwdth also tends to ncrease. 3 In both fgures, the nterface bandwdth wth shapng s always smaller than the nterface bandwdth wthout shapng, across all component s workload utlzaton values. Furthermore, the number of component workloads that requre an nterface bandwdth larger than 1 (hghlghted by the shaded area n Fgure 13) wthout shapng s at least 2% larger than wth shapng. Such component workloads are not schedulable on a unt-one processor, even t s fully avalable. In general, the above results show that shapers not only reduce the nterface bandwdth values but also mnmze the percentage of component workloads that requre larger nterface bandwdths. Ths s llustrated more explctly by Fgure 14, whch shows the mprovement of nterface bandwdth wth shapng, compared to the conventonal component 3 Note that, the nterface bandwdth n the presence of jtter s not strctly an ncreasng functon of the workload utlzaton because t depends on not only the workload utlzaton but also on the jtter values of the tasks.