Resource Sharing. CSCE 990: Real-Time Systems. Steve Goddard. Resources & Resource Access Control (Chapter 8 of Liu)

Transcription

1 CSCE 990: Real-Tme Systems Resource Sharng Steve Goddard Resources & Resource Access Control (Chapter 8 of Lu) Real-Tme Systems Resource Sharng - Untl now, we have assumed that tasks are ndependent. We now remove ths restrcton. We frst consder how to adapt the analyss dscussed prevously when tasks access shared resources. Later, n our dscusson of dstrbuted systems, we wll consder tasks that have precedence constrants. Real-Tme Systems Resource Sharng - 2 2

2 Shared Resources We contnue to consder sngle-processor systems. We add to the model a set of ρ serally reusable resources R, R 2,, R ρ, where there are v unts of resource R.» Examples of resources: Bnary semaphore, for whch there s one unt. Countng semaphore, for whch there may be many unts. Reader/wrter locks. Prnter. Remote server. Locks A ob that wants n unts of resource R executes a lock request, denoted L(R, n). It unlocks the resource by executng a correspondng unlock request, denoted U(R, n). A matchng lock/unlock par s a crtcal secton. A crtcal secton correspondng to n unts of resource R, wth an executon cost of e, wll be denoted [R, n; e]. If n =, then ths s smplfed to [R; e]. Real-Tme Systems Resource Sharng - 3 Real-Tme Systems Resource Sharng

3 Locks can be nested. Locks (Contnued) We wll use notaton lke ths:»[r ; 4 [R 4, 3; 9 [R 5, 4; 3]]] In our analyss, we wll be mostly nterested n outermost crtcal sectons. Note: For smplcty, we only have one knd of lock request.» So, for example, we can t actually dstngush between reader locks and wrter locks. Conflcts Two obs have a resource conflct f some of the resources they requre are the same.» Note that f we had reader/wrter locks, then noton of a conflct would be a lttle more complcated. Two obs contend for a resource when one ob requests a resource that the other ob already has. The scheduler wll always deny a lock request f there are not enough free unts of the resource to satsfy the request. Real-Tme Systems Resource Sharng - 5 Real-Tme Systems Resource Sharng

4 Example Tmng Anomales J When tasks share resources, there may be tmng anomales. Example: Let us reduce J 3 s crtcal secton executon from 4 tme unts to 2.5. Then J msses ts deadlne! J 2 J 3 J = access of sngle-unt resource R J 2 J Real-Tme Systems Resource Sharng - 7 Real-Tme Systems Resource Sharng

5 Prorty Inversons When tasks share resources, there may be prorty nversons. Example: prorty nverson Deadlocks When tasks share resources, deadlocks may be a problem. Example: J accesses green, then red (nested). J 3 accesses red, then green (nested). J J J 2 J 3 J 2 J 3 can t lock green! What s a very smple way to fx ths problem? Real-Tme Systems Resource Sharng - 9 Real-Tme Systems Resource Sharng

6 Wat-for Graphs We wll specfy blockng relatonshps usng a wat-for graph. Specfyng Resource Requrements Resource requrements wll be specfed lke ths: Example: J 2 R, J 3 J 3 has locked the sngle unt of resource R and J 2 s watng to lock t. Queston: Can we use a wat-for graph to determne f there s a deadlock? J Real-Tme Systems Resource Sharng - J J 2 J R J requres the sngle-unt resource R for 2 tme unts. Each ob of T requres 2 unts of R for at most 3 tme unts and one unt of R 2 for at most tme unt. T T 2 (2; 3) T 3 [R 2 ; 8 [R, 4; ][R, ; 5]] 2 T 4 R R 2 Smple resource requrements are shown on edges. Complcated ones by the correspondng task. Real-Tme Systems Resource Sharng

