Problèmes de base 1 Élection dans un anneau orienté (avec

M4102C - Algorithmique distribuée
Problèmes de base
TD1
1 Élection dans un anneau orienté (avec identifiant)
On suppose que la topologie est un anneau orienté : chaque sommet peut envoyer des messages à
son voisin dans le sens des aiguilles d’une montre. Chaque sommet a un identifiant unique (numéro).
Exécutez l’algorithme donné (adaptation de LCR, vu en cours) sur le graphe ci-dessous, en suppo-
sant que l’exécution est synchrone : à chaque ronde, les nœuds recoivent les messages envoyés à la
ronde précédente et en envoient de nouveaux (qui seront reçus à la ronde suivante, etc.). Vous pouvez
représenter les messages envoyés en les écrivant sur les arcs du graphe.
init(): // round 1
send(myID)
onMessage(otherID):
if (otherID > myID)
send(otherID)
else
if (otherID = myID)
ELECTED <- true
23
14
ronde 1
23
14
ronde 2
23
14
ronde 3
23
14
ronde 4
23
14
ronde 5
1. Quelle est la complexité en temps de cet algorithme (nombre de rondes en fonction du nombre
de sommets n) ?
2. Quelle est sa complexité en nombre de message
(a) Dans l’exemple ci-dessus ?
(b) Dans le meilleur des cas pour nsommets ? (dessinez le réseau correspondant pour n= 4)
(c) Dans le pire des cas pour nsommets ? (dessinez le réseau correspondant pour n= 4)
2 Diffusion d’information
On considère le prototype d’algorithme de diffusion suivant dans une topologie arbitraire (non-
orientée), un sommet étant initialement informé (informed à vrai). Chaque message envoyé avec la
primitive sendAll est envoyé à tous les voisins. L’exécution est supposée synchrone (tout le monde
agit au même rythme en parallèle).
init():
if (informed)
sendAll(information)
onMessage(message):
if (! informed)
informed <- true
sendAll(information)

1. Combien de rondes faut-il pour que tout le monde soit informé, si l’émetteur initial est choisi
par un adversaire ?
2. Combien de messages vont être échangés (en fonction du nombre d’arêtes m) ? Pour quel
type de topologie ce nombre est-il le pire ? Si l’on sait à l’avance qu’on est dans ce type de
topologie, peut-on faire mieux ? Comment ?
3 Modification de l’algorithme
On considère toujours une diffusion d’information, mais cette fois l’information à transmettre est
un fichier volumineux. On distingue deux types de messages : les gros messages (envoi du fichier lui-
même) et les petits messages (coordination de l’algorithme). Le propriétaire du réseau vous facture
en fonction du nombre de gros messages envoyés (les petits sont gratuits).
Sans faire d’hypothèse sur la topologie (qui est arbitraire), élaborez une stratégie (abstraite) pour
minimiser le nombre de gros messages envoyés.
1. Comment faîtes-vous ?
2. Combien de gros messages sont utilisés maintenant ? Est-ce optimal ?
4 Construction d’arbres couvrants
L’algorithme suivant construit un arbre couvrant dans le réseau. C’est le même que dans la pré-
sentation avec quelques éléments en plus. Notamment, l’un des sommets est initialisé comme racine
(booléen root à vrai) et chaque autre sommet s’efforce de mémoriser son parent dans l’arbre (en
l’occurence, le sommet depuis lequel il a été atteint en premier).
Node parent <- null
init():
if (root)
parent <- mySelf;
sendAll(empty);
onMessage(message):
if (parent == null)
parent <- message.getSender();
sendAll(empty);
1. On désire modifier cet algorithme pour que les parents aussi sachent quels sommets sont leurs
enfants. Votre stratégie ne doit engendrer aucun message supplémentaire.
2. Faites maintenant en sorte que la racine de l’arbre détecte quand la construction de l’arbre est
terminée (on parle de détection de la terminaison d’un algorithme distribué). On simplifiera
légèrement en utilisant une fonction “oracle” isLeaf(), qui renvoie vrai si le sommet qui
l’appelle est une feuille de l’arbre. Ecrivez l’algorithme complet (nous le coderons en TP).
3. Combien de messages ont été échangés en tout ?
5 Énumération
Comment peut-on adapter l’algorithme de construction d’arbre couvrant de l’exercice 3.2 pour
que la racine apprenne le nombre de participants dans l’arbre ? Réfléchir aussi à une version où la
racine apprend la profondeur de l’arbre (sera utilisée en TP).
Page 2