1. CS5270 Lecture 31 Uppaal, and Scheduling, and Resource Access Protocols CS 5270 Lecture 3

2. 2 Assignment 1… Eight questions Some reading may be required… Hand in Feb 16

3. CS5270 Lecture 33 Last week… Some system examples Time triggered architectures Requirements for hard RT systems –Functional –Temporal –Dependability/safety Clocks The design challenge…(not done…)

4. CS5270 Lecture 34 This week… The design challenge. Uppaal Scheduling overview Scheduling algorithms –RMS – Rate Monotonic Scheduling –EDF – Earliest Deadline First Resource Access overview (if time)

5. CS5270 Lecture 35 Uppaal: Website…

6. CS5270 Lecture 36 Uppaal: License…

7. CS5270 Lecture 37 Uppaal: Download…

8. CS5270 Lecture 38 Uppaal: Download…

9. CS5270 Lecture 39 Uppaal: Instructions…

10. CS5270 Lecture 310 Uppaal: Extract/unzip…

11. CS5270 Lecture 311 Uppaal: Click on Jar file…

12. CS5270 Lecture 312 Uppaal: The application…

13. CS5270 Lecture 313 Uppaal: Help…

14. CS5270 Lecture 314 Uppaal: Load up demo…

15. CS5270 Lecture 315 Uppaal: Look at TTS…

16. CS5270 Lecture 316 Uppaal: Simulation…

17. CS5270 Lecture 317 Uppaal: Simulation…

18. CS5270 Lecture 318 Uppaal: Simulation…

19. CS5270 Lecture 319 Uppaal: Verification…

20. CS5270 Lecture 320 Scheduling

21. CS5270 Lecture 321 Non-preemptive scheduling

22. CS5270 Lecture 322 Preemptive scheduling

23. CS5270 Lecture 323 Scheduling terms Feasible – a schedule is termed feasible if all tasks can be completed within the constraints specified Schedulable – a task set is schedulable if a particular scheduling algorithm produces a feasible schedule

24. CS5270 Lecture 324 Constraints for scheduling Timing (deadlines for tasks) Precedence (which task comes first) Resource (shared access) Hard and Soft constraints

25. CS5270 Lecture 325 Deadlines Each task runs for time Cj, and must complete before a deadline

26. CS5270 Lecture 326 Periodic tasks

27. CS5270 Lecture 327 Precedence between tasks

28. CS5270 Lecture 328 Resource Access Protocols Multiple tasks. Uniprocessor Shared resources. –Need proper protocols for accessing shared resources. –Resource access protocols. Avoid priority inversion!

29. CS5270 Lecture 329 Resource constraints Critical resource constraints Mutual exclusion Critical sections

30. CS5270 Lecture 330 Critical sections

31. CS5270 Lecture 331 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.

32. CS5270 Lecture 332 Structure of Critical Sections.

33. CS5270 Lecture 333 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:

34. CS5270 Lecture 334 Task access to resources

35. 35 Blocking via Exclusive Resource J 1 has higher priority than J 2. Preemption is in play. Only one processor available.

36. CS5270 Lecture 336 Scheduling algorithms - RMS

37. CS5270 Lecture 337 A Classic Policy Rate Monotonic Scheduling. –Task set : {J 1, J 2, …, J n } –Each task is periodic. T 1, T 2,.., T n –  i = 0 for each i. –D i = T i for each i. –Each task runs for time C i –Pre-emption allowed, only one processor, no precedence constraints, no shared resources.

38. CS5270 Lecture 338 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 T i is executing and T j arrives which has higher priority (shorter period), then preempt T i and start executing T j.

39. CS5270 Lecture 339 RMS Example (3, 2) (5, 1) Period Duration TiTi CiCi

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

41. CS5270 Lecture 341 RMS Results RMS is optimal. – If a set of of periodic tasks (satisfying the assumptions set out previously) is not schedulable under RMS then no static priority algorithm can schedule this set of tasks. RMS requires very little run time processing.

42. CS5270 Lecture 342 Schedulability

43. CS5270 Lecture 343 Process Utilization Factor Task set = {T 1, T 2, …, T n } Process Utilization Factor –  C i / T i –C 1 / T 1 + C 2 / T 2 + … C n / T n If this factor is GREATER than 1 then the task set can not be scheduled. –Why? If UF ≤ 1 it may be RMS-schedulable.