7 Resource Access Control Protocols We now consder several protocols for allocatng resources that control prorty nversons and/or deadlocks. From now on, the term crtcal secton s taken to mean outermost crtcal secton unless specfed otherwse. Real-Tme Systems Resource Sharng - 3 Nonpreemptve Crtcal Secton Protocol The smplest protocol: ust execute each crtcal secton nonpreemptvely. If tasks are ndexed by prorty (or relatve deadlne n the case of EDF), then task T has a blockng term equal to max + k n c k, where c k s the executon cost of the longest crtcal secton of T k. We ve talked before about how to ncorporate such blockng terms nto schedulng analyss. Advantage: Very smple. Dsadvantage: T s blockng term may depend on tasks that t doesn t even have conflcts wth. Real-Tme Systems Resource Sharng

8 The Prorty Inhertance Protocol (Sha, Rakumar, Lehoczky) Observaton: In a system wth lock-based resources, prorty nverson cannot be elmnated. Thus, our only choce s to lmt ther duraton. Consder agan ths example: The Prorty Inhertance Protocol The problem here s not the low-prorty ob J 3 t s the medum prorty ob J 2! We must fnd a way to prevent a medum-prorty ob lke ths from lengthenng the duraton of a prorty nverson. J J J 2 J 2 J 3 J Real-Tme Systems Resource Sharng - 5 Real-Tme Systems Resource Sharng

9 The Prorty Inhertance Protocol Prorty Inhertance Protocol: When a low-prorty ob blocks a hghprorty ob, t nherts the hgh-prorty ob s prorty. Ths prevents an untmely preempton by a medum-prorty ob. PIP Defnton Each ob J k has an assgned prorty (e.g., RM prorty) and a current prorty π k (t).. Schedulng Rule: Ready obs are scheduled on the processor preemptvely n a prorty-drven manner accordng to ther current prortes. At ts release tme t, the current prorty of every ob s equal to ts assgned prorty. The ob remans at ths prorty except under the condton stated n rule 3. J J 2 J 3 executed at J s prorty Allocaton Rule: When a ob J requests a resource R at tme t, (a) f R s free, R s allocated to J untl J releases t, and (b) f R s not free, the request s dened and J s blocked. 3. Prorty-Inhertance Rule: When the requestng ob J becomes blocked, the ob J l that blocks J nherts the current prorty of J. The ob J l executes at ts nherted prorty untl t releases R (or untl t nherts an even hgher prorty); the prorty of J l returns to ts prorty π l (t ) at the tme t when t acqures the resource R. Real-Tme Systems Resource Sharng - 7 Real-Tme Systems Resource Sharng

10 A More Complcated Example (Ths s slghtly dfferent from the example n Fgure 8-8 n the book.) J J J J 2 J 2 J 3 J 4 J 4 J J J J 5 J 5 J 5 J 2 J J Ths means ths porton of the crtcal secton executes at J 2 s prorty Real-Tme Systems Resource Sharng - 9 Propertes of the PIP We have two knds of blockng wth the PIP: drect blockng and nhertance blockng. In the prevous example, J 2 s drectly blocked by J 5 over the nterval [6,9] and s nhertance blocked by J 4 over the nterval [,5]. Jobs can transtvely block each other. At tme.5, J 5 blocks J 4 and J 4 blocks J. The PIP doesn t prevent deadlock. A obs that requres v resources and conflcts wth k lower prorty obs can be blocked for mn(v,k) tmes, each for the duraton of an outermost CS. It s possble to do much better. Real-Tme Systems Resource Sharng

