Hauptseminar Modellüberprüfung Kathrin Ott 15.02.2002 Model Checker SPIN Hauptseminar Modellüberprüfung Kathrin Ott 15.02.2002

SPIN Softwarepaket zur formalen Überprüfung von verteilten Systemen, meist Datenkontrollprotokolle Simple Promela INterpreter in den 80er Jahren von den Bell Labs entwickelt SPIN ist ein kostenlos erhältliches Programm jährliche Workshops zu Erweiterung von SPIN

SPIN Designspezifikationen werden in der Verifikationssprache PROMELA formuliert PROcess MEta LAnguage Arbeitsweise: 1. High-Level Model 2. Syntaxfehler 3. Mehrere Durchläufe 4. Ergebnisanalyse zu Generierung neuer Testläufe unter Verwendung von Reduktionsalgorithmen werden die Durchläufe optimiert

PROMELA C-ähnliche Syntax Programmiersprache bestehen aus (ein oder mehreren) Prozessen, Nachrichtenkanälen und Variablen fünf Arten von Zeichen: Bezeichner, Schlüsselwörter, Konstanten, Operatoren und Separatoren

Temporale Logik unterscheidet sich von der normalen Logik durch zeitliche Gebundenheit Aussagen über Verhalten mit einem Zustands-übergangsgraphen endliches Zustandssystem kann als Tupel beschrieben werden

Algorithmen M=<S,T,R,L> S - endliche Menge von Zuständen T  S - eine Menge von Grundzuständen R  SS - Übergangsrelation, die mögliche Übergänge von Zustand zu Zustand beschreibt L ist eine Funktion

Temporale Logik

LTL Lineare Temporale Logik jeder Pfad im Zustandsübergangsgraph wird für sich durch die Formel gewertet bis, seit, immer, eventuell, ... f ::= p |true |false |(f) |f binop f |unop f unop ::= o | | ! binop ::= U | && | ∥ |  | 

LTL z.B.: p bleibt wahr solange bis q wahr wird = o (p U q) zu jeder Zeit in der Ausführung wird p zumindest noch einmal wahr werden o( p)

LTL und Automaten Erfüllt ein gegebenes System eine gegeben Formel? Ja, wenn alle seine Berechnungen die Formel erfüllen, also seine Sprache eine Teilmenge der Formelsprache ist unendliche Sprache repräsentieren und die Inklusion testen. unendliche Automaten wie den Büchi Automat

Büchi Automat eine unendliche Folge von Zuständen lässt sich in einem Büchi Automat darstellen eine Formel ist dann erfüllt, wenn ihre Sprache nicht leer ist, d.h. es gibt einen akzeptierenden Lauf (unendliche Folge von Zuständen), der unendlich oft einen Endzustand des Automaten beinhaltet wenn es einen unendlichen Weg durch den Automatengraph gibt, dann gibt es auch einen erreichbaren Kreis, auf dem der Endzustand liegt

LTL -> Büchi Automat Büchi Automat der LTL-Formeln o (p U q) o ( p)

LTL -> PROMELA $ spin -f „ o( p)“ never { T0: if :: (true)  goto T0 :: (p)  goto accept fi; accept: }

LTL -> PROMELA $ spin -f „ o (p U q)“ never { T0: if :: (p)  goto T0 :: (q)  goto accept fi; accept: :: ((p) || (q))  goto T0 }

Algorithmen zur Reduktion von Zeit und Speicher SPIN verwendet neben dem Büchi Automaten noch weitere Algorithmen: Partial Order Reduktion Tiefensuche Bit State Hashing zur Reduktion von Zeit und Speicher

Beispiel: ABP Alternating Bit Protocol Datentransferprotokoll Stop-And-Go-Protokoll Datenübertragung zu einem Zeitpunkt und in eine Richtung alternating bit, weil der Sender abwechselnd (alternatively) 0 und 1 anhängt

ABP Sender Empfänger Unzuverlässige Datenübertragung mesg1 ack1 mesg0

ABP in PROMELA Code mtype = { msg0, msg1, ack0, ack1 }; chan sender = [1] of { mtype }; chan receiver = [1] of { mtype }; inline phase(msg, good_ack, bad_ack) { do :: sender?good_ack -> break :: sender?bad_ack :: timeout -> if :: receiver!msg; :: skip /* lose message */ fi; od } inline recv(cur_msg, cur_ack, lst_msg, lst_ack) :: receiver?cur_msg -> sender!cur_ack; break /* accept */ :: receiver?lst_msg -> sender!lst_ack od;

ABP in PROMELA Code active proctype Sender() { do :: phase(msg1, ack1, ack0); phase(msg0, ack0, ack1) od } active proctype Receiver() :: recv(msg1, ack1, msg0, ack0); recv(msg0, ack0, msg1, ack1) Tests: [] (ack1 -> <> mesg1)

LTL Anforderungen an ABP immer wird nach ack1 eventuell msg1 gesendet [] (ack1 -> <> mesg1) immer wird nach mesg1 solange nicht ack1 empfangen bis ack0 empfangen wird [] (mesg1 -> (! ack1 U ack0)) (error behavior) immer wird nach mesg1 solange nicht ack0 empfangen bis ack1 empfangen wird [] (mesg1 -> (! ack0 U ack1)) (desired behavior)