Vous êtes sur la page 1sur 51

COURS-TP-TD Kamel Karoui

PROMELA/SPIN
TP INGÉNIERIE DES RÉSEA
UX ET  PROTOCOLE TCP/IP​

► Introduction au Langage Promela


► Guide d’installation de iSpin​Windows
► Les codes des exemples de cours
►Vérifier les erreurs éventuelles avec Ispin
INTRODUCTION AU LANGAGE
PROMELA
Promela “Protocol Meta Language” : langage qui permet de modéliser des systèmes
distribués, des processus qui se déroulent en parallèle et qui se communiquent à
travers des canaux.
Un modèle de protocole écrit par Promela peut être simulé et vérifié par le logiciel
spin et son interface graphique xspin ou ispin. Ces logiciels permettent d’étudier un
protocole de façon exhaustive et de trouver toutes les possibilités d’erreur qu’il
renferme, par exemple les erreurs non fonctionnelles : inter blocage (deadlocks), les
boucles infinies (livelock) etc. ou les erreurs fonctionnelles.
Ainsi lorsqu’un protocole de communication a été modélisé sous Promela et qu’il a
été prouvé qu’il ne contient aucune erreur, alors l’implantation effective du protocole
dans un programme s’en déduit de façon assez directe.
PROMELA : TYPES DE
DONNÉES
ENUMERATION TYPE
mtype = { apple, pear, orange, banana };
mtype = { fruit, vegetables, cardboard };

init {
mtype n = pear;

printf (“the value of n is ”);


printm (n);
printf (“\n”);
}
USER-DEFINED TYPE
typedef Field {
short f = 3;
byte g
};
typedef Record {
byte a[3];
int fld1;
Field fld2;
chan p[3];
bit b
};
proctype me (Field z) {
z.g = 12
}
init {
Record goo;
Field foo;

run me(foo);
}
PROMELA : EXECUTABILITÉ
En Promela toutes les instructions sont soit exécutables, soit bloquantes. Certaines
instructions sont toujours exécutables, d’autres sont toujours bloquantes, mais la
plupart peuvent être l’un ou l’autre en fonction des conditions. En particulier, une
instruction bloquante peut être rendue exécutable (et vice-versa) par certains
événements.
Par exemple en C la séquence : En Promela, cette séquence
While (a!=b); /* attend que a soit egal à b */ s’écrit :
a = a+1; /* ensuite augemente a de 1 */ (a==b); a=a+1;

• Les affectations, comme a=2 ; ou encore a=a+1 ; etc sont toujours exécutables.
• L’instruction « skip » est une instruction toujours exécutable, mais qui ne fait rien et ne rend aucune valeur.
• Les instructions 1 ; ou encore n ; (où n représente un nombre non-nul) sont également des instructions (qui
ne servent pas à grand chose, certes) mais qui sont toujours exécutables.
• 0 ; est une autre instruction, tout aussi utile, mais qui n’est jamais exécutable.
PROMELA : LES PROCESSUS
Le comportement de tous les processus est défini par une déclaration proctype. Par exemple la déclaration
suivante définit un type de processus appelé A avec une seule variable locale state.

proctype A()
{
byte state;
state = 3;
}

La syntaxe est proche de celle des procédures dans les langages comme pascal ou C. Pourtant comme nous
le verrons ces définitions ont un rôle très différent de celui des procédures.
INITIALISATION DE
PROCESSUS ET EXÉCUTION
DE PROCESSUS
init peut lancer autant de processus de type différent, ou de même type, éventuellement en leur donnant des arguments
différents. Par exemple :
int b=3; Dans cette spécification, b est une variable globale,
proctype A(int a) alors que x et y sont des variables locales à chacun
{ des processus.
byte x;
x = a+b; Le processus init lance trois processus, l’un de type
} A() et les deux autres de type B(). Ces processus ne
proctype B(int m) sont pas exécutés séquentiellement, l’un après
{ l’autre, mais en parallèle.
byte y=0;
(m==3) -> y=(y + b)%8; Le premier processus, de type A, affecte la somme
} a+b (c’est à dire 3+2=5) à la variable locale x et
init ensuite se termine.
{
run A(2); run B(3); run B(5); Le second processus et le troisième processus, sont
} tous les deux de type B, mais sont lancés avec des
paramètres différents
EXÉCUTION DE PROCESSUS
Les processus peuvent également être créés en ajoutant « active » devant la déclaration proctype.