11 The Prorty-Celng Protocol (Sha, Rakumar, Lehoczky) Two key assumptons: The assgned prortes of all obs are fxed (as before). The resources requred by all obs are know a pror before the executon of any ob begns. Defnton: The prorty celng of any resource R s the hghest prorty of all the obs that requre R, and s denoted Π(R). Defnton: The current prorty celng Π (R) of the system s equal to the hghest prorty celng of the resources currently n use, or Ω f no resources are currently n use (Ω s a prorty lower than any real prorty). Note: I ve used nstead of ^ due to PowerPont lmtatons.. Schedulng Rule: PCP Defnton (a) At ts release tme t, the current prorty π(t) of every ob J equals ts assgned prorty. The ob remans at ths prorty except under the condtons of rule 3. (b) Every ready ob J s scheduled preemptvely and n a prorty-drven manner at ts current prorty π(t). 2. Allocaton Rule: Whenever a ob J requests a resource R at tme t, one of the followng two condtons occurs: (a) R s held by another ob. J s request fals and J becomes blocked. (b) R s free. () If J s prorty π(t) s hgher than the current prorty celng Π (t), R s allocated to J. () If J s prorty π(t) s not hgher than the celng Π (t), R s allocated to J only f J s the ob holdng the resource(s) whose prorty celng equals Π (t); otherwse, J s request s dened and J becomes blocked. 3. Prorty-Inhertance Rule: When J becomes blocked, the ob J l that blocks J nherts the current prorty π(t) of J. J l executes at ts nherted prorty untl t releases every resource whose prorty celng s π(t) (or untl t nherts an even hgher prorty); at that tme, the prorty of J l returns to ts prorty π(t ) at the tme t when t was granted the resources. Real-Tme Systems Resource Sharng - 2 Real-Tme Systems Resource Sharng

12 Example (Ths s the PCP counterpart of our complcated PIP example.) J J J J 2 J 2 J 3 J 4 J J J J 5 J 5 J 5 J 4 J 2 J Propertes of the PCP The PCP s not greedy. For example, J 4 n the example s prevented from lockng the green obect, even though t s free. We now have three knds of blockng:» Drect blockng (as before). For example, J 5 drectly blocks J 2 at tme 6.» Prorty-nhertance blockng (also as before). Ths doesn t occur n our example.» Prorty-celng blockng (ths s new). J 4 suffers a prorty-celng blockng at tme 3. Real-Tme Systems Resource Sharng - 23 Real-Tme Systems Resource Sharng

13 Two Theorems Theorem 8-: When the resource accesses of a system of preemptve, prorty-drven obs on one processor are controlled by the PCP, deadlock can never occur. Deadlock Avodance Wth the PIP, deadlock could occur f nested crtcal sectons are nvoked n an nconsstent order. Here s an example we looked at earler. Example: J accesses green, then red (nested). J 3 accesses red, then green (nested). J Theorem 8-2: When the resource accesses of a system of preemptve, prorty-drven obs on one processor are controlled by the PCP, a ob can be blocked for at most the duraton of one crtcal secton. J 2 J 3 can t lock green! The PCP would prevent J from lockng green. Why? Real-Tme Systems Resource Sharng - 25 Real-Tme Systems Resource Sharng

14 Blockng Term Suppose J blocks when accessng the green crtcal secton and later blocks when accessng the red crtcal secton. Blockng Term For J block on green, some lower-prorty ob must have held the lock on green when J began to execute. J blocks on green J blocks on green J Real-Tme Systems Resource Sharng - 27 Real-Tme Systems Resource Sharng

15 Blockng Term For J to later block on red, some lower-prorty ob must have held the lock on red when J began executng. Blockng Term Whchever way J 2 and J 3 are prortzed (here, J 2 has prorty over J 3 ), we have a contradcton. Why? J blocks on green blocks on red J blocks on green blocks on red J 2 J 2 J 3 J Real-Tme Systems Resource Sharng - 29 Real-Tme Systems Resource Sharng

16 Some Comments on the PCP When computng blockng terms, t s mportant to carefully consder all three knds of blockngs (drect, nhertance, celng).» See the book for an example where ths s done systematcally (Fgure 8-5). Wth the PCP, we have to pay for extra two context swtches per blockng term.» Such context swtchng costs can really add up n a large system.» Ths s the motvaton for the Stack Resource Polcy (SRP), descrbed next. Real-Tme Systems Resource Sharng - 3 Stack-based Resource Sharng So far, we have assumed that each task has ts own runtme stack. In many systems, tasks can share a run-tme task. Ths can lead to memory savngs because there s less fragmentaton. Real-Tme Systems Resource Sharng

