Inter-task communication mechanisms

Size: px

Start display at page:

Download "Inter-task communication mechanisms"

Elisabeth Casey
6 years ago
Views:

1 Inter-task communication mechanisms Sistemi Real-Time Prof. Davide Brugali Università degli Studi di Bergamo Tratto da G.C. Buttazzo, «Sistemi in Tempo Reale», Capitolo 10

2 Global shared variables In most RT applications, tasks exchange data through global shared variables. Advantages this is the fastest mechanism low run-time overhead schedulability analysis is available Disadvantages Data must be accessed in mutual exclusion: non-preemptive regions; semaphores, priority inheritance, priority ceiling. Not good for modular design: local details are exposed to other tasks; a change in a task affect other tasks. 2

3 Message passing paradigm Another approach is to exchange data through a message passing paradigm: Every task operates on a private memory space; Data are exchanged by messages through a channel. 3

4 Communication Ports Many operating systems provides the channel abstraction through the port construct. A task can use a port to exchange messages by means of two primitives: send sends a message to a port receive receives a message from a port Some operating systems allows the user to define different types of ports, with peculiar semantics 4

5 Port characteristics Ports may differ for: number of tasks allowed to send messages; number of tasks allowed to receive messages; policy used to insert and extract messages. behavior to manage exceptions (sending to a full port or receiving from an empty port). Before being used, a port has to be created, and then destroyed when it is not needed any more. Port attributes need to be defined at creation time 5

6 Sending a message 6

7 Receiving a message 7

8 Using a port 8

9 Periodic task communication 9

10 Periodic task communication 10

11 Periodic task communication 11

12 Exchanged messages 12

13 Buffer saturation 13

14 STICK Ports 14

15 STICK Ports 15

16 Blocking on STICK ports Although a task cannot blocks for a full or empty buffer, it can block for mutual exclusion: indeed a semaphore is needed to protect the internal buffer from simultaneous accesses. Long messages may cause long blocking delays on such a semaphore. Long waiting times due to long messages can be avoided through a buffer replication mechanism. 16

17 Cyclic Asynchronous Buffer (CAB) It is a mechanism for exchanging messages among periodic tasks with different rates. Memory conflicts are avoided by replicating the internal buffers. At any time, the most recent message is always available for reading. A new message overrides the previous one. Messages are not consumed by reading. 17

18 Simultaneous accesses 18

19 Dual buffering Dual buffering is often used to transfer large data, (images) from the input peripheral device to a task: Once written, the new message becomes available to the next reader: 19

20 Accessing a CAB A CAB generalizes dual buffering for N readers; Data is accessed through a memory pointer. Hence, a reader is not forced to copy the message in its memory space. More tasks can concurrently read the same message. At any time, a pointer (mrb) points to the most recent buffer used for writing a new message. 20

21 CAB example 21

22 CAB example 22

23 CAB example 23

24 Dimensioning a CAB If a CAB is used by N tasks, to avoid blocking, it must have at least N +1 buffers. The (N+1)-th buffer is needed for keeping the most recent message in the case all the other buffers are used. 24

25 Inconsistency with N buffers 25

26 Writing Protocol To write a message in a CAB a task must: 1. ask the CAB for a pointer to a free buffer; 2. copy the message into the buffer using the pointer; 3. release the pointer to the CAB to make the message accessible to the next reader. 26

27 Reading Protocol To read a message from a CAB a task must 1. get the pointer to the most recent message in the CAB; 2. process the message through the pointer; 3. release the pointer, to allow the CAB to recycle the buffer if it is not used. 27

28 CAB Primitives 28

29 CAB Primitives 29

30 Writing in a CAB 30

31 Reading from a CAB 31

32 Implementing CABs 32

33 cab_reserve() 33

34 cab_putmes() 34

35 cab_getmes() 35

36 cab_unget() 36

37 Scheduling Policy in Posix 37

38 Scheduling policy 38

39 Scheduling in POSIX 39

40 Example pthread_t th1, th2, th3; pthread_attr_t my_attr; struct sched_param param1, param2, param3; pthread_attr_init(&my_attr); pthread_attr_setschedpolicy(&my_attr, SCHED_FIFO); param1.sched_priority = 1; pthread_attr_setschedparam(&my_attr, &param1); pthread_create(&th1, & my_attr, task1, 0); param2.sched_priority = 2; pthread_attr_setschedparam(& my_attr, &param2); pthread_create(&th2, & my_attr, task2, 0); param3.sched_priority = 3; pthread_attr_setschedparam(& my_attr, &param3); pthread_create(&th3, & my_attr, task3, 0); pthread_attr_destroy(& my_attr); 40

41 Setting protocol attributes 41

42 Priority Ceiling 42

43 Example with priority inheritance 43

44 Example with priority ceiling 44

Global shared variables. Message passing paradigm. Communication Ports. Port characteristics. Sending a message 07/11/2018

Global shared variables. Message passing paradigm. Communication Ports. Port characteristics. Sending a message 07/11/2018 Global shared variables In most RT applications, tasks exchange data through global shared variables. Advantages High efficiency Low run-time overhead Schedulability analysis is available Disadvantages