TD 2 - Causalité et horloges

Module AR
TD 2 – page 2/4
P1
TD 2 - Causalité et horloges
P2
P3
P1
m2
m2
m1
P2
m3
m1
m3
P3
C1
C2
P1
Contexte
P2
m2
m1
m3
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini,
P3
✯ le nombre N de processus est fixe et connu de tous,
C3
✯ il n’y a pas de panne de machine.
Dans l’ensemble de ce TD, on considère un ensemble de processus indépendants, chaque processus s’exécutant sur
un site distinct. Le seul moyen de communication qu’ils possèdent est l’échange de messages. Par la suite, on pourra
confondre l’identité d’un processus avec l’identité du site sur lequel il s’exécute.
Exercice(s)
F IGURE 1 – Trois exécutions distribuées
P1
P2
Exercice 1 – Causalité
P3
On s’intéresse à une application répartie composée de 3 processus échangeant des messages. On note respectivement
send(m) et receive(m) l’émission et la réception d’un message m. On dit que les communications sont CO (pour
Causally Ordered) si, pour tout message m et m� , on a :
send(m) → send(m� ) ⇒ receive(m) → receive(m� )
(1)
où → désigne la relation de causalité.
Soient 3 exécutions C1 , C2 et C3 représentées dans la figure 1.
F IGURE 2 – Communication par messages
Question 1
Donnez les horloges logiques (Lamport) associées à chacun des événements, et les valeurs d’horloge véhiculées par
les messages.
Question 2
Question 1
Quelles sont, parmi ces trois exécutions, celles dans lesquelles les communications ne sont pas CO ?
Donnez les horloges vectorielles (Mattern) associées à chacun des événements, et les valeurs d’horloge véhiculées par
les messages.
Question 2
Des communications FIFO sont-elles nécessairement CO ? Inversement, des communications CO sont-elles
nécessairement FIFO ?
Question 3
Donnez la relation de causalité pour l’exécution C1 . Citez deux événements concurrents dans ce calcul.
Exercice 2 – Gestion d’horloges
On considère trois processus coopérants qui réalisent un algorithme quelconque et s’échangent des messages. On
s’intéresse à l’exécution de la figure 2.
Toutes les horloges sont initialisées à 0.
1
Exercice 3 – Horloges et causalité
Soit un système composé d’un tuyau dont le débit est contrôlé par une jauge, et d’une pompe servant à réguler ce débit.
Les processus liés à la jauge et à la pompe communiquent par messages avec un observateur chargé de surveiller le
fonctionnement du système. On s’intéresse à l’exécution représentée dans la figure 3, dans laquelle :
– lors de l’événement a, le processus de la jauge diffuse le message “baisse de pression détectée”,
– lors de l’événement b, le processus de la pompe envoie le message “débit augmenté”.
Question 1
Les messages ne comportent aucune information temporelle. Donnez une interprétation possible des informations
reçues par l’observateur.
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 2 – page 3/4
jauge
b
observateur
P1
Question 2
1
0
0
2
2
maintenant
0
Les messages
sont
P2
reçues par l’observateur.
P3 3
Question
F IGURE 3 – Système de surveillance de1 pression
2
2
0
0
2
1
0
2
3
datés
0
2
4
avec
0
P1
0
0
0
0
2
2
2
3
2
4
des horloges scalaires.P2
Donnez une interprétation
0possible
0
0 des informations
A
P3
2
1
0
Le vecteur V Ci est initialisé à 0 et la matrice Mi est initialisée à 1.
La date associée à l’envoi d’un message est calculée avant l’exécution des opérations liées à l’émission, la date
associée à la réception d’un message est calculée après l’exécution des opérations liées à la réception.
A
Question 3
2 possible
2
2 informaLes messages sont maintenant datés0 avec
vectorielles. Donnez une interprétation
des
B des horloges
B
Mattern
4
4
4
4
tions reçuesSinghal
par l’observateur.
1
TD 2 – page 4/4
∀(k, vc) ∈ V C :
si ( vc == V Ci [k] ){
Mi [j, k] = 1 ;
}
si ( vc > V Ci [k] ){
V Ci [k] = vc ;
Mi [j, k] = 1 ;
∀n, n �= i, n �= j, n �= k, Mi [n, k] = 0 ;
}
a
pompe
Module AR
2
1
2
Donnez une interprétation du contenu de la matrice Mi .
Question 4
Donnez le contenu des matrices Mi après chacun des événements de l’exécution représentée dans la figure 5, ainsi
que les valeurs véhiculées par les messages.
Exercice 4 – Implémentation d’horloges vectorielles
On s’intéresse à l’exécution de l’algorithme de Singhal et Kshemkalyani sur l’exemple de la figure 4.
P1
P1
P2
P2
P3
P3
F IGURE 4 – Implémentation d’horloges sur 3 sites
P4
Question 1
Donnez, pour chaque événement eji les valeurs des vecteurs V Ci , LUi et LSi , ainsi que les valeurs véhiculées par les
messages.
F IGURE 5 – Calcul d’horloges vectorielles sur 4 sites
Question 2
Comparez les valeurs obtenues avec les valeurs des horloges obtenues en appliquant l’algorithme de Mattern. Que
constatez-vous ? Est-ce un problème ?
Puisque l’algorithme de Singhal et Kshemkalyani ne fonctionne correctement que pour des liaisons FIFO, Raynal
propose une autre implémentation d’horloges vectorielles qui fonctionne même si les liaisons ne sont pas FIFO. Le
but là aussi est de minimiser l’information envoyée sur le réseau.
En plus de son horloge vectorielle, chaque site i gère localement une matrice Mi de taille N × N (où N est le
nombre de sites de l’application).
Les opérations exécutées lors des différents événements sur le site i sont les suivantes :
A l’occurrence d’un événement sur i :
– i incrémente la composante locale de son horloge logique : V Ci [i] = V Ci [i] + 1 ;
– i associe cette horloge à l’événement ;
– i modifie la colonne i de sa matrice : ∀j �= i, Mi [j, i] = 0.
A l’envoi d’un message par i à j :
i joint au message l’ensemble V C = {(k, V Ci [k]) | Mi [j, k] = 0}.
A la réception par i d’un message en provenance de j :
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TME 2 – page 2/2
Question 1
TME 2 - Implantation sous MPI d’horloges de Lamport
Quel échange de message permet à un philosophe de prendre une baguette ? Quelles sont les variables locales à gérer ?
Que se passe-t-il si deux voisins font leur demande en même temps ?
Question 2
Que se passe-t-il si tous les philosophes font leur demande en même temps ?
Une solution est d’instaurer des priorités croissantes entre philosophes. Pour ce faire, on fournit à chaque philosophe
un identifiant entier unique. Tout philosophe est prioritaire par rapport à son voisin si ce dernier possède un identifiant
de valeur supérieure. Lorsqu’il n’est pas en train de manger, un processus doit céder la baguette qu’il possède si elle
est demandée par un processus plus prioritaire que lui.
Comme les identifiants sont uniques, on est certain qu’un philosophe (celui dont l’identifiant est le plus petit) pourra
toujours obtenir ses baguettes et qu’il n’y aura donc pas d’interblocage
Exercice(s)
Question 3
Pour l’implémentation, nous décidons que chaque philosophe souhaite manger NB_MEALS repas.
À quel moment le processus représentant un philosophe doit-il se terminer ?
Exercice 1 – Dı̂ner de philosophes
Le problème du dı̂ner de philosophes est un problème classique dans le domaine des systèmes répartis, énoncé par
E. Dijkstra. Ce problème est posé de la manière suivante :
– N philosophes ( a priori asiatiques car ils consomment des nouilles avec des baguettes) se trouvent autour d’une
table ronde ;
– chacun des philosophes a devant lui un bol de nouilles ;
– entre chaque bol se trouve exactement une baguette.
Question 4
Proposez un algorithme décrivant le comportement d’un philosophe dans la solution proposée ci-dessus. Prenez soin
de détailler les opérations effectuées (1) à l’initialisation (ie. avant chaque repas), et (2) à la réception de chaque type
de message.
Question 5
Ecrivez un programme MPI qui implémente la solution proposée pour un nombre NB (fixé à l’exécution) de processus
philosophe. Chaque processus consommera NB_MEALS repas.
Question 6
Ajoutez un mécanisme d’horloges logiques à votre système et affichez, pour chaque philosophe, la date de consommation de chacun de ses repas. Le but est de pouvoir recomposer une vision globale de l’exécution selon laquelle les
dates des repas sont cohérentes avec les échanges de messages.
Un philosophe n’a que trois états possibles :
– THINKING : penser pendant un temps indéterminé ;
– HUNGRY : être affamé (pendant un temps déterminé et fini sinon il y a famine) ;
– EATING : manger pendant un temps déterminé et fini.
Des contraintes extérieures s’imposent à cette situation :
– pour manger, un philosophe a besoin de deux baguettes : celle qui se trouve à gauche de sa propre assiette, et
celle qui se trouve à gauche de celle de son voisin de droite (c’est-à-dire les deux baguettes qui entourent sa
propre assiette) ;
– quand un philosophe a faim, il passe dans l’état HUNGRY et il y reste jusqu’à ce qu’il ait obtenu les deux baguettes ;
– quand il termine de manger, il repose les deux baguettes.
Nous nous intéressons dans un premier temps au mécanisme permettant à un philosophe de s’approprier une baguette. La baguette est un élément passif, elle ne peut donc pas émettre ou recevoir des messages.
1
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 3 - Algorithmes à base d’horloges
TD 3 – page 2/3
Un site qui envoie un acquittement autorise donc le processus émetteur de la requête à entrer en section critique.
Par conséquent, l’algorithme doit fixer l’instant auquel un site émet un acquittement, de manière à garantir qu’il n’y
a jamais deux processus simultanément en section critique. On pose aussi la contrainte que la requête servie soit
toujours la plus ancienne requête non traitée.
Un site n’émet qu’une requête à la fois. Autrement dit, il ne pourra faire une nouvelle demande d’accès en section
critique que lorsque la précédente aura été satisfaite.
Question 1
On considère 3 processus i, j et k. i et j ont émis une requête d’entrée en section critique, celle de i est antérieure à
celle de j. k n’a pas émis de requête.
A quel moment i répond-il à j ? j répond-il à i ? k répond-il à i et j ? Combien de types de messages sont-ils
nécessaires pour ces réponses ?
Contexte
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini,
✯ le nombre N de processus est fixe et connu de tous,
Question 2
Comment un site peut-il être sûr qu’il n’y a pas de requête plus ancienne que la sienne en transit ?
Question 3
✯ il n’y a pas de panne de machine.
Dans l’ensemble de ce TD, on considère un ensemble de processus indépendants, chaque processus s’exécutant sur
un site distinct. Le seul moyen de communication qu’ils possèdent est l’échange de messages. Par la suite, on pourra
confondre l’identité d’un processus avec l’identité du site sur lequel il s’exécute.
Exercice(s)
Pourquoi n’utilise-t-on pas les horloges physiques pour dater les messages ?
Toutes les références temporelles se font maintenant par rapport aux horloges logiques.
Question 4
Quelles sont les informations que doit gérer localement un site pour savoir s’il remplit la condition d’entrée en section
critique ?
Question 5
Exercice 1 – Gestion centralisée d’une exclusion mutuelle répartie
On considère un ensemble de processus répartis se partageant une ressource critique. Pour garantir l’exclusion mutuelle, on utilise un processus particulier, appelé maı̂tre, qui est chargé de gérer les requêtes d’accès à la ressource.
Les accès à la ressource se font de manière locale, i.e., le maı̂tre ne fait que délivrer les autorisations, il ne traite pas
les accès.
Question 1
Proposez un algorithme pour gérer cette exclusion mutuelle (précisez les actions effectuées par le maı̂tre, les autres
processus et les messages échangés).
Question 2
Représentez sur un exemple impliquant trois sites (P, Q, R) le fonctionnement de cet algorithme. On supposera que
les demandes d’entrées en section critique sont reçues par le maı̂tre dans l’ordre P, R, Q.
Question 3
Quelle est la complexité en nombre de messages échangés de cet algorithme, lorsque tous les processus demandent
une fois la section critique ? Que se passe-t-il si le maı̂tre ne respecte pas l’ordre d’arrivée des demandes ?
Question 4
Quelles sont les avantages et inconvénients de cette solution ?
Exercice 2 – Algorithme de Ricart et Agrawala
On veut maintenant gérer l’exclusion mutuelle de manière complètement répartie : au lieu d’avoir un site maı̂tre,
chaque site gère localement des informations sur les requêtes en attente. Un processus peut entrer en section critique
lorsque sa requête a été acquittée par tous les autres processus.
1
Quelles sont les informations que doit gérer localement un site pour savoir à quel moment il doit répondre à une
requête ?
Question 6
Écrivez cet algorithme, en précisant les actions effectuées par un processus
– lors de la réception d’un message ;
– lorsqu’il fait une demande d’entrée en section critique ;
– lorsqu’il sort de section critique.
Question 7
Expliquez pourquoi deux processus ne peuvent pas se trouver simultanément en section critique.
Question 8
À un instant donné, tous les sites ont-ils la même image de la file d’attente ? Expliquez pourquoi ce n’est pas un
problème.
Question 9
Quelle est la complexité, en nombre de messages échangés, de cet algorithme pour une demande de section critique ?
Exercice 3 – Section critique à entrées multiples
On considère le problème de la k-exclusion mutuelle : une ressource qui doit être accédée en exclusion mutuelle est
disponible en k exemplaires. Toutes les demandes des processus ne portent que sur un exemplaire de la ressource et
un processus n’émet pas de nouvelle demande tant que sa demande en cours n’a pas été satisfaite. On peut donc avoir
jusqu’à k processus simultanément en section critique.
On se propose dans cet exercice d’étendre l’algorithme de Ricart-Agrawala pour résoudre le problème de la kexclusion mutuelle (solution proposée par Raymond).
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 3 – page 3/3
Question 1
Quelles sont les propriétés de sûreté et vivacité à assurer ?
Question 2
Comme dans l’algorithme original de Ricart-Agrawala, lorsqu’un processus i veut accéder à la section critique (un
exemplaire de la ressource), il envoie une requête (message req) à chacun des (N − 1) autres processus.
La ressource est disponible en k exemplaires. Quel est le nombre de permissions nbacki =
nombre de messages ack que le processus i doit attendre avant de rentrer en section critique ? Justifiez votre réponse.
TME 3 - Implantation sous MPI de l’algorithme de Ricart & Agrawala
Question 3
En recevant nbacki permissions, le site i peut rentrer en section critique. Cela dit, ayant envoyé (N − 1) requêtes, il
recevra quand-même (N − 1) permissions.
Cependant, un certain nombre (N − 1 − nbacki ) de ces permissions arriveront pendant qu’il exécute la section
critique ou même une fois qu’il l’a quittée.
De plus, un site j peut recevoir plusieurs requêtes de i avant de répondre si, par exemple, j se trouve dans une
section critique de longue durée.
Quelles modifications (ajout de variables, modification du contrôle) doit-on apporter à l’algorithme de RicartAgrawala pour assurer la cohérence des autorisations d’accès ?
Exercice(s)
Exercice 1 – L’algorithme de Ricart & Agrawala
Question 1
Question 4
Modifiez l’algorithme de Ricart-Agrawala en conséquence pour permettre à k processus d’accéder à la section critique
simultanément.
Ecrivez un programme MPI qui implémente l’algorithme de Ricart & Agrawala pour un nombre nb_proc (fixé à
l’exécution) de processus.
Chaque processus demande MAX_CS fois l’accès à la section critique.
Ici se pose en plus le problème d’une terminaison “propre” de l’application : si un processus se termine dès qu’il a
effectué tous ses accès à la section critique, il ne pourra pas répondre aux éventuelles demandes des autres processus
qui n’ont pas encore été satisfaites.
Il faut donc maintenir l’ensemble des processus en vie jusqu’à ce que tous les accès aient été autorisés. Pour cela,
on choisit le mécanisme suivant : lorsqu’un processus termine ses accès, il diffuse un message de fin à l’ensemble des
autres processus. Un processus qui a reçu de tous un message de fin sait donc qu’il ne sera plus sollicité et il peut se
terminer.
Question 2
Ajoutez le mécanisme de terminaison à votre programme. Testez l’exécution en faisant varier le nombre de processus.
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
Module AR
TD 4 – page 2/3
Question 2
Quels sont les affichages possibles du programme ? L’affichage est-il cohérent ? Si non, comment le corriger ?
TD 4 - premiers programmes en promela
Exercice 2 – Boucles
Question 1 – Calcul de la puissance
Ecrivez un programme en promela qui reçoit comme paramètre deux entiers naturels x et y et affiche le nombre x
élevé à la puissance y (xy ).
Objectif(s)
Considérez le processus ci-dessous qui est activé avec deux paramètres : l’entier x, et le booléen boo.
✯ Appréhender les spécificités de la programmation avec promela
Exercice(s)
Exercice 1 – Non déterminisme
Considérez le processus ci-dessous :
1 proctype proc1(int x)
2 {
3
if
4
:: (x%2==0) -> printf ("x est un nombre pair\n");
5
:: (x == 0) -> printf ("x est nul \n")
6
fi
7 }
Question 1
Quels sont les affichages possibles du programme si le processus est activé avec :
a) run proc1(2);
b) run proc1(0);
c) run proc1(1);
Considérez maintenant les processus ci-dessous :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1 proctype boucle(short x; bit boo)
2 {
3
do
4
:: (x > 0) ->
5
(boo == true) -> x--;
6
7
:: ( (boo == false) || (x <= 0) ) ->
8
printf ("fin boucle \n");
9
break
10
od;
11 }
Question 2
Le processus boucle se termine-t-il toujours ? Justifiez votre réponse et proposez une solution, si nécessaire.
Exercice 3 – Echange de messages
On considère deux instanciations du même processus dont l’identifiant, passé au moment de leur activation, est
unique (id=0 et id=1). Le processus 0 attend un caractère depuis l’entrée standard. Celle-ci est représentée par un
canal prédéfini STDIN sur lequel les données lues sont interprétées comme des entiers. Ce canal doit être déclaré
dans le programme, mais il n’est pas nécessaire de préciser son format (puisque celui-ci n’est pas libre).
Dès qu’il a reçu un caractère, le processus 0 l’envoie au processus 1 via un canal. Une fois qu’il a reçu le caractère,
le processus 1 l’affiche.
Question 1
int x = 2;
proctype proc_pair( ) {
(x%2==0) -> printf ("x:%d est pair\n",x);
}
proctype proc_inc( )
{
x=x+1;
printf ("valeur finale de x=%d\n",x);
}
init{
run proc_inc ();
run proc_pair();
}
Programmez cette synchronisation en promela.
Considérons maintenant N processus organisés en anneau. Le voisin de droite du processus i est le processus i+1
sauf pour le processus N-1, dont le voisin de droite est le processus 0. Le voisin de gauche du processus i est le
processus i-1, sauf pour le processus 0, dont le voisin de gauche est le processus N-1.
Le processus 0 envoie au processus 1 (voisin de droite) un message contenant son identifiant et une valeur quelconque. Il attend alors recevoir un message de son voisin de gauche, le processus N-1, puis affiche la valeur reçue et
se termine.
Chacun des autres processus i commence par attendre un message de son voisin de gauche. A la réception de ce
message, le processus i incrémente la valeur reçue, l’envoie à son voisin de droite puis se termine.
Question 2
Programmez cette synchronisation en promela.
1
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 4 – page 3/3
Exercice 4 – Exclusion mutuelle : l’algorithme de Le Lann
L’algorithme d’exclusion mutuelle de Le Lann est fondé sur l’unicité d’un jeton. Les processus sont organisés en
anneau logique. Le jeton circule dans une seule direction par l’envoi de messages. Au début le processus 0 possède le
jeton.
Quand un processus reçoit le jeton, il a le droit d’entrer en section critique. En sortant de la section critique ou s’il
ne souhaite pas utiliser la section critique, le processus envoie le jeton à son voisin.
TME 4 - Implantation sous SPIN de l’algorithme de Naimi & Tréhel
Question 1
Programmez en promela l’algorithme d’exclusion mutuelle de Le Lann.
Question 2
Exercice(s)
Comment pourrait-on vérifier que cet algorithme est correct ?
Exercice 1 – L’algorithme de Naimi & Tréhel
On souhaite utiliser SPIN pour vérifier que l’algorithme de Naimi & Tréhel réalise bien une exclusion mutuelle et
que de plus, il ne crée pas de problème de famine : si un processus demande la section critique, il finira par l’obtenir.
Dans un premier temps, nous devons donc traduire l’algorithme en un programme promela.
Question 1
Complétez le squelette suivant, accessible à partir de la page web du module.
#define N
3
#define L
10
#define NIL (N+1)
/* Number of processes */
/* Buffer size */
/* for an undefined value */
mtype = {req, tk};
/* le processus i recoit ses messages dans canal[i] */
chan canal[N] = [L] of {mtype, byte};
/* pour un message de type tk,
on mettra la valeur associee a 0 */
byte SharedVar = 0;
/* la variable partagee */
inline Initialisation ( ) {
/* initialise les variables locales, sauf reqId, val et typ_mes */
}
inline Request_CS ( ) {
/* operations effectuees lors d’une demande de SC */
}
inline Release_CS ( ) {
/* operations effectuees en sortie de SC */
}
inline Receive_Request_CS ( ) {
/* traitement de la reception d’une requete */
}
inline Receive_Token () {
/* traitement de la reception du jeton */
}
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
Module AR
TME 4 – page 2/3
/* indique si le processus a demande la SC ou pas */
/* indique si le processus possede le jeton ou non */
byte father;
byte next;
byte val;
mtype typ_mes;
byte reqId;
/*
/*
/*
/*
/*
TME 4 – page 3/3
Question 4
proctype node(byte id; byte Initial_Token_Holder){
bit requesting;
bit token;
Module AR
Vérifiez que cette propriété est réalisée pour le processus node[1].
probable owner */
next node to whom send the token */
la valeur contenue dans le message */
le type du message recu */
l’Id du demandeur, pour une requete */
chan canal_rec = canal[id];
xr canal_rec;
/* un alias pour mon canal de reception */
/* je dois etre le seul a le lire */
/* Chaque processus execute une boucle infinie */
Initialisation ( );
do
:: ((token == true) && empty(canal_rec) && (requesting == true)) ->
/* on oblige le detenteur du jeton a consulter les messages recus */
in_SC :
/* acces a la ressource critique (actions sur SharedVar),
puis sortie de SC */
:: canal_rec ? typ_mes(val) ->
/* traitement du message recu */
:: (requesting == false) -> /* demander la SC */
Request_CS ( );
od ;
}
/* Cree un ensemble de N processus */
init {
byte proc;
atomic {
proc=0;
do
:: proc <N ->
run node(proc, 0);
proc++
:: proc == N -> break
od
}
}
Question 2
Vérifiez que l’algorithme réalise bien une exclusion mutuelle.
L’algorithme de Naimi & Tréhel est symétrique : tous les processus exécutent le même code. Pour vérifier l’absence
de famine, il suffit donc de vérifier pour un processus donné que si celui-ci demande la section critique, il finira par
l’obtenir.
Question 3
De quel type de propriété (suivant la classification de SPIN) s’agit-il ?
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 5 – page 2/3
1
1
3
TD 5 - Parcours
2
11
8
3
4
4
5
6
3
14
Contexte
5
6
17
F IGURE 1 – Exemple de topologie en arbre
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini,
1
2
Question 3
✯ les liaisons sont bidirectionnelles,
✯ le réseau est fortement connexe,
✯ les sites ont tous des noms distincts, et savent que leurs noms sont distincts.
On note sendij (val) (resp. recij (val)) l’envoi du site i au site j (resp. la réception par j en provenance de i)
d’un message contenant la valeur val. Donnez un exemple d’exécution de l’algorithme sur la topologie de la figure 1
(les valeurs en gras sont les identités des sites, celles en italique les minimums locaux).
4
Exercice(s)
Exercice 1 – Calcul du minimum sur un arbre, avec annonce
Nous rappelons le principe de l’algorithme de l’arbre (vu en cours) qui permet d’effectuer un calcul de minimum sans
annonce :
3
Question 4
6
Adaptez l’algorithme du parcours d’arbre pour que le résultat du calcul de minimum soit annoncé à tous les processus.
Question 5
Comment distingue-t-on les décideurs (les processus qui obtiennent la valeur du minimum, même s’il n’y a pas
d’annonce) des autres processus ?
Rp :
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
Sp :
{ Sentp = faux et ∃q ∈ Voisp , ∀r ∈ Voisp \{q} : Recup [r] }
envoyer �x� à q ;
Sentp = vrai ;
Dp :
5
Nous nous proposons maintenant de compléter l’algorithme de calcul du minimum sur un arbre pour que les processus ayant calculé le résultat informent ceux de leurs voisins qui ne le connaissent pas encore.
{ ∀q ∈ Voisp : Recup [q] }
décision
Exercice 2 – Construction d’un arbre de recouvrement
Le but de cet exercice est de produire un algorithme qui permette de construire sur n’importe quel système un arbre de
recouvrement. Autrement dit, sur un réseau de topologie quelconque, on veut organiser les sites en un arbre qui inclut
exactement une fois chaque site. On se propose pour cela d’adapter l’algorithme ECHO, dont on rappelle le principe :
Sp :
Nous rappelons quelques propriétés de cet algorithme :
1. Tant que l’application n’a pas atteint un état permettant la décision, il y a toujours une émission ou une réception
possible ;
2. Dans un état terminal (plus d’émission, de réception ou de décision possible), tous les sites ont émis exactement
une fois ;
Rp :
3. Il y a exactement deux décideurs.
p initiateur
{ spontanément, une fois }
pour tout q ∈ Voisp faire
envoyer �x� à q ;
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
Question 1
Montrez que les deux décideurs sont nécessairement voisins.
Question 2
Montrez que le dernier site dont un décideur reçoit un message est aussi un décideur.
1
Dp :
{ ∀q ∈ Voisp : Recup [q] }
décision
c
�2009/2010
(by UPMC/LMD/MI048)
p non initiateur
{ ∀q ∈ Voisp : Recup [q] }
envoyer �x� à perep ;
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
si ( perep == nil) {
perep = q ;
pour tout r ∈ Voisp \ {q} faire
envoyer �x� à r ;
}
20 janvier 2010
Module AR
TD 5 – page 3/3
1
1
3
11
8
2
3
TME 5 - Implantation sous SPIN du calcul de minimum sur un arbre
4
5
5
6
3
5
6
17
F IGURE 2 – Exemple pour la construction d’un arbre de recouvrement
1
Question 1
Exercice(s)
2
Indiquez les variables supplémentaires qu’il faut gérer sur chaque site pour réaliser cet algorithme.
Exercice 1 – Calcul de minimum sur un arbre
Question 2
On souhaite utiliser SPIN pour vérifier l’algorithme de calcul de minimum sur un arbre sans annonce. On choisit
pour cela d’appliquer l’algorithme sur l’arbre présenté dans la figure 1, où la valeur du minimum local de chaque site
est indiquée en italique.
4 réaliser l’algorithme
5?
Combien de types de messages sont nécessaires pour
Question 3
3
6
1
Modifiez l’algorithme ECHO pour construire un arbre de recouvrement.
1
3
Question 4
2
Donnez un exemple d’exécution pour le réseau de la figure 2 (on suppose que la construction est initiée par le site 1).
11
8
3
4
4
5
6
3
14
5
6
17
F IGURE 1 – Topologie en arbre
1
2
Question 1
Écrivez un programme promela réalisant le calcul de minimum sur un arbre. Vous pourrez pour cela compléter le
squelette suivant qui se trouve sur la page web de l’UE.
#define N 6
#define NB_V_MAX 3
/* Number of processes */
/* maximum degree of a node */
4
5
mtype = {calcul};
3
chan channel_IN[N] = [N] of {mtype, byte, byte};
/* All messages to process i are received on channel_IN[i]
a message contains information <type, sender, value>
*/
/**************************************************************/
inline Simulateur() {
if
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
6
Module AR
TME 5 – page 2/3
:: (id == 0) ->
minloc = 3; nb_voisins = 2;
voisins[0] = 1; voisins[1] = 2;
:: (id == 1) ->
minloc = 11; nb_voisins = 3;
voisins[0] = 0; voisins[1] = 3; voisins[2] = 4;
:: (id == 2) ->
minloc = 8; nb_voisins = 2;
voisins[0] = 0; voisins[1] = 5;
:: (id == 3) ->
minloc = 14; nb_voisins = 1;
voisins[0] = 1;
:: (id == 4) ->
minloc = 5; nb_voisins = 1;
voisins[0] = 1;
:: (id == 5) ->
minloc = 17; nb_voisins = 1;
voisins[0] = 2;
Module AR
TME 5 – page 3/3
:: /* test reception et traitement correspondant */
:: /* test terminaison */
od;
printf("%d : le minimum est %d\n", _pid, mincal);
}
/**************************************************************/
/* Creates a network of 6 nodes
The structure of the network is given by array voisins */
init{
byte proc;
atomic {
proc=0;
do
:: proc <N ->
run node(proc);
proc++
:: proc == N -> break
od
}
fi;
mincal = minloc
}
/**************************************************************/
inline Test_Emission (q) {
/* determine si l’on peut emettre et identifie le destinataire q */
}
}
Une fois l’algorithme traduit en promela, on souhaite s’assurer qu’il fonctionne correctement. En particulier, on
voudrait vérifier qu’il y a toujours au moins un processus qui parvient à une décision.
inline Test_Decision () {
/* determine si l’on peut decider */
}
Question 2
/**************************************************************/
De quel type de propriété temporelle (suivant la classification de SPIN) s’agit-il ? Écrivez une formule exprimant cette
propriété et vérifiez-la.
proctype node( byte id ) {
byte nb_voisins;
byte voisins[NB_V_MAX];
chan canal_IN = channel_IN[id];
xr canal_IN;
/* only id reads on this channel */
mtype type;
byte i, nb_recus;
byte sender, receiver, minloc, mincal;
/* tableau initialise a 0 ; recu[i] = 1 si on a recu de i */
byte recu[N];
bool emission, wait = 0, decision, deja_emis = 0;
Simulateur();
/* Each process executes a finite loop */
do
:: /* test emission et traitement correspondant
- on ne doit emettre qu’une fois
- si on ne peut pas emettre, on attend (wait = 1) que la
condition ait pu etre modifiee
c
�2009/2010
(by UPMC/LMD/MI048)
*/
20 janvier 2010
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
2
4
6
5
2
4
9
6
5
Module AR
1
TD 6 – page 2/3
0
TD 6 - Routage
2
3
6
5
3
1
1
4
1
6
1
2
2
Contexte
F IGURE 1 – Topologie pour l’exécution de l’algorithme de Chandy et Misra
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini ;
✯ un valeur positif est associé à chaque liaison. Les liaisons sont bidirectionnelles, mais les valeur ne sont pas
nécessairement symétriques ;
Question 4
Donnez une exécution possible de l’algorithme sur l’exemple de la figure 1.
Exercice 2 – Analyse de l’algorithme de Chandy et Misra
✯ le réseau est fortement connexe ;
✯ les sites ont tous des noms distincts, et savent que leurs noms sont distincts.
Exercice(s)
Nous souhaitons maintenant montrer d’une part que les valeurs des chemins calculées par l’algorithme sont correctes, d’autre part que l’algorithme se termine.
Question 1
Montrez qu’à tout instant, pour tout si , Li0 ≤ disti0
Exercice 1 – Routage : l’algorithme de Chandy et Misra
Soit un réseau dans lequel une valeur w(i, j) > 0 est associée à chaque liaison (si , sj ). Par convention, w(i, i) = 0.
Un site connaı̂t la valeur de chacune de ses liaisons entrantes. Autrement dit, le site si connaı̂t l’ensemble des valeurs
w(·, i).
L’algorithme de Chandy et Misra calcule tous les plus courts chemins (en terme de valeur minimum) vers une
destination s0 en utilisant un calcul par vagues, initialisé par le site s0 . Il détermine aussi, pour chaque site si , celui
de ses voisins à qui il doit propager les messages à destination de s0 pour que le coût total du transfert soit minimum.
Question 2
Montrez que, pour tout si , il existe un instant à partir duquel Li0 ≥ disti0 .
Vous pourrez, pour cela, raisonner par récurrence sur la longueur en nombre d’arcs des chemins de valeur minimum.
Question 3
Cet algorithme se termine-t-il ?
Question 4
Question 1
Proposez une relation récursive qui permette de calculer la valeur minimale Li0 d’un chemin de si à s0 .
On veut maintenant écrire un algorithme distribué qui calcule les plus courts chemins en se basant sur la relation
précédente. Puisque seul s0 connaı̂t initialement sa distance à de s0 , c’est lui qui va initialiser le calcul en envoyant à
chacun de ses voisins j la valeur w(j, 0).
Chaque voisin de s0 possèdera alors une première estimation de sa distance à s0 qu’il va affiner ensuite en utilisant
les informations envoyées par ses autres voisins.
Question 2
Précisez les variables que doit gérer un site i, leur initialisation et les types de messages nécessaires.
Question 3
Le principe de l’algorithme est que chaque fois qu’un site diminue la valeur estimée de sa distance à s0 , il en informe
tous ses voisins.
Écrivez les fonctions exécutées
– par le site s0 lors de l’intialisation du calcul,
– par chaque site à la réception d’un message.
1
Dans le cas particulier où toutes les liaisons ont le même valeur, quelle est la complexité de l’algorithme, en nombre
de messages échangés ?
Exercice 3 – Terminaison de l’algorithme de Chandy et Misra
Nous venons de voir que l’algorithme de Chandy et Misra se termine. Il faut maintenant compléter cet algorithme
pour que l’un (au moins) des sites soit averti de la terminaison. Chandy et Misra proposent un mécanisme d’acquittement basé sur le principe suivant :
Un message d’acquittement ne contient pas de donnée. Un site sj envoie un ack à son voisin si en réponse
à un message de si contenant une valeur. Intuitivement, un ack traduit le fait que la valeur envoyée par si
a été (ou va être) prise en compte par tous les sites accessibles par sj .
Question 1
À partir de l’exemple d’exécution que vous avez construit dans l’exercice précédent, déduisez le moment auquel un
site doit envoyer un acquittement.
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TD 6 – page 3/3
Question 2
On se place dans l’hypothèse d’un buffer de réception infini : tous les messages envoyés par le site j sont stockés par
le site i jusqu’à leur traitement. Modifiez l’algorithme pour prendre en compte le mécanisme d’acquittement.
TME 6 - Minimum sur un arbre et Echo avec MPI
Question 3
Donnez une exécution de l’algorithme avec acquittements sur l’exemple de la figure 1.
Question 4
Qui peut décider de la terminaison de l’algorithme, et à quel moment ?
Exercice(s)
Exercice 1 – Calcul de minimum sur un arbre
Le but de cet exercice est d’utiliser MPI pour mettre en œuvre un calcul de minimum réparti. On suppose que la
topologie sur laquelle ce calcul est effectué est une topologie en arbre, où toutes les liaisons sont bidirectionnelles.
Comme les machines des salles de TME sont organisées en grappes, on est obligé de simuler cette topologie. Pour
cela, on décide qu’un processus particulier, le processus 0, sera chargé d’initialiser l’application répartie. La structure
du programme exécuté par chaque processus est donc la suivante :
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char* argv[]) {
int nb_proc,rang;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &nb_proc);
if (nb_proc != NB_SITE+1) {
printf("Nombre de processus incorrect !\n");
MPI_Finalize();
exit(2);
}
MPI_Comm_rank(MPI_COMM_WORLD, &rang);
if (rang == 0) {
simulateur();
} else {
calcul_min(rang);
}
MPI_Finalize();
return 0;
}
où NB_SITE est une constante donnant le nombre de nœuds de l’arbre. On a donc au total, en comptant le processus
0, NB_SITE+1 processus. Le processus 0 transmet à chaque noeud participant au calcul de minimum les informations
suivantes :
– son nombre de voisins,
– la liste de ses voisins,
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
Module AR
TME 6 – page 2/4
Module AR
1
1
3
2
11
8
4
4
5
5
6
Sp :
{ Sentp = faux et ∃q ∈ Voisp , ∀r ∈ Voisp \{q} : Recup [r] }
envoyer �x� à q ;
Sentp = vrai ;
Dp :
{ ∀q ∈ Voisp : Recup [q] }
décision
6
17
La version que l’on veut implémenter est celle du calcul de minimum avec annonce, vue en TD : les processus
parvenus à une décision informent ceux de leurs voisins qui ne connaissent pas encore le résultat.
F IGURE 1 – Topologie en arbre
1
2
Les fonctions main et simulateur sont disponibles sur la page web de l’UE.
Question 1
– la valeur de son minimum local.
Par exemple, on souhaite simuler l’arbre présenté dans la figure 1 où la valeur du minimum local de chaque site est
indiquée en italique.
4
5
Implémentez sous MPI la fonction calcul_min(rang) qui réalise un calcul de minimum avec annonce, en affichant l’identité des processus décideurs et la valeur du minimum calculé.
Question 2
La fonction simulateur exécutée par le processus 0 est donnée par :
3
#define TAGINIT
#define NB_SITE 6
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
5
3
14
Rp :
2
3
TME 6 – page 3/4
6
0
Testez votre implémentation sur la topologie ci-dessus, en exécutant tous les processus sur des machines différentes.
Répétez l’exécution plusieurs fois. Que constatez-vous ?
Exercice 2 – L’algorithme ECHO
void simulateur(void) {
int i;
Le but de cet exercice est d’utiliser MPI pour mettre en œuvre un calcul de minimum réparti sur une topologie quelconque où toutes les liaisons sont bidirectionnelles. Comme pour l’exercice précédent, il est nécessaire de simuler
cette topologie. Le programme principal est identique à celui de l’exercice précédent. La fonction simulateur correspondant à la topologie de la figure 2 est donnée par :
/* nb_voisins[i] est le nombre de voisins du site i */
int nb_voisins[NB_SITE+1] = {-1, 2, 3, 2, 1, 1, 1};
int min_local[NB_SITE+1] = {-1, 3, 11, 8, 14, 5, 17};
#define TAGINIT
#define NB_SITE 6
/* liste des voisins */
int voisins[NB_SITE+1][3] = {{-1, -1, -1},
{2, 3, -1}, {1, 4, 5},
{1, 6, -1}, {2, -1, -1},
{2, -1, -1}, {3, -1, -1}};
0
void simulateur(void) {
int i;
/* nb_voisins[i] est le nombre de voisins du site i */
int nb_voisins[NB_SITE+1] = {-1, 3, 3, 2, 3, 5, 2};
int min_local[NB_SITE+1] = {-1, 12, 11, 8, 14, 5, 17};
for(i=1; i<=NB_SITE; i++){
MPI_Send(&nb_voisins[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(voisins[i],nb_voisins[i], MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(&min_local[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
}
/* liste des voisins */
int voisins[NB_SITE+1][5] = {{-1, -1, -1, -1, -1},
{2, 5, 3, -1, -1}, {4, 1, 5, -1, -1},
{1, 5, -1, -1, -1}, {6, 2, 5, -1, -1},
{1, 2, 6, 4, 3}, {4, 5, -1, -1, -1}};
}
for(i=1; i<=NB_SITE; i++){
MPI_Send(&nb_voisins[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(voisins[i], nb_voisins[i], MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(&min_local[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
}
La valeur -1 est attribuée aux informations non significatives. nb_voisins[i] et min_local[i] donnent
respectivement le nombre de voisins du site i et la valeur locale utilisée pour le calcul de minimum. voisins[i][j]
est le (j+1)ème voisin du site i. MPI garantit le séquencement des messages entre deux sites, par conséquent les
informations envoyées par le processus 0 seront reçues dans le même ordre sur les sites distants.
On se propose d’écrire la fonction calcul_min(rang) réalisant un calcul de minimum réparti en appliquant un
algorithme de parcours d’arbre. On rappelle le principe de cet algorithme :
}
c
�2009/2010
(by UPMC/LMD/MI048)
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
On veut effectuer le calcul au moyen de l’algorithme ECHO dont on rappelle le principe :
20 janvier 2010
2
4
5
Module AR
TME 6 – page 4/4
1
TD 7 - Phase
2
3
5
4
Contexte
6
F IGURE 2 – Topologie pour l’exécution de ECHO
Sp :
Rp :
Dp :
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini,
✯ les liaisons sont bidirectionnelles,
p initiateur
p non initiateur
{ spontanément, une fois }
∀q ∈ Voisp faire
envoyer �x� à q ;
{ ∀q ∈ Voisp : Recup [q] }
envoyer �x� à perep ;
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
{ un message �x� arrive de q }
recevoir �x� ;
Recup [q] = vrai ;
si ( perep == nil ) {
perep = q
∀ r ∈ Voisp \{q} faire
envoyer �x� à r
}
✯ le réseau est fortement connexe,
✯ les sites ont tous des noms distincts, et savent que leurs noms sont distincts.
Exercice(s)
{ ∀q ∈ Voisp : Recup [q] }
décision
Les fonctions main et simulateur sont disponibles sur la page web de l’UE.
Exercice 1 – Exécution et analyse de l’algorithme PHASE
On veut utiliser l’algorithme PHASE pour réaliser un calcul de minimum sur un réseau orienté de topologie quelconque. On rappelle le principe de cet algorithme :
où
– D est le diamètre du réseau,
– Inp (resp. Outp ) la liste des voisins entrants (resp. sortants) de p,
– Scptp compte les messages envoyés par p,
– Rcptp [q] est le nombre de messages reçus par p en provenance de q.
La primitive Sp doit être exécutée initialement par (au moins) un site, appelé initiateur. Les autres sites l’exécutent au
plus tard lorsqu’ils reçoivent leur premier message.
On considère le réseau de la figure 1.
Question 1
Quel est le diamètre du réseau proposé en exemple ? Donnez un chemin aboutissant à cette valeur.
Question 1
Implémentez sous MPI la fonction calcul_min(rang) qui réalise un calcul de minimum réparti en appliquant
l’algorithme ECHO.
Question 2
Donnez une exécution de l’algorithme PHASE sur le réseau de l’exemple.
Question 2
Appliquez votre programme sur la topologie fournie en exemple, en exécutant tous les processus sur des machines
différentes.
1
3
Question 3
Modifiez votre implémentation pour que le calcul de minimum s’accompagne de la construction d’un arbre de recouvrement. Utilisez cet arbre pour réaliser une annonce du résultat du calcul de minimum.
2
4
5
F IGURE 1 – Topologie pour l’exécution de PHASE
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
Module AR
TD 7 – page 2/2
Question 3
Quelle est la complexité de cet algorithme en nombre de messages ?
Question 4
TME 7 - Phase
Montrez qu’à la fin de toute exécution, s’il y a eu (au moins) un initiateur alors chaque processus a émis au moins un
message.
Question 5
Complétez le raisonnement pour montrer que lorsqu’il n’y a plus ni émission, ni réception possible, tous les processus
peuvent décider.
On choisit d’appliquer l’algorithme PHASE pour un calcul de minimum réparti.
Exercice(s)
Question 6
Justifiez informellement pourquoi, lorsque l’algorithme se termine, tous les sites connaissent le minimum sur le réseau.
Exercice 1 – L’algorithme PHASE
On veut réaliser un calcul de minimum sur un réseau orienté de topologie quelconque. On va pour cela utiliser
l’algorithme PHASE. On utilise toujours le même principe : le processus 0 envoie aux processus 1 à n des informations
sur la topologie. Comme le réseau est orienté, les informations fournies distinguent maintenant pour chaque noeud les
voisins entrants et les voisins sortants. La fonction simulateur correspondant à la topologie de la figure 1 est donnée
par :
#define TAGINIT
#define NB_SITE 6
0
#define DIAMETRE
#define DEG_IN_MAX 2
#define DEG_OUT_MAX 2
/* !!!!! valeur a initialiser !!!!! */
/* le max des degres entrants des noeuds */
/* le max des degres sortants des noeuds */
void simulateur(void) {
int i;
/* nb_voisins_in[i] est le nombre de voisins entrants du site i */
/* nb_voisins_out[i] est le nombre de voisins sortants du site i */
int nb_voisins_in[NB_SITE+1] = {-1, 2, 1, 1, 2, 1, 1};
int nb_voisins_out[NB_SITE+1] = {-1, 2, 1, 1, 1, 2, 1};
int min_local[NB_SITE+1] = {-1, 4, 7, 1, 6, 2, 9};
/* liste des voisins entrants */
int voisins_in[NB_SITE+1][2] = {{-1, -1},
{4, 5}, {1, -1}, {1, -1},
{3, 5}, {6, -1}, {2, -1}};
/* liste des voisins sortants
int voisins_out[NB_SITE+1][2]
{2, 3}, {6, -1},
{1, -1}, {1, 4},
*/
= {{-1, -1},
{4, -1},
{5,-1}};
for(i=1; i<=NB_SITE; i++){
MPI_Send(&nb_voisins_in[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(&nb_voisins_out[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
MPI_Send(voisins_in[i], nb_voisins_in[i], MPI_INT, i, TAGINIT,
MPI_COMM_WORLD);
MPI_Send(voisins_out[i], nb_voisins_out[i], MPI_INT, i, TAGINIT,
MPI_COMM_WORLD);
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
1
Module AR
TME 7 – page 2/2
3
3
1
4
1
2
7
TD 8 - État global
4
6
2
4
9
6
5
F IGURE 1 – Topologie pour l’exécution de PHASE
1
L’état global d’un système est constitué d’un état local de chacun des processus, ainsi que de l’état des canaux de
communication. Un algorithme de calcul d’état global doit coordonner les enregistrements effectués sur les différents
sites de manière à garantir que l’état obtenu en rassemblant les informations locales est cohérent : si cet état ne s’est
pas produit effectivement lors de l’exécution de l’application, il pourrait se produire lors d’une autre exécution.
MPI_Send(&min_local[i], 1, MPI_INT, i, TAGINIT, MPI_COMM_WORLD);
}
}
5
3
Le programme
principal est identique à celui proposé dans le TME précédent. Les fonctions main et simulateur
sont disponibles sur la page web de l’UE.
Question 1
Implémentez sous MPI la fonction calcul_min(rang) qui réalise un calcul de minimum réparti en appliquant
l’algorithme PHASE.
Contexte
✯ N processus communiquant par messages au travers d’un réseau fortement connexe.
✯ Liaisons fiables : les messages transitent en un temps arbitraire mais fini et non nul.
✯ Liaisons FIFO.
6
Question 2
Appliquez votre programme sur la topologie fournie en exemple, en exécutant tous les processus sur des machines
différentes.
Exercice(s)
Exercice 1 – Exécution de l’algorithme de Chandy & Lamport
Question 1
On considère 3 processus P1 , P2 et P3 , reliés comme indiqué dans la figure 1, et le schéma d’exécution correspondant.
P1 et P2 enregistrent spontanément leur état local aux instants représentés par les triangles. Complétez la figure 1
en ajoutant les marqueurs manquants et en indiquant l’instant où P3 enregistre son état local. Donnez l’état local
enregistré par chaque processus ainsi que l’état enregistré pour les liaisons.
e11
e12
e13
e14
P1
P1
b
a
P2
c
e25
e22
P2
e21
e23
e24
P3
e31
e32
F IGURE 1 – Construction d’un état global
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
g
f
d
P3
1
e33
Module AR
TD 8 – page 2/3
Exercice 2 – Pertinence de l’algorithme de Chandy & Lamport
De manière générale, un état global calculé ne correspond à aucun des états atteints par l’application au cours de
l’exécution sur laquelle le calcul d’état global a été lancé.
Nous allons montrer qu’il s’agit cependant d’un état que l’application pourrait atteindre. Pour éviter la confusion,
nous appelons configurations les états effectivement atteints lors de l’exécution (qui correspondent à un trait vertical
dans une représentation telle que celle donnée dans la figure 2).
Soit Cτ la configuration du système au moment où l’algorithme de calcul d’état global est initialisé, Cφ la configuration au moment où l’algorithme se termine, et S* l’état global calculé par l’algorithme.
e11
e12
e13
a
P2
P2
e22
e23
Question 4
Donnez une exécution seq’ équivalente à seq pour l’exemple de la figure 2, dans laquelle les événements postenregistrement ont tous lieu après les événements pré-enregistrement.
Nous voulons maintentant montrer que le résultat de la question précédente est général. Pour cela, nous considérons
une exécution répartie quelconque seq et une application de l’algorithme de Chandy et Lamport sur cette exécution.
Question 6
En déduire que pour toute exécution seq, il existe une exécution équivalente dont Cτ , Cφ et l’état global S ∗ enregistré
par l’algorithme de Chandy et Lamport sont des configurations. Représentez cette exécution pour l’exemple de la
figure 2.
c
P3
P3
Autrement dit, e → e’ dans seq ⇔ e → e’ dans seq’ .
Montrez qu’il existe une exécution seq’ équivalente à seq dans laquelle les événements post-enregistrement ont tous
lieu après les événements pré-enregistrement.
b
e21
TD 8 – page 3/3
Question 5
e14
P1
P1
Module AR
e31
e32
F IGURE 2 – Exécution de l’algorithme de Chandy & Lamport
Question 1
Donnez les valeurs de Cτ , S ∗ et Cφ pour l’exemple de la figure 2. S ∗ correspond-il à une configuration de cette
exécution ?
Ici, nous allons appeler exécution répartie la liste classée par ordre d’occurrence de tous les événements de l’application (dans la pratique, cette information est inaccessible puisqu’il faut connaı̂tre instantanément l’état de tous les
sites).
Question 2
Donnez l’exécution répartie seq correspondant à l’exemple de la figure 2.
Le calcul d’un état global nécessite que chaque site enregistre son état local. On appelle événement préenregistrement (resp. post-enregistrement) un événement ayant lieu sur le site pi avant (resp. après) l’enregistrement
par pi de son état local.
Question 3
Donnez la liste des événements pré-enregistrement et la liste des événements post-enregistrement pour l’exemple de
la figure 2.
On rappelle la définition de la relation de causalité entre deux événements : Soit E un ensemble d’événements, e1
et e2 deux éléments de E. La relation de causalité sur E, notée “→” est telle que, pour une exécution donnée, e1 → e2
si l’une des 3 conditions suivantes est vérifiée :
1. e1 et e2 sont deux événements du même processus et e1 précède e2 ,
2. e1 est l’événement “envoi d’un message” et e2 est l’événement “réception de message” correspondant,
3. il existe un événement e3 tel que e1 → e3 et e3 → e2 (transitivité).
Lorsque deux événements ne sont pas reliés causalement (par exemple, e12 et e22 ), l’ordre dans lequel ils se produisent n’influence pas réellement le comportement de l’application répartie. On peut donc construire une relation
d’équivalence entre exécutions en se basant sur la causalité :
seq ∼ seq’
c
�2009/2010
(by UPMC/LMD/MI048)
⇔
seq et seq’ ont même relation de causalité.
20 janvier 2010
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
Module AR
TME 8 - Élection
Exercice(s)
Exercice 1 – L’algorithme de Chang & Roberts (1979)
L’algorithme de Chang & Roberts réalise une élection sur un anneau unidirectionnel où les communications sont
asynchrones. Le principe est le suivant :
– l’élection peut être initiée par plusieurs processus ;
– un processus initiateur envoie un jeton portant son identité à son successeur ;
– lorsqu’un processus reçoit un jeton :
– s’il n’est pas encore initiateur, il ne peut plus le devenir : il passe dans l’état battu et transmet le jeton ;
– s’il est initiateur, il ne transmet le jeton que si celui-ci porte une identité supérieure à la sienne.
Question 1
Quel est le processus qui gagne l’élection ? Comment le sait-il ?
On veut implémenter une version de cet algorithme qui inclut une annonce de résultat : lorsque l’algorithme
se termine, tous les processus connaissent l’identité du processus élu. D’autre part, pour conserver un certain
indéterminisme, chaque processus décide aléatoirement s’il est initiateur ou non en exécutant le code suivant :
TME 8 – page 2/2
– Pour avertir tous les processus qu’une élection est en cours, chaque site initiateur envoie un message reveil à
l’ensemble de ses voisins.
– Un site qui reçoit pour la première fois un message reveil renvoie un message reveil à l’ensemble de ses
voisins, sauf celui qui vient de lui en envoyer un.
– Le principe de l’élection est ensuite celui du calcul de minimum sur un arbre. Un deuxième type de messages
(ident) circule dans l’application : ce message porte la valeur de l’identité minimum connue du site émetteur.
Un site ayant reçu un tel message de tous ses voisins sauf un envoie un message ident au voisin qui n’a pas
émis.
– Un site ayant reçu un message ident de tous ses voisins connaı̂t l’identité minimum dans l’arbre. Le processus
ayant cette identité minimum est élu. Le site renvoie alors un message ident à tous ses voisins, sauf celui à qui
il en a déjà envoyé un (comme on ne cherche pas à savoir qui a pris la décision, on n’a pas besoin d’un troisième
type de message).
Dès qu’une feuille sait qu’une élection est en cours, elle peut envoyer son identité. Si elle est initiateur, il est inutile
qu’elle envoie un message reveil avant son message ident. On veut donc réaliser une version de l’algorithme où
les feuilles n’envoient qu’un seul message.
Question 1
Quelles sont les changements induits par cette modification dans le traitement de la réception des messages ?
Question 2
Implémentez cet algorithme sous MPI, en utilisant le même tirage aléatoire que dans l’exercice 1 pour décider si un
site est initiateur ou non.
Question 3
Testez votre implémentation sur l’arbre utilisé comme exemple pour le calcul de minimum. Vous pouvez à nouveau
récupérer les éléments de programme sur la page web de l’UE.
srand(getpid());
initiateur = rand()%2;
Ce choix laisse un risque (faible) de n’avoir aucun processus initiateur : dans ce cas, on interrompt l’exécution et on
recommence...
Question 2
Implémentez l’algorithme sous MPI, en affichant
– l’identité des processus initiateurs,
– les opérations de destruction de jeton,
– le résultat de l’élection sur tous les sites.
Question 3
Exécutez plusieurs fois le programme pour vérifier que les résultats sont corrects quand le nombre et l’identité des
initiateurs varient.
Exercice 2 – Élection sur un arbre
On veut implémenter un algorithme d’élection sur une topologie en arbre. Comme pour le calcul de minimum, il s’agit
de faire remonter l’information depuis les feuilles. Comme celles-ci ne font pas forcément partie des initiateurs de
l’élection, il faut les avertir qu’une élection est en cours : c’est le but des messages reveil.
Le principe général de l’algorithme est le suivant :
1
c
�2009/2010
(by UPMC/LMD/MI048)
20 janvier 2010
TME 9 - Implémentation du Protocole P2P CHORD
Le but de ce projet est d’implémenter le système Peer to Peer (P2P) CHORD [1].
Bref rappel du protocole CHORD
connexion / déconnexion des pairs : pour se connecter au réseau, un pair doit contacter un pair déjà existant pour
qu’il puisse intégrer la topologie. Le pair se déconnecte du réseau de deux manières : les départs avec notifications et les départs brusques.
échange des tables de hachage : chaque pair est responsable d’une portion de la table de hachage. Quand un pair
rejoint/quitte le réseau, des mises à jour doivent être effectuées sur les domaines de responsabilité des voisins.
recherche de données : elle consiste à appliquer une fonction de hachage sur le nom de la donnée recherchée puis
utiliser le protocole de routage CHORD afin de retrouver le nœud responsable.
stabilisation de la topologie : ce processus permet à CHORD de mettre à jour sa topologie endommagée suite à des
départs brusques des pairs.
Exercice(s)
Exercice 1 – Mise en place du protocol CHORD
Le programme devra être réalisé sous MPI. Un processus simulateur va créer une topologie de bootstrap composée
de n processus. En début du programme le processus simulateur enverra à chaque processus du système :
– sa clé CHORD choisie aléatoirement dans l’ensemble d’identifiants CHORD sur m bits où m est une constante
du protocole.
– l’ensemble de clés dont le processus est résponsable.
– l’ensemble de données que le processus est censé gérer. Les données seront identifiées par des clé CHORD
également.
– le successeur du processus dans l’anneau CHORD.
– une suite d’événements à gérer au cours de son exécution :
– recherche d’une donnée identifiée via une clé CHORD
– insertion d’un nouveau nœud CHORD
– déconnexion avec/sans notification
– responsabilité d’une nouvelle donnée
– lancement d’un processus de stabilisation (l’échange d’information avec les voisins)
TD 10 - Terminaison
Contexte
✯ les communications sont fiables : tout message émis est délivré au bout d’un temps arbitraire mais fini ;
✯ les liaisons sont bidirectionnelles ;
✯ il y a N sites qui ont tous des noms distincts, et savent que leurs noms sont distincts. De plus, N est connu de
tous les sites.
Exercice(s)
Exercice 1 – L’algorithme de Huang (1988)
Cet algorithme généralise l’algorithme de Rana (1980) et permet de détecter la terminaison sur
une topologie de réseau quelconque. On suppose simplement que l’on dispose de deux primitives
broadcast(<type, horloge, emetteur>) qui permet à un émetteur de diffuser une information à
tous les sites, et send(<type, horloge, emetteur, recepteur>) qui envoie un message de l’émetteur
au récepteur. Le principe de l’algorithme est le suivant :
– chaque site doit s’assurer qu’aucun des messages qu’il a envoyés n’est encore en transit. Lorsqu’il est passif et
que cette condition est réalisée, on dit qu’un site est dans l’état “inerte”.
– un site qui détecte que tous, y compris lui-même, sont inertes annonce la terminaison.
Comme on ne dispose pas d’horloge globale, chaque site gère une horloge logique. Lorsqu’un site devient inerte, il
envoie à tous les autres un message de type term. Lorsqu’un site reçoit un tel message, il ne répond que s’il est luimême inerte et si la date contenue dans le message est supérieure à toute date de passage à l’état inerte qu’il connaı̂t.
La réponse se fait en envoyant un message de type agr.
Question 1
A quel moment un site peut-il décider que l’application est terminée ?
Question 2
Proposez un mécanisme pour permettre à chaque site de savoir si ses messages sont en transit. Donnez les variables
nécessaires à la gestion de ce mécanisme.
Question 3
Écrivez les primitives exécutées par le site i
– lorsqu’il envoie un message (de l’application),
– lorsqu’il reçoit un message (de l’application).
Question 4
A quel moment le site i peut-il lancer une détection de la terminaison ?
1
1
Module AR
TD 10 – page 2/2
P
P1
t
m
m
P3
a
t
P
P2
t
t
a
t
TME 10 - Implantation sous SPIN de l’algorithme de Huang
P
t
P
F IGURE 1 – Exécution sur 3 sites
Écrivez les primitives exécutées par le site i lorsqu’il passe de l’état actif à l’état passif, et lorsqu’il reçoit un
acquittement.
Question 5
Exercice(s)
Exercice 1 – L’algorithme de Huang
Écrivez la primitive exécutée par le site i lorsqu’il reçoit un message de type term.
Question 6
Question 1
Écrivez la primitive exécutée par le site i lorsqu’il reçoit un message de type agr.
Écrivez un programme promela réalisant l’algorithme de terminaison de Huang.
Question 7
Complétez le schéma d’exécution de la figure 1 en ajoutant les messages et les estampilles manquant (les états P
représentent les états ou un site devient passif, les lettres indiquent les types de messages).
Question 2
Lancez différentes simulations de votre programme.
Question 3
Question 8
Quelles sont les modifications à apporter pour optimiser l’algorithme si la structure de contrôle est un anneau ?
Que pensez-vous de la possibilité d’utiliser spin pour vérifier que cet algorithme détecte correctement la terminaison ?
Exercice 2 – Preuve informelle de l’algorithme de Huang
Question 1
Sûrété : soit j un site qui annonce la terminaison de l’application. Montrez informellement que lorsque j annonce la
terminaison, l’application est réellement terminée (aucun site n’a pu être réactivé).
Question 2
Vivacité : montrez que lorsque l’application est terminée, cette terminaison est détectée (et annoncée) au bout d’un
temps fini.
c
�2009/2010
(by UPMC/LMD/MI048)
16 février 2010
1