byte x=0 , y=0

active proctype P
{ x++ ;
(y>0) ; x-- }

active proctype Q
{ (x>0) ; y++ ;
(x==0) ; y-- }
INSTRUCTION « ATOMIC »
En enfermant un ensemble d’instructions dans un bloc préfixé atomic, on peut s’assurer que ces instructions seront exécutées
comme un tout indivisible, sans que d’autres instructions venant d’autre processus s’intercalent entre eux. Exemple :
byte state = 1;
proctype A()
{ atomic
{ (state==1) -> state = int value;
state+1; } proctype increment()
} { atomic
proctype B() { x = value;
{ atomic x = x + 1;
{ (state==1) -> state =
value = x;
}
state-1; } }
}
init
{ run A(); run B()}

Ainsi on peut s’assurer que la valeur de state ne peut être que 0 ou 2 et l’un des processus restera bloqué. Dans une séquence
atomique, toutes les instructions doivent être exécutables, sauf éventuellement la première. Si une instruction n’est pas
exécutable, alors il s’agira d’un deadlock, car aucun autre processus ne pourra rendre cette instruction exécutable et débloquer
la situation.
TRANSMISSION DE MESSAGES
: DÉCLARATION DE CANAUX
Les canaux (“channels”) modélisent le transfert de données entre processus. On définit les canaux par des déclarations :

chan qname = [16] of {short}

Ceci définit un canal qui peut contenir jusqu’à 16 messages de type short. Chaque message peut avoir plus d’un champ. Par exemple, dans le canal suivant
:

chan qname = [16] of {byte, int, byte}

contient jusqu’à 16 message, chacun consistant en deux valeurs de 8 bits, une valeur de 32 bits et un nom de canal.

- Synchronisation :

Soit un canal de taille nulle :

chan qname = [0] of {byte};

Avec un tel canal, les messages peuvent passer mais ils ne peuvent pas être stockés. La lecture dans un tel canal est toujours bloquante, jusqu’à ce que, de
l’autre côté du canal un, autre processus soit prêt à écrire quelque chose. De même l’écriture est bloquante jusqu’à ce que, de l’autre côté du canal, un
autre processus soit prêt à y lire quelque chose. En utilisant ces canaux un processus peut “donner rendez-vous” à un autre processus à un point précis de
leur évolution respective, de manière à pouvoir partir de ce point ensemble. Autrement dit, les canaux de taille nulle permettent de synchroniser
plusieurs processus.
TRANSMISSION DE MESSAGES
: L’ENVOI ET LA RÉCEPTION
DE MESSAGES
qname!expr;
Voici un exemple dans lequel le processus init lance deux
processus A et B en leur donnant le même canal en
paramètre. Le processus A envoie l’entier 123 au processus B
envoie la valeur de l’expression expr sur le canal que nous venons de qui l’enregistre dans la variable x.
créer. Plus précisément, elle met expr à la fin du canal.
proctype A(chan q1)
qname?msg; { q1!123; }
proctype B(chan q2)
reçoit le message. Elle le retire du début du canal et l’enregistre dans la
variable msg. Les canaux sont du type FIFO. Si plus d’une seule valeur {
doit être transférée dans un seul message, on écrit: int x;
q2?x;
qname!expr1,expr2,expr3; }
qname?var1,var2,var3; init
{
L’opération d’émission n’est exécutable que lorsque le canal en chan q1 = [1] of {int};
question n’est pas plein. De même, l’opération de réception n’est run A(q1); run B(q1);
exécutable que lorsque le canal en question n’est pas vide.
}
INSTRUCTION
CONDITIONNELLE
Dans une instruction if on pourra avoir autant d’options qu’on le désire :
if
:: instr1 -> option1;
:: instr2 -> option2;
...
:: instrN -> optionN;
fi;

Si parmi les premières instructions instr1, instr2 ..., instrN :


– aucune instruction n’est exécutable, alors l’instruction if dans son ensemble ne sera pas exécutable.
– une seule instrk est exécutable, alors toute les instructions contenues dans l’optionk seront exécutés, mais les autres options ne le seront
pas.
– plusieurs voire toutes les instructions sont exécutables, alors une des lignes est choisie au hasard et l’option correspondante est exécutée.
USAGES DE IF
/* else */ x == 0
/* max x et y */ /* in C, if(x==0) y=10; */
If If else
:: x >= y -> m =x :: x == 0 -> y = 10
:: x <= y -> m = y :: else /* i.e., x != 0 */ y = 10
fi fi

