Scheduling and Resource Access Protocols: Basic Aspects

1. Scheduling and Resource Access Protocols: Basic Aspects CS 5270 Lecture 3 CS5270 Lecture 3

2. A Classic Policy • Rate Monotonic Scheduling. • Task set : {J1, J2, …, Jn} • Each task is periodic. T1, T2,.., Tn • i = 0 for each i. • Di = Ti for each i. • Pre-emption allowed. • Only one processor • No precedence constraints • No shared resources. CS5270 Lecture 3

3. RMS • The RMS algorithm: • Assign a static priority to the tasks according to their periods. • Priority of a task does not change during execution. • Tasks with shorter periods have higher priorities. • Preemption policy: • If Ti is executing and Tj arrives which has higher priority (shorter period), then preempt Ti and start executing Tj. CS5270 Lecture 3

4. RMS Example (3, 2) (5, 1) CS5270 Lecture 3

5. RMS Example (3, 1) (5, 2) CS5270 Lecture 3

6. RMS Results • RMS is optimal. • If a set of of periodic tasks (satisfying the assumptions set out previously) is not schedulable under RMS then nostatic priority algorithm can schedule this set of tasks. • RMS requires very little run time processing. CS5270 Lecture 3

7. Process Utilization Factor • Task set = {T1, T2, …, Tn} • Process Utilization Factor •  Ci / Ti • C1 / T1 + C2 / T2 + … Cn / Tn • If this factor is GREATER than 1 then the task set can not be scheduled. • Why? • If UF ≤ 1 it may be RMS-schedulable. CS5270 Lecture 3

8. RMS Schedulability • Task set = {T1, T2, …, Tn} • If UF  Ulub then it is guaranteed to be schedulable. • Ulub - The least upper bound of processor utility. • For RMS, Ulub = n( 21/n – 1) CS5270 Lecture 3

9. Process Utilization Factor • Task set = {T1, T2, …, Tn} • If UF  Ulub then it is guaranteed to be schedulable. • But if UF is greater than Ulub and not greater than 1, we must check explicitly whether the task set is RMS-schedulable. CS5270 Lecture 3

10. RMS Schedulability This is only a sufficient criterion! This criterion may fail and yet an RMS may exist.

11. RMS Example UF = 0.66 + 0.20 = 0.86 Ulub = 0. 828 (3, 2) (5, 1) CS5270 Lecture 3

12. RMS Example UF = 0.33 + 0.40 = 0.73 Ulub = 0. 828 (3, 1) (5, 2) CS5270 Lecture 3

13. EDF • Earliest Deadline First. • Tasks with earlier deadlines will have higher priorities. • Applies to both periodic and aperiodic tasks. • EDF is optimal for dynamic priority algorithms. • A set of periodic tasks is schedulable with EDF iff the utilization factor is not greater than 1. CS5270 Lecture 3

14. {T1, T2} T1 = ( 5, 2) T2 = (7, 4) UF = 0.4 + 0.57 = 0.97 An Example CS5270 Lecture 3

15. An RMS Schedule? Time-Overflow CS5270 Lecture 3

16. The Example • UF = 0.4 + 0.57 = 0.97 • Guaranteed to be schedulable under EDF! CS5270 Lecture 3

17. An EDF Schedule CS5270 Lecture 3

18. Shared Resources • Inter-process communication • Shared resources, critical sections, priority inversion, access protocols. • Material taken from: • Buttazzo’s Book: parts of chapter 7. CS5270 Lecture 3

19. The Host Computer DSP Processor Timer ASIC Memory CS5270 Lecture 3

20. Tasks TASK1 TASK2 TASK3 TASK4 DATA SETS CS5270 Lecture 3

21. Resource Constraints • resource: • software structure used by a task during its execution. • A data structure, variables, an area of main memory, a file, a piece of code, a set of registers of a peripheral device. • Shared resource: • Used by more than one task. • Exclusive resource: • No simultaneous access. • Require mutual exclusion. • Operating must provide a synchronization mechanism to ensure sequential access.. CS5270 Lecture 3

22. Critical Section • Critical section: • A piece of code belonging to task executed under mutual exclusion constraints. • Mutual exclusion enforced by semaphores. • wait(s) • Blocked if s = 0. • signal(s) • s is set to 1 when signal(s) executes. CS5270 Lecture 3

23. Structure of Critical Sections. CS5270 Lecture 3

24. Wait State • A task waiting for an exclusive resource is blocked on that resource. • Tasks blocked on the same resource are kept in a wait queue associated with the semaphore protecting the resource. • A task in the running state executing wait(s) on a locked semaphore (s = 0) enters the waiting state. • When a task currently using the resource executes signal(s), the semaphore is released. • When a task leaves its waiting state (because the semaphore has been released) it goes into the ready state: CS5270 Lecture 3

25. Waiting State CS5270 Lecture 3

26. Blocking via Exclusive Resource J1 has higher priority than J2. Preemption is in play. Only one processor available.

27. Resource Access Protocols • Multiple tasks. • Uniprocessor • Shared resources. • Need proper protocols for accessing shared resources. • Resource access protocols. • Avoid priority inversion! CS5270 Lecture 3

