1. EMERALDS
Landon Cox
March 22, 2017

2. Real-time systems Typical hardware constraints Typical workload
Slow, low-power processors
Small memories
Little to no persistent storage
Typical workload
Periodic sensing and actuation
Task periodicity  deadlines

3. EMERALDS OS for embedded systems Due to hardware constraints
Want to minimize overhead everywhere
Use resources on real work, not management
Focus on three system services
Task scheduling
Synchronization
Communication

4. Rate-monotonic scheduling
Each task has
A periodicity (e.g., must run every 10 ms)
A worst-case execution time (e.g., 5 ms)
A static priority (i.e., does not change over time)
Basic idea
Assign task priorities based on periodicity
Tasks with smaller period get higher priority
Can use pre-emption to interrupt a task

5. Rate-monotonic scheduling
T1 (Period 100ms, execution time 50ms) T2 (Period 200ms, execution time 80ms) Pre-empt and schedule every 50ms 50
100
150
180
200 T1 T2 T1 T2
What to run next?
What to run next?
What to run next?
Did we meet all of our deadlines?
What was our utilization?

6. Rate-monotonic scheduling
Rate-monotonic is optimal for fixed-priority
Maximizes task-set “schedulability”
Ensures that max number of tasks meet their deadlines
Scheduability test for RM (Liu and Layland)
Completion time
m tasks
Task period

7. Rate-monotonic scheduling
Rate-monotonic is optimal for fixed-priority
Maximizes task-set “schedulability”
Ensures that max number of tasks meet their deadlines
Scheduability test for RM (Liu and Layland)
If utilization is below this number, a feasible schedule exists

8. Rate-monotonic scheduling
Rate-monotonic is optimal for fixed-priority
Maximizes task-set “schedulability”
Ensures that max number of tasks meet their deadlines
Scheduability test for RM (Liu and Layland)
for m = 2, utilization < .83

9. Rate-monotonic scheduling
Rate-monotonic is optimal for fixed-priority
Maximizes task-set “schedulability”
Ensures that max number of tasks meet their deadlines
Scheduability test for RM (Liu and Layland)
As long as utilization is below 0.69, RM will meet all deadlines
for m  ∞, utilization < ln(2) ≈ 0.69

10. Rate-monotonic scheduling
Rate-monotonic is optimal for fixed-priority
Maximizes task-set “schedulability”
Ensures that max number of tasks meet their deadlines
Scheduability test for RM (Liu and Layland)
Leaves roughly 31% CPU for scheduler and other stalls
for m  ∞, utilization < ln(2) ≈ 0.69

11. Rate-monotonic scheduling
T1 (Period 100ms, execution time 50ms) T2 (Period 200ms, execution time 80ms) Pre-empt and schedule every 50ms 50
100
150
180
200 T1 T2 T1 T2
How is RM different than earliest-deadline first (EDF)?
RM priorities are static, EDF prioritizes task closest to deadline

12. Scheduling overheads Runtime overhead Schedulability overhead
Time to decide what to run next
Want fast access to TCB queues
Schedulability overhead
For a given a task set
Can all tasks in set be processed in time?

13. Runtime overhead EDF (dynamic priorities) RM (fixed priorities)
Tasks are kept in an unsorted list
Walk the whole list to find one with earliest deadline
O(1) to block/unblock a task (to update TCB)
O(n) to schedule next task (to find earliest deadline)
RM (fixed priorities)
Tasks are kept in a sorted list
Keep pointer to highest priority ready task
O(n) to block (to update TCB, set highestP pointer)
O(1) to unblock (update TCB)
O(1) to schedule next task (use highestP pointer)

14. Scheduability overhead
EDF
Can schedule all workloads where
Zero scheduability overhead RM
Observed utilizations of 0.88 on average for RM 1

15. Rate-monotonic scheduling1 2 3 4 5 6 7 8 9 10 Pi 20 30 50
100
130 ci
1.0
0.5 T1 1 T2 2 T3 3 T4 4 T1 5 T2 6 T3 7 T4 8
What’s wrong?
What to run next?
What to run next?
What to run next?
What to run next?
What to run next?
What to run next?
What to run next?
What to run next?
When would T5 run under EDF?

16. Combined static/dynamic (CSD)
Hybrid approach
Very useful for solving many kinds of problems
Use one approach when it does well
Use another approach when it does well
Main idea: two queues
Dynamic queue (unsorted, used by EDF)
Fixed queue (sorted, used by RM)
Key is figuring out which queue to put tasks on

17. CSD scheduling DPQ FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100 130 ci
1.0
0.5
Need to identify longest-period task that fails under RM T1
DPQ T2 T3 T4 T5
Which tasks have higher priority?
FPQ T6 T7 T8 T9
T10