/* aléatoire */
If If
:: n=0 :: ch?msg1 -> …
:: n=1 :: ch?msg2 ->
:: n=2 :: else -> … exp_else
fi fi

15
BOUCLES
do
:: count = count + 1;
:: count = count - 1;
:: (count == 0) -> break;
od;

Aussi longtemps que le processus n’aura pas rencontré un « break » (ou un « goto » comme on le
verra) il répétera les actions décrites ci-dessus pour l’instruction if. Dans l’exemple ci-dessus, les
deux premières instructions sont toujours exécutables (ce sont des affectations) La troisième ne
l’est que si count est nul. Ainsi, la variable count sera aléatoirement incrémenté ou décrémenté au
cours des cycles de do. La boucle ne pourra s’arrêter que lorsque count est nul. Mais même s’il est
nul, l’arrêt ne sera pas nécessaire, puisque les deux autres instructions restent toujours exécutables.
GOTO
L’instruction goto au sein d’une boucle est un autre moyen de sortir d’une boucle. Voici un
exemple :

proctype PGCD(int x,y)


{
do
:: (x>y) -> x = x-y
:: (x<y) -> x = y-x
:: (x==y) -> goto done
od;
done:
skip
}

Utilisez “end:” pour éviter les boucles infinies.


USAGES DE DO
do Loop: if
:: (x == y) -> break :: (x == y) -> skip
:: else -> skip :: else -> goto Loop
od fi

else else

x==y skip x==y

Note that break or goto is not a statement, but control-flow modifiers

18
GOTO ET TRADUCTION FSM
PROMELA

? .x
? .x

a=a-1
a=a+1
end
INLINE DEFINITION (1)
L’invocation de inline est remplacée par le texte de sa definition.
inline example (x) {
inline example (x, y) { int y;
y = a; y = x;
init {
x = b; printf (“%d\n”, y)
int a, b;
assert (x) }
} b = a;
init { init {
a = b;
int a, b; int a;
assert (a);
example (a, b); a = 34;
}
} example (a);
y = 0;
}
AUTRES OPERATEURS

More operators
 The standard C preprocessors can be used
 #define, #if, #ifdef, #include
 To overcome limitation of lack of functions
 #define add(a,b,c) c = a + b
 inline add(a,b,c) { c = a + b }
 Note that these two facilities still do not return a value
 Build multi-dimension array
 typedef array {byte y[3];}
array x[2];
x[2].y[1] = 10;

21
INTÉGRATION CODE C
Spin versions 4.0 and later support the inclusion of embedded C code
into Promela model
 c_expr : a user defined boolean guard
 c_code : a user defined C statement
 c_decl : declares data types
 c_state: declares data objects
 c_track: to guide the verifier whether it should track the value of data
object or not
Embedded C codes are trusted blindly and copied through from the
text of the model into the code of pan.c
22
EXEMPLE 1
c_decl {typedef struct Coord {int x, y; } Coord;}

c_state “Coord pt” “Global” /* goes inside state vector */

int z = 3; /* standard global declaration */

active proctype example() {

c_code { now.pt.x = now.pt.y = 0;};

do

:: c_expr {now.pt.x == now.pt.y } ->

c_code {now.pt.y++}

:: else -> break

od;

c_code {

printf(“values %d:%d,%d,%d\n”,

Pexample-> _pid, now.z, now.pt.x, now.pt.y); };

assert(false);

}
23
COMMUNICATION CODE C INTEGRÉ ET PROMELA

c_state primitive introduces a new global data object pt of


type Coord into the state vector
 The object is initialized to zero according to the convention of Promela

A global data object in a Promela model can be accessed through


now.<var> in embedded C codes
A local data object in a Promela model can be accessed through
P<procname>-><var>

24
EXEMPLE 2
c_decl {typedef struct Coord {int x, y; } Coord;}

c_code {Coord pt;} /* Embedded declaration goes inside state vector */

int z = 3; /* standard global declaration */

