Algorithmique Distribuée

Algorithmique Distribuée
Réseaux Asynchrones
Arnaud labourel
http://pageperso.lif.univ-mrs.fr/˜arnaud.labourel
Aix-Marseille Université
5 mars 2013
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
1 / 37
Réseaux Asynchrones
Assumptions
Chaque message qui a été envoyé est éventuellement
reçu par le destinataire.
Il n’existe pas un borne sur le délai de transmission.
Par conséquent, il n’est pas possible de détecter des
fautes (perte de messages). On va donc supposer
qu’il n’y a pas de fautes.
Le but : Trouver les meilleurs algorithmes
(Complexité en termes de nombre de messages
transmis.)
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
2 / 37
Calcul dans les arbres : convergecast
Il est plus facile de faire des calculs distribués dans un
arbre que dans un réseau arbitraire.
Technique de Saturation (“Convergecast")
Feuille : Envoyer un message à l’unique voisin.
Autres nœuds : Attendre de recevoir les messages
de tous les voisins sauf un et ensuite envoyer à
l’unique voisin n’ayant rien envoyé.
Il existe un processus qui reçois des messages de tous
ses voisins. On le nomme processus Saturé.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
3 / 37
Propriétés du convergecast
Il y a exactement un ou deux processus qui va être
saturé (recevoir les messages de tous ses voisins).
S’il y a deux processus saturés, ils sont voisins.
Attention
Les processus saturés ne sont pas forcément les mêmes
pour toutes les exécutions d’un même algorithme sur un
même arbre. La vitesse de transmission des messages
détermine quel processus va être saturé.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
4 / 37
Applications de la technique de Saturation
(1) ELECTION dans un arbre avec UID :
Exécuter la Saturation
Si il y a un seul processus qui est Saturé, il est élu.
Sinon, les deux processus saturés communiquent
entre eux (ils sont voisins), et celui qui a le plus
grand UID est élu.
Complexité = n + 2 messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
5 / 37
Applications de la technique de Saturation
(2) Le Problème de GOSSIP dans une arbre :
Chaque processus exécute la Saturation avec leurs
données (et les informations reçues).
Les processus qui sont Saturés ont reçu toutes les
informations.
Les processus saturés effectuent un Broadcast
(diffusion) de toutes les informations.
Complexité : ≤ 2n messages.
(≤ n messages pour la saturation et ≤ n messages pour la
diffusion)
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
6 / 37
Applications de la technique de Saturation
(3) Trouver le centre d’un arbre :
Centre = Le sommet qui minimise la distance maximale
à tous les autres sommets.
Un arbre peut avoir 1 ou 2 centres. S’il a deux centres,
alors ils sont adjacents (arête centrale).
Les centres sont toujours sur un chemin diamétral (de
longueur égal au diamètre)
d1 (x) : plus grande distance de x à un sommet y connecté
par un voisin u
d2 (x) : deuxième plus grande distance de x à un sommet
z connecté par un voisin v 6= u
Un sommet x est un centre si et seulement si
d1 (x) − d2 (x) ≤ 1.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
7 / 37
Applications de la technique de Saturation
(3) Trouver le centre d’un arbre :
Effectuer la Saturation avec la valeur de niveau
(distance à partir de feuilles).
Les feuilles envoient "0" ; Les autres envoient 1+ (le
max reçu) ;
Les processus qui sont Saturés, effectuer la résolution
suivante :
I
I
Si (Max - 2ième Max ≤ 1) devenir Centre
Sinon envoie (1+ 2ième Max) à celui de qui Max a été
reçu.
Complexité = 23 n messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
8 / 37
Calculs dans les graphes arbitraires
Construction d’un Arbre Couvrant [SPT]
Effectuer un algorithme d’élection
Le processus Elu initie une Diffusion (Broadcast)
Si un processus reçoit des messages de plusieurs
processus, il nomme l’un d’eux comme son parent et
il envoie un message au parent choisi pour l’en
informer.
(il est toujours possible de départager les parents).
Chaque processus envoie des messages à {Voisinage envoyeurs}.
Cette algorithme crée un arbre couvrant enraciné
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
9 / 37
Calculabilité
Est-il toujours possible de construire un arbre
couvrant (SPT : spanning tree) ?
On sait : ELECTION ⇒ SPT
Rappel : Election n’est pas possible dans un anneau
anonyme !
Théorème
La construction d’un arbre couvrant n’est pas possible
dans les graphes arbitraires anonymes.
Attention : Il existe des graphes dans lesquels on peut
résoudre SPT mais pas ELECTION.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
10 / 37
ELECTION dans les graphes arbitraires
Hypothèse UID : Chaque processus a un identifiant
unique !
Avec l’hypothèse d’UID, Il est toujours possible de
résoudre l’ELECTION (sans panne).
On est intéressé par la complexité du problème
d’ELECTION.
Est-ce qu’il y a une borne inférieure sur le nombre de
messages devant être transmis pour résoudre le
problème de l’ELECTION ?
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
11 / 37
Borne inférieure pour l’ELECTION
Théorème
Election dans les graphes arbitraires nécessite
Ω(m + n log n) messages dans le pire des cas.
m = #arêtes
n = #sommets
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
12 / 37
Borne inférieur pour ELECTION
Lemme ([Burns 1980, Bodlaender 1987])
L’élection dans un anneau nécessite la transmission de
Ω(n log n) messages.
1
8
6
4
3
7
Arnaud Labourel (AMU)
5
2
Algorithmique Distribuée
5 mars 2013
13 / 37
Borne inférieure
Lemme
Election dans un graphe arbitraire nécessite le
transmission de Ω(m) messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
14 / 37
Borne inférieure
Lemme
Election dans un graphe arbitraire nécessite le
transmission de Ω(m) messages.
Il faut envoyer au moins un message sur chaque arête !
Sinon, supposons il existe un algorithme A qui effectue
ELECTION dans un graphe G sans envoyer des messages sur
une arête e = (u, v ).
On prends deux copies G1 et G2 du graphe {G − e}. On ajoute
des arêtes entre les noeuds u1 de G1 et le noeud v2 dans G2 et
entre v1 et u2 . On appelle le graphe obtenu G 0 .
Si nous exécutons l’algorithme A sur G 0 , deux noeuds seront
élus (un dans G1 et 1 dans G2 ) ⇒ l’algorithme A n’est pas
correct ! Par contradiction, le lemme est vrai.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
14 / 37
Algorithme Optimal
Théorème
Election dans les graphes arbitraires nécessite
Ω(m + n log n) messages dans le pire des cas.
Y a-t-il un algorithme qui utilise le nombre optimal de
messages ?
GHS algorithme [Gallager, Humblet, Spira 1983]
Construction d’un arbre couvrant minimal enraciné [MST]
dans les graphes arbitraires, avec la complexité de
O(m + n log n) messages.
L’algorithme de MST peut être utilisé aussi pour effectuer
l’ELECTION (racine = leader).
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
15 / 37
Construction d’un arbre couvrant minimal
Définition (MST)
Etant doné un graphe G où chaque arête a un poids,
l’arbre couvrant minimal T est un arbre couvrant de G
avec le poids total minimum.
Si chaque arrêt de G a un poids unique, il existe un unique
MST.
Algorithme distribué pour MST :
On commence par V (G ) ; C’est une forêt où chaque sommet
est un arbre.
Fusionner 2 arbres en utilisant l’arête de poids minimum entre
eux. (encore une forêt, #arbres diminue)
Continuer jusqu’à ce qu’il n’y a qu’un seul arbre.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
16 / 37
Algorithme GHS
Chaque arbre possède un nom (UID de la racine) et un niveau
(initialement 1).
Chaque arbre choisit l’arête minimum sortante. Comment ?
Il envoie un message sur l’arête choisie e = (x, y ), avec son
nom et niveau.
Fusion
Si Niveau(T (x)) = niveau(T (y )) et les deux choisit (x, y ), les
deux arbres sont fusionnés, le niveau est augmenté par un.
Nom du nouvel arbre = MAX(UID(x), UID(y )).
Absorption
Si Niveau(T (x)) <Niveau(T (y )), alors l’arbre T(x) est
absorbé dans T(y). On garde le nom et le niveau de T (y ).
Dans tous les autres cas, (même niveau mais arête 6= ou
niveau plus grand) l’envoyeur du message doit attendre.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
17 / 37
Correction d’ Algorithme GHS
Un processus peut attendre seulement pour un autre
qui a niveau inférieur ou égal.
Un processus non-suspendu va augmenter son niveau
et débloquer les processus qu’il bloquait.
Il n’ y a pas d’attentes en cycle ⇒ pas de blocages !
Il y a toujours un forêt et le nombre d’arbres diminue
de façon monotone.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
18 / 37
Complexité d’ Algorithme GHS
Chaque arbre à niveau i a au moins 2i processus.
Niveau(T ) ≤ log n, pour chaque arbre T .
Tout processus à niveau i ensemble envoient O(n)
messages.
Il y a au plus 2(m − n + 1) messages sur les arêtes
qui ne font pas parties du MST.
Complexité = O(m + n log n).
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
19 / 37
Comment effectuer ELECTION ?
La racine du MST est Elu.
Il faut donner des poids uniques aux arêtes de G. À chaque
arête e = (x, y ), on attribuée le poids (a, b) où
a = MAX (UID(x), UID(y )) et b = MIN(UID(x), UID(y )).
Comment comparer les poids ? Ordre lexicographique
(a1 , a2 ) < (b1 , b2 ) ssi a1 < a2 ou, a1 = b1 et a2 < b2 .
Pour calculer la valeurs des poids de ses arêtes incidentes,
chaque processus doit communiquer avec ses voisins. On
ajoute 2m à la complexité.
Le algorithme GHS est optimal pour ELECTION, en
termes de nombre de messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
20 / 37
Autres Algorithmes
Algorithme YO-YO [Santoro 2007]
Donner une orientation à chaque arête (min → max)
Un ou plusieurs nœuds deviennent des puits.
Un ou plusieurs nœuds deviennent des sources.
Le reste sont des nœuds intermédiaires.
Le graphe est devenu un DAG (Directed Acyclic Graph
pour Graphe Acyclique Dirigé)
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
21 / 37
Algorithme YO-YO
Sources
Puits
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
22 / 37
Algorithme YO-YO
Les sources sont candidates, elles envoient leurs UID.
Les intermédiaires envoient le Minimum des valeurs
reçues.
Chaque sommet sauf les sources envoie un message
OUI (ou NON) sur chaque lien entrant du DAG si la
valeur reçu sur le lien est (n’est pas) la plus petite
parmi celles reçues.
Les sources qui n’ont reçu que des OUI sont
candidates pour la prochaine étape.
On change l’orientation des arrêts sur laquelle NON a
été envoyé.
Le graphe est toujours un DAG mais le nombre de sources
diminue à chaque étape.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
23 / 37
Algorithme YO-YO
Finalement il y a plus qu’une seule source
⇒ le processus Elu
Comment détecter la terminaison ?
Tailler la partie du graphe qui n’est pas utile (à
chaque étape)
I
I
enlever les puits de degré 1.
lorsqu’un nœud reçoit la même valeur de plusieurs liens,
couper tous ces liens sauf un.
A la fin, il reste un sommet, le Elu.
Complexité de l’algorithme (sans taillage) : O(m log n)
Le vrai complexité est inconnue.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
24 / 37
Famille de Graphes Specifiques
Doit-on toujours besoin de O(m + n log n) messages pour
l’ELECTION ?
Pour les famille de graphes spécifiques, c’est possible de
trouver des algorithmes plus efficaces pour ELECTION.
Quelques Exemples :
La Famille d’Arbres
Les Hypercubes orientés.
Les graphes cordales.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
25 / 37
Election dans les Hypercubes Orientés
A étape i, faire une compétition sur le dimension i.
Complexité : O(n) messages.
I
n/2i−1 candidats en étape i ; chaque candidat envoie 1
message sur arête ‘i’
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
26 / 37
Election dans les Anneaux Cordaux
Complexité : O(n + n/t log n/t) messages.
Utiliser les cordes pour éviter les sommets inactifs.
Pour un graphe complet : O(n) messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
27 / 37
Sense of Direction (SoD)
SoD : les processus ont des informations sur les nœuds
derrière les numéros de ports.
(numéros de ports “bien” choisis)
Exemple :
grille orientée (N,S,W,E)
anneau cordal (#port correspond à la distance dans
l’anneau)
Le “sense of direction"
peut se définir sur tous les graphes.
permet d’avoir des algorithmes plus efficaces.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
28 / 37
Problème d’exploration
Algorithme d’exploration
Un algorithme d’exploration consiste en :
un initiateur pouvant envoyer un seul message.
un processus ne peut agir qu’à la réception d’un
message, il peut soit décider (terminer) soit envoyer
un seul message.
l’algorithme est correct s’il termine quand tout les
nœuds ont envoyé au moins un message.
f (x)-exploration ⇒ après f (x) envois de messages
min{n, x} nœuds différents ont envoyé des messages.
On peut voir l’algorithme comme un jeton se déplaçant.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
29 / 37
Technique Modulaire pour l’ELECTION
ELECTION dans les graphes arbitraires.
Utiliser une exploration efficace pour effectuer une
ELECTION efficace.
Algorithme KKM [Korach, Kutten, et Moran, 1990]
Complexité : (n + f (n))(log n + 1)
f (n) : Complexité de l’exploration (visiter tous les
sommets)
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
30 / 37
KKM Algorithme
Chaque initiateur envoie un jeton avec son UID (et
niveau= 1).
Le jeton fait un trajet du graphe.
Si deux jetons se rencontrent, ils sont fusionnés et le
niveau est augmenté par 1. Il recommence une
exploration.
Si le jeton arrive à un sommet marqué par un jeton
de plus haut niveau ou plus grand UID, il est perdu.
Un seul jeton réussit à traverser le graphe
entièrement et rentrer chez lui. Ce sommet est Elu.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
31 / 37
KKM Algorithme
Règles pour les jetons :
I
I
I
I
I
I
Un jeton est soit Annexing(A), Chasing(C), ou
Waiting(W)
Chaque jeton écrit sur chaque sommet qu’il visite.
Un jeton est tué quand il arrive à un sommet de plus
haut niveau.
Un jeton-A devient C (W) s’il arrive à somme de même
niveau, mais marquée par plus petit (grand) UID.
Un jeton-C devient W s’il arrive à sommet marqué par
un autre jeton-C.
S’il y a deux jetons de même niveau à un sommet, ils
sont fusionnés et le niveau est augmenté.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
32 / 37
Correction et Complexité (KKM)
S’il existe k > 1 jetons à niveau i, il existe au moins
1 et au plus k/2 jetons à niveau (i + 1)
S’il y a un seul jeton à niveau i, il va réussir à visiter
tous les sommets.
Pour k initiateurs, il y a k/2i jetons à niveau i.
Nombre de messages à chaque niveau est f (n) + n.
Complexité = (n + f (n))(log k + 1) messages.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
33 / 37
Synchronisation
On a vu les algorithmes pour les réseaux asynchrones
quelconques.
C’est plus facile (efficace) d’utiliser les algorithmes
pour les réseaux synchrone.
Comment utiliser les algorithmes synchrones dans les
réseaux asynchrones ?
Définition (Synchroniseur)
Un algorithme qui simule un réseau synchrone sur un
réseau asynchrone.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
34 / 37
Synchroniseurs
Synchroniseur α.
I
I
Messages = O(m) par ronde.
Temps = O(1) par ronde.
Synchroniseur β.
I
I
Messages = O(n) par ronde.
Temps = O(n) par ronde.
Synchroniseur γ.
I
I
Une mélange des deux.
Le coût dépend de la méthode de regroupement.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
35 / 37
Algorithmes pour Synchroniseurs
Synchroniseur α
I
I
Après ronde i envoyer OK à chaque voisin.
Commencer ronde i + 1 après avoir reçu OK de chaque
voisin.
Synchroniseur β
Construire un arbre couvrant T (enraciné)
I
I
I
Après ronde i envoyer OK à parent.
Racine : Recevoir OK de tout enfants ; Diffuser message
OK sur T.
Commencer ronde i + 1 après avoir reçu OK de parent.
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
36 / 37
Algorithmes pour Synchroniseurs
Synchroniseur γ
I
I
I
Construire une partition des sommets (avec un arête
préférée entre chaque partie).
Effectuer Synchroniseur β dans chaque partie.
Effectuer Synchroniseur α sur les arêtes préférées pour
synchroniser entre les groupes.
Complexité :
Messages = O(k.n) par ronde.
Temps = O(log n/ log k) par ronde.
Pour 1 < k < n, avec regroupement [Awerbuch’85]
I
I
Partitions particulières
I
I
Si chaque sommet est une partie (k=n)
⇒ Synchroniseur α
Si tout le graphe est une partie (k=1)
⇒ Synchroniseur β
Arnaud Labourel (AMU)
Algorithmique Distribuée
5 mars 2013
37 / 37