Resource Access Protocols

Transcription

1 The Blocking Problem Resource Access Protocols Now we remove the assumption that tasks are independent, sharing resources, t interacting The main problem: priority inversion igh priority tasks are blocked by lower priority tasks The main sources of priority inversion: Non preemptable sections (we mentioned this earlier) Sharing resources Synchronization and mutual exclusion The response time calculation should be modified 2 Contents The simpliest form of priority inversion Priority inversion phemen Resource access protocols ighest Priority Inheritance Non preemption protocol (NPP) Immedate Priority Inheritance ighest ocker s priority Protocol (P) Ada95 (protected object) and POSIX mutexes Shared Resource R Resource access By semaphore Basic Priority Inheritance Protocol (BIP) POSIX (RT OS standard) mutexes Priority Ceiling Protocols (PCP) Blocking and response time analysis computing using R blocked 3 4 Unbounded priority inversion Solutions Shared Resource R Resource access by semaphore computing Tasks are forced to follow certain rules when locking and unlocking semaphores (requesting and releasing resources) The rules are called Resource access protocols NPP, BIP, P, PCP A common rule of these protocols: tasks must release all semaphores before the next instance; when a task finishes executing, it must have released all semaphores using R blocked 5 6

2 Non Preemption Protocol (NPP) odify so that the caller is assigned the highest priority if it succeeds in locking S ighest priority=n preemtion! odify so that the caller is assigned its own priority back when it releases S This is the simplest method to avoid Priority Inversion! The equation for response time calculation: Ri= Bi + Ci + j P(i) Ri/Tj *Cj Where Bi is the longest time that task i can be blocked by lowerpriority tasks with n preemptive section Exercise ()Show the runtime schedules with(out) NPP (2) Calculate the worst case response times (te that R=85) T T2 T3 C T Blocking NPP: + and Simple and to implement (+), how? Deadlock free (++), why? Number of blocking = (+), Why? Allow lowpriority tasks to block highpriority tasks including those that have sharing resources () P(s) issinig all deadlines! V(s) Basic Priority Inheritance Protocol (BIP) supported in RT POSIX Idea: A gets semaphore S B with higher priority tries to lock S, and blocked by S B transfers its priority to A (so A is resumed and run with B s priority) Run time behaviour: whenever a lowerpriotity task blocks a higher priority task, it inherits the priority of the blocked task 9 Example Property/Problem : potential deadlock Task 3 Deadlock! Running with pr Blocked Using S Using S2 : :