44. CS5270 Lecture 344 RMS Schedulability Task set = {T 1, T 2, …, T n } If UF  U lub then it is guaranteed to be schedulable. U lub - The least upper bound of processor utility. For RMS, U lub = n( 2 1/n – 1)

45. CS5270 Lecture 345 Process Utilization Factor Task set = {T 1, T 2, …, T n } If UF  U lub then it is guaranteed to be schedulable. But if UF is greater than U lub and not greater than 1, we must check explicitly whether the task set is RMS-schedulable.

46. 46 RMS Schedulability nU lub 11.000 20.828 30.780 40.757 50.743 6 0.735 7 0.729  0.690 This is only a sufficient criterion! This criterion may fail and yet an RMS may exist.

47. CS5270 Lecture 347 RMS Example (Guaranteed) (3, 1) (5, 2) UF = 0.33 + 0.40 = 0.73 U lub = 0. 828 (U F ≤U lub )

48. CS5270 Lecture 348 RMS Example (still schedulable) (3, 2) (5, 1) UF = 0.66 + 0.20 = 0.86 U lub = 0. 828 (U F >U lub )

49. CS5270 Lecture 349 Scheduling algorithms - EDF

50. CS5270 Lecture 350 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.

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

52. CS5270 Lecture 352 An RMS Schedule? Time-Overflow

53. CS5270 Lecture 353 The Example UF = 0.4 + 0.57 = 0.97 Guaranteed to be schedulable under EDF!

54. CS5270 Lecture 354 An EDF Schedule

55. CS5270 Lecture 355 Priority inversion

56. CS5270 Lecture 356 Priority Inversion. 0 1 2 3 4 5 6 7 J 1 > J 2 > J 3 [3, 6] priority inversion period. J 1 waits for the execution of J 2 and the critical section of J 3 J1J1 J2J2 J3J3

57. CS5270 Lecture 357 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!

58. CS5270 Lecture 358 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.

59. CS5270 Lecture 359 Resource access - PIP

60. CS5270 Lecture 360 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.

61. CS5270 Lecture 361 Priority Inheritance Protocol Basic idea : – When J i blocks higher-priority tasks, then its active priority is set to the highest of the priorities of the tasks it blocks. –J i inherits -temporarily – the highest priority of the blocked tasks. –This prevents medium priority tasks from preempting J i and prolonging the blocking duration of the higher priority tasks.

62. CS5270 Lecture 362 Priority Inheritance Protocol The Protocol: Jobs are scheduled based on their active priorities. If J i tries to enter a critical section and the corresponding resource is being held by J j then J i is blocked; it is said to be blocked by J j. 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.

63. CS5270 Lecture 363 Priority Inheritance Protocol The Protocol: When J k 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 J k is set to the highest priority of the job it is currently blocking. If none, its priority is set to its nominal one.

64. CS5270 Lecture 364 Example

65. CS5270 Lecture 365 Nested Critical Sections

66. CS5270 Lecture 366 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.

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

68. CS5270 Lecture 368 Resource access - PCP

69. CS5270 Lecture 369 Chained Blocking

70. CS5270 Lecture 370 Deadlock

71. CS5270 Lecture 371 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.

72. CS5270 Lecture 372 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’).

73. CS5270 Lecture 373 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.

74. CS5270 Lecture 374 Example

75. CS5270 Lecture 375 C (S0) = P0 C(S1) = P0 C(S2) = P1 Example

76. CS5270 Lecture 376 C (S0) = ? C(S1) = ? C(S2) = ? Example

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

78. CS5270 Lecture 378 Example @ t5 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.

79. CS5270 Lecture 379 Example @ t6 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.

80. CS5270 Lecture 380 Example @ t7 t7 : J2 resumes execution with priority P1.

81. CS5270 Lecture 381 Example @ t8 t8 : J2 unlocks S2 and goes back to its nominal priority P2. So J1 preempts J0 and runs to completion.

82. CS5270 Lecture 382 Two Key Properties Under priority ceiling protocol, a job can be blocked for at most the duration of one critical section. The priority ceiling protocol prevents deadlocks.