Interactions atomiques 1 Configuration de JBotSim 2

M4102C - Algorithmique distribuée
Interactions atomiques
(implémentation)
TP2
1 Configuration de JBotSim
Si vous n’avez jamais utilisé JBotSim, téléchargez-le et suivez l’exemple HelloWorld sur le site
http://jbotsim.sf.net, puis revenez à cette feuille de TD.
2 Principe de fonctionnement
Aujourd’hui nous allons créer un support d’exécution pour algorithmes à base d’interactions ato-
miques. Comme vu en cours, ce modèle permet de faire abstraction de la communication en considé-
rant directement comment deux voisins transforment leur état quand ils interagissent. Nous n’utilise-
rons donc pas de messages dans ce TP.
Le résultat d’une exécution dépend ici de deux éléments :
1. Comment les états sont modifiés lors d’une interaction (c.à.d. votre algorithme).
2. Dans quel ordre les interactions se produisent (c.à.d. l’ordonnancement).
Ainsi, l’algorithme ne contrôle pas où se font les interactions. C’est l’ordonnanceur qui choisi tour
à tour l’arête concernée et la donne à l’algorithme. Nous allons commencer par créer cet ordonnanceur
indépendemment de tout algorithme.
3 Création de l’ordonnanceur et premier algorithme
Notre ordonnanceur sera aléatoire : à chaque top d’horloge, il choisira une arête au hasard parmi
toutes les arêtes. Nous nous contenterons d’abord de mettre cette arête en gras pour la visualiser. (Plus
tard, nous la passerons à l’algorithme pour qu’il réalise l’interaction.)
1. Récupérez les classes Main et Scheduler (ordonnanceur, en anglais) sur la page du cours
et placez-les dans un package algodist.tp2. Comprenez leur contenu, puis codez les
fonctionnalités indiquées en commentaire dans la classe Scheduler (sélections successives
d’arêtes aléatoires). L’objectif est atteint si vous voyez clignoter tour à tour les arêtes sélec-
tionnées.
2. Récupérez maintenant la classe Algorithm (même package). Il s’agit d’une classe abstraite
qui masque certains aspects que tous les algorithmes ont en commun. Pour l’utiliser, il suffit
d’en hériter et d’implémenter les trois méthodes abstraites, qui vous permettront de spécifier
1) quel état initial donner par défaut à tous les nœuds, 2) quel état donner à un éventuel nœud
choisi par un clic molette et 3) comment modifier les états quand il y a une interaction.
→Observez ces trois méthodes et leur mécanisme d’appel dans la classe Algorithm.

→Créez une classe DiffusionAlgorithm qui hérite de Algorithm. Implémentez les trois
méthodes abstraites de sorte à réaliser l’algorithme 1 ci-dessous. On utilisera des couleurs à la
place des états Iet N. Vous pouvez récupérer les nœuds de part et d’autre d’une arête donnée
en utilisant link.endpoint(0) et link.endpoint(1). Pensez à tester les deux sens pos-
sibles (côté 0 informé et 1 non-informé ou l’inverse).
→Faites le lien entre l’ordonnanceur et l’algorithme, par exemple, vous pouvez créer l’algo-
rithme dans votre main() et le passer au constructeur de votre ordonnanceur (en modifiant
les paramètres).
Algorithm 1 Diffusion d’une information dans le réseau
Etats initiaux : I(informé) pour le sommet sélectionné ; N(non-informé) pour tous les autres.
Règle d’interaction : I N I I
4 Algorithmes de comptage
On veut maintenant faire du comptage. On s’intéressera d’abord au cas où un nœud distingué
se charge de compter ceux qu’il rencontre directement, puis on s’intéressera à d’autres variantes où
l’initialisation est uniforme.
→Comprenez la logique de l’algorithme de comptage suivant, notamment à quoi correspondent les
trois lettres et l’entier. Puis implémentez cet algorithme dans une nouvelle classe.
Algorithm 2 Comptage du nombre de sommets (avec compteur sélectionné)
Etats initiaux : C,1 pour le nœud compteur (sélectionné) ; Npour tous les autres.
Règle d’interaction : C, i NC, i + 1 F
Astuce : utilisez trois couleurs pour les états C, N, F ! Et utilisez setState() et getState()
pour stoquer l’entier sur le nœud compteur.
→Quelle forme doit avoir la topologie pour que l’Algorithme 2 réussisse à compter tout le
monde ? Vous répondrez pour les deux cas où 1) on peut choisir le compteur qu’on veut et 2) c’est un
adversaire qui choisit le compteur.
→Comprenez la logique de l’algorithme de comptage suivant, en particulier le fait qu’il utilise une
initialisation uniforme (tous les nœuds ont le même état initial). Puis implémentez cet algorithme dans
une nouvelle classe.
Algorithm 3 Comptage du nombre de sommets (version uniforme avec compteurs fusionnants)
Etats initiaux : 1pour tous les sommets.
Règle d’interaction : i6= 0 j6= 0 i+j0
→Quelle forme doit avoir la topologie pour que l’Algorithme 3 réussisse à compter tout le
monde ? Vous répondrez pour les deux cas où 1) le compteur qui survit après chaque interaction
est celui qui nous arrange et 2) c’est un adversaire qui choisit le compteur qui survit.
→Comprenez la logique de l’algorithme de comptage suivant, en particulier le fait qu’il utilise plu-
sieurs règles d’interaction. Puis implémentez cet algorithme dans une nouvelle classe.
Page 2

Algorithm 4 Comptage du nombre de sommets (avec compteurs fusionnants et circulants)
Etats initiaux : 1pour tous les sommets.
Règle de fusion : i6= 0 j6= 0 i+j0
Règle de circulation : i6= 0 0 0 i
→Quelle forme doit avoir la topologie pour que l’Algorithme 4 parvienne à compter tout le
monde ?
5 Forêt couvrante pour réseaux dynamiques
Nous considérons maintenant un algorithme de maintien d’une forêt couvrante. Cet algorithme
est constitué de trois règles de réétiquetage :
1. une règle de fusion : si deux racines d’arbres différents se retrouvent en vis à vis, l’une des
deux est supprimée et les deux arbres sont fusionnés en mettant en gras l’arête correspondante
(désactiver le setWidth() de l’ordonnanceur pour ne pas confondre). De plus, le nœud “per-
dant” choisit l’autre comme parent. On utilisera setProperty(“parent”, noeud) sur le
nœud perdant pour mémoriser l’orientation enfant vers parent, cette dernière n’étant pas dessi-
née par ailleurs. Les méthodes setProperty et getProperty permettent de stocker dans n’importe
quel nœud un objet identifié par une clé textuelle.
2. une règle de circulation, consistant à faire circuler la racine au sein de son propre arbre, en
inversant la relation parent/enfant locale à chaque mouvement.
La troisième règle est différente. Elle consiste à régénérer une racine sur un nœud si une arête vers
son parent disparait.
Algorithm 5 Maintien d’une forêt d’arbres couvrants
Etats initiaux : Rpour tous les sommets.
Règle de fusion : R R R N
Règle de circulation : R N N R
Règle de réparation : N R
×
La troisième règle sera codée en utilisant l’interface ConnectivityListener. Concrètement,
votre algorithme doit se mettre à l’écoute de l’apparition/disparition d’arêtes en s’enregistrant via
addConnectivityListener dans le constructeur. Vous pourrez alors associer votre traitement à
l’évènement onLinkRemoved(). En gros, cela consistera à tester si l’un des deux nœuds de cette
arête avait l’autre pour parent, et si oui, le faire devenir une racine.
Page 3