3 Property/Problem 2: chained blocking ( needs resources may be blocked times) SCB to implement BIP Semaphores Control Block for PIP counter queue Task 3 Pointer to next SCB experiences Chainedblocking by and! Blocked Using S Using S2 older 3 4 Standard Poperation (without BIP) P(scb): Disableinterrupt; If scb.counter>0 then {scb.counter ; else {savecontext( ); currenttask.state := blocked; insert(currenttask, scb.queue); dispatch(); loadcontext() } Enableinterrupt Poperation with BIP P(scb): Disableinterrupt; If scb.counter>0 then {scb.counter ; scb.holder:= currenttask add(currenttask.semlist,scb)} else {savecontext( ); currenttask.state := blocked; insert(currenttask, scb.queue); /*queue sorted according to task priority? */ save(scb.holder.priotiry); scb.holder.priority := currenttask.priority; dispatch(); loadcontext() } Enableinterrupt 5 6 Standard Voperation (without BIP) Voperation with BIP V(scb): Disableinterrupt; If tempty(scb.queue) then { nexttorun := getfirst(scb.queue); nexttorun.state := ready; insert(nexttorun, readyqueue); savecontext(); schedule(); /* dispatch invoked*/ loadcontext() } else scb.counter ++; Enableinterrupt V(scb): Disableinterrupt; currenttask.priority := original/prvious priority /* highestpriority of tasks blocked by smaphors ownd by currenttask*/ /* check all blocked tasks waiting for sem in currenttcb.semlist*/ If tempty(scb.queue) then { nexttorun := getfirst(scb.queue); /*queue sorted according to task priority? */ nexttorun.state := ready; scb.holder := nexttorun; add(nexttorun.semlist, scb); insert(nexttorun, readyqueue); savecontext(); schedule(); /* dispatch invoked*/ loadcontext() } else scb.counter ++; Enableinterrupt 7 8

4 Properties of BIP: + and Bounded Priority inversion (+) Reasonable Runtime performance (+) Require info on resource usage of tasks (+) potential deadlock, the same reason as in OS () It may cause chainblocking (a task needs semaphores may be blocked times!): why, example? () Complicated to compute the maximal blocking times and response times () Immediate Priority Inheritance: =ighest ocker s Priority Protocol (P) =Priority Protect Protocol (PPP) Adopted in Ada95 (protected object), POSIX mutexes Idea: define the ceiling C(S) of a semaphore S to be the highest priority of all tasks that use S during execution. Note that C(S) can be calculated statically (offline) Runtime behaviour of P Example Whenever a task succeeds in holding a semaphor S, its priority is changed dynamically to the maximum of its current priority and C(S). When it finishes with S, it sets its priority back to what it was before Task 3 priority use S3 S, S S, S2 C(S)= C(S2)= C(S3)= C(S)= Task 4 ower S2, S 2 22 Example: ighest ocker s Priority Protocol Property : Deadlock free (P) and ower share S New release computing blocked using resource released ower 23 Once task 2 gets S, it runs with pri, task will be blocked ( chance to get S2 before task 2) 24

5 Property 2: Tasks will be blocked at most once Ready and blocked Ready and blocked P: Response Time Analysis et CS(k,S) dete the computing time for the critical section that task k uses semaphore S. Use(S) is the set of tasks using S Then the maximal blocking time B and response time Ri for task i is as follows: B =max{cs(k,s) i,k in Use(S), pr(k)<pr(i)<=c(s)} Ri= B + Ci + j P(i) Ri/Tj *Cj Implementation of P Calculate the ceiling for all semaphores odify SCB odify P and Voperations SCB to implement P Semaphores Control Block for P counter queue Pointer to next SCB Ceiling Poperation with P P(scb): Disableinterrupt; If scb.counter>0 then { scb.counter ; save(currenttask.priority); currenttask.priority := C(scb) } else {savecontext(); currenttask.state := blocked insert(currenttask, scb.queue); dispatch(); loadcontext() } Enableinterrupt Voperation with P V(scb): Disableinterrupt; currenttask.priority := get(previouspriority) If tempty(scb.queue) then nexttorun := getfirst(scb.queue); nexttorun.state := ready; nexttorun.priority := C(scb); insert(nexttorun, readyqueue); savecontext(); schedule(); /* dispatch invoked*/ loadcontext(); end then else scb.counter ++; end else Enableinterrupt 29 30

6 Properties of P: + and Summary Bounded priority inversion Deadlock free (+), Why? Number of blocking = (+), Why? P is a simplified version of PCP (priority ceiling protocol, with the same worst case blocking time as PCP (+) The extreme case of P=NPP () E.g when the highest priority task uses all semaphores (even only once in its whole life), the lower priority tasks will inherit the highest priority Bounded Priority Inversion Avoid deadlock Avoid Unnecessary blocking Blocking time calculalation NPP Easy BIP hard P / 3 32 Priority Ceiling Protocol (combining P and BIP) Each semaphore S has a Ceiling C(S) = the priority of the highest priority task that can lock S Runtime behaviour: Assume that S is the semaphore with highest ceiling locked by other tasks currently If a task A wants to lock a semaphore (t necessarily S), it must have a strictly higher priority than the ceilings of all semaphors locked by other tasks, i.e. P(A) > C(S). Otherwise A is blocked, and it transmitts its priority(+ε) to the task currently holding S PCP: Response Time Analysis (precisely the same as P) et CS(k,S) dete the computing time for the critical section that task k uses semaphore S. Use(S) is the set of tasks using S Then the maximal blocking time B and response time Ri for task i is as follows: B=max{CS(k,S) i,k in Use(S), pr(k)<pr(i)<=c(s)} Ri= B + Ci + j P(i) Ri/Tj *Cj Example: PCP Example: PCP Task A Task B Task C C D T 50 Priority Task A Task B Task C C C(S)= C(S2)=C(S3)= D T 50 Priority A:... B:...P(S3)...V(S3)... C:...P(S3)...V(S3) A:... B:...P(S3)...V(S3)... C:...P(S3)...V(S3) Thus: C(S)= C(S2)=C(S3)= B arrives P(S3) Blocked on S3 Get S2 P(S3) V(S3) V(S3) 35 Run with B s priority (+ε) Run with its own priority 36

7 Exercise: implementation of PCP Implement P,Voperations that follow PCP Properties of PCP: + and Bounded priority inversion (+) Deadlock free (+) Number of blocking = (+) Better response times for high priority tasks (+) Avoid unnecessary blocking Not to implement () Summary NPP BIP P PCP Bounded Priority Inversion Avoid deadlock Avoid Unnecessary blocking / Blocking time calculalation hard Number of blocking > Implementation hard 39