Transcript sujet TP1

TP1 Promela
1. Algorithme d'exclusion mutuelle de Dekker
#define
#define
#define
#define
true 1
false 0
Aturn false
Bturn true
bool x, y, t;
proctype A()
{
x = true;
t = Bturn;
(y == false || t == Aturn);
/* critical section */
x = false
}
proctype B()
{
y = true;
t = Aturn;
(x == false || t == Bturn);
/* critical section */
y = false
}
init { run A(); run B() }
Coder en Promela l'algorithme de Dekker. Vérifier à l'aide du mécanisme «assert» que cet
algorithme assure bien l'exclusion mutuelle.
2. Boucles
–
écrire en Promela un processus qui prend en paramètre un entier n, puis affiche la somme
des n premiers entiers, en émulant le comportement de la boucle «while».
–
écrire en Promela un processus qui affiche la valeur maximum d'un tableau de n entiers.
3. Protocole de Lynch
Ce protocole est réalisé par deux processus distants A et B qui communiquent par échange de messages.
La spécification est la suivante :
- les processus A et B s'envoient des données dans les deux sens de communication (ils sont à la fois
émetteurs et récepteurs de données) :
• i représente la donnée reçue (input)
• o représente la donnée émise (output)
- l'émetteur de données produit un nouveau message o lorsqu'il reçoit un acquittement du message
précédemment envoyé.
- le récepteur de données consomme un nouveau message i lorsqu'il reçoit ack(i) ou nak(i)
- l'initialisation du transfert de données se fait par l'envoi d'un message err(0)
Le code est le suivant :
Les canaux inc et out représentent les communications des processus (A ou B) avec leur couche
supérieure (service : production/consommation de données locale au site).
Les canaux chin et chout représentent les canaux de communication entre les processus A et B
(protocole : échange de messages entre processus distants).
mtype = { ack, nak, err, next, accept }
proctype transfer (chan inc, out, chin, chout)
{byte o, i;
inc?next(o);
do
:: chin?nak(i) -> out!accept(i); chout!ack(o)
:: chin?ack(i) -> out!accept(i); inc?next(o); chout!ack(o)
:: chin?err(i) -> chout!nak(o)
od
}
init
{chan
chan
chan
chan
chan
chan
AtoB = [1] of {byte, byte};
BtoA = [1] of {byte, byte};
Ain = [2] of {byte,byte};
Bin = [2] of {byte,byte} ;
Aout = [2] of {byte,byte};
Bout = [2] of {byte,byte};
atomic {
run transfer(Ain, Aout, BtoA, AtoB);
run transfer(Bin, Bout, AtoB, BtoA);
Ain ! next(1); Ain ! next(2); Bin ! next(3); Bin ! next(4)
};
BtoA!err(0)
}
a) tester ce code en simulation en exécutant différents scénarios d'échange
b) lancer la vérification. Pourquoi donne-t-elle un résultat incorrect ?
c) la fin du transfert de données est-elle prévue dans le protocole ?
d) corriger le code pour que la vérification soit correcte
e) montrer que si l'initialisation se fait dans les deux sens à la fois, il peut y avoir des duplications
de messages. Donner un exemple de scénario.