TD 2 - Causalité et horloges

TD 2 - Causalit´ e et horloges
Contexte
✯les communications sont fiables : tout message ´ emis est d´ elivr´ e au bout d’un temps arbitraire mais fini,
✯le nombre N de processus est fixe et connu de tous,
✯il n’y a pas de panne de machine.
Dans l’ensemble de ce TD, on consid` ere un ensemble de processus ind´ ependants, chaque processus s’ex´ ecutant sur
un site distinct. Le seul moyen de communication qu’ils poss` edent est l’´ echange de messages. Par la suite, on pourra
confondre l’identit´ e d’un processus avec l’identit´ e du site sur lequel il s’ex´ ecute.
Exercice(s)
Exercice 1 – Causalit´ e
On s’int´ eresse ` a une application r´ epartie compos´ ee de 3 processus ´ echangeant des messages. On note respectivement
send(m)et receive(m)l’´ emission et la r´ eception d’un message m. On dit que les communications sont CO (pour
Causally Ordered) si, pour tout message met m�,ona:
send(m)→send(m�)⇒receive(m)→receive(m�)(1)
o` u→d´ esigne la relation de causalit´ e.
Soient 3 ex´ ecutions C1,C2et C3repr´ esent´ ees dans la figure 1.
Question 1
Quelles sont, parmi ces trois ex´ ecutions, celles dans lesquelles les communications ne sont pas CO ?
Question 2
Des communications FIFO sont-elles n´ ecessairement CO ? Inversement, des communications CO sont-elles
n´ ecessairement FIFO ?
Question 3
Donnez la relation de causalit´ e pour l’ex´ ecution C1. Citez deux ´ ev´ enements concurrents dans ce calcul.
Exercice 2 – Gestion d’horloges
On consid` ere trois processus coop´ erants qui r´ ealisent un algorithme quelconque et s’´ echangent des messages. On
s’int´ eresse ` a l’ex´ ecution de la figure 2.
Toutes les horloges sont initialis´ ees ` a 0.
1
Module AR TD 2 – page 2/4
P1
P2
P3
m1
m2
m3
C1
P1
P2
P3
m1
m2
m3
C2
P1
P2
P3
m1
m2
m3
C3
FIGURE 1 – Trois ex´ ecutions distribu´ ees
P1
P2
P3
FIGURE 2 – Communication par messages
Question 1
Donnez les horloges logiques (Lamport) associ´ ees ` a chacun des ´ ev´ enements, et les valeurs d’horloge v´ ehicul´ ees par
les messages.
Question 2
Donnez les horloges vectorielles (Mattern) associ´ ees ` a chacun des ´ ev´ enements, et les valeurs d’horloge v´ ehicul´ ees par
les messages.
Exercice 3 – Horloges et causalit´ e
Soit un syst` eme compos´ e d’un tuyau dont le d´ ebit est contrˆ ol´ e par une jauge, et d’une pompe servant ` ar
´
eguler ce d´ ebit.
Les processus li´ es ` a la jauge et ` a la pompe communiquent par messages avec un observateur charg´ e de surveiller le
fonctionnement du syst` eme. On s’int´ eresse ` a l’ex´ ecution repr´ esent´ ee dans la figure 3, dans laquelle :
– lors de l’´ ev´ enement a, le processus de la jauge diffuse le message “baisse de pression d´ etect´ ee”,
– lors de l’´ ev´ enement b, le processus de la pompe envoie le message “d´ ebit augment´ e”.
Question 1
Les messages ne comportent aucune information temporelle. Donnez une interpr´ etation 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
pompe
observateur
a
b
FIGURE 3 – Syst` eme de surveillance de pression
Question 2
Les messages sont maintenant dat´ es avec des horloges scalaires. Donnez une interpr´ etation possible des informations
rec¸ues par l’observateur.
Question 3
Les messages sont maintenant dat´ es avec des horloges vectorielles. Donnez une interpr´ etation possible des informa-
tions rec¸ues par l’observateur.
Exercice 4 – Impl´ ementation d’horloges vectorielles
On s’int´ eresse ` a l’ex´ ecution de l’algorithme de Singhal et Kshemkalyani sur l’exemple de la figure 4.
P1
P2
P3
A
B
Singhal
2
0
0
2
2
0
2
4
0
2
1
0
0
4
1
2
4
2
2
3
0
1
0
0
P1
P2
P3
A
B
Mattern
2
0
0
2
2
0
2
4
0
2
1
0
2
4
1
2
4
2
2
3
0
1
0
0
P1
P2
P3
FIGURE 4 – Impl´ ementation d’horloges sur 3 sites
Question 1
Donnez, pour chaque ´ ev´ enement ej
iles valeurs des vecteurs VC
i,LUiet LSi, ainsi que les valeurs v´
ehicul´ ees par les
messages.
Question 2
Comparez les valeurs obtenues avec les valeurs des horloges obtenues en appliquant l’algorithme de Mattern. Que
constatez-vous ? Est-ce un probl` eme ?
Puisque l’algorithme de Singhal et Kshemkalyani ne fonctionne correctement que pour des liaisons FIFO, Raynal
propose une autre impl´ ementation d’horloges vectorielles qui fonctionne mˆ eme si les liaisons ne sont pas FIFO. Le
but l` a aussi est de minimiser l’information envoy´ ee sur le r´ eseau.
En plus de son horloge vectorielle, chaque site ig` ere localement une matrice Mide taille N×N(o` uNest le
nombre de sites de l’application).
Les op´ erations ex´ ecut´ ees lors des diff´ erents ´ ev´ enements sur le site isont les suivantes :
A l’occurrence d’un ´ ev´ enement sur i:
–iincr´ emente la composante locale de son horloge logique : VC
i[i]=VC i[i]+1;
–iassocie cette horloge ` a l’´ ev´ enement ;
–imodifie la colonne ide sa matrice : ∀j=i, Mi[j, i]=0.
A l’envoi d’un message par i` aj:
ijoint au message l’ensemble VC ={(k, V Ci[k]) |Mi[j, k]=0}.
A la r´ eception par id’un message en provenance de j:
c
2009/2010 (by UPMC/LMD/MI048) 20 janvier 2010
Module AR TD 2 – page 4/4
∀(k, vc)∈VC:
si ( vc == VC
i[k]){
Mi[j, k]=1;
}
si ( vc > V Ci[k]){
VC
i[k]=vc ;
Mi[j, k]=1;
∀n, n =i, n =j, n =k, Mi[n, k]=0;
}
Le vecteur VC
iest initialis´
e` a 0 et la matrice Miest initialis´ ee ` a 1.
La date associ´ ee ` a l’envoi d’un message est calcul´ ee avant l’ex´ ecution des op´ erations li´ ees ` a l’´ emission, la date
associ´ ee ` a la r´ eception d’un message est calcul´ ee apr` es l’ex´ ecution des op´ erations li´ ees ` a la r´ eception.
Question 3
Donnez une interpr´ etation du contenu de la matrice Mi.
Question 4
Donnez le contenu des matrices Miapr` es chacun des ´ ev´ enements de l’ex´ ecution repr´ esent´ ee dans la figure 5, ainsi
que les valeurs v´ ehicul´ ees par les messages.
P1
P2
P3
P4
FIGURE 5 – Calcul d’horloges vectorielles sur 4 sites
c
2009/2010 (by UPMC/LMD/MI048) 20 janvier 2010

TME 2 - Implantation sous MPI d’horloges de Lamport
Exercice(s)
Exercice 1 – Dˆ ıner de philosophes
Le probl` eme du dˆ ıner de philosophes est un probl` eme classique dans le domaine des syst` emes r´ epartis, ´ enonc´ e par
E. Dijkstra. Ce probl` eme est pos´ e de la mani` ere 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.
Un philosophe n’a que trois ´ etats possibles :
–THINKING : penser pendant un temps ind´ etermin´ e;
–HUNGRY :ˆ etre affam´ e (pendant un temps d´ etermin´ e et fini sinon il y a famine) ;
–EATING : manger pendant un temps d´ etermin´ e et fini.
Des contraintes ext´ erieures 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’´ etat HUNGRY et il y reste jusqu’` a ce qu’il ait obtenu les deux ba-
guettes ;
– quand il termine de manger, il repose les deux baguettes.
Nous nous int´ eressons dans un premier temps au m´ ecanisme permettant ` a un philosophe de s’approprier une ba-
guette. La baguette est un ´ el´ ement passif, elle ne peut donc pas ´ emettre ou recevoir des messages.
1
Module AR TME 2 – page 2/2
Question 1
Quel ´ echange de message permet ` a un philosophe de prendre une baguette ? Quelles sont les variables locales ` ag
´
erer ?
Que se passe-t-il si deux voisins font leur demande en mˆ eme temps ?
Question 2
Que se passe-t-il si tous les philosophes font leur demande en mˆ eme temps ?
Une solution est d’instaurer des priorit´ es 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 poss` ede un identifiant
de valeur sup´ erieure. Lorsqu’il n’est pas en train de manger, un processus doit c´ eder la baguette qu’il poss` ede si elle
est demand´ ee 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
Question 3
Pour l’impl´ ementation, nous d´ ecidons que chaque philosophe souhaite manger NB_MEALS repas.
`
A quel moment le processus repr´ esentant un philosophe doit-il se terminer ?
Question 4
Proposez un algorithme d´ ecrivant le comportement d’un philosophe dans la solution propos´ ee ci-dessus. Prenez soin
de d´ etailler les op´ erations effectu´ ees (1) ` a l’initialisation (ie. avant chaque repas), et (2) ` a la r´ eception de chaque type
de message.
Question 5
Ecrivez un programme MPI qui impl´ emente la solution propos´ ee pour un nombre NB (fix´ e` a l’ex´ ecution) de processus
philosophe. Chaque processus consommera NB_MEALS repas.
Question 6
Ajoutez un m´ ecanisme d’horloges logiques ` a votre syst` eme et affichez, pour chaque philosophe, la date de consom-
mation de chacun de ses repas. Le but est de pouvoir recomposer une vision globale de l’ex´ ecution selon laquelle les
dates des repas sont coh´ erentes avec les ´ echanges de messages.
c
�2009/2010 (by UPMC/LMD/MI048) 20 janvier 2010

TD 3 - Algorithmes ` a base d’horloges
Contexte
✯les communications sont fiables : tout message ´ emis est d´ elivr´ e au bout d’un temps arbitraire mais fini,
✯le nombre N de processus est fixe et connu de tous,
✯il n’y a pas de panne de machine.
Dans l’ensemble de ce TD, on consid` ere un ensemble de processus ind´ ependants, chaque processus s’ex´ ecutant sur
un site distinct. Le seul moyen de communication qu’ils poss` edent est l’´ echange de messages. Par la suite, on pourra
confondre l’identit´ e d’un processus avec l’identit´ e du site sur lequel il s’ex´ ecute.
Exercice(s)
Exercice 1 – Gestion centralis´ ee d’une exclusion mutuelle r´ epartie
On consid` ere un ensemble de processus r´ epartis se partageant une ressource critique. Pour garantir l’exclusion mu-
tuelle, on utilise un processus particulier, appel´ e maˆ ıtre, qui est charg´ e de g´ erer les requˆ etes d’acc` es ` a la ressource.
Les acc` es ` a la ressource se font de mani` ere locale, i.e., le maˆ ıtre ne fait que d´ elivrer les autorisations, il ne traite pas
les acc` es.
Question 1
Proposez un algorithme pour g´ erer cette exclusion mutuelle (pr´ ecisez les actions effectu´ ees par le maˆ ıtre, les autres
processus et les messages ´ echang´ es).
Question 2
Repr´ esentez sur un exemple impliquant trois sites (P, Q, R) le fonctionnement de cet algorithme. On supposera que
les demandes d’entr´ ees en section critique sont rec¸ues par le maˆ ıtre dans l’ordre P, R, Q.
Question 3
Quelle est la complexit´ e en nombre de messages ´ echang´ es 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’arriv´ ee des demandes ?
Question 4
Quelles sont les avantages et inconv´ enients de cette solution ?
Exercice 2 – Algorithme de Ricart et Agrawala
On veut maintenant g´ erer l’exclusion mutuelle de mani` ere compl` etement r´ epartie : au lieu d’avoir un site maˆ ıtre,
chaque site g` ere localement des informations sur les requˆ etes en attente. Un processus peut entrer en section critique
lorsque sa requˆ ete a ´ et´ e acquitt´ ee par tous les autres processus.
1
Module AR TD 3 – page 2/3
Un site qui envoie un acquittement autorise donc le processus ´ emetteur de la requˆ ete ` a entrer en section critique.
Par cons´ equent, l’algorithme doit fixer l’instant auquel un site ´ emet un acquittement, de mani` ere ` a garantir qu’il n’y
a jamais deux processus simultan´ ement en section critique. On pose aussi la contrainte que la requˆ ete servie soit
toujours la plus ancienne requˆ ete non trait´ ee.
Un site n’´ emet qu’une requˆ ete ` a la fois. Autrement dit, il ne pourra faire une nouvelle demande d’acc` es en section
critique que lorsque la pr´ ec´ edente aura ´ et´ e satisfaite.
Question 1
On consid` ere 3 processus i,jet k.iet jont ´ emis une requˆ ete d’entr´ ee en section critique, celle de iest ant´ erieure ` a
celle de j.kn’a pas ´ emis de requˆ ete.
A quel moment ir´ epond-il ` aj?jr´ epond-il ` ai?kr´ epond-il ` aiet j? Combien de types de messages sont-ils
n´ ecessaires pour ces r´ eponses ?
Question 2
Comment un site peut-il ˆ etre sˆ ur qu’il n’y a pas de requˆ ete plus ancienne que la sienne en transit ?
Question 3
Pourquoi n’utilise-t-on pas les horloges physiques pour dater les messages ?
Toutes les r´ ef´ erences temporelles se font maintenant par rapport aux horloges logiques.
Question 4
Quelles sont les informations que doit g´ erer localement un site pour savoir s’il remplit la condition d’entr´ ee en section
critique ?
Question 5
Quelles sont les informations que doit g´ erer localement un site pour savoir ` a quel moment il doit r´ epondre ` a une
requˆ ete ?
Question 6
´
Ecrivez cet algorithme, en pr´ ecisant les actions effectu´ ees par un processus
– lors de la r´ eception d’un message ;
– lorsqu’il fait une demande d’entr´ ee en section critique ;
– lorsqu’il sort de section critique.
Question 7
Expliquez pourquoi deux processus ne peuvent pas se trouver simultan´ ement en section critique.
Question 8
`
A un instant donn´ e, tous les sites ont-ils la mˆ eme image de la file d’attente ? Expliquez pourquoi ce n’est pas un
probl` eme.
Question 9
Quelle est la complexit´ e, en nombre de messages ´ echang´ es, de cet algorithme pour une demande de section critique ?
Exercice 3 – Section critique ` a entr´ ees multiples
On consid` ere le probl` eme de la k-exclusion mutuelle : une ressource qui doit ˆ etre acc´ ed´ ee en exclusion mutuelle est
disponible en kexemplaires. Toutes les demandes des processus ne portent que sur un exemplaire de la ressource et
un processus n’´ emet pas de nouvelle demande tant que sa demande en cours n’a pas ´ et´ e satisfaite. On peut donc avoir
jusqu’` akprocessus simultan´ ement en section critique.
On se propose dans cet exercice d’´ etendre l’algorithme de Ricart-Agrawala pour r´ esoudre le probl` eme de la k-
exclusion mutuelle (solution propos´ ee par Raymond).
c
�2009/2010 (by UPMC/LMD/MI048) 20 janvier 2010

Module AR TD 3 – page 3/3
Question 1
Quelles sont les propri´ et´ es de sˆ uret´ eet vivacit´ e` a assurer ?
Question 2
Comme dans l’algorithme original de Ricart-Agrawala, lorsqu’un processus iveut acc´ eder ` a la section critique (un
exemplaire de la ressource), il envoie une requˆ ete (message req)` a chacun des (N−1) autres processus.
La ressource est disponible en kexemplaires. Quel est le nombre de permissions nbacki=
nombre de messages ack que le processus idoit attendre avant de rentrer en section critique ? Justifiez votre r´ eponse.
Question 3
En recevant nbackipermissions, le site ipeut rentrer en section critique. Cela dit, ayant envoy´ e(N−1) requˆ etes, il
recevra quand-mˆ eme (N−1) permissions.
Cependant, un certain nombre (N−1−nbacki)de ces permissions arriveront pendant qu’il ex´ ecute la section
critique ou mˆ eme une fois qu’il l’a quitt´ ee.
De plus, un site jpeut recevoir plusieurs requˆ etes de iavant de r´ epondre si, par exemple, jse trouve dans une
section critique de longue dur´ ee.
Quelles modifications (ajout de variables, modification du contrˆ ole) doit-on apporter ` a l’algorithme de Ricart-
Agrawala pour assurer la coh´ erence des autorisations d’acc` es ?
Question 4
Modifiez l’algorithme de Ricart-Agrawala en cons´ equence pour permettre ` akprocessus d’acc´ eder ` a la section critique
simultan´ ement.
c
�2009/2010 (by UPMC/LMD/MI048) 20 janvier 2010
TME 3 - Implantation sous MPI de l’algorithme de Ricart & Agrawala
Exercice(s)
Exercice 1 – L’algorithme de Ricart & Agrawala
Question 1
Ecrivez un programme MPI qui impl´ emente l’algorithme de Ricart & Agrawala pour un nombre nb_proc (fix´ e` a
l’ex´ ecution) de processus.
Chaque processus demande MAX_CS fois l’acc` es ` a la section critique.
Ici se pose en plus le probl` eme d’une terminaison “propre” de l’application : si un processus se termine d` es qu’il a
effectu´ e tous ses acc` es ` a la section critique, il ne pourra pas r´ epondre aux ´ eventuelles demandes des autres processus
qui n’ont pas encore ´ et´ e satisfaites.
Il faut donc maintenir l’ensemble des processus en vie jusqu’` a ce que tous les acc` es aient ´ et´ e autoris´ es. Pour cela,
on choisit le m´ ecanisme suivant : lorsqu’un processus termine ses acc` es, 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 sollicit´ e et il peut se
terminer.
Question 2
Ajoutez le m´ ecanisme de terminaison ` a votre programme. Testez l’ex´ ecution en faisant varier le nombre de processus.
1