Embedded Software TI2725 C. 5. Software architectures. Koen Langendoen. Embedded Software Group

Size: px

Start display at page:

Download "Embedded Software TI2725 C. 5. Software architectures. Koen Langendoen. Embedded Software Group"

Oliver Cummings
5 years ago
Views:

1 Embedded Software 5. Software architectures TI2725 C Koen Langendoen Embedded Software Group

2 Lec.2: Interrupts & data sharing volatile static long int lsecondstoday; void interrupt vupdatetime() ++lsecondstoday; long lgetseconds() long lreturn; lsecondstoday - previous lsecondstoday - current lreturn = lsecondstoday; while (lreturn!=lsecondstoday) lreturn = lsecondstoday; return (lreturn); lreturn - desired lreturn - bad 2

3 Exercise static int cerrors; void interrupt testint(void) ++cerrors; void test(void) ++cerrors; Does this code suffer from the data-sharing bug? 3

4 ++cerrors; Intel 80x86 INC (cerrors) RET 8051 controller nocarry: MOVE MOVX INC MOVX JNZ MOVE MOVX INC MOVX RET DPTR, #cerrors+01h A nocarry DPTR, #cerrors A,@DPTR A 4

5 Exercise static int cerrors; void interrupt testint(void) ++cerrors; int test(void) return (++cerrors); Modify this code in such a way to minimize the chance of a shared-data bug. 5

6 Outline Embedded system architectures Examples of architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Task switching X32 6

7 Achitectures the book Problem (in the book): system response time Solution: software architectures Simple: systems with low load and few constraints Complex: systems with high load and many constraints Complex architectures introduce additional costs Additional information (compulsory reading) Edward A. Lee Embedded software, Advances in computers, vol. 56, 2002, p

8 Embedded software Just software on small computers? Well Timeliness (software takes time, physical processes) Concurrency (network of sensors and actuators, tools) Liveness (Turing machines) Interfaces (temporal properties, combination of objects) Heterogeneity (programming languages) Reactivity (data streaming processing, adaptive) 8

9 Models of computation Definition: the laws governing component interactions Recommended model supporting concurrency =? Sequential computation Von Neumann architecture Successive transformation of the system state Distributed systems system state unknown System/modules can be expressed in various languages VHDL + FPGA reconfigurable components Java portability + security C efficient execution 9

10 Examples of models Dataflow LabView; synchronous, boolean, dynamic Time triggered clock, time triggered architecture, discrete time models, SystemC Synchronous/reactive Signals can have no value at various moments Token ring protocol for media access control Discrete events Events (value, time stamp) Process networks Components = processes, asynchronous communication Publish/subscribe mechanisms Connections are event streams Others: finite state machines, rendevous, continuous time 10

11 Publish subscribe mechanisms Each component Create data from a set of data types Consume data from a set of data types Central entity Data type associations with components Buffers and distributed data to them Architectures can be dynamically changed C1 C2 C3 C4 Blackboard 11

12 Round Robin architecture void main(void) while(true) if (!! I/O device A needs attention )!! Take care of device A and handle its data if (!! I/O device B needs attention )!! Take care of device B and handle its data if (!! I/O device Z needs attention)!! Take care of device Z and handle its data 12

13 RR Examples Digital multimeter Measure: resistance, current and potential For each situation select the right scale Washing machine Airbag controller Anything that displays information 13

14 Round Robin Evaluation Simplicity! No priorities, no interrupts, no data sharing bugs Suited for systems with no latency concerns Worst response time of task code = sum of all task code Alternative design: interleaving devices Fragile design: timing in future versions? A B C D A B A C A D 14

15 Outline Embedded system architectures Architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Task switching X32 15

16 Round Robin with Interrupts bool flaga=false, flagb=false,, flagz=false; void interrupt handlea (void)!! Take care of the I/O device A flaga = TRUE; void interrupt handlez (void)!! Take care of the I/O device Z flagz = TRUE; void main(void) while(true) if (flaga) flaga = FALSE!! Handle data from device A if (flagb) 16

17 RR ISR Characteristics Splits the work between interrupts and main Interrupts handle I/O of devices Main function deals with processing data Why use interrupts? Allow fast response time for handling I/O buffers (event based design vs. polling design) Set flags to indicate work has to be done Take advantage of the interrupt priority system Often the most appropriate architecture! 17

18 RR ISR Examples Systems with few components needing fast response time (limited processing needed) Most likely to be found in: Stopwatches Modern washing machines Coffee machines Microwave ovens Central heating units Traffic light controllers Other: data bridge devices and barcode scanners 18

19 RR ISR Evaluation Leads to a simple design (still ) Data sharing problem introduced All task codes have the same priority no long tasks!!! Worst response time = sum of all task code + ISR times Alternative designs: Move code in interrupts Interleaving devices in main() Fragile design: timing in future versions? Changing code or ISR priority for one device 19

20 Outline Architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Task switching X32 20

21 Function Queue Architecture!! Queue of function pointers void interrupt handlea(void)!! Take care of I/O device A!! Put functiona on queue of function pointers!! ISR for devices B Z void functiona(void)!! Handle actions required by A!! Functions for devices B Z void main(void) while(true) while (!! Queue of function pointers is empty) ;!! Call first function on the queue 21

22 FQ Evaluation Splitting of responsibilities similar to RR ISR Interrupts handle I/O of devices Main function deals with processing data (via functions) Insert operation for the queue was not specified! FIFO queue leads to RR ISR Priority queue leads to task priorities FQ architecture gives the basis for non preemptive OSes Worst response time = longest task + tasks with higher priority + ISR routines 22

