Transcript File

Spécification d’un modèle de
protocole : Promela
Azza Ouled Zaid
Institut Supérieur d’Informatique
2ème année Cycle Ingénieur
1
Analyse/Vérification des
modèles

Dans la conception des systèmes distribués, les
protocoles de communication, les applications
client-serveur, etc, on se trouve confronter par des
erreurs non détectées dans les phases de la
conception, codage, compilation et «debugging».

De telles erreurs ont des effets catastrophiques en
tant que sécurité et économique en même temps,
d’où la nécessité extrêmement importante de
l’analyse et vérifications des modèles.
2
Qu'est ce que la vérification ?
Specification
(What we want)
verification
Desin
Implementation
(What we get)

La vérification est l'opération qui, dans la pratique, tente de
s'assurer qu'une implémentation est compatible avec la spécification
3
Différents types d’erreurs




Deadlock : état accessible non désirable où tous les
processus sont bloqués. Il s'agit des états autres que ceux
marqués du label ``end''.
Non-progress cycles : désignent des cycles passant par
aucun état marqué par le label ``progress''.
Livelocks : désignent des cycles passant par au moins un
état marqué par le label ``accept'‘.
Violations de contraintes:


Capacité maximale des files: Si la capacité maximum d’une file
est atteinte et d’autres messages arrivent, qu’est-ce qu’on doit
faire avec celles-là
Violations des limites de vecteurs: affectation des valeurs non
acceptées par les vecteurs
4
Différents types d’erreurs (suite)

Le calcul de la vitesse: L’estimation de la vitesse de
l’application peut être différente de la vitesse réelle de
l’application implantée (en action).

Exactitude logique

Performance temps-réel : parfois, l’application perd de son
exactitude logique ou bien se soumet à des dégradations
de sa performance en temps réel après un intervalle de
temps.
5
Analyse des modèles , Model
Checking

Est-ce que le modèle M vérifie la propriété φ dans
tous les cas après l’explosion d’états : oui ou non, si
non, tracer l’erreur.
Modèle M
Espace d’états
byte n;
proctype Aap() {
do
:: n++
:: noot!MIES
od
}
Propriété 
[] (n<3)
M | 
Model Checker
OUI,la propriété est satisfaite
Explosion d’états: l’espace d’états
6
grandit
exponentiellement mais
sera toujours un nombre fini.
NON,
+ tracer
jusqu’à
l’erreur
Analyse moderne et analyse
classique

Dans l’industrie informatique on distingue deux
approches différentes d’analyse de modèles :

Approche traditionnelle :
• Dans le processus de conception, on crée un modèle abstrait
du processus avant de commencer l’implémentation.
• L’analyse est faite sur ce modèle.
• L’implémentation est obtenue à partir du modèle par un
procédé de raffinement.

Approche dite ‘moderne’ :
• Le modèle est obtenu à partir de l’implémentation par un
procédé d’abstraction qui est automatisable.
7
Approches Classique et
“Moderne”
Classic Approach
Modern Approach
(initial) Design
(manual)
abstractions
Abstract
Verification Model
Model
Checker
refinement
techniques
Abstract
Verification Model
abstraction
techniques
Implementation
Implementation
8
C, Java
Abstraction is the key activity
in both approaches.
To cope with the
state space explosion.
Promela/SPIN: un système pour
l’analyse des modèles

Promela/SPIN est un système développé à partir
du début des années 1990 par Gerhard Holzmann,
un chercheur d’AT&T Labs

Il est un des analyseurs de modèles les plus
connus et efficaces
9
Promela

Protocol/Process Meta Language

Influencé par C

Mais il est un langage pour la spécification de
modèles

Pas un langage d’implémentation

De compréhension facile pour les
développeurs

Admet la communication

Par variables globales partagées

Synchrone (rendez-vous), directe
10
Asynchrone, par canaux de communication fifo
Promela

11
Un programme Promela est une liste de
déclarations de processus, de canaux et
des variables
Atouts de ce système

Automatique, sans intervention humaine

Après la définition du problème

Implantation très efficace en C

Interface conviviale

Excellent appui

Il combine un grand nombre de connaissances
sur le sujet

12
Plusieurs chercheurs chevronnés ont participé à
son développement
SPIN

Spin est un outil pour la vérification et la simulation des
systèmes concurrents, en particulier les protocoles de
communication.

Pour être étudié, un système est d'abord décrit en
Promela, le langage de modélisation de Spin.