18. Need to identify longest-period task that fails under RM
CSD scheduling i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50
100
130 ci
1.0
0.5
Need to identify longest-period task that fails under RM T1
DPQ T2 T3 T4 T5
When do FPQ tasks run?
FPQ T6 T7 T8 T9
T10

19. When would FPQ tasks run?
CSD scheduling i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50
100
130 ci
1.0
0.5 T1 1 T2 2 T3 3 T4 4 T5
4.5 T1
5.5 T2
6.5 T3
7.5 T1
DPQ T2 T3 T4 T5 T1 T2 T3 T4 T5
When would FPQ tasks run?
FPQ T6 T7 T8 T9
T10
Need a DPQ task to block

20. CSD scheduling DPQ FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100 130 ci
1.0
0.5 T1 1 T2 2 T3 3 T4 4 T5
4.5 T1
5.5 T2
6.5 T3
7.5 T1
DPQ T2 T3 T4 T5 T1 T2 T3 T5
What if we have a lot of tasks?
FPQ T6 T7 T8 T9
T10
Time to walk DPQ could grow

21. CSD scheduling DPQ FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100 130 ci
1.0
0.5 T1 1 T2 2 T3 3 T4 4 T5
4.5 T1
5.5 T2
6.5 T3
7.5 T1
DPQ T2 T3 T4 T5 T1 T2 T3 T5
Why might this be a problem?
FPQ T6 T7 T8 T9
T10
May start missing deadlines

22. CSD scheduling DPQ FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100 130 ci
1.0
0.5 T1 1 T2 2 T3 3 T4 4 T5
4.5 T1
5.5 T2
6.5 T3
7.5 T1
DPQ T2 T3 T4 T5 T1 T2 T3 T5
What’s the solution?
FPQ T6 T7 T8 T9
T10
Split DPQ into two Qs

23. CSD3 scheduling DPQ1 DPQ2 FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100
130 ci
1.0
0.5
Which tasks go on which queue? T1
DPQ1 T2 T3
More frequent tasks in DPQ1 T4
DPQ2 T5
FPQ T6 T7 T8 T9
T10

24. CSD3 scheduling DPQ1 DPQ2 FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100
130 ci
1.0
0.5
Why is DPQ1 helpful? T1
DPQ1 T2 T3
Lower search time for frequent tasks. Longer searches occur less frequently. T4
DPQ2 T5
FPQ T6 T7 T8 T9
T10

25. CSD3 scheduling DPQ1 DPQ2 FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100
130 ci
1.0
0.5 T1
DPQ1 T2 T3
When do DPQ2 tasks run? T4
DPQ2 T5
When DPQ1 is empty
FPQ T6 T7 T8 T9
T10

26. CSD3 scheduling DPQ1 DPQ2 FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100
130 ci
1.0
0.5 T1
DPQ1 T2 T3
When do FPQ tasks run? T4
DPQ2 T5
When DPQ1, DPQ2 are empty
FPQ T6 T7 T8 T9
T10

27. CSD3 scheduling DPQ1 DPQ2 FPQ i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50 100
130 ci
1.0
0.5 T1
DPQ1 T2 T3
What is the downside of DPQ2? T4
DPQ2 T5
Schedualibility suffers
FPQ T6 T7 T8 T9
T10

28. We’re back to missing its deadline
CSD3 scheduling i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50
100
130 ci
1.0
0.5 T4
DPQ2 T5 T1
DPQ1 T2 T3
What if DPQ2 only has T5?
We’re back to missing its deadline
FPQ T6 T7 T8 T9
T10

29. Exhaustive offline search!
CSD3 scheduling i 1 2 3 4 5 6 7 8 9 10 Pi 20 30 50
100
130 ci
1.0
0.5 T4
DPQ2 T5 T1
DPQ1 T2 T3
What’s the solution?
Exhaustive offline search!
FPQ T6 T7 T8 T9
T10

30. Synchronization General approach Main primitive: semaphores
Integrate synchronization with scheduling
Same approach as most thread libraries
Main primitive: semaphores
Initialize w/ value one to use as a lock
Initizlize w/ value zero to use for ordering (e.g., CV)

31. Synchronization Semaphores w/ priority inheritance for locking
if (sem locked) {
do priority inheritance;
add calling thread to wait queue;
block; }
lock sem;

32. How do we get rid of this context switch?
Synchronization Tx
How do we get rid of this context switch?
Schedule T1 before T2
unlock T1
(lock holder)
lock T2

33. Synchronization Tx What extra info must be passed to blocking call?
ID of semaphore to be acquired
unlock T1
(lock holder)
lock T2

34. What does the scheduler do before it tries to run T2?
Synchronization Tx
What does the scheduler do before it tries to run T2?
Checks if semaphore is held. If so, transfers T2 priority to T1. Blocks T2 on semaphore wait list.
unlock T1
(lock holder)
lock T2