23 Non preemptive scheduling First in First out scheduling algorithm Shortest Job First scheduling Shortest Remaining Time Scheduling Priority scheduling Multilevel queue scheduling 23

24 Performance comparison RR RR-ISR FQS High priority Low priority everything Dev. A ISR Dev. B ISR Dev. Z ISR Task code Dev. A ISR Dev. B ISR Dev. Z ISR Task code A Task code B Task code Z 24

25 Outline Embedded system architectures Architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Task switching X32 25

26 Real Time OS Architecture Characteristics Evolved from the FQ Architecture Contains a set of ISR (dealing with fast events from devices) Contains a set of tasks (one or more for each device) Signaling between ISRs and tasks is part of the OS No more while(1) loops in the main code > OS scheduler OS can stop a task to run another one (preemption) Terminology! 26

27 RTOS Evaluation System response is relatively stable Changing a piece of code has a reduced effect (changing lower priority tasks does not matter) RTOSes consume time themselves Synchronization mechanisms Task preemption Better response time vs. throughput Large number of RTOSes developed They come with an increasing set of tools 27

28 Task Synchronization Global data ( data sharing problem) Semaphores pend (semaphore, WAIT_FOREVER, err) block task post (semaphore) unblock task Queues, Mailboxes, and Pipes Synchronization + data communication No shared data problems unless you pass pointer to the original data in other task (cf. Fig. 7.4) Same pitfalls as semaphores (deadlock, etc.) 28

29 FIFO Queue Must be initialized #define MSGQ_SIZE 10 // max no of messages OS_EVENT* mymsgq; // msg Queue void* mymsgqdata[msgq_size]; // storage for msgs mymsgq = OSQCreate (mymsgqdata, MSGQ_SIZE); Can be used by the reading task msg = (char*) OSQPend(myMsgQ, WAIT_FOREVER, &err); Can be used by the writing task OSQPost(myMsgQ, (void*)msg); (uc/os, book pp. 333) 29

30 Mailbox Similar to queue Create, write, read But also check, destroy Some RTOS provide priorities in mailboxes But, Only 1 message (under X32) No blocking on the reader side (Queue WAIT_FOREVER timeout) void* OSMboxAccept (OSEvend* mbox); Blocking OSMboxPend ( ) 30

31 Pipe (not in X32 uc/os) Similar to queue and mailbox But, Variable length messages 31

32 Queue vs. Mailbox vs. Pipe Queues for FIFO communication Mailboxes for non blocking communication Communication according to priorities Pipes for Variable length messages Huge overhead compared with global variables! 32

Task Synchronization Pitfalls Typically no protection of queues, mailboxes, pipes Any task can use them any time Is the right task writing to/reading from the right communication channel?

33 Task Synchronization Pitfalls Typically no protection of queues, mailboxes, pipes Any task can use them any time Is the right task writing to/reading from the right communication channel? Pointer problems Passing pointers to a communication channel can create data sharing problems Type and length of messages Write an integer/read a byte! Potential memory leaks Malloc/free Space problems What if queue is full? some recovery mechanism! 33

34 Choosing the right architecture Select the simplest one! Think of the model first Writing code for ES is complicated enough Remember: customers will want more features in version 2! Use an RTOS if the system needs real time response Make use of the offered tools rather than reinventing them Your system will most likely require a hybrid architecture 34

35 Outline Embedded system architectures Architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Task switching X32 35

36 Task switching Switching from current context (PC, stack, registers) to another Context Thread identity > multithreading Needs two constructs: Initialize a context Switch to a context Often used (standard C library): setjmp, longjmp X32 void *stack[1024] init_stack(stack, (void*)task, (void *)0); context_switch(new_context, &old_context) 36

37 Simple example X32 void **thread_main, **thread_a; void *stack_a[1024]; int main(void) thread_a = init_stack(stack_a, task_a); printf("now in thread_main\r\n"); context_switch(thread_a, &thread_main); printf("back in main thread\r\n"); void task_a(void) printf("now in thread_a\r\n"); context_switch(thread_main, &thread_a); 37

38 Time Slicing Example (1) void **thread_main, **thread_a; void *stack_a[1024]; int thread_id; void isr_timer(void) if (thread_id==0) thread_id = 1; context_switch(thread_a, &thread_main); else thread_id = 0; context_switch(thread_main, &thread_a); 38

39 Time Slicing Example (2) int main(void) thread_a = init_stack(stack_a, task_a); thread_id = 0; // now in main!! set timer to interrupt every 10ms while(true) printf("now in thread_main\r\n"); void task_a(void) while(true) printf("now in thread_a\r\n"); 39

40 Conclusions Architectures: Round Robin Round Robin with Interrupts Function Queue Real Time Operating Systems Some task synchronization mechanisms Task switching X32 Conclusion: Choose the simplest architecture for your system Keep in mind that design requirements will change 40

41 X32: Demo Demo.. (x32_projects.tgz, fqs.c, rrobin.c, rrobin2.c, rrobinisr.c, slicing.c) 41

Embedded Software TI2726 B. 4. Interrupts. Koen Langendoen. Embedded Software Group

Embedded Software TI2726 B. 4. Interrupts. Koen Langendoen. Embedded Software Group Embedded Software 4. Interrupts TI2726 B Koen Langendoen Embedded Software Group What is an Interrupt? Asynchronous signal from hardware Synchronous signal from software Indicates the need for attention