evaluating the performance of wait-free snapshots in real-time systems

Håkan Sundell, [email protected]

Chalmers University of Technology

1

Evaluating the performance of wait-free snapshots in real-time

systemsBjörn Allvin

Andreas Ermedahl

Hans Hansson

Marina Papatriantafilou

Håkan Sundell

Philippas Tsigas



2

Schedule

• What are we evaluating

• How did we do the evaluation

• Evaluation platform

• Analysis

• Experiments

• Conclusions

• Future work



3

• 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

What are we evaluating



4


• Synchronization methods– Lock

• Uses semaphores, spinning, disabling interrupts

• Negative– Blocking

– Priority inversion

– Risk of deadlock

• Positive– Execution time guarantees easy to do

Take lockTake lock

... do operation ...... do operation ...

Release lockRelease lock



5


• Synchronization methods– Lock-free

• Retries until not interfered by other operations

• Usually uses some kind of shared flag variable

Write flagWrite flag

... do operation ...... do operation ...

Check flag and maybe retryCheck flag and maybe retry



6


• 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



7


• Synchronization methods– Wait-free

• Uses atomic synchronization primitives

• Uses shared memory

• Negative– Complex algorithms

– Memory consuming

Test&SetTest&Set

CompareCompare&Swap&Swap

CopyingCopying

HelpingHelping

AnnouncingAnnouncing

SplitSplitoperationoperation

??????



8


• 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



9


• Wait-free snapshot algorithm– Several register copies– Uses Test&Set for synchronization

Used by writerUsed by writer

Used by readerUsed by reader



10

How did we do the evaluation

• Analytically– Single-processor system– Measured schedulability



11

How did we do the evaluation

• Experimentally– Single-processor system

• Measured schedulability

– Multi-processor system with CAN-bus• Measured snapshot response time



12

Evaluation platform

• Hardware– CAN-bus , 1 Mhz– Nodes

• 1 processor , Motorola 68020 , 20 MHz

• Single wait-state memory

• CAN-controller



13

Evaluation platform

• Software– RTOS– Device tasks (interrupts)– Updater tasks– Local snapshot tasks– System snapshot task



14

Evaluation platform

• Additional parameters– Snapshot algorithm timings from WCET

analysis• Cross-compiling

• Cycle counting

– CAN-bus timing from estimation



15

Analysis

• Parameters– 10 tasks– 15 devices– Snapshot of 5 components



16

Analysis

• Response time formulas

RRii CCii CCjjRRii

TTjj

==jjhp(i)hp(i)

++

......

......



17

Analysis

• Generation of 100 random scenarios for each of 31 different CPU loads

• Each scenario schedulable without any synchronization method



18

Analysis

• Results



19

Experiments

• Simulation– RT-simulator in Erlang

• Fixed priority preemptive scheduler

• Execution time

• Semaphores

• Memory

• Messages



20

Experiments

• Single-node– Parameters

• 10 tasks

• 15 devices

• Snapshot of 5 components



21

Experiments

• Single-node– Simulator programming

• Using subset of scenarios used for the analysis

• Lock– Execution and semaphores

• Lock-free– Execution and shared memory

• Wait-free– Execution



22

Experiments

• Single-node– Results



23

Experiments

• Multi-node– CAN-simulation

• Sending– Execution

• Receiving– Execution of highest priority task

– Execution



24

Experiments

• Multi-node– Parameters

• 10 nodes

• 10 tasks on each node

• 15 devices on each node

• Local snapshot of 24 components on each node

• 1 super snapshot task on last node



25

Experiments

• Multi-node– Simulator programming

• Using subset of scenarios used for the analysis

• Lock– Execution, semaphores and messages

• Lock-free– Execution, shared memory and messages

• Wait-free– Execution and messages



26

Experiments

• Multi-node– Results



27

Experiments

• Multi-node– Results



28

Conclusions

• Wait-free is always better than lock

• Lock-free mostly performs better than lock – Single-node

• Lock-free performs best in practice

• Wait-free performs very good

– Multi-node• Lock-free performs poor

• Wait-free performs best



29

Future work

• Investigations of other wait-free synchronization methods

• Implementations in RTOS kernels, by Enea and NRTG

• WARPing project - http://www.cs.chalmers.se/~phs/warp

evaluating the performance of wait-free snapshots in real-time systems

Documents