28. Priority Inversion. J1 J2 J3 0 1 2 3 4 5 6 7 J1 > J2 > J3 [3, 6] priority inversion period. J1 waits for the execution of J2 and the critical section of J3 CS5270 Lecture 3

29. Priority Inversion • The Mars pathfinder Mission in 1997 ran into serious problem. • The spacecraft began experiencing total system resets with loss of data each time. • It turned out to be due to priority inversion. • See the web page and the links there in the IVLE area! CS5270 Lecture 3

30. Avoiding Priority inversion • Disallow preemption during the execution of a critical section. • Works only if critical sections are short. • Might unneccesarily block higher priority processes that do not even use any shared resources! • Resource access protocols: • Priority inheritance protocol. • Priority ceiling protocol. CS5270 Lecture 3

31. Priority Inheritance Protocol • Tasks have nominal and active priorities. • Nominal priority: • assigned by the scheduling algorithm (RMS, EDF,..) • Active priority • assigned by the protocol –dynamically- to avoid priority inversion. CS5270 Lecture 3

32. Priority Inheritance Protocol • Basic idea : • When Ji blocks higher-priority tasks, then its active priority is set to the highest of the priorities of the tasks it blocks. • Jiinherits -temporarily – the highest priority of the blocked tasks. • This prevents medium priority tasks from preempting Ji and prolonging the blocking duration of the higher priority tasks. CS5270 Lecture 3

33. Priority Inheritance Protocol The Protocol: • Jobs are scheduled based on their active priorities. • If Ji tries to enter a critical section and the corresponding resource is being held by Jj then Ji is blocked; it is said to be blocked by Jj. • When a job is blocked on a semaphore, it transmits its active priority to the job that holds the semaphore; in general, a task inherits the highest priority of the jobs blocked by it. CS5270 Lecture 3

34. Priority Inheritance Protocol The Protocol: • When Jk exits a critical section, it unlocks the semaphore; the job with the highest priority that is blocked on the semaphore, if any, is awakened. The priority of Jk is set to the highest priority of the job it is currently blocking. If none, its priority is set to its nominal one. CS5270 Lecture 3

35. Example CS5270 Lecture 3

36. Nested Critical Sections CS5270 Lecture 3

37. Priority Inheritance Protocol • Good news: • If there are m distinct semaphores that can block a job J then J can be blocked for at most the duration of at most one critical section, one for each of the semaphores. • It can never be as long as the WCET of a lower priority task. CS5270 Lecture 3

38. Priority Inheritance Protocol • Bad news: • Chained Blocking: • J can get blocked on n critical sections held by n distinct lower priority jobs. • Deadlocks. CS5270 Lecture 3

39. Chained Blocking CS5270 Lecture 3

40. Deadlock CS5270 Lecture 3

41. Priority Ceiling Protocol • Extension of the Priority Inheritance Protocol. • Avoids chained blocking and deadlocks. • Basic Idea: • A task is not allowed to enter a critical section if there are already locked semaphores which could block it eventually (due to a sub-critical section nested within the entering critical section). • Hence, once a task enters a critical section, it can not be blocked by lower priority tasks till its completion. CS5270 Lecture 3

42. Priority Ceiling Protocol • The Protocol: • Each semaphore S is assigned a priority ceiling C(S). It is the priority of the highest priority task that can lock S. This is a static value. • Suppose J is currently running and it wants to lock the semaphore S. J is allowed to lock S only if the priority of J is strictly higher than the priority ceiling C(S’) of the semaphore S’ where: • S’ is the semaphore with the highest priority ceiling among all the semaphores which are currently locked by jobs other than J. • In this case, J is said to blocked by the semaphore S’ (and the job currently holding S’). CS5270 Lecture 3

43. Priority Ceiling Protocol The Protocol: • When J gets blocked by S’ then the priority of J is transmitted to the job that currently holds S’. • When J’ leaves a critical section guarded by S’ then it unlocks S’ and the highest priority job, if any, which is blocked by S’ is awakened. • The priority of J’ is set to the highest priority of the job that is blocked by some semaphore that J’ is still holding. If none, the priority of J’ is set to be its nominal one. CS5270 Lecture 3

44. Example CS5270 Lecture 3

45. C (S0) = ? C(S1) = ? C(S2) = ? CS5270 Lecture 3

46. C (S0) = P0 C(S1) = P0 C(S2) = P1 CS5270 Lecture 3

47. t2 : J1 can not lock S2. Currently J2 is holding S2 and C(S2) = P1 and the current priority of J1 is also P1. CS5270 Lecture 3

48. t5 : J0 can not lock S0. Currently J2 is holding S2 and S1 and C(S1) = P0 and the current priority of J0 is also P0. The (inherited) priority of J2 is now P0. CS5270 Lecture 3

49. t6 : J2 unlocks S1. It awakens J0. But J2’s (inherited) priority is now only P1 while P0 > C(S2) = P1. So J0 preempts J2 and runs to completion. CS5270 Lecture 3

50. t7 : J2 resumes execution with priority P1. CS5270 Lecture 3