17 Stack-based Resource Sharng (Cont d) If tasks share a runtme stack, we clearly cannot allow a schedule lke the followng. (Why?) J J 2 We must delay the executon of each ob untl we are sure all the resources t needs are avalable. Real-Tme Systems Resource Sharng - 33 Stack Resource Polcy (Baker) 0. Update of the Current Celng: Whenever all the resources are free, the celng of the system s Ω. The celng Π (t) s updated each tme a resource s allocated or freed.. Schedulng Rule: After a ob s released, t s blocked from startng executng untl ts assgned prorty s hgher than the current celng Π (t) of the system. At all tmes, obs that are not blocked are scheduled on the processor n prorty-drven, preemptve manner accordng to ther assgned prortes. 2. Allocaton Rule: Whenever a ob requests a resource, t s allocated the resource. Note: Can be mplemented usng a sngle runtme stack, but ths sn t requred. Real-Tme Systems Resource Sharng

18 J J 2 J 3 J 4 J 5 Example (Ths s the SRP counterpart of our complcated example.) Notce how J 4 ncurs ts blockng term up front, before t actually starts to execute Propertes of the SRP No ob s ever blocked once ts executon begns.» Thus, there can never be any deadlock. The blockng term calculaton s the same as wth the PCP.» Convnce yourself of ths!» One dfference, though: Wth the SRP, a ob s blocked only before t begns executon, so extra context swtches due to blockngs are avoded. Real-Tme Systems Resource Sharng - 35 Real-Tme Systems Resource Sharng

19 Schedulng, Revsted We have already talked about how to ncorporate blockng terms nto schedulng condtons. For example, wth TDA and generalzed TDA, we changed our tmedemand functon by addng a blockng term. For TDA, we got ths: w (t) = e + b + k= t p k e for 0 < t mn(d, p ) For EDF-scheduled systems, we stated the followng utlzaton-based condton: n ek b + mn(d,p ) mn(d, p ) k= k k k A Closer Look at Dynamc-Prorty Systems It turns out that ths EDF condton s not very tght. We now cover a paper by Jeffay that presents a much tghter condton.» Although t may not seem lke t on frst readng, Jeffay s paper bascally renvents the SRP, but for dynamcprorty systems.» However, the schedulng analyss for dynamc-prorty systems gven by Jeffay s much better than that found elsewhere. Real-Tme Systems Resource Sharng - 37 Real-Tme Systems Resource Sharng

20 Schedulng Sporadc Tasks wth Shared Resources (Jeffay) In the model of ths paper, each task T s parttoned nto n dstnct phases.» In each phase, ether no resource s requred or exactly one resource s requred.» If resource R k s requred by T s th phase, then we denote ths by r = k, where k m.» If no resource s requred, then r = 0. Sngle-Phase Systems In a sngle-phase system, each task s ether a crtcal secton that accesses some resource, or a non-crtcal secton that accesses no resource. Notaton: Each task T wll be denoted by (s, (c, C, r ), p ) where: s s ts release tme; c s ts mnmum executon cost; C s ts maxmum executon cost; r ndcates whch (f any) resource s accessed; p s ts perod. Defnton: We let P denote the perod of the shortest task that requres resource R,.e., P = mn n (p r = ). Real-Tme Systems Resource Sharng - 39 Real-Tme Systems Resource Sharng

21 Necessary Schedulng Condton Theorem 3.2: Let T = {T, T 2,, T n } be a system of sngle-phase, sporadc tasks wth relatve deadlnes equal to ther perods such that the tasks n T are ndexed n non-decreasng order by perod (.e., f <, then p p ). If T s schedulable on a sngle processor, then: n C ) = p - L 2) : n r < < + 0 :: L :Pr L p :: L C C = p Compare ths to the feasblty condton we had for nonpreemptve EDF, whch s repeated on the followng slde. Real-Tme Systems Resource Sharng - 4 Non-preemptve EDF, Revsted Theorem : Let T = {T, T 2,, T n } be a system of ndependent, perodc tasks wth relatve deadlnes equal to ther perods such that the tasks n T are ndexed n non-decreasng order by perod (.e., f <, then p p ). T can be scheduled by the non-preemptve EDF algorthm f: n e ) = p 2) : n :: L : p < L < p :: L e + = L e p Remember, we showed ths condton s also necessary for sporadc tasks. Real-Tme Systems Resource Sharng

