Formale Systeme. Die Sprache PROMELA. Prof. Dr. Bernhard Beckert WS 2009/2010 KIT INSTITUT FÜR THEORETISCHE INFORMATIK

Transkript

1 Formale Systeme Prof. Dr. Bernhard Beckert WS 29/2 KIT INSTITUT FÜR THEORETISCHE INFORMATIK KIT University of the State of Baden-Württemberg and National Large-scale Research Center of the Helmholtz Association

2 Beschreibung endlicher Automaten Die Darstellung konkreter endlicher Automaten in graphischer Form ist nur für kleine Automaten möglich, für größere, wie sie in realistischen Anwendungen auftreten, ist das nicht praktikabel. Wir betrachten als eine Alternative die Modellierungssprache Promela. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 2/9

3 Beschreibung endlicher Automaten Die Darstellung konkreter endlicher Automaten in graphischer Form ist nur für kleine Automaten möglich, für größere, wie sie in realistischen Anwendungen auftreten, ist das nicht praktikabel. Wir betrachten als eine Alternative die Modellierungssprache Promela. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 2/9

4 Promela Process meta language Modellierungssprache für indeterministische gekoppelte erweiterte endliche Automaten. Entwickelt von Gerard Holzmann seit 98. Weit verbreitetes Verifikationswerkzeug SPIN (Simple Promela INterpreter) Angabe der zu verifizierenden Eigenschaft als LTL Formel oder Büchi-Automat. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 3/9

5 Promela Process meta language Modellierungssprache für indeterministische gekoppelte erweiterte endliche Automaten. Entwickelt von Gerard Holzmann seit 98. Weit verbreitetes Verifikationswerkzeug SPIN (Simple Promela INterpreter) Angabe der zu verifizierenden Eigenschaft als LTL Formel oder Büchi-Automat. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 3/9

6 Promela Process meta language Modellierungssprache für indeterministische gekoppelte erweiterte endliche Automaten. Entwickelt von Gerard Holzmann seit 98. Weit verbreitetes Verifikationswerkzeug SPIN (Simple Promela INterpreter) Angabe der zu verifizierenden Eigenschaft als LTL Formel oder Büchi-Automat. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 3/9

7 Promela Process meta language Modellierungssprache für indeterministische gekoppelte erweiterte endliche Automaten. Entwickelt von Gerard Holzmann seit 98. Weit verbreitetes Verifikationswerkzeug SPIN (Simple Promela INterpreter) Angabe der zu verifizierenden Eigenschaft als LTL Formel oder Büchi-Automat. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 3/9

8 Promela Process meta language Modellierungssprache für indeterministische gekoppelte erweiterte endliche Automaten. Entwickelt von Gerard Holzmann seit 98. Weit verbreitetes Verifikationswerkzeug SPIN (Simple Promela INterpreter) Angabe der zu verifizierenden Eigenschaft als LTL Formel oder Büchi-Automat. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 3/9

9 /* Peterson: mutual exclusion [98] */ bool turn, flag[2]; byte ncrit; { assert(_pid == _pid == ); again: flag[_pid] = ; turn = _pid; (flag[ - _pid] == turn == - _pid); assert(ncrit == ); /* critical section */ flag[_pid] = ; goto again} Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 5/9

10 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

11 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Promela beschreibt Zustandsübergangssysteme durch die Definition von Prozesstypen (process types). Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

12 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } In diesem Beispiel wird der Prozesstyp user() deklariert. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

13 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Die Deklaration eines Prozesstyps bewirkt noch nichts. Erst mit der Erzeugung einer Instanz eines Prozesstypes sind Aktionen verbunden. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

14 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Instanzen eines Prozesstyps werden normalerweise in einem Initialisierungprozess erzeugt, z.b. init { run users(); }. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

15 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } active [2] ist eine Abkürzung für init { run users(); run users(); }. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

16 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Prozesse werden in der Reihenfolge ihrer Aktivierung durchnumeriert. Auf diese Nummer kann mit der lokalen Variablen pid zugegriffen werden. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

17 bool turn, flag[2]; byte ncrit; { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Globale Variablen, im Beispiel turn, flag[2], ncrit, können von jedem Prozess gelesen und beschrieben werden. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

18 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } In Promela ist jeder Ausdruck auch ein Befehl. Ergibt die Auswertung den Wahrheitswert wahr oder einen Wert >, dann geht die Ausführung mit der nächsten Anweisung weiter. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

19 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Andernfalls bleibt der Prozess blockiert bis der Ausdruck durch Aktionen anderer Prozesse wahr wird. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

20 { assert( pid == pid == ); again: flag[ pid] = ; turn = pid; (flag[ - pid] == turn == - pid); assert(ncrit == ); /* critical section */ flag[ pid] = ; goto again } Falls das Argument des assert Befehls wahr ist geht die Ausführung mit der nächsten Zeile weiter, anderenfalls wird ein Fehler berichtet und die Simulation oder Verifikation abgebrochen. Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 6/9

21 Generischer Automat zum user Prozess line 8 assert((( pid == ) ( pid == ))) line flag[ pid]= line 8 flag[ pid] = line ncrit = (ncrit - ) turn = pid line 2 line 6 ((flag[- pid]==) (turn == (- pid))) assert(ncrit == ) line 4 ncrit = (ncrit+) line 5 Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 7/9

22 Instanzen des generischen Automaten line 8 line 8 assert((( pid == ) ( pid == ))) assert((( pid == ) ( pid == ))) line flag[]= line 8 line flag[]= line 8 flag[] = flag[] = line ncrit = (ncrit - ) line ncrit = (ncrit - ) turn = turn = line 2 line 6 line 2 line 6 ((flag[]==) (turn == ())) assert(ncrit == ) ((flag[]==) (turn == ))) assert(ncrit == ) line 4 ncrit = (ncrit+) line 5 line 4 ncrit = (ncrit+) line 5 Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 8/9

23 Approximation Produktautomat Prof. Dr. Bernhard Beckert Formale Systeme WS 29/2 9/9