Using Timing Information on Wait-Free Algorithms in Real-Time Systems (2 papers)

1. Using Timing Information on Wait-Free Algorithms in Real-Time Systems (2 papers) Håkan Sundell Philippas Tsigas Yi Zhang Computing Science Chalmers University of Technology

2. Real-Time System Synchronization Algorithms (Snapshot + Buffer) Bounding Experiments Conclusions Future work Schedule

3. Multiprocessor system Interconnection Network Shared memory (with or without constraints) Real-Time System CPU CPU CPU CPU

4. Cooperating Tasks Timing constraints Need synchronization Shared Data Objects In this presentation: Atomic Snapshot and Atomic Buffer Real-Time System

5. Synchronization methods Lock Uses semaphores, spinning, disabling interrupts Negative Blocking Priority inversion Risk of deadlock Positive Execution time guarantees easy to do Synchronization Take lock ... do operation ... Release lock

6. Synchronization methods Lock-free Retries until not interfered by other operations Usually uses some kind of shared flag variable Synchronization Write flag with unique value ... do operation ... Check flag value and maybe retry

7. Synchronization methods Lock-free Negative No execution time guarantees, can continue forever - thus can cause starvation Positive Avoids blocking and priority inversion Avoids deadlock Fast execution when low contention Synchronization

8. Synchronization methods Wait-free Uses atomic synchronization primitives Uses shared memory Negative Complex algorithms Memory consuming Synchronization Test&Set Compare &Swap Copying Helping Announcing Split operation ???

9. Synchronization methods Wait-free Positive Execution time guarantees Fast execution Avoids blocking and priority inversion Avoids deadlock Avoids starvation Same implementation on both single- and multiprocessor systems Synchronization

10. Snapshot A consistent momentous state of a set of several shared variables One reader Reads the whole set of variables in one atomic step Many writers Writes to only one variable each time Snapshot

11. Wait-Free Snapshot Algorithm Unbounded memory Each component represented by an infinite nil-value-initialized array, higher index for more recent values A global index register where all component writers writes the updated value The reader scans all component arrays backwards from current position Algorithm

12. Unbounded Snapshot Protocol Algorithm Snapshotindex ? = previous values / nil w = writer position c1 v ? ? ? ? w nil nil ci v ? ? ? ? w nil nil cc v ? ? ? ? w nil nil t

13. Constructing an Atomic Buffer N-readers and N-writers Constraints , non-uniform memory Constructing of simple components Algorithm (Buffer) • register that can be written by processor i • and read by processor j

14. Wait-Free Atomic Shared Buffer by Vitanyi et. al A Matrix of 1-reader 1-writer registers Algorithm Readers R11 R12 ... R21 R22 … ... ... ... Rij • written by i • read by j Writers

15. The tag increases with each write operation Unbounded maximum size for the tag field in the value/tag pair Assume 8 writer tasks with 10 ms period Maximum tag after one hour is 2880000 which needs 22 bits! Memory size is very important, 8 bit computers are still most common Algorithm

16. Assuming system with periodic fixed-priority scheduling Notations from Standard Real-Time Response Time Analysis Use information about Periods , T Computation time , C Response times , R Bounding

17. We must recycle the array indexes in some way Keep track of the scanner versus the updaters positions Previous solution by Ermedahl et. al Synchronized using atomic Test and Set operations Bounding (Snapshot)

18. Needed buffer length for component k Can be refined even further Bounding where Ts is the period for the snapshot task Tw is the period for the writer tasks

19. Recycling of the tags is necessary Timing information is available in real-time systems (J. Chen, A. Burns) Analysing the maximum difference between tags possible observable by a task at two consecutive invocations of the algorithm Using notations from the standard response time analysis for periodic fixed priority scheduling Bounding (Buffer)

20. In any possible execution: Where Tmax is the longest period Rmax is the longest response time Twr is the period of the writer tasks Bounding

21. Analyse how to recycle the tags Newer tags can restart from zero when we reach a certain tag value In order to be able to decide if newer tags are newer we need to have: Bounding

22. Using a Sun Enterprise 10000 multiprocessor computer 1 scanner task and 10 updater tasks, one on each cpu Comparing two wait-free snapshot algorithms Using timing information Using test and set synchronization Experiments

23. 7 different scenarios Experiments

24. Scan operation - Average Response Time Experiments

25. Update operation – Average Response Time Experiments

26. Example Task Scenario on 8 processors Examples (Buffer)

27. Tmax = Rmax = 1000 MaxTagDiff = 38 TagFieldSize = 76 TagFieldBits = 7 Unbounded algorithm would have reached tag 68400 in one hour , needing >16 bits Examples

28. Update operation Using timing information gives up to 400 % better performance Scan operation Using timing information gives up to 20 % better performance in common practical scenarios Update operation is much more frequent than Scan Timing information can improve the performance significantly Simpler algorithm Conclusions (Snapshot)

29. We have presented an atomic n-reader n-writer shared buffer. Usage of timing information enables us to recycle the tags and thus bound the memory usage The modified algorithm has small space requirements Conclusions (Buffer)

30. Investigations of other wait-free synchronization methods Implementations in RTOS kernels Future work