22 Proof Sketch of Theorem 3.2 Gven our prevous dscusson of nonpreemptve EDF, Theorem 3.2 should be pretty obvous. Clearly, f T s schedulable, total utlzaton must be at most one,.e., condton () must hold. Condton (2) accounts for the worst-case blockng that can be experenced by each task T. Remember, wth nonpreemptve EDF, the worst-case pattern of ob releases occurs when a ob of some T begns executng (non-preemptvely!) one tme unt before some tasks wth smaller perods begn releasng some obs. Real-Tme Systems Resource Sharng - 43 Here s an llustraton: T T T 2 T 3 Proof Sketch (Contnued) Moreover, wth sporadc tasks, such releases are always possble, and thus f T s schedulable, then t s necessary to ensure no deadlne s mssed n the face of ob releases lke ths. In a sngle-phase system, we have the same knd of necessary condton, but now a task may only be blocked by a task that accesses a common resource. Real-Tme Systems Resource Sharng

23 EDF-DDM Our goal now s to defne a schedulng algorthm for whch the condtons of Theorem 3.2 are necessary. Snce EDF s optmal n the absence of resources, t makes sense to look at some varant of EDF. Remember wth the PIP, PCP, and SRP, the dea s to rase a lower-prorty ob s prorty when a blockng occurs. Wth EDF, rasng a prorty means temporarly shrnkng the ob s deadlne. The resultng scheme s called EDF wth dynamc deadlne modfcaton. Real-Tme Systems Resource Sharng - 45 Example Here s what can happen wthout dynamc deadlne modfcaton: T 3 T T 2 Here s the correspondng schedule wth dynamc deadlne modfcaton: T T T Notce that T 2 does not preempt T at tme. Real-Tme Systems Resource Sharng

24 EDF/DDM Defnton Let t r be the tme when ob J of task T s released, and let t s be the tme ob J starts to execute. In the nterval [t r, t s ), J s deadlne s t r + p, ust lke wth EDF.» Ths s called J s ntal deadlne. At tme t s, J s deadlne s changed to mn(t r + p, (t s + ) + P r ).» Ths s called J s contendng deadlne. Suffcent Condton for EDF/DDM Theorem 3.4: Let T = {T, T 2,, T n } be a system of sngle-phase, sporadc tasks wth relatve deadlnes equal to ther perods such that the tasks n T are ndexed n non-decreasng order by perod (.e., f <, then p p ). The EDF/DDM dscplne wll succeed n schedulng T f condtons () and (2) from Theorem 3.2 hold. Thus, by Theorem 3.2, () and (2) are feasblty condtons. Not surprsngly, the proof of Theorem 3.4 s very smlar to the correspondng proof we dd for nonpreemptve EDF systems. Real-Tme Systems Resource Sharng - 47 Real-Tme Systems Resource Sharng

25 Proof of Theorem 3.4 Suppose condtons () and (2) hold for T but a deadlne s mssed. Let t d be the earlest pont n tme at whch a deadlne s mssed. There are two cases. Case : No ob wth an ntal deadlne after tme t d s scheduled pror to tme t d. The analyss s ust lke wth preemptve EDF. As before, let t - be the last dle nstant. (Ths s denoted t 0 n the paper, but I ve used t - to be consstent wth prevous proofs.) Because a deadlne s mssed at t d, demand over [t -, t d ] exceeds t d t -. In addton, ths demand s at most =,..,n (t d t - )/p C. Thus, we have t d t - < =,..,n (t d t - )/p C =,..,n [(t d t - )/p ] C. Ths mples utlzaton exceeds one, whch contradcts condton (). Real-Tme Systems Resource Sharng - 49 Proof (Contnued) Case 2: Some ob wth an ntal deadlne after tme t d s scheduled pror to tme t d. Let T be the task wth the last ob wth an ntal deadlne after t d that s scheduled pror to t d. Then, we have the followng: Tme T t Let us bound the processor demand n [t, t d ] (Ths s where thngs start to get a lttle dfferent from the nonpreemptve EDF proof.) Real-Tme Systems Resource Sharng - 50 t d 49 50