active proctype example() {

c_code { pt.x = pt.y = 0;};

do

:: c_expr {pt.x == pt.y } ->

c_code {pt.y++}

:: else -> break

od;

c_code {

printf(“values %d:%d,%d,%d\n”,

Pexample-> _pid, now.z, pt.x, pt.y); };

assert(false);

}
25
TP INGÉNIERIE DES RÉSEA
UX ET  PROTOCOLE TCP/IP​
Plan de la présentation du TP:
►guide d’installation de Spin​
►Les codes des exemples de cours
►Vérifier les erreurs éventuelles avec Ispin
INTRODUCTION A 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 (Protocol Meta Langage), le langage de
modélisation de Spin. Promela est un langage impératif qui se ressemble au langage C agrémenté de
quelques primitives de communication. Pour communiquer, les processus peuvent utiliser des canaux
de communication fifo, prendre rendez-vous ou utiliser des variables partagées.

Spin comporte essentiellement deux modes :Simulation : le système est exécuté pas à pas, ce qui
permet de se familiariser avec son comportement. Vérification : les états du système sont explorés
exhaustivement pour vérifier que le système satisfait bien certaines propriétés exprimées, par
exemple, en LTL.Un programme Promela est constitué d’un ensemble de processus. Un processus est
donné par une déclaration proctype.Spin transforme chaque proctype vers un automate.Une fois créé,
un processus s’exécute en parallèle aux autres processus.Deux mécanismes de synchronisation entre
processus :Les variables globales (déclarées hors processus).Les canaux de communication
permettant l’échange de messages entre processus.
GUIDE INSTALLATION
SPIN 
La premier étape de télécharger spin de l’url :
http://spinroot.com/spin/Bin/index.html

La version spin qu’on a installée est spin 6.5.1 puis il suffit de taper
spin.exe pour vérifier qu’elle est bien installé
On pourrait de plus définir spin.exe
comme une variable extérieure
pour qu’on puisse lancer spin dans
toutes les répertoire
GUIDE INSTALLATION
SPIN 
La deuxième étape et de télécharger Ispin qui est une GUI (interface
d’utilisateur graphique pour spin) depuis ce lien:
http://spinroot.com/spin/Src/index.html

Malheureusement Ispin est de l’extension .tcl ainsi on ne peut pas l’ouvrir


ni l’exécuter sans avoir installer Active-TCL depuis ce lien :
https://www.activestate.com/products/tcl/
GUIDE INSTALLATION
SPIN 
La Troisième étape est d’installer Active-Tcl c’est une simple étapes qui consiste à
cliquer sur continue et installer
GUIDE INSTALLATION
SPIN 
La quatrième étape : Maintenant après l’installation de Active-TCL ispin
n’aura pas de problème de s’ouvrir :

Mais malheureusement on ne peut pas ni compiler


nos code promela ni l’exécuter ni le vérifier. Pour
cela on a besoin d’un compilateur C ou C++ qui est
fournit par le programme MinGW :

Le compilateur qu’on a besoin s’appelle gcc.exe


GUIDE INSTALLATION SPIN  
La cinquième étape est la suivante de télécharger MingW depuis ce lien:
https://sourceforge.net/projects/mingw/files/
Et de l’installer et de l’ajouter aux variables d’environnement pour que tous les programmes puisent
l’utiliser
GUIDE INSTALLATION SPIN  
Dans La sixième étape on installerait un autre programme appelé Graphiz qui permet de
visualiser les automates on peut le télécharger depuis ce lien : https://graphviz.org/download/
GUIDE INSTALLATION SPIN  
Dans la septième étapes il faut configurer Ispin.Tcl ainsi il faut l’ouvrir avec Notepad ou
changer Les Tools gcc et graphiz avec L’emplacement de nos dossier
GUIDE INSTALLATION
SPIN 
Finalement après ces étapes spin serait installer et on peut l’utiliser pour visualiser et vérifier les
conceptions de nos protocoles avec la langage promela dans la documentation se trouve dans
http://spinroot.com/spin/Man/promela.html
VÉRIFIER LES ERREURS ÉVENTUELLES AVEC ISPIN

