INTRODUZIONE AI SISTEMI OPERATIVI EMBEDDED

Transcript

1 1 INTRODUZIONE AI SISTEMI OPERATIVI EMBEDDED ROUND ROBIN ROUND ROBIN CON INTERRUPT FUNCTION QUEUE SCHEDULING REAL TIME OPERATING SYSTEMS (RTOS) INTERRUPT PROGRAMMATI: TIMER

2 INTRODUZIONE 2 In relazione al funzionamento reale delle applicazioni su sistemi embedded il comportamento delle applicazioni viste finora non era realistico. L architettura software prevedeva l esecuzione di un certo numero di task e dopodiché l applicazione si considerava conclusa. In applicazioni reali il sistema funziona a partire dall accensione fino al venir meno dell alimentazione o fino al reset. Esistono architetture software che implementano tale funzionamento, a partire dalle più semplici in assoluto fino ai sistemi operativi real time (cenni). I due esempi più semplici di architettura software per sistemi embedded sono: round robin; round robin con interrupts.

3 3 ROUND ROBIN

4 ARCHITETTURA SOFTWARE ROUND ROBIN 4 La più semplice architettura software è definita round robin. Un loop infinito si occupa di interrogare a turno (polling) ciascuna delle periferiche di I/O e di eseguire le routine associato ogni qualvolta sia necessario.

5 APPLICAZIONE DI ESEMPIO: ROUND ROBIN 5

6 PRO e CONTRO Vantaggi: è l architettura software più semplice. Limiti: funziona bene sotto particolari condizioni: poche porte di I/O; elaborazioni brevi; vincoli di tempi di risposta in I/O non stringenti. Se uno degli ingressi richiede tempi di risposta inferiori al tempo di risposta del sistema nel caso peggiore, il sistema non funziona. E sufficiente che uno dei task abbia una durata elevata, affinché il sistema diventi inservibile, pur continuando a funzionare. La struttura del software non è robusta: può essere sufficiente l inserimento si una sola nuova periferica da gestire per modificare la risposta temporale complessiva in maniera inaccettabile. 6

7 7 ROUND ROBIN CON INTERRUPT

8 ARCHITETTURA SOFTWARE ROUND ROBIN CON INTERRUPTS (1) 8 Gli interrupt presentano un incremento di complessità a livello architetturale, ma offre sicuramente più vantaggi. La struttura dell architettura prevede che: le routine di interrupt (Interrupt Service Routine - ISR) si occupino di servire le incombenze urgenti legate alle periferiche di I/O settando i flag ogni qualvolta viene acquisito/spedito un dato; Il loop principale interroga i flag associati alle ISR ed esegue le elaborazioni associate solo quando necessario. Il vantaggio fondamentale è che tramite questa architettura software si può introdurre una priorità nella gestione dei task. La gestione dei dati sotto interrupt introduce un problema sostanziale che è quello della condivisione fra i dati fra applicazione principale (main) routine di interrupt.

9 ARCHITETTURA SOFTWARE ROUND ROBIN CON INTERRUPTS (2) 9

10 GESTIONE DEI DATI CONDIVISI 10 Il problema fondamentale di questo tipo di architettura software deriva dai malfunzionamenti causati dall accesso asincrono ai dati condivisi di programma principale e routine di interrupt. APPLICAZIONE D ESEMPIO: Supponiamo di utilizzare un sistema embedded per acquisire dei valori fisici di temperatura da dei sensori posti in diversi punti di un reattore nucleare. Un allarme deve essere sollevato se le temperature rilevate non sono uguali. L acquisizione avviene tramite interrupt. La segnalazione dell allarme nella routine principale. Supponiamo inoltre di monitorare la temperatura solo tramite due sensori e che, per semplicità, venga omessa la gestione dei flag.

11 APPLICAZIONE DI ESEMPIO: ROUND ROBIN + INT (1) 11

12 APPLICAZIONE DI ESEMPIO: ROUND ROBIN + INT (2) 12 Se si verificassero le seguenti condizioni in contemporanea: 1) un interrupt viene sollevato fra l esecuzione delle due istruzioni che assegnano le temperature rilevate dai sensori alle variabili temporanee temp1 e temp2 del programma principale; 2) le due nuove temperature rilevate, pur rimanendo uguali fra loro, sono cambiate rispetto alle temperature che erano state rilevate durante la precedente esecuzione della ISR. Si assiste alla generazione di un FALSO ALLARME.