26 Proof (Contnued) Case 2a: T s contendng deadlne s less than or equal to t d. Ths means T must be a resource requestng task. We have the followng: Observe the followng: Proof (Contnued)» Other than task T, no task wth a perod greater than or equal to t d t executes n the nterval [t, t d ]. Such a task would contradct our choce of T. Tme T contendng ntal» Other than T, no task that executes n [t, t d ] could have been nvoked at tme t. t The proof for ths subcase s very much lke Case 2 n the nonpreemptve EDF proof (we get a contradcton of condton (2)). t d» The processor s fully utlzed n [t, t d ]. Real-Tme Systems Resource Sharng - 5 Real-Tme Systems Resource Sharng

27 Proof (Contnued) From these facts, we conclude that demand over [t, t d ] s less than or equal to - t d (t + ) C + C. = p Let L = t d t. We have p > L > P r. (Why?) Also, - L L < C + C. = p Ths contradcts condton (2). Proof (Contnued) Case 2b: T s contendng deadlne s greater than t d. Ths means ether T doesn t request any resource or (t + ) + P r > t d. We have the followng: Tme T t t d contendng T s preemptable by any ob whose perod les wth [t, t d ]. (Why?) Real-Tme Systems Resource Sharng - 53 Real-Tme Systems Resource Sharng

28 Proof (Contnued) Let t - > t be the later of the end of the last dle perod n [t, t d ] or the tme T last stops executng pror to t d. All nvocatons of tasks occurrng pror to t - wth deadlnes less than or equal to t d must have completed executng by t -. (Why?) Tme T t As n Case, we can show that demand over [t -, t d ] exceeds t d t -, whch mples that condton () s volated. t - t d contendng Mult-Phase Systems Notaton: In a mult-phase system, each task T s denoted by (s, (c, C, r ), p ), n, n, where: s s ts release tme; n s the number of phases n each ob of T ; c s the mnmum executon cost of the th phase; C s the maxmum executon cost of the th phase; r ndcates whch (f any) resource s accessed n the th phase; p s ts perod. Defnton: We let P rk = mn n (p r l = r k for some l n the range l n ). Defnton: The executon cost of T s E = k =,,n C k. Real-Tme Systems Resource Sharng - 55 Real-Tme Systems Resource Sharng