Spin permet de visualiser Les automates, les FSM et les CFSM Ceci avec les deux
fonctionnalités vérification et Simulate and run : pour l'onglet intitulé Vérification dans la barre
de menu supérieure. Il y a beaucoup de choix qui peuvent être faits concernant le type de
vérification qui peut être fait. Les commandes générées par iSpin sont imprimées dans le
journal, qui est affiché dans le panneau noir de droite. iSpin génère d'abord un vérificateur, puis
le compile et l'exécute, et affiche les résultats. Si tout va bien, aucune erreur n'est détectée dans
la spécification. La version du protocole d'élection du chef qui est en cours de vérification
contient plusieurs exigences d'exactitude spécifiées sous forme de formule LTL en ligne. Par
défaut, iSpin est configuré pour effectuer une vérification de sécurité uniquement. Pour vérifier
l'une des propriétés LTL, sélectionnez sous Liveness (côté gauche de l'écran, en bleu clair),
l'option cycles d'acceptation et le nom de la propriété LTL à vérifier dans la case juste au-
dessus des boutons Exécuter et Arrêter
L’onglet vérification
L’ONGLET SIMULATION/RUN
LES EXEMPLES DE COURS : MACHINE DE MOORE
 :

Fichier : Moore.pml
->Puisque c’est un exemple éducatif, ce modèle n’a pas d’objectif. La seule etapequ’il fait et d’envoyer le message 1 et arrive
à l’erreur de Reception non spécifiée.
LES EXEMPLES DE COURS :
Machine de Mealy
CFSM
Machine CFSM:
En informatique, une machine à états finis communicante est une machine à états finis étiquetée
par des opérations recevoir et envoyer sur un certain alphabet de canaux. Les machines à états
finis communicants sont fréquemment utilisées pour modéliser un protocole de communication
car elles permettent de détecter les erreurs majeures de conception de protocole, y compris les
limites, les blocages et les réceptions non spécifiées.L'avantage des machines à états finis
communicants est qu'elles permettent de décider de nombreuses propriétés dans les protocoles
de communication, au-delà du niveau de la simple détection de telles propriétés. Cet avantage
exclut le besoin d'assistance humaine ou de restriction en général. Les machines à états finis
communicants peuvent être plus puissantes que les machines à états finis dans des situations où
le délai de propagation n'est pas négligeable dans des situations où il est naturel de décrire les
parties au protocole et le support de communication en tant qu'entités distinctes.
LES EXEMPLES DE COURS : CFSM normal :

CFSM normale (sans erreurs) :

-> Ce modèle ne contient aucune erreur non-fonctionelle. Chaque envoie de message dans le process A est reçu dans le process B
et réciproquement
LES EXEMPLES DE COURS : Inter blocage
(Deadlock) :

->Ce modèle contient l’erreur de l’inter blocage(Deadlock). On abouti à un état global(<12,22>,<e,e>) où on ne peut plus avancer.
LES EXEMPLES DE COURS : Réception non
spécifiée:

->Ce modèle contient l’erreur de la réception non spécifiée (Unspécified Reception). On abouti à un état bloquant car la valeur 1 que A envoie
dans le chanelc12 n’est pas reçu dans B (qui attend de recevoir un 4).
LES EXEMPLES DE COURS : Buffer Overflow:

->Ce modèle contient l’erreur dudépassement de capacité de file d’attente (Buffer Overflow)On est abouti à un état où le channel 21 dépasse
sa limite et possède deux valeurs (2 et 2).de
LES EXEMPLES DE COURS : Boucle
infinie (Livelock):

->Ce modèle contient l’erreur de la boucle infinie (livelock). La simulation s’exécute infiniment sans aboutir à un état global final qui la termine
LES EXEMPLES DE COURS : Exercice avec 3
erreurs :
LES EXEMPLES DE COURS : Exercice avec
3 erreurs :
->Ce modèle contient 3 erreurs non fonctionnelles :

- Buffer Overflow : La file d’attente c12 est remplit avec


deux valeurs (a et c) si on exécute !a.c12 puis !c.c12

- Deadlock : La simulation peut arriver à un inter - blocage


si on fait cette exécution

-UnspecifiedReception : La simulation peut arriver


à un état où la valeur c dans le channel c12 n’a pas
de réception depuis B.
LES EXEMPLES DE COURS : Protocole ABP
(Original) :

Protocole ABP (Original) :


LES EXEMPLES DE COURS : Protocole ABP
sans acquittement trame 0 :
Protocole ABP sans acquittement trame 0 :
On enlève l’acquittement de la trame 0 :
Lors de la vérification, il y’a une erreur

On voit le graphe d’accessibilité et on remarque


que c’est une erreur de réception non spécifié

Vous aimerez peut-être aussi