35. When T1 releases the lock. This transfers T2 priority back to T2.
Synchronization Tx
When is T2 unblocked?
When T1 releases the lock. This transfers T2 priority back to T2.
unlock T1
(lock holder)
lock T2

36. Synchronization Tx
unlock T1
(lock holder)
lock T2

37. Communication Typical access pattern Could use producer-consumer queue
One task reading a sensor
Many tasks processing sensor values
Single writer, multiple readers
Could use producer-consumer queue
Writer acquires lock on shared queue
Readers block acquiring lock to read queue
Writer adds new value to queue
Readers take turns acquiring lock, reading value
Too slow for an embedded system

38. Communication Index = 0 State Message
Note this is for a uni-processor.
System is concurrent, but not parallel. R0 R1
Reader R2 R3 R4
Writer R5
Index = 0
State Message
Reader

39. What is the difference between concurrency and parallelism?
Communication
What is the difference between concurrency and parallelism? R0 R1
Reader R2
Parallelism is when threads run at the same time. Concurrency is when threads’ execution overlaps in time. R3 R4
Writer R5
Index = 0
State Message
Reader

40. Communication Index = 0 State Message What operations are atomic? R0
Reader R2
Loads and stores to access B bytes. R3 R4
Writer R5
Index = 0
State Message
Reader

41. Do I need this circular buffer if my data is ≤ B bytes?
Communication
Do I need this circular buffer if my data is ≤ B bytes? R0 R1
Reader R2
No, can just update with load or store. Value won’t be partially written. Need buffers when data is > B bytes. R3 R4
Writer R5
Index = 0
State Message
Reader

42. What happens if reader runs between 1 and 2?
Communication R0
To update SM:
Read new sensor value
Read index into i
Write value to (i+1)%6
Update index to (i+1)%6 R1
Reader R2
To read SM:
Read index into i
Read value at buffer[i]
What happens if reader runs between 1 and 2? R3 R4
Writer R5
Index = 0
Sees old value
State Message
Reader

43. What happens if reader runs between 3 and 4?
Communication R0
To update SM:
Read new sensor value
Read index into i
Write value to (i+1)%6
Update index to (i+1)%6 R1
Reader R2
To read SM:
Read index into i
Read value at buffer[i]
What happens if reader runs between 3 and 4? R3 R4
Writer R5
Index = 0
Sees old value
State Message
Reader

44. What happens if writer runs between 1 and 2?
Communication R0
To update SM:
Read new sensor value
Read index into i
Write value to (i+1)%6
Update index to (i+1)%6 R1
Reader R2
To read SM:
Read index into i
Read value at buffer[i] R3
What happens if writer runs between 1 and 2? R4
Writer R5
Index = 0
Sees old value
State Message
Reader

45. Communication Index = 0 State Message R0 R1 Reader R2 R3
To update SM:
Read new sensor value
Read index into i
Write value to (i+1)%6
Update index to (i+1)%6 R1
Reader R2
To read SM:
Read index into i
Read value at buffer[i] R3
What happens if writer runs 6 times between start of 2 and end of 2? R4
Writer R5
Index = 0
Reader will see garbled value
State Message
Reader

46. Communication Index = 0 State Message R0 R1 Reader R2 R3
To update SM:
Read new sensor value
Read index into i
Write value to (i+1)%6
Update index to (i+1)%6 R1
Reader R2
To read SM:
Read index into i
Read value at buffer[i] R3
What happens if writer runs 6 times between start of 2 and end of 2? R4
Writer R5
Index = 0
Reader will see garbled value
State Message
Reader

47. Communication Could make the buffer longer Idea
Making the buffer too long will waste memory
Idea
We know how long read and write tasks take
Set buffer length based on longest a read could take
d is reader’s period (deadline)
c is reader’s compute time
cr is time to read value
maxReadTime = d – (c – cr)

48. Communication Could make the buffer longer Idea
Making the buffer too long will waste memory
Idea
We know how long read and write tasks take
Set buffer length based on longest a read could take
xmax is max writes that could garble values
Pw is writer’s period
dw is writer’s deadline
maxReadTime = d – (c – cr)
xmax > FLOOR((maxReadTime – (Pw – dw))/Pw)

49. Communication Could make the buffer longer Idea
Making the buffer too long will waste memory
Idea
We know how long read and write tasks take
Set buffer length based on longest a read could take
maxReadTime W W W W W dw pw
maxReadTime = d – (c – cr)
xmax > FLOOR((maxReadTime – (Pw – dw))/Pw)

50. Course administration
Research projects
Study use of native code in Android apps
Build a FUSE file system for Linux