29 Necessary Schedulng Condton Theorem 4.: Let T = {T, T 2,, T n } be a system of mult-phase, sporadc tasks wth relatve deadlnes equal to ther perods such that the tasks n T are ndexed n non-decreasng order by perod (.e., f <, then p p ). If T s schedulable on a sngle processor, then: n E ) = p 2) (, k : n k n r 0 :: L : Pr < L < p Sk :: L C + k k 0 f k = where Sk = k < c = f k n k Ugh! - = L E p Real-Tme Systems Resource Sharng - 57 EDF/DDM for Mult-phase Systems Let t r be the tme when ob J of task T s released, and let t sk be the tme ob J s k th phase starts to execute. In the nterval [t r, t s ), J s deadlne s t r + p, ust lke wth EDF. At tme t sk, J s deadlne s changed to mn(t r + p, (t sk + ) + P rk ). When one of J s phases completes, ts deadlne mmedately reverts to t r + p. Note that ths algorthm prevents a ob from begnnng executon untl all the resources t requres are avalable,.e., ths s ust a dynamc-prorty SRP. Real-Tme Systems Resource Sharng

30 Suffcent Condton for EDF/DDM An Alternatve to Crtcal Sectons Theorem 4.3: Let T = {T, T 2,, T n } be a system of mult-phase, sporadc tasks wth relatve deadlnes equal to ther perods such that the tasks n T are ndexed n non-decreasng order by perod (.e., f <, then p p ). The EDF/DDM dscplne wll succeed n schedulng T f condtons () and (2) from Theorem 4. hold. Thus, by Theorem 4., () and (2) are feasblty condtons for mult-phase, sporadc task systems. We wll not cover the proofs of Theorems 4. and 4.3 n class, but you should read through them n the paper. Real-Tme Systems Resource Sharng - 59 Crtcal sectons are often used to mplement software shared obects.» Example: producer/consumer buffer. Such obects actually can be mplemented wthout usng crtcal sectons or related mechansms. Such shared-obect algorthms are called nonblockng algorthms. Bottom Lne: We can avod prorty nversons altogether when mplementng software shared obects. Real-Tme Systems Resource Sharng

31 Nonblockng Algorthms Two varants:» Lock-Free: Perform operatons optmstcally. Retry operatons that are nterfered wth.» Wat-Free: No watng of any knd: No busy-watng. No blockng synchronzaton constructs. No unbounded retres. Recent research at UNC has shown how to account for lock-free and wat-free overheads n schedulng analyss. Frst, some background Real-Tme Systems Resource Sharng - 6 type Qtype = record v: valtype; next: ponter to Qtype end shared var Tal: ponter to Qtype; local var old, new: ponter to Qtype old Tal Lock-Free Example procedure Enqueue (nput: valtype) new := (nput, NIL); repeat old := Tal untl CAS2(&Tal, &(old->next), old, NIL, new, new) new old Tal new Real-Tme Systems Resource Sharng

32 current copy ponter to shared obect Wat-Free Algorthms (Herlhy s Helpng Scheme) process p s copy process q s copy process r s copy announce array Can only retry once! Dsadvantage: Copyng overhead. Algorthm: announce operaton; retry untl done: create local copy of the obect; apply all announced operatons on local copy; attempt to make local copy the current copy usng a strong synchronzaton prmtve Real-Tme Systems Resource Sharng - 63 Usng Wat-Free Algorthms n Realtme Systems On unprocesors, helpng-based algorthms are not very attractve.» Only hgh-prorty tasks help lower-prorty tasks. Smlar to prorty nverson.» Such algorthms can have hgh overhead due to copyng and havng to use costly synchronzaton prmtves. Some wat-free algorthms avod these problems and are useful. Example: Collson avodng read/wrte buffers. On the other hand, on multprocessors, wat-free algorthms may be the best choce. Real-Tme Systems Resource Sharng

33 Usng Lock-Free Obects on Real-tme Unprocessors (Anderson, Ramamurthy, Jeffay) Advantages of Lock-free Obects:» No prorty nversons.» Lower overhead than helpng-based wat-free obects.» Overhead s charged to low-prorty tasks. But:» Access tmes are potentally unbounded. Schedulng wth Lock-Free Obects On a unprocessor, lock-free retres really aren t unbounded. A task fals to update a shared obect only f preempted durng ts obect call. Hgh Low Faled retry-loop Successful retry-loop Can compute a bound on retres by countng preemptons. Real-Tme Systems Resource Sharng - 65 Real-Tme Systems Resource Sharng

34 67 Real-Tme Systems Resource Sharng - 67 RM Suffcent Condton Assume rate-monotonc prorty assgnment. Suffcent Schedulng Condton: + < = = t s p t e p t :: p t 0 : t :: In ths condton, s s the tme to update a lock-free obect (one retry loop teraton). We are assumng at ths pont that all retry loops have the same cost. 68 Real-Tme Systems Resource Sharng - 68 Proof of RM Condton The proof strategy should be very famlar to you by now. To Prove: If a task set s not schedulable, then the suffcent condton does not hold,.e., > + < = = t s p t e p t :: p t 0 : t ::

35 Settng Up the Proof Let the k th ob of T be the frst to mss ts deadlne. Let t - be the latest dle nstant before r,k+. Intuton If a task set s not schedulable, then at all nstants t n (t -,r,k+ ], Hgh Med T s t - r,k r,k+ Faled retry-loop Successful retry-loop the demand placed on the processor by T and hgher-prorty tasks n [t -,t) s greater than the avalable processor tme n [t -,t). Suppose not: Case t (t -,r,k ]: Contradcts choce of t -. Case t (r,k,r,k+ ]: T s deadlne at r,k+ s not mssed. Real-Tme Systems Resource Sharng - 69 Real-Tme Systems Resource Sharng

36 Fnshng the Proof... Fnshng the Proof For any t n (t -,r,k+ ], the followng holds. avalable processor tme n [t -,t) < demand due to T and hgher-prorty obs n [t -,t) = demand due to ob releases of T and hgher-prorty tasks + demand due to faled loop tres n T and hgher-prorty tasks =, (number of obs of T released n [t -,t) ) e + =,- (number of preemptons T can cause n T and hgher-prorty tasks) (cost of faled loop try) Hence, for any t n (t -,r,k+ ], t t t t t t < e + s. = p = p Replacng t t - by t n (0, r,k+ t - ], t < = t e p t = + s. p Real-Tme Systems Resource Sharng - 7 Real-Tme Systems Resource Sharng

37 EDF Suffcent Condton Assume earlest-deadlne-frst prorty assgnment. Suffcent Condton: N = e + s p Settng Up the Proof... Same set-up as before s As before To Prove: If a task set T s not schedulable, then N = e + s > p T t- r,k r,k+ Faled retry-loop Successful retry-loop Real-Tme Systems Resource Sharng - 73 Real-Tme Systems Resource Sharng

38 Intuton Fnshng the Proof... avalable processor tme n [t -,r,k+ ] If a task set s not schedulable, then the demand placed on the processor n [t -,r,k+ ) by obs wth deadlnes at or before r,k+ s greater than the avalable processor tme n [t -,r,k+ ]. < demand due to obs wth deadlnes r,k+ = demand due to releases of those obs + demand due to faled loop tres n those obs =,,N [number of obs of T wth deadlnes at or before r,k+ released n [t -,r,k+ )] e + =,,N (number of preemptons T can cause n such obs) (cost of faled loop try) Real-Tme Systems Resource Sharng - 75 Real-Tme Systems Resource Sharng

39 Hence, whch mples, Fnshng the Proof r t r t N N,k+,k+, k+ t < e + s, = p = p r r t N N,k+,k+, k+ t < e + s. = p = p r Cancelng r,k+ t - yelds < N e p + N = = s p. r t Real-Tme Systems Resource Sharng - 77 Comparson of Lock-Free & Lock-Based It can be shown analytcally that lock-free wns over lock-based f:» (lock-free access cost) (lock-based access cost)/2. For many obects, ths wll be the case, because wth a lockbased mplementaton, you get one obect access for the prce of many (due to all the kernel obects that have to be accessed). Breakdown utlzaton experments nvolvng randomly-generated task sets show that lock-free s lkely to wn f:» (lock-free access cost) (lock-based access cost). Real-Tme Systems Resource Sharng

40 Better Schedulng Condtons Prevous condtons perform poorly when retry loop costs vary wdely. Also, they over-count nterferences (not every preempton causes an nterference). Queston: How to ncorporate dfferent retry loop costs? Answer: Use lnear programmng.» Can apply lnear programmng to both RM and EDF (and also DM).» We only consder RM here. Real-Tme Systems Resource Sharng - 79 Lnear-Programmng RM Condton (Anderson and Ramamurthy) Defnton: E (t) w() = v= l= m,v l (t)s,v l w() - Number of phases of T. m l,v (t) - Number of nterferences n T s v th phase due to T l n an nterval of length t. s l,v - Cost of one such nterference. Approach: Vew E (t) as a lnear expresson, where m l,v (t) are the varables. Maxmze E (t) subect to some constrants. Real-Tme Systems Resource Sharng

41 8 Real-Tme Systems Resource Sharng - 8 LP RM Condton (Contnued) Example Constrants (the easy ones): Let E (t) be an upper bound on E (t) obtaned by lnear programmng. RM Condton: + < = t ) (t E e p t :: p t 0 : t + < = w() v,v p t (t) m :: :, + = = = = w() v,v p t (t) m :: l l