Verifica di programmi C con SPIN

Transcript

1 Verifica di programmi C con SPIN

2 Importanza delle astrazioni Astrazione (perdita di dettaglio) è un concetto cruciale nella verifica Per individuare una buona astrazione bisogna tener conto sia della proprietà da verificare che delle risorse a disposizione Non tutto può essere automatizzato il giudizio umano è necessario per effettuare delle scelte effettuate le scelte il resto del procedimento di astrazione può essere meccanizzato Obiettivo: estrarre automaticamente un modello astratto dal source code, seguendo funzioni di astrazione definite dall'utente

3 Estrazione di modelli PROMELA da C #include <stdio.h> int main(void) { int lower, upper, step; float fahr, celsius; lower = 0; upper = 300; step = 20; fahr = lower; } while (fahr <= upper) { } celsius = (5.0/9.0) * (fahr ); printf("%4.0f %6.1f\n", fahr, celsius); fahr = fahr + step;

4 Control-flow: nessun problema Strutture di controllo di Promela (eccetto chiamate ricorsive) sono tipiche della programmazione strutturata fahr = lower; do od :: (fahr <= upper) -> celsius = (5/9) * (fahr-32); printf("%d %d\n", fahr, celsius); fahr = fahr + step; :: else -> break

5 Costrutti e definizioni non supportate in Promela Occorre basarsi sull'astrazione Ad es. possiamo definire un'astrazione del tipo: "ogni float è mappato a int" o addirittura "a bool" Questo non è sempre la cosa più conveniente a volte è preferibile avere un modello che sia il più vicino possibile al sistema ad es. possiamo mantenere i dati e le computazioni su float Possiamo sfruttare il fatto che SPIN genera codice C da Promela (pan.c) per eseguire la verifica Infatti, è possibile includere parti di codice C in un programma Promela con l'istruzione c_code

6 Parole chiave c_code e c_expr c_code { celsius = (5/9) * (fahr-32); }; il codice contenuto nel blocco preceduto da c_code, viene considerato trusted da SPIN è quindi non viene verificato e non viene neanche analizzato dal suo parser versione con guardia: c_code [fahrtocelsius]{ celsius = (5/9) * (fahr-32); }; dove fahrtocelsius è una qualsiasi espressione condizionale se fahrtocelsius è vera, allora si esegue il codice in {.. } altrimenti, l'esecuzione prosegue come se si violasse un'asserzione c_expr è analogo a c_code, usato per espressioni che non possono essere espresse direttamente in Promela

7 Parola chiave c_state possiamo includere variabili usate nella porzione di codice in C nello stato del modello Promela c_state "float fahr" "Local main" c_state "float celsius" "Local main" dicono che le dichiarazioni "float fahr" e "float celsius" devono essere inserite nella dichiarazione del proctype main con visibilità locale in questo caso, il blocco c_code di prima va modificato per dire che celsius e fahr sono variabili importate definite localmente in proctype main c_code { Pmain->celsius = (5/9) * (Pmain->fahr-32); } c_state può comparire solo fuori da ogni proctype (globale);

8 Parola chiave c_state c_state può essere seguito da 2 o 3 stringhe tra doppi apici la prima riporta la dichiarazione in C della variabile la seconda riporta lo scope della variabile la terza è opzionale e viene usata per specificare un valore iniziale sono possibili 3 scope: Global, Local e Hidden. se viene usato Local, questo deve essere seguito dal nome del proctype in cui la dichiarazione deve comparire se viene usato "Hidden" la variabile sarà dichiarata globale ma ma non farà parte dello stato del modello