SPIN est l’analyseur (model checker) d’un modèle spécifié
13
Simulation en Promela/SPIN




La simulation d'une spécification Promela est réalisée par l'outil
SPIN.
Elle permet d'observer pas à pas le fonctionnement d'un
protocole, et de contrôler l'absence de comportement
indésirable.
La simulation n'est pas exhaustive dans la mesure ou la
séquence à exécuter est choisie de manière interactive ou bien
aléatoirement.
Les seuls critères vérifiés au cours de la simulation sont les
assertions et les états terminaux invalides. En cas d'erreur, la
simulation est arrêtée et l'état des processus est affiché
(variables, files, registres d'instructions, ...).
14
Déclaration de variables :

On indique le type (un des bit, byte, short, or int),
le nom de la variable et optionnellement sa valeur
initiale.
bool b1 = false, b2 = false; bit k = 0;

Les variables de type tableau sont déclarées
comme en C, par exemple :
bit porteouverte[3];
15
Déclaration de canaux

On l'introduit par le mot clé chan, suivi du nom du canal et
optionnellement de la longueur du fifo et du type des messages qui
circulent.

Par exemple :

chan Ouvreporte=[0] of {byte, bit}, Transfert=[2] of {bit, short, chan};

ouvreporte est un canal synchrone, car sa longueur est 0, ce qui
correspond à un rendez-vous ;
 sur ce canal circulent des messages ayant une partie byte et une
partie bit.

Transfert est un canal asynchrone, car il peut stocker (au plus) deux
messages.
16
Déclaration de processus :

La forme la plus simple de déclaration de processus est :
proctype nom ( paramètres_formels )
{ instructions }

Un processus est instancié en utilisant l'instruction run :
run nom ( paramètres_actuels )

Par exemple :
proctype P (bit i) {
...
}
proctype porte (byte i) {
...
}
proctype ascenseur () {
...
}
17
Opérations sur les canaux

Sur un canal on peut
• envoyer (opération ``!'')
• ou recevoir (opération ``?'') des messages.

Par exemple : ouvreporte!i,0; ouvreporte?i,1;
ouvreporte?eval(etage),1
• La fonction ``eval'' force l'égalité des valeurs
reçues avec etage, la variable etage n'est pas
changée.
18
Expressions

Un expression peut être utilisée comme une
instruction si elle ne fait pas des effet de bord
(opérations ``--'' et ``++'' de C).

Dans ce cas, elle est exécutable quand sa
valeur devient vraie (par le changement des
valeurs des variables partagées).

Par exemple : (a == b); est équivalent à :
while (a != b) skip;
19
Instruction ``init''

L'exécution du système commence par le
processus init (c'est le main de Promela).
Par exemple :

init { run porte(1); run porte(2); run porte(3); run
ascenseur() }
20
Instruction ``atomic''

L'exécution d'une séquence d'instructions préfixée
par ``atomic'' peut être rendue indivisible, c'est-àdire sans l'entrelacement des actions des autres
processus.

Par exemple : atomic { run porte(1); run porte(2);
run porte(3); run ascenseur() }
21
Instruction ``if''

Une branche de l'instruction ``if'' est exécutable si la première
instruction de la branche, appelée aussi sa garde, est vraie.

L'instruction ``if'' bloque jusque à ce qu'une branche devient
exécutable. Si plusieurs branches sont exécutables, l'une est
choisie aléatoirement (non-déterminisme).

L'exemple suivant incrémente ou décrémente la valeur de count
une fois.
if
:: count = count + 1
:: count = count - 1
fi
22
Instruction ``do''

Similaire à l'instruction ``if'', sauf que
l'instruction est exécutée et puis la sélection est
répétée jusqu’à l'exécution d'une instruction
``break''.
proctype ascenseur () {
byte etage = 1;
do
:: (etage != 3) -> etage++
:: (etage != 1) -> etage-:: ouvreporte!etage,1; ouvreporte?eval(etage),0
od
}
23
Modèle Promela
 Un modèle Promela consiste de :

Déclaration des types

Déclaration des canaux
mtype, constants,
typedefs (records)
chan ch = [dim] of {type, …}
asynchronous: dim > 0
rendez-vous:
dim == 0

Déclaration des variables globales

Déclaration des processus

[processus init]
- simple vars
- structured vars
- vars can be accessed
by all processes
behaviour of the processes:
local variables + statements
initialises variables and
starts processes
24
Example of a Promela model
Modèle Promela
mtype = {REQ,ACK};
message types (constants)
typedef Msg {
byte a[2];
“record” declaration
mtype tp;
} ;
chan toR = [1] of {Msg}; channel declaration
bool flag;
global variable
proctype Sender() {
Msg m;
...
m.a[0]=2; m.a[1]=7; m.tp = REQ;
toR ! m;
}
Inputs/outputs
proctype Receiver(byte n) {
Msg m;
local variable
...
toR ? m;
}
creates processes
init {
run Sender();
run Receiver(2);
}
25
A Promela model corresponds to a (usually
very large, but) finite transition system, so
 no unbounded data
 no unbounded channels
 no unbounded processes
 no unbounded process creation
Processus
(1)
 Un type de processus (proctype) consiste de
 Un nom
 Une liste de paramètres formelles
 Déclaration des variables locales
 Un corps
name
formal parameters
proctype Sender(chan in; chan out) {
bit sndB, rcvB;
local variables
do
:: out ! MSG, sndB ->
in ? ACK, rcvB;
if
body
:: sndB == rcvB -> sndB = 1-sndB
:: else -> skip
fi
The body consist of a
od
sequence of statements.
}
26
Formulation du problème
(instructions)
 Le corps d’un processus consiste d’une séquence
d’instructions ou spécifications. Une instruction est ou bien


exécutable: la formulation peut être exécutée immédiatement
bloquée : la formulation ne peut pas être exécutée. executable/blocked
depends on the global
state of the system.
 Une affectation est toujours exécutable.
 Une expression est aussi une instruction; elle est
exécutable si elle est évaluée à une valeur non nulle.
2 < 3
toujours exécutable
x < 27
exécutable si la valeur de x est
inferieure à 27
3 + x
exécutable si x n’est pas égale à –3
27
Formulations du problème
Statements are
separated by a
(2) semi-colon: “;”.
or by the equivalent “->”
skip est toujours exécutable.

“ne fait rien”, elle change uniquement le compteur du
processus
run est uniquement exécutable si un nouveau
processus peut être crée (Rappel : le nombre des processus
est limité).
int x;
proctype Aap()
{
int y=1;
skip;
run Noot();
x=2;
x>2 && y==1;
skip;
28
}
Executable if Noot can be created…
Can only become executable if some
other process makes x greater than 2.
Formulations du problème (3)
 assert(<expr>);



Assert est toujours executable.
Si <expr> est evaluée à zéro, SPIN arrêtera avec un message d’erreur,
comme l’ <expr> “a été violée”.
Assert est souvent utilisée avec les modèles Promela, pour vérifier si
dans un état certaines propriétés sont valides ou pas.
proctype monitor() {
assert(n <= 3);
}
proctype receiver() {
byte msg;
...
toReceiver ? msg;
assert(msg != ERROR);
...
}
29
We will later see that this is not the
preferred way to check for invariance.
Sémantiques interactives

Les processus Promela s’exécutent simultanément.

Planification non-deterministe des processus.

Les processus sont interactifs


exception: communication rendez-vous.

Toutes les instructions sont atomic; chaque instruction
est exécutée sans interaction avec les autres processus.
Chaque processus peut avoir plusieurs actions
différentes possibles activées à chaque point de
l’exécution.

Un seul choix est pris en compte, d’une manière non
déterministe.
30
Promela: exemple 1
Processus: ’’Hello World’’
active proctype main ( )
{
printf(’’hello world\n’’)
}
Simulation run:
$ spin hello.pml
hello world
1 process created
$
init {
printf(’’hello world\n”)
}
Vérification run:
$ spin –a hello.pml
$ gcc –o pan pan.c
$ ./pan
… depth reached 2, errors 0
$
Pas de ;
31
Vérification avec SPIN


SPIN génère avec l'option -a un analyseur d'un programme
PROMELA sous la forme d'un programme c (pan.c).
Cet analyseur, une fois compilé et exécuté, explore tous les
états accessibles du programme PROMELA.

Exemple :
$ spin -a phil
$ cc -o pan pan.c
$ a.out

Si une erreur est détectée lors de l'analyse, une trace est
sauvgardée dans le fichier pan.trail.
Cette trace est visualisable avec spin en utilisant l'option -t.
Exemple :
$ spin -t -p -g phil

32
Remarques

Une seule valeur par message


plusieurs valeurs par message




qname!expr1(expr2,expr3)
Optionnellement, certains arguments dans l’opération de réception peuvent être
des constantes


qname!expr1,expr2,expr3
qname?var1,var2,var3
Par convention, le premier champ du message et toujours utilisé pour spécifier
le message
Une alternative pour les opérations d’émission et réception consiste à spécifier
le type du message, suivi de la liste des champs du message


qname?msg
qname?cons1,var2,cons2
La condition d’execution de cette opération est que toutes les valeurs affectées
à touts les champs de message spécifiées comme des constantes coïncident
avec les valeurs du message qui sont à l’entête du canal
33
Remarques : initialisation des
canaux




34
chan a = [16] of { short }
 Le canal peut stocker jusqu’à 16 messages du type short.
chan c[3] = [4] of { byte }
 Un vecteur de 3 canaux, chacun avec une capacité de 4
trames de message, chaque trame est constituée d’un
champ de message de type byte.
Si le message contient plus qu’un champ, la déclaration
sera:
chan qname = [16] of { byte, int, chan, byte }
 Un seul canal qui peut stocker jusqu’à16 messages,
Chaque message consiste de 4 champs
Promela: exemple
byte count;
proctype counter()
{
do
:: count = count + 1
:: count = count – 1
:: (count == 0) -> break
od
}


Cette boucle se termine que si count
atteint zéro,
Pour terminer la boucle il faut modifier
le code
35
proctype counter()
{
do
:: (count != 0) ->
if
:: count = count + 1
:: count = count – 1
fi
:: (count == 0) -> break
od
}
Promela: exemple
Proctype PGCD(int x, y)
{
do
:: (x > y) -> x = x – y
:: (x < y) -> y = y – x
:: (x == y) -> goto done
od;
done:
skip
}
36
Modélisation des timeouts

Timeout est une instruction prédéfinie

abandonner l’attente d’une condition qui ne peut
plus se réaliser.

Offre une sortie à partir d’un état bloqué.

une condition prédéfinie artificielle qui devient vraie
que si les autres instructions dans le système
distribué sont executables

Elle n’implique pas un intervalle de timeout mais
une possibilité de timeout

Abstraction à partir de temporisateurcrucial pour
la validation
37
Modélisation des timeouts
proctype watchdog()
{
do
:: timeout -> guard!reset
od


38
}
Dans ce cas le timeout ne modélise pas l’erreur
causée par des timeouts prématurés dans un
système distribué.
Si c’est nécessaire, cela peut être réalisé en
redéfinissant le mot clé dans une macro
#define timeout 1 /* activée tout le temps, delai arbitraire */
Promela: exemple 2

Objectif : formalisation du comportement de la
couche inférieure
39
Promela: exemple 2 (suite)

Déclatration des type de messages
>> mtype = { data, control } /* data and acks */

Formalisation des canaux de messages entre A et B
chan fromA = [N] of { byte, byte, bit }; /* data, udata, seqno */
chan toB = [N] of { byte, byte, bit }; /* data, udata, seqno */
chan fromB = [N] of { byte, bit }; /* control, seqno */
chan toA = [N] of { byte, bit }; /* control, seqno */
N est une constante qui spécifie la capacité du canal (dans ce cas N=1)
40
Modèle d’un canal idéal
proctype lower(chan fromA, toA, fromB, toB)
{ byte d; bit b;
do
:: fromA?data(d,b) -> toB!data(d,b)
:: fromB?control(b) -> toA!control(b)
od
}

fromA?data(d,b) : une garde, l’opération de réception
n’est exécutable que si un message du type demandé
est inséré dans le canal fromA.
41
Exécutabilité en PROMELA

Chaque instruction est ou bien exécutable ou bien non exécutable.

Instructions de déclaration  toujours exécutables
Les conditions booléennes  exécutables uniquement si elles sont vrais.

Toute instruction non exécutable peut bloquer l’exécution du processus.

Dans l’exemple précédant, l’état des canaux détermine l’une des deux
gardes exécutables, à sélectionner par le processus

Si aucune garde n’est exécutable, le processus se bloque.

Si les deux gardes sont exécutables, l’une d’entre elles sera sélectionnée
aléatoirement

42
Modèle d’un canal non idéal
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
43
proctype lower(chan fromA, toA, fromB, toB)
{ byte d; bit b;
e
do
:: fromA?data(d,b) ->
if
:: toB!data(d,b) /* correct */
:: toB!error /* distorted */
fi
:: fromB?control(b) ->
if
:: toA!control(b)
:: toA!error
fi
od
}
Modèle d’un canal non idéal

Pour modéliser la possibilité de perte de message, ajouter
l’option skip
 skip est l’opération nulle de PROMELA.
 Toujours exécutable et sans effet.

La définition du processus lower donne une description du
comportement du protocole utilisé à la couche inférieure,
vérifiant les contraintes imposées par le concepteur du
protocole.

Pour compléter la validation du protocole, il faut le combiner
avec la déclaration des canaux et trouver une place ou un
processus du type lower est instancié avec les canaux
appropriés.
44
Modélisation de l’émetteur A
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
45
21.
proctype A(chan in, out)
{ byte mt; /* message de données */
bit at; /* bit alterné */
bit vr; /* bit de verificat° */
e
FETCH; /* chercher un nouv mess */
out!data(mt,at); /* l’envoyer */
do
:: in?control(vr) -> /* attendre la réponse */
if
:: (vr == 1) -> /* emission correcte */
FETCH; /* nouv message */
at = 1-at /* complement à un */
:: (vr == 0) -> /* envoyer erreur */
skip /* ne pas chercher */
fi;
out!data(mt,at)
:: in?error(vr) -> /* recevoir erreur */
out!data(mt,at)
od
#define FETCH mt = (mt+1)%MAX
}
Modélisation du recepteur B
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
46
21.
proctype B(chan in, out)
{ byte mr; /* message de données */
byte last_mr; /* nbr du dernier message sans erreur */
bit ar; /* bit alterné */
bit lar; /* ar du dernier message sans erreur */
e
do
:: in?error(mr,ar) ->
out!control(0)
:: in?data(mr,ar) ->
out!control(1);
if
:: (ar == lar) ->
skip
:: (ar != lar) ->
ACCEPT;
lar = ar;
last_mr = mr
fi
od
}
#define ACCEPT assert(mr == (last_mr+1)%MAX)

Proctype: défini le comportement du processus,

Il ne spécifie pas le moment à partir duquel il va être
réalisé ou la façon avec laquelle il a été instancié

Chaque modèle de validation est défini par un
processus initial (fonction main en C)

Modèle de l’exemple : déclare les canaux, instanciation
de chacun des proctypes A, B, et lower
47
Modèle d’initiation : init
4.
#define N 2
#define MAX 8
#define FETCH mt = (mt+1)%MAX
#define ACCEPT assert(mr == (last_mr+1)%MAX)
5.
e
6.
mtype = { data, control, error };
7.
e
8.
#include "lynch0.A "
#include "lynch0.B"
#include "lynch0.C"
e
init {
chan fromA = [N] of { byte, byte, bit };
chan toB = [N] of { byte, byte, bit };
chan fromB = [N] of { byte, bit };
chan toA = [N] of { byte, bit };
e
atomic {
run A(toA, fromA);
run B(toB, fromB);
run lower(fromA, toA, fromB, toB)
}
}
1.
2.
3.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
48
22.
23.
Simulation : SPIN

Utilisation par défaut SPIN : exécution aléatoire
de la simulation du modèle de validation
 pas

Les exceptions sont les erreurs non tolérées:



49
de vérification de la justesse
blocage, réception non spécifiée, violation des
assertions.
Dans ce cas l’exécution de la simulation
s’estompe si une violation d’assertion
apparaisse
Il manque d’autres critères de justesse
Options disponibles
Les principales options disponibles, entre autre pour la

simulation, sont les suivantes :
-p
affiche les changements d'états des processus
-l
affiche les valeurs des variables locales
-g
affiche les valeurs des variables globales
-r
affiche les réceptions de messages
-s
affiche les émissions de messages
-m
indique qu'un message est perdu quand il est envoyé
dans un canal plein
-t
50
permet de consulter la trace qui conduit à une erreur
Conclusion

Description des règles de procédures d’un protocole avec le
langage de spécification et modélisation PROMELA

Décrire les structures de description du comportement.

Dans ce qui va suivre nous allons étudier les structures du
langage PROMELA, spécialement reliées au critère de
justesse

Un langage de validation dispose de certaines structures non
usuelles qui le rend plus adapté à la modélisation des
systèmes distribués

Toutes les communications entre les processus prennent
place ou bien à travers les messages ou les variables
partagées
51
Conclusion

Chaque instruction en PROMELA peut potentiellement
modéliser un délai (executable ou non)

L’interaction et la coordination entre les processus est la
base du langage PROMELA

Pas de types de données abstraits mais quelques types de
variables de base

Le modèle de validation est un niveau d’abstraction pour
l’implémentation

L’abstraction maintien l’interaction d’un processus afin
qu’il puisse être étudié d’une manière isolée
52