13 APPLICAZIONE DI ESEMPIO: ROUND ROBIN + INT (3) 13 Teoricamente si potrebbe pensare di ottimizzare l architettura software ma ciò non servirebbe. Perché? NON SERVE PERCHE' LE ROUTINE DI INTERRUPT POSSONO INTERROMPERE IL PROGRAMMA FRA 2 DELLE ISTRUZIONI ASSEMBLY CHE IMPLEMENTANO IL TEST DI UGUAGLIANZA

14 APPLICAZIONE DI ESEMPIO: ROUND ROBIN + INT (4) 14 Questo problema si verifica a causa della condivisione dei dati. Il pezzo di codice del programma principale la cui interruzione può generare il problema viene definito critical section. La soluzione di tale problema è la disabilitazione degli interrupt all ingresso della sezione critica.

15 PRO e CONTRO (1) 15 Svantaggi: sicuramente più complessa della round robin; tutti i task del programma principale vengono gestiti con la stessa priorità; poca stabilità del codice: se si modifica il codice di un task si influenza il tempo di risposta degli altri. Esempio: Supponiamo di avere nel programma principale tre task (A, B e C) eseguiti nell ordine: A, B, C. Se gli interrupt associati ad A, B e C si verificano tutti all inizio dell esecuzione del programma principale: il tempo di attesa per eseguire il task A è pari alla somma dei tempi di esecuzione delle routine di interrupt associate ad A, B e C; il tempo di attesa per eseguire il task B è pari alla somma del tempo di esecuzione del task A più i tempi di esecuzione delle routine di interrupt associate ad A, B e C; il tempo di attesa per eseguire il task C è pari alla somma del tempo di esecuzione dei task A e B più i tempi di esecuzione delle routine di interrupt associate ad A, B e C.

16 PRO e CONTRO (2) Ovviamente questo crea dei problemi perché il tempo di attesa di C (caso peggiore) potrebbe essere inaccettabile per le sue specifiche di temporizzazione. Nel qual caso si potrebbe pensare di cambiare l ordine in cui il programma principale schedula i task mettendo C per primo (e.g C, A, B) ma questo impatta sui tempi di attesa di A e B a cui va sommato il tempo di esecuzione di C e non è detto che questa soluzione sia a sua volta accettabile. 16 Supponiamo che sia accettabile ma che sia necessario aggiungere un controllo al task C, aumentando il suo tempo di esecuzione di un fattore, il tempo di attesa per eseguire il task B (pari alla somma del tempo di esecuzione dei task C e A più i tempi di esecuzione delle routine di interrupt associate ad A, B e C più ) potrebbe solo a questo punto diventare inaccettabile. Per cui questa architettura software non è robusta.

17 17 FUNCTION QUEUE SCHEDULING

18 ARCHITETTURA SOFTWARE FUNCTION QUEUE SCHEDULING Le varie routine di interrupt comunicano al programma principale la necessità di eseguire il task di elaborazione associato non più settando un flag ma inserendo (PUSH) un puntatore al task da eseguire, associato alla routine di interrupt in fase di richiesta, in una coda di puntatori a funzioni. Il programma principale deve leggere dalla coda un puntatore ed eseguire il codice del task ad esso associato. Dove sta il vantaggio rispetto a prima? NESSUNA REGOLA MI DICE CHE DEVO PER FORZA LEGGERE DALLA CODA LE FUNZIONI NELL'ORDINE IN CUI VI SONO STATE INSERITE POSSO QUINDI PRIVILEGIARE (IN MANIERA ORDINATA E SISTEMATICA) I TASK CON UNA PRIORITA' MAGGIORE. POSSO ADDIRITTURA MODIFICARE LA PRIORITA' A TEMPO DI ESECUZIONE ADATTANDOMI AD EVENTUALI MODIFICHE DELLE CONDIZIONI AL CONTORNO IN MANIERA DINAMICA Il tempo di risposta nel caso peggiore per il task a priorità più elevata è pari al tempo di esecuzione del task più lento più la somma dei tempi delle routine di interrupt. Ovviamente anche una architettura software fatta in questa maniera non è estremamente stabile perché modificando il tempo di esecuzione di uno qualsiasi dei task si influenza necessariamente il tempo di attesa degli altri, ma il fatto di poter gestire le priorità a runtime consente di arginare la non ammissibilità ci certe situazioni. 18

19 19 REAL TIME OPERATING SYSTEMS (RTOS)

20 ARCHITETTURA SOFTWARE RTOS (1) 20 Le routine di interrupt, come nelle altre architetture software, anche qui si occupano delle operazioni più urgenti (I/O) e segnalano al programma principale che deve essere eseguito il task a loro associato. Le differenze sono: 1) la comunicazione fra ISR e programma principale è gestita dal sistema operativo; 2) la sequenza di esecuzione dei task è gestita dal sistema operativo, non esistono loop o codici in cui il programmatore possa gestire in maniera esplicita lo scheduling. IL CODICE DEL RTOS SI OCCUPA DELLO SCHEDULING DEI TASK, GESTENDO LE PRIORITA' DI ESECUZIONE NELLA MANIERA PIU' APPROPRIATA 3) Il RTOS può gestire la sospensione di un task per eseguirne uno a priorità più elevata.

21 ARCHITETTURA SOFTWARE RTOS (2) 21 Le prime due differenze forniscono dei vantaggi legati alle modalità di programmazione, semplificando ovviamente il compito del programmatore. La terza differenza è sostanziale, perché non solo le routine di interrupt possono sospendere un task ma anche altri task a priorità più alta. Quindi un architettura software di questo tipo è in grado di gestire una priorità di esecuzione sistematica non solo delle routine di interrupt, ma anche dei task del programma principale. Il tempo di risposta nel caso peggiore per il task a priorità più elevata si riduce alla somma dei tempi di esecuzione delle routine di interrupt, quindi questa architettura guadagna non solo in termini di flessibilità ma anche in termini di robustezza, perché modificando il tempo di esecuzione di un task in negativo non si impatta sul tempo di risposta di un task a priorità più elevata. Altro vantaggio è che gli RTOS sono prodotti commerciali, quindi posso abbattere i tempi di sviluppo di un sistema embedded a costi ragionevoli o nulli (codice freeware). Lo svantaggio è che ovviamente l esecuzione stessa del RTOS è time consuming quindi sottrarrà del tempo all elaborazione.

22 RIASSUMENDO 22

23 23 INTERRUPT PROGRAMMATI: TIMER

24 FUNZIONALITA DEL TIMER (1) Le specifiche di temporizzazione legate alla gestione real-time dell interazione con l ambiente esterno, rendono spesso indispensabile l utilizzo di meccanismi per consentire l esecuzione di determinati task (e.g. acquisizione dati, scrittura su periferiche, etc ) in maniera asincrona rispetto al ciclo di esecuzione del programma principale. Questa problematica si gestisce tramite l impiego di interrupt e nel caso in cui la gestione real-time richieda lo svolgimento di determinate operazioni con una temporizzazione predefinita sarà necessario disporre di una periferica che comunichi tale esigenza al processore. In pratica si deve predisporre un modulo programmabile che generi le interruzioni a frequenza predefinita. Tipicamente si usa un timer. Il timer è programmabile via software e a livello hardware è un contatore, che conta i cicli di clock in ingresso generando un segnale di interrupt a ogni fine conteggio. 24

25 FUNZIONALITA DEL TIMER (2) 25 ES: ISR Compia immediata dei dati in I/O in modo di rilassare le specifiche di temporizzazione sul programma principale. Programma Principale Si occupa della gestione effettiva de dati di I/O, pena la perdita delle informazioni. La Routine di Interrupt deve comunicare la necessità dell intervento del programma principale tramite il settaggio di una zona di memoria condivisa ad hoc.

26 MODELLO Nella nostra piattaforma di simulazione il timer è una periferica memory-mapped, dotata di un registro di stato leggibile dal processore e parzialmente scrivibile e di una uscita di interrupt. Il clock che il timer riceve in ingresso per il conteggio non è il global clock ma un altro segnale di clock inserito ad hoc nel sistema (sample clock). 26

27 STATUS REGISTER DI UN TIMER 27 Nello status register vengono conservate le informazioni circa: bit [15:0] - il numero di cicli del conteggio (scrivibile dal processore); bit [30] - lo stato di abilitazione del timer (scrivibile dal processore), codifica: 1 = ABILITATO, 0 = DISABILITATO; bit [31] - richiesta di interrupt pendente (leggibile dal processore). I campi scrivibili dal processore sono necessari a settare l intervallo di interrupt e gestire la sua abilitazione/disabilitazione. Il bit leggibile serve a segnalare l interrupt e viene usato dal processore per capire quale è la periferica che ha sollevato la richiesta di interruzione nel caso ce ne fossero n abilitate.

28 TIMER: CODIFICA VERILOG (1) 28 //supponendo che timer_reg_addr sia l indirizzo di memoria in cui è //stato mappato il timer or timer_reg) case (RWAddr) timer_reg_addr: to_data_bus = timer_reg; default: to_data_bus = 32'bX; endcase clk) if( rst == 1'b1) // sul reset i 30 bit bassi vengono posti a zero //il processore scrive su 31 e legge il 32esimo writable_timer_reg = 30'h0; else //scrittura da parte del processore se l indirizzo sul bus è quello //della periferica e se c è l abilitazione della scrittura if (RWAddr == timer_reg_addr) begin if (we) begin writable_timer_reg = from_data_bus[30:0]; end end

29 TIMER: CODIFICA VERILOG (2) 29 //definizione dello status reg assign timer_reg[30:0] = {writable_timer_reg}; assign timer_reg[31] = pending_int_flag; //abilitazione assign int_enable = timer_reg [30] ; //periodo assign int_period = timer_reg[15:0];... //count_rst generator process or rst) if ((rst!= 1'b0) (int_enable!= 1'b1)) count_rst = 1; else count_rst = 0;

30 TIMER: CODIFICA VERILOG (3) 30. sample_clk) begin //pending_int_flag set generator process if (count_rst ==1'b1) count = 1'b0; else if (count == int_period) begin count = 0; pending_int_flag_set = 1'b1; end else begin count = count + 1; pending_int_flag_set = 1'b0; end end.

31 TIMER: CODIFICA VERILOG (4) 31. clk) begin //pending_int_flag_reset generator process if( rst == 1'b1) //sul reset non c è interrupt pendente pending_int_flag_reset = 1'b0; else begin //leggo il timer quindi posso resettarne il valore if (RWAddr == (timer_reg_addr)) begin pending_int_flag_reset= 1'b1; end else begin

32 TIMER: CODIFICA VERILOG (5) 32 clk) //pending_int_flag generator process if( rst == 1'b1) pending_int_flag = 1'b0; else casex ({pending_int_flag, pending_int_flag_set, pending_int_flag_reset}) 3'bxx1: int_flag = 1'b0; 3'b1x0: int_flag = 1'b1; 3'b010: int_flag = 1'b1; 3'b000: int_flag = 1'b0; default: int_flag = 1'b0; endcase

33 SCHEMA A BLOCCHI ARCHITETTURA SOFTWARE 33

34 GESTIONE SW DEL TIMER 34 void drv_t0_init(int period) { int *t0_status_p ; t0_status_p = (int*) t0_status_addr; *t0_status_p = (int) period; } void drv_t0_enable(void) { int *t0_status_p = (int*) t0_status_addr; int mask, temp; mask = 0x ; //maschera a 32 bit tutti zeri tranne il penultimo //(enable) temp = *t0_status_p; *t0_status_p = (int) mask temp; // in or quindi forzo un 1 nel penultimo bit } void drv_t0_disable(void) { int *t0_status_p = (int*) t0_status_addr; int mask, temp; mask = 0xBFFFFFFF; //maschera a 32 bit tutti uno tranne il penultimo //(enable) temp = *t0_status_p; *t0_status_p = (int) mask & temp; // in and quindi forzo uno 0 nel penultimo bit }

35 SELEZIONE DELLA SORGENTE DI INTERRUPT 35 Ho solo due sorgenti di Interrupt ;salva registri sw $2,0x3020($0); salva $2 sw $3,0x3024($0); salva $3 li $2, 0x ; crea la maschera su $2. ; la maschera è lw $3,0x4010($0) ; copio T0_status_reg su $3 and $3,$3,$2 ; maschero il valore di $3 con $2 ; rimane solo il bit 31 eventualm diverso da zero ; se c'è interrupt (bit 31!=0) salta alla routine associata a T0 bnez $3, T0_INT_ROUTINE ; se non era T0 è sicuramente T1 lw $3,0x4018($0) ; copia T1_status_reg su $3 j T1_INT_ROUTINE ; salta alla routine associata a T1

36 ROUTINE: LETTURA DI UN DATO DA UNA PERIFERICA 36 T0_INT_ROUTINE: ; supponendo la periferica mappata in 4000 lw $3,0x4000($0) ; copio il contenuto di CH0 reg (il dato in input) su $3 ; supponendo il buffer associato a tale periferica mappato in 3008 sw $3,0x3008($0); copio su buffer0 il dato in input li $2,1 ; setta il flag_0 a 1 sw $2,0x3000($0) ; setta il task0_flag in modo che il task princ legga i dati j RETURN_TO_MAIN

37 PIATTAFORMA D ESEMPIO 37

38 ES.0 - DESCRIZIONE 38 Un solo canale di input viene utilizzato per monitorare la temperatura dell environment. Il valore di ingresso viene campionato sotto interrupt ad intervalli regolari, essendo stato abilitato il timer 0, e viene scritto in una locazione di memoria condivisa col programma principale. La ISR, oltre a campionare i dati, setta il flag di comunicazione alto ogni qualvolta effettua una lettura. Il task del programma principale (unico in questo primo esempio), quando riceve la segnalazione di avvenuto interrupt copia il dato dalla singola locazione condivisa in un vettore (allocato nello stack) che tiene conto degli ultimi N dati campionati. Quando questo vettore è pieno, il programma principale calcola la media e se è superiore ad una soglia predeterminata segnala una condizione di allarme sul canale di output.

39 ES.0 MAPPA DELLA MEMORIA 39

40 ES.0 MAIN 40 drv_t0_init(50); drv_t0_enable(); while(1) { if((*p_task0_flag) == 1){ // copia i singoli sample acquisiti nel vettore copy_ch0_sample(index, temp_samples_vector, temp_samples_vector_dim); if (index == temp_samples_vector_dim-1) { index = 0; somma_temp = elab_samples_sum(temp_samples_vector, temp_samples_vector_dim); media_temp = somma_temp>>temp_samples_vector_dim_log; if( media_temp > (25)) { drv_ch2_write(0); drv_ch2_write(media_temp); } } else { index++; } *p_task0_flag = (int) 0; } }

41 ES.0 ISR (1) 41 INT_SELECT_ROUTINE : sw $2,0x3020($0); salva $2 sw $3,0x3024($0); salva $3 li $2, 0x ; crea la maschera su $2. la maschera è lw $3,0x4010($0) ; copio T0_status_reg su $3 ; maschero il valore di $3 con $2, rimane solo il bit 31 eventualm diverso da zero and $3,$3,$2 bnez $3, T0_INT_ROUTINE ; se c'è interrupt salta alla routine associata a T0 lw $3,0x4018($0) ; copia T1_status_reg su $3 j T1_INT_ROUTINE ; salta alla routine associata a T1 T0_INT_ROUTINE: lw $3,0x4000($0) ; copio il contenuto di CH0 reg (il dato in input) su $3 sw $3,0x3008($0); copio su buffer0 il dato in input li $2,1 sw $2,0x3000($0) ; setta il task0_flag in modo che il progr princ legga i dati j RETURN_TO_MAIN

42 ES.0 ISR (2) 42 T1_INT_ROUTINE: ; nel primo esempio è vuota perché c è una sola periferica temporizzata RETURN_TO_MAIN: lw $2,0x3020($0) ;ripristina $2 lw $3,0x3024($0) ;ripristina $3 rfe ;restituisce il controllo del flusso di esecuz al programma principale con rfe

43 ES.1 GESTIONE DI DUE PERIFERICHE TEMPORIZZATE 43 Per gestire due periferiche temporizzate è necessario completare la routine si selezione della periferica che ha generato l niterrupt (T1_INT_ROUTINE) La seconda periferica va mappata in memoria in maniera coerente con la mappa fornita già per ES.0 e ovviamente nel main va aggiunto il task di gestione di questa seconda periferica.

44 ES.2 DISACCOPPIAMENTO ISR/MAIN La gestione dell I/O tramite interrupt è tanto più efficace quanto più disaccoppiata è l acquisizione dei dati rispetto alla loro gestione. Quindi acquisirne uno alla volta e poi interpellare il processore non è sicuramente un disaccoppiamento sufficiente per questa applicazione che poi calcola la media di un set di valori. Sarebbe meglio acquisire tutto il set e poi chiamare il processore quando può calcolare la media sul set. Per fare ciò si utilizza una FIFO circolare. 44

45 ES.2 GESTIONE FIFO CIRCOLARE Per accedere alla FIFO si utilizzano due puntatori: P_YOUNG punta alla prima locazione scrivibile e viene utilizzato dalla ISR per aggiungere un dato al vettore condiviso P_OLD punta alla locazione scritta da più tempo e viene utilizzato dal programma principale per leggere il vettore condiviso senza perdere dati Se la FIFO circolare è allocata da 3100 a 31FC, la gestione circolare prevede che: i due puntatori vengano inizializzati a 100; ad ogni interrupt P_YOUNG venga incrementato di 4 (1 WORD = 4 BYTE); quando il programma principale viene triggerato P_OLD viene incrementato di N*4 (N = dati prelevati in contemporanea); incremento: IF (POINTER == 31FC) POINTER = 3100; ELSE POINTER++; 45

46 ES.2 MAIN 46 drv_fifo0_init(); drv_t0_init(num_conteggi); while(1) { if((*p_task0_flag) == 1){ // acquisisce la temperatura copy_ch0_samples_vector(temp_samples_vector, temp_samples_vector_dim); // calcola la somma dei campioni somma_temp = elab_samples_sum(temp_samples_vector, temp_samples_vector_dim); media_temp = somma_temp >> temp_samples_vector_log; if( media_temp > 20 ){ drv_ch2_write(0); drv_ch2_write(media_temp); } *p_task0_flag = (int) 0; } }

47 ES.2 ISR (1) 47 T0_INT_ROUTINE: lw $3,0x4000($0) ; copio il contenuto di CH0 reg (il dato in input) su $3 ; scrivo su $2 l'ind del primo elemento libero del CH0 buffer - p_young lw $2,0x3008($0) sw $3,0x0($2); copio sul primo elemento libero del CH0 buffer il dato in input ; aggiorno il puntatore al primo elemento libero del CH0 buffer li $3,0x31FC; carico su $3 l'indirizzo più alto del buffer ; se l'indirizzo del top del buffer è uguale all'indirizzo più alto disponibile aggiorna in ; maniera circolare beq $2,$3,CH0_SPECIAL_INCREMENT j CH0_STANDARD_INCREMENT CH0_SPECIAL_INCREMENT: ; setta il puntatore al fondo del buffer addi $2,$0,0x3100 j END_CH0_INT_ROUTINE CH0_STANDARD_INCREMENT: ; incrementa il puntatore di una posizione addi $2,$2, 0x0004

48 ES.2 ISR (2) 48 END_CH0_INT_ROUTINE: sw $2,0x3008($0); salva il valore del puntatore young lw $3,0x3018($0) ; copio il valore del num di elementi contenuti nella pila in $3 ; scrivo il num di elementi contenuti da leggere in una sola volta per il task0 +1 = ; temp_samples_vector_dim+1 li $2,33 beq $2,$3, SET_FLAG0 ; li ho letti tutti e ho anche incrementato per questo +1 j RETURN_TO_MAIN SET_FLAG0: li $2,1 sw $2,0x3000($0) ; setta il task0_flag in modo che il progr princ legga i dati j RETURN_TO_MAIN T1_INT_ROUTINE: RETURN_TO_MAIN: lw $2,0x3020($0) ;ripristina $2 lw $3,0x3024($0) ;ripristina $3 rfe ;restituisce il controllo del flusso di esecuz al programma principale con rfe