9 Parola chiave c_decl c_decl è usato per dichiarare nuovi tipi in C che vengono usati in altri punti del codice (tipi definiti con typedef) ad es. c_decl { typedef struct Pair { int x; int y;} Pair; } ma anche c_decl { \#include "types.h"} può comparire solo fuori da ogni proctype (globale);

10 Parola chiave c_track c_track è usato per dichiarare che una variabile (definita in qualsiasi modo) o più in generale un pezzo di memoria fa parte dello stato del modello ha due parametri: indirizzo iniziale e taglia (in numero di byte) della memoria da considerare ad es. c_code { Pair p;} ; c_track "&p" "sizeof(pair)" può comparire solo fuori da ogni proctype (globale); SPIN codifica il verificatore in modo che ogni variabile dichiarata c_track viene copiata e cancellata dallo stato del modello nelle esplorazioni dello spazio degli stati cancellazioni/copie impiegano tempo preferibile usare c_state se possibile

11 Note le primitive di Promela per includere codice C sono pensate per l'estrazione di modelli da programmi C i frammenti di codice C non sono analizzati da SPIN né come parsing né come verifica il codice viene inglobato nel verificatore generato da SPIN e quindi vengono dati in pasto direttamente al compilatore (il significato è ottenuto tramite il compilatore C) quando viene eseguita una traccia d'errore tuttavia questi frammenti di codice C vengono eseguiti e quindi gli stati (incluse le variabili importate dai frammenti) possono essere visualizzati in tutte le componenti

12 Estrazione automatica di modelli: Modex Modello estratto con Modex da esempio conversione temperature: c_state "float fahr" "Local main" c_state "float celsius" "Local main" active proctype main() { } int lower; int upper; int step; c_code { Pmain->lower=0; }; c_code { Pmain->upper=300; }; c_code { Pmain->step=20; }; c_code { Pmain->fahr=Pmain->lower; }; do :: c_expr { (Pmain->fahr <= Pmain->upper) }; c_code { Pmain->celsius = ((5.0/9.0)*(Pmain->fahr-32.0)); }; c_code { Printf("%4.0f %6.1f\n", Pmain->fahr, Pmain->celsius); }; c_code { Pmain->fahr = (Pmain->fahr+Pmain->step); }; :: else -> break od

13 Note modello costruito da Modex: fa in modo che tutte le variabili abbiano il prefisso appropriato usa Printf una funzione predefinita di SPIN che: sopprime le chiamate a printf quando SPIN visita lo state space durante la verifica esegue printf quando avviene simulazione su traccia d'errore con file.trail SPIN non controlla il contenuto del codice C incorporato nel modello Promela (possono annidarsi errori) le versioni di c_code e c_expr con condizione, possono essere usate per testare precondizioni (embedded assertions)

14 Embedded assertion c_state "int *ptr;" "Local main"... c_code [Pmain->ptr!= NULL] { *(Pmain->ptr) = 5; }; codice viene eseguito a patto che il puntatore non sia nullo c_code { int *ptr; int x[256]; int j; };... c_code { ptr = x; }; if :: c_expr [j >= 0 && j < 256] { x[j]!= 25 } -> c_code [ptr >= x && ptr < &(x[256])] { *ptr = 25; } :: else fi prima condizione testa che indice array è entro i limiti seconda condizione stessa cosa ma per accesso tramite puntatore

15 Traduzione di default di Modex Modex se non vengono passate delle astrazioni definite dall'utente esegue una trasformazione di default: ogni instruzione del codice che non ha un equivalente in Promela viene semplicemente inglobata usando le primitive c_code, c_expr, c_state, c_decl e c_track le astrazioni per le istruzioni non esprimibili in Promela possono essere espresse in forma tabulare (lookup table) prima colonna contiene l'istruzione C seconda colonna come lo vogliamo rimpiazzare nel modello

16 Modex lookup table di default tavola usata da Modex per l'estrazione del modello dal programma di conversione temperature: 1. (fahr<=upper) 2.!(fahr<=upper) 3. lower=0 4. upper= step=20 6. fahr=lower 7. fahr=(fahr+step) 8. celsius=((5/9)*(fahr-32)) 9. printf("%4.0f %6.1f\n",fahr,celsius) c_expr { (Pmain->fahr<=Pmain->upper) } else c_code { Pmain->lower=0; } c_code { Pmain->upper=300; } c_code { Pmain->step=20; } c_code { Pmain->fahr=Pmain->lower; } c_code { Pmain->fahr=(Pmain->fahr+Pmain->step); } c_code { Pmain->celsius=((5.0/9.0)*(Pmain->fahr-32.0)); } c_code { Printf("%4.0f %6.1f\n", \ Pmain->fahr, Pmain->celsius); }

17 Sovrascrittura delle traduzioni di default ogni regola di default usata da Modex può essere forzata stabilendo una nuova regola di conversione Ad es. rimpiazziamo le variabili con una versione int: Declare int fahr main Declare int celsius main Declare int upper Declare int lower Declare int step main main main Declare deve essere seguito da tre campi separati da tab nome tipo di dati nome variabile scope della variabile (se è locale indicare nome proctype, si usa la parola chiave Global per globale)

18 Sovrascrittura delle traduzioni di default per effetto della nuova definizione molte istruzioni del programma C possono essere interpretate direttamente in Promela si usa la parola chiave keep Le prime 7 entry della tabella diventano: 1. (fahr<=upper) 2.!(fahr<=upper) 3. lower=0 4. upper= step=20 6. fahr=lower 7. fahr=(fahr+step) keep else keep keep keep keep keep

19 Sovrascrittura delle traduzioni di default l'istruzione "celsius=((5/9)*(fahr-32))" deve essere modificata in "celsius=((fahr-32)*5)/9" in quanto ora "/" è una divisione intera nella printf occorre sostituire i marcatori di conversione con %d 8. celsius=((5/9)*(fahr-32)) 9. printf("%4.0f %6.1f\n",fahr,celsius) regola seguita da Modex: cerca per una entry nella prima colonna della tabella fornita dall'utente se trova il testo ricercato, usa la traduzione data altrimenti usa la regola di default celsius=((fahr-32)*5)/9 printf("%d %d\n",fahr,celsius)

20 Modello ottenuto con nuove regole active proctype main() { int step; int lower; int upper; int celsius; int fahr; lower = 0; upper = 300; step = 20; fahr = lower; do :: (fahr<=upper); celsius = ((fahr-32)*5)/9; printf("%d %d\n", fahr, celsius); fahr=(fahr+step) :: else -> break od }

21 Astrazione di programmi astrazione è una funzione α: dominio concreto dominio astratto ad es.: funzione definita tramite una Modex lookup table P: programma del dominio concreto ad es.: programma C α(p): programma del dominio astratto ottenuto tramite α ad es.: modello Promela di P ottenuto tramite la lookup table α L: proprietà logica ad es.: formula LTL su simboli di P per effetto dell'astrazione L può non essere definita per α(p) e può necessitare trasformare consistentemente L in α(l) ad es.: L può far riferimento ad una program location cancellata da α α(l) è quindi un'astrazione di L, il corrispondente di L tramite α nel dominio astratto

22 Astrazione di programmi denotato con α l'inverso di un'astrazione α, si ha che per ogni istruzione s: s α(α(s)) Vale quanto segue: per ogni computazione π di P, α(π) definisce un'unica computazione di α(p) corrispondente e per ogni esecuzione di π' in α(p), α(π') definisce un insieme di sequenze di istruzioni di P corrispondenti Un'astrazione rimuove dettaglio: una sequenza di α(π') può non corrispondere ad alcuna esecuzione di P in ogni caso, esiste almeno una sequenza di α(π') che corrisponde ad esecuzione di P

23 Correttezza logica (soundness) Definizione: α è logicamente corretta rispetto a P e L se per ogni computazione π di P che soddisfa L la computazione α(π) di α(p) anche soddisfa α(l) un'astrazione che è logicamente corretta esclude i falsi positivi (se il modello astratto rivela un bug allora il programma concreto ha quel bug)

24 Correttezza logica (completeness) Definizione: α è logicamente completa rispetto a P e L se per ogni computazione astratta π di α(p) che soddisfa α(l) ogni computazione concreta di P in α(π) soddisfa L un'astrazione che è logicamente completa esclude i falsi negativi (se il modello astratto non presenta bug allora anche il programma concreto è esente da bug)

25 Selective data hiding metodo di astrazione corretto e completo rispetto ad ogni proprietà espressa in LTL si basa sulla capacità di individuare dei dati che sono irrilevanti rispetto alla proprietà da verificare e che quindi possono essere rimossi dal modello (insieme alle istruzioni che li usano) questo metodo può essere automatizzato attraverso un semplice algoritmo di slicing (SPIN ne implementa uno) si parte dalla formula e si individuano tutti i dati che sono direttamente utilizzati (simboli, etichette, variabili) poi si seguono le dipendenze nel programma e si accumulano nuovi dati fino a che non se possono più aggiungere tutti gli dati che non sono stati inseriti sono irrilevanti vengono cancellati insieme alle operazioni collegate

26 Selective data hiding con Modex cancellazione avviene rimpiazzando espressioni irrilevanti con true istruzioni irrilevanti con skip la caratteristica positiva di questo metodo è che le astrazioni ottenute sono sia corrette che complete la caratteristica negativa è che questo non necessariamente vale per proprietà che non possono essere espresse come LTL (ad es. assenza di deadlock)

27 Esempio: word count 1 chan STDIN; 2 int c, nl, nw, nc; 3 4 init { 5 bool inword = false; 6 7 do 8 :: STDIN?c -> 9 if 10 :: c == -1 -> break /* EOF */ 11 :: c == '\n' -> nc++; nl++ 12 :: else -> nc++ 13 fi; 14 if 15 :: c == ' ' c == '\t' c == '\n' -> 16 inword = false 17 :: else -> 18 if 19 ::!inword -> 20 nw++; inword = true 21 :: else /* do nothing */ 22 fi 23 fi 24 od; 25 assert(nc >= nl); 26 printf("%d\t%d\t%d\n", nl, nw, nc) 27 }

28 Modello ottenuto con SPIN 1 chan STDIN; 2 int c, nl, nw, nc; 3 4 init { do 8 :: STDIN?c -> 9 if 10 :: c == -1 -> break /* EOF */ 11 :: c == '\n' -> nc++; nl++ 12 :: else -> nc++ 13 fi; 14 if 15 :: true -> 16 skip 17 :: true -> 18 if 19 :: true-> 20 skip ; skip 21 :: true 22 fi 23 fi 24 od; 25 assert(nc >= nl); 26 printf("%d\t%d\n", nl, nc) 27 }

29 Selective restriction metodo di astrazione né corretto né completo può essere ugualmente utile in caso non esista un metodo sound/complete oppure non consente di ottenere modelli trattabili consiste nel limitare la verifica ad una restrizione del problema di partenza ad es. limitare la capacità dei buffer o il numero massimo di processi attivi è molto utile nella fase iniziale della verifica per studiare il problema su una variante del sistema di minore complessità

30 Data type abstraction metodo di astrazione logicamente corretto ma non necessariamente completo consiste nel ridurre il dominio di alcuni dati selezionati ad esempio modellare floating point con interi oppure interi con tre valori (positivo, zero, negativo) una simile astrazione può essere motivata dalla considerazione che le proprietà da verificare non dipendono dai valori effettivi ma dai valori astratti individuati astrarre i valori di alcune variabili può avere conseguenze anche su altre variabili si effettua un analisi delle dipendenze tra variabili e eventualmente si procede ad una modifica

31 Galois connection Siano: (V, ), (A, ): insiemi dotati di ordinamento parziale α: V A (astrazione) β: A V (concretizzazione) la coppia (α, β) è una Galois connection se: per ogni x V e per ogni y A, α(x) y sse x β(y) Sia γ una concretizzazione definita in modo che γ(y) α(y) Ogni astrazione α tale che (α, γ) è una Galois connection è logicamente completa

32 Esempio consideriamo la formula: nota: nella formula è importante il segno non il valore consideriamo il frammento di codice: (x>5); x=0; x++; possiamo usare una funzione di astrazione α che mappa ogni intero negativo a true e ogni altro intero a false definiamo la funzione di concretizzazione γ tale che: γ(true)=-1 e γ(false)=0 consideriamo come relazione d'ordine: per il dominio concreto : ordinamento per interi crescenti per il dominio astratto : true precede false Si può verificare che (α, γ) è una Galois connection, e quindi l'astrazione definita da α è logicamente completa

33 Esempio: trasformazione del codice tabella trasformazione codice: la formula diventa

34 Falsi negativi utilizzando metodi di astrazione che non sono logicamente completi (incomplete) si possono verificare dei falsi negativi i falsi positivi non sono un grosso problema in genere: con la simulazione guidata del controesempio trovato si può subito individuare l'informazione mancante che ha generato il falso positivo si modifica di conseguenza l'astrazione e si ripete l'analisi analizzare i falsi negativi è in genere molto più complicato

35 Esercizi verificare la correttezza di un programma C a scelta verificare la correttezza di un programma C che implementa il quicksort