solution

Aix-Marseille Université
Master Informatique
Algorithmique Distribuée
2014
ALGORITHMIQUE DISTRIBUÉE
Devoir à la maison
CORRECTION
1
Élection dans les anneaux
A. Pendant l’exécution de l’algorithme ALTERNER, pour chaque sommet qui reste candidat dans une étape
paire (impaire), le prochain candidat à gauche (droite) va devenir passif dans cette étape. Donc, pour
2 étapes consécutives quelconques, le nombre de candidats est au moins réduit de moitié. Après 2 log n
étapes, il restera un seul candidat et ce candidat deviendra élu.
Nombres de messages à chaque étape = n (car il y a exactement un message qui est transmis sur chaque
arête de l’anneau). Notez que les sommets passifs retransmettent les messages du candidats et donc qu’il
faut aussi compter ces messages.
Par conséquent la complexité de l’algorithme = n × 2 log n = O(n log n).
B. Voici un exemple : (il y a des autres exemples possibles)
Figure 1 – Exemple d’anneau avec n = 16 sommets.
C. Pendant la première étape, les sommets avec un UID égal n/2 + 1, n/2 + 2, . . . ou n, vont devenir passifs.
Pendant la deuxième étape, les sommets avec un UID égal à 2, 3, . . . ou n/2, vont devenir passifs.
Pendant la troisième étape, le seul candidat (celui qui a un U ID égal à 1) va envoyer son UID à droite
et ce message va traverser l’anneau et revenir sur le candidat.
Alors, il y a 3 étapes et n messages sont transmis pendant chaque étape. Donc, le nombre de messages
transmis est égal à 3n au total.
1
D. On va ajouter une phase initiale à l’algorithme. Chaque sommet va commencer par envoyer son identifiant
à gauche et il va recevoir l’identifiant du voisin au droite. Maintenant chaque sommet va construire un
nouvel identifiant ID0 = (mon identifiant, identifiant du voisin au droite).
Après cette phase initiale, tous les sommets vont exécuter l’algorithme ALTERNER avec ces nouveaux
identifiants. Comme les nouveaux identifiants sont uniques, l’algorithme va réussir.
2
Les Réseaux Synchrones
On va supposer que les sommets ont des identifiants uniques (UID). Si les sommets sont anonymes, il n’est pas
toujours possible de construire un arbre couvrant dans une grille non-orientée (par exemple, c’est impossible
dans la grille 2 × 2 qui est un anneau de taille 4).
A. Il est facile de construire un arbre couvrant quand il y a un sommet élu. Le sommet élu peut commencer
un diffusion avec son UID et chaque sommet u va choisir comme son père le voisin v qui envoie le première
message vers lui.
Mais au début, il n’y a pas de sommet élu. Il y a trois types de sommets dans la grille : (1) les sommets
au coin (degré 2), (2) les sommets au bord (degré 3) et (3) les sommets à l’intérieur (degré 4). Les 4
sommets au coin vont devenir candidats, et chaque candidat va commencer une diffusion avec son UID.
Chaque un sommet du bord ou intérieur reçoit un message "x", il va le renvoyer vers les autres voisins
différent de l’émetteur du message "x". Une fois qu’un sommet u a reçu un message de chaque voisin,
le sommet u va choisir comme père le voisin qui a lui envoyé le plus petit UID. (Si le sommet u reçoit
le même UID de deux voisins ou plus, il va choisir parmi ces sommets le voisin qui est incident à l’arête
correspondant au plus petit numéro de port).
Complexité de l’algorithme : Le message diffusé d’un sommet du coin va arriver au sommet le plus
distant, en temps√(h + l − 2) rondes. La complexité de l’algorithme en temps est donc de O(h + l) rondes.
(Notez bien que n < (h + l) < n + 1. )
B. On va changer l’algorithme pour minimiser le nombre de bits transmis. Dans une grille il y a soit un, soit
deux, ou soit 4 centres (selon la taille de la grille c’est-à-dire la hauteur h et la largeur l).
— Si h est impair et l est impair =⇒ la grille a un seule centre.
— Si h est paire et l est impair, ou si h est impair et l est pair =⇒ la grille a deux centres.
— Si h et l sont pairs =⇒ la grille a 4 centres (qui forment un carré de taille 1 × 1 au milieu de la
grille).
Pour identifier les sommets au centre, il suffit de commencer un diffusion des sommets au coin. S’il y a
un seul centre, le sommet du centre va recevoir les messages de ses 4 voisins en même temps. S’il y a
deux centres, les sommets au centre vont recevoir 3 messages à un temps t et le dernier message à temps
(t + 1). Par contre s’il y a quatre centres, les sommets au centre vont recevoir 2 messages à un temps t et
2 autres message au temps (t + 1). Les contenus de ces messages ne sont pas importants. On peut donc
transmettre un seul bit (le bit ‘0’ par exemple) dans ces messages.
Les sommet(s) au centre de la grille vont devenir candidats. S’il y a plusieurs candidats (2 ou 4), le
candidat avec le plus petit UID va devenir élu. Dans le pire cas, il y a 4 candidats et la distance entre
les candidats est inférieure ou égale à 2. L’élection a donc besoin d’au plus 10 messages.
Une fois qu’on a un seul sommet élu, celui-ci va commencer une diffusion en utilisant les messages du
taille d’un bit (envoyant le bit ‘1’ par exemple) pour la construction de l’arbre couvrant.
Complexité de l’algorithme : Pendant la diffusion (des sommets des coins jusqu’au centre et des
sommets du centre jusqu’aux coins) il n’y a que deux bits transmis sur chaque arête. De plus, il y au
plus 10 messages de taille O(log n) bits utilisé pour l’élection entre les sommets du centre. Puisqu’il y a
(2n − h − l) arêtes dans la grille, la complexité de l’algorithme = O(n) bits.
2
Remarque : On peut utiliser le même algorithme avec une petite modification, pour une grille avec
des sommets anonymes. L’élection entres les plusieurs centres peut être effectuer par un algorithme
randomisé. L’autre partie de l’algorithme changera pas.
C. On va utiliser l’arbre couvrant pour calculer la moyenne de toutes les valeurs dans le réseau. Chaque
sommet ui va calculer le somme de toutes les valeurs dans son sous-arbre et il va envoyer à son père le
message (Si , ni ) avec Si la somme de toutes les valeurs contenues dans son sous-arbre et ni le nombre de
sommets dans son sous-arbre. Pour une feuille uj de l’arbre couvrant, Sj est égale à la valeur du sommet
uj et nj = 1. Lorsqu’un sommet ui (ayant pour valeur initiale xi ) qui a reçu les messages (S1 , n1 ),
(S2 , n2 ), . . . (Sk , nk ) de ses k fils, le sommet ui va calculer le message à envoyer de la manière suivante :
Si = (S1 + S2 + · · · + Sk ) + xi
ni = (n1 + n2 + · · · + nk ) + 1
Enfin, la racine ur de l’arbre couvrant va calculer la moyenne qui est M = (Sr /nr ).
Complexité de l’algorithme : L’algorithme utilise (n − 1) messages puisqu’il y a n − 1 arêtes dans
l’arbre couvrant. Chaque message a une taille d’au plus (log (p · n) + log n) bits = log p + 2 log n bits.
(on rappelle que p > n). La complexité de l’algorithme est donc de O(n log p) bits.
D. On va utiliser encore l’arbre couvrant pour calculer les 5 plus petites valeurs dans l’ensemble D.
Initialement, chaque feuille envoie les 5 plus petites valeurs dans son sous-ensemble vers son père. Un
processus qui reçoit les valeurs envoyées par ses fils, va envoyer les 5 plus petites valeurs parmi celles
reçues plus les siennes. En fin de compte, la racine recevra séparément les plus petites valeurs de ses
sous-arbres. Donc, les 5 plus petites valeurs globales sont celles qui sont les plus petites parmi celles
reçues par la racine et celles de la racine.
Complexité de l’algorithme : L’algorithme utilise (n − 1) messages comme avant. Comme chaque
message contient que 5 valeurs de O(log n) bits, chaque message a une taille de O(log n) bits. La
complexité de l’algorithme est donc de O(n log n) bits.
3
Tolérance aux Pannes
A. S’il n’y a aucune défaillance, on a un algorithme simple qui résout le problème du consensus.
— L’algorithme : Chaque processus va envoyer son valeur vi à tous les voisins ; Chaque processus va
décider la valeur du ET logique sur l’ensemble des valeurs reçues et sa propre valeur.
— Correction : Chaque processus va décider après la première ronde de communication. Comme il n’y
aucune défaillance, chaque processus va recevoir le valeur de toutes les autres processus ; l’ensemble
de valeurs calculées par chaque processus est la même. Par conséquent, chaque processus va décider
la même valeur. La valeur décidée est le ET logique des valeurs proposées (1 si tous les valeurs étaient
1 et 0 sinon). La valeur décidée est donc forcément une des valeurs proposées.
— Complexité : 1 ronde de communication.
B. Oui, c’est possible de résoudre le problème du consensus, quand au plus (n/2 − 1) liens peuvent tomber
en panne.
Dans un graphe complet, il y a (n − 1) chemins différents (et disjoints) entre chaque paire de processus
dans le réseau et chacun de ces chemins est de longueur 2 (ou moins). Si seulement (n/2 − 1) liens sont
3
en panne, il restes toujours un chemin de longueur 2 entre chaque paire de processus. Chaque processus
peut donc recevoir toutes les valeurs initiales des autres processus en 2 rondes.
On va utiliser l’algorithme suivant. Au début, chaque processus va envoyer sa valeur initiale à tous ses
voisins et il va recevoir les messages sur les liens qui sont pas en panne. À deuxième ronde, il va renvoyer
l’ensemble des valeurs reçues (plus sa propre valeur) vers tous ses voisins. Après la deuxième ronde chaque
processus va décider sur le ET logique de toutes les valeurs qu’il a reçues.
Donc, l’algorithme va décider le même valeur que l’algorithme du partie [A].
La complexité de l’algorithme est de 2 rondes de communication.
C. Pour le cas quand il y des omissions de (au plus n/2) messages, on va utiliser un algorithme similaire. Au
début, chaque processus pi va envoyer sa valeur initiale à tous ses voisins (tous les n−1 autres processus).
S’il y a au plus n/2 omissions par ronde, au moins n/2 processus connaissent la valeur du processus pi
après la première ronde. À la deuxième ronde, chaque processus va envoyer l’ensemble des valeurs qu’il
a reçues. Donc, après la deuxième ronde, il peut rester au plus un processus qui ne connait pas encore
la valeur du processus pi . Dans ce cas, à la troisième ronde, ce processus va recevoir la valeur de pi des
autres n − 1 processus (un adversaire peut omettre au plus n/2 de ces n − 1 messages). Après 3 rondes
de communication, tous les processus vont connaitre toutes les valeurs initiales et donc, les processus
peuvent décider sur la valeur du ET logique de toutes les valeurs.
La complexité de l’algorithme est de 3 rondes de communication.
D. Dans le cas où il peut se produire des corruptions de messages, on va envoyer la valeur ‘0’ seulement
dans les rondes paires et la valeur ‘1’ seulement dans les rondes impaires. Donc on va utiliser le même
algorithme que précédemment (voir partie [C]) en utilisant 2 fois plus de rondes.
La complexité de l’algorithme est de 2 × 3 = 6 rondes de communication.
4
Rendez-vous d’agents mobiles avec jeton
A. Chaque agent va poser son jeton au sommet de départ et il va se déplacer dans le sens des aiguilles en
comptant la distance d1 jusqu’au prochain jeton. Ensuite il va continuer de se déplacer dans le même sens
en comptant le distance d2 jusqu’au sommet suivant qui contient un jeton. Si d1 > d2 l’agent va s’arrêter
et attendre l’autre agent. Sinon, il va continuer de bouger dans le même sens jusqu’au rendez-vous avec
l’autre agent.
Bien noter que pour un de deux agents d1 = d and d2 = d0 et pour l’autre agent d1 = d0 and d2 = d.
Donc, seulement un des agents va s’arrêter après un tour de l’anneau. L’autre agent va traverser d arêtes
de plus et il va arriver au sommet dans lequel le premier agent attend.
La complexité de l’algorithme est de n + d = O(n) rondes.
B. Si d = d0 = n/2 et l’anneau est orienté, les deux agents vont être dans une situation symétrique au début.
Si un agent bouge dans le sens des aiguilles d’une montre (ou le sens opposé), l’autre agent va bouge
dans le même sens. Donc, la distance entre les deux agents va toujours être égale à n/2. Maintenant si les
agents posent leurs jetons, la distance entre les deux jeton va être également n/2. A partir de ce moment,
les deux agents vont voir la même chose à chaque étape. Si un des deux agents est dans un sommet sans
jeton (respectivement avec jeton) l’autre agent va être dans un autre sommet sans jeton (respectivement
avec jeton). Donc, les deux agents vont toujours effectuer la même action et la distance entre les deux
agents va toujours être égale à n/2. Le rendez-vous est donc impossible dans ce cas.
C. Dans le cas où l’anneau est non-orienté, un agent peut choisir un sens initial et continuer de se déplacer
toujours dans le même sens pour calculer les deux distances d1 et d2 entre les jetons comme dans
l’algorithme de la partie [A]. On sait que n = (d1 + d2 ) est impair, donc soit d1 ou bien d2 est impair.
4
Les agents peuvent donc se donner rendez-vous sur le milieu du chemin entre les deux jetons de longueur
impaire.
D. Un exemple d’un anneau de taille 4 où le rendez-vous déterministe est impossible, est donné à Figure 2.
Pour une généralisation à toutes les anneaux de taille paire, voir le figure au bas.
1
1
2
2
1
1
2
2
1
1
2
2
1
1
2
---
---
2
2
2
1
1
2
2
Figure 2 – Exemple d’anneau symétrique où rendez-vous n’est pas possible.
5