Vous êtes sur la page 1sur 16

Algorithmes Distribus

Master 1 Informatique anne 2005/2006 Universit de Bordeaux 1

Objectifs
Ce cours d'algorithmes distribus consiste : Introduire le calcul distribu concevoir et analyser des algorithmes distribus programmer des algorithmes (c.f. TP en utilisant un simulateur (!I"I#I$

Introduction
Qu'est ce que le calcul distribu?
%ne machine ou architecture s&uentielle permet le traitement d'une seule opration la fois. ''e(trait de programme ci) dessous est donc une suite d'instruction &ui vont s'effectuer de mani*re s&uentielle : +, ( :- ( . + /, y :- /0( 1 2 3, Print y 'es machines parall*les permettent le traitement de plusieurs oprations en parall*le. Par e(emple4 les architectures 3/ bits sont d5 des architectures parall*les dans la mesure ou elles traitent 3/ bits simultanment. 'ors&ue le nombre de bits devient tr*s important4 on parle aussi de machines vectorielles. %n syst*me distribu est une machine parall*le la diffrence &u'il y a plusieurs entits de calculs autonomes distantes. 'a diffrence principale avec la programmation d'architectures parall*les repose donc sur le fait &ue la distance entre les entits de calcul est plus importantes (chelle plantaire et ncessite donc forcment l'utilisation d'un rseau de communication (type Internet .

Pourquoi utiliser des systmes distribus?


'es ob5ectifs re5oignent principalement ceu( tudis en programmation des architectures parall*les : $ugmenter la capacit de calcul ( moindre coup en a5outant graduellement des entits ou regrouper des ensembles d'entits d5 e(istant. Par e(emple 67I#8,,, en 9rance est un regroupement de 8,,, calculateurs rpartis sur tout le territoire. Communi&uer entre entits distantes (Telecommunication4 7seau '$:4 "atellite4 ;ifi4 ... et mettre en rapport des ban&ues de donnes rparties (Internet4 Peer 1 To 1 Peer .

Un cadre de base pour les systmes distribus


'es entits seront les processeurs4 des ordinateurs4 des P#$4 des satellites. Il e(iste principalement deu( mod*les d'archirectures distribues : le < passage de messages = et la < mmoire distribue = : Passage de messages : ce mod*le traite e(plicitement des communications. 'ors&u'un processeur veut communi&uer avec un autre4 il doit lui envoyer un message via le medium. >moire partage : $u contraire4 les processeurs ne communi&ue pas entre >moire Partage (>.P. eu( directement. Ils ont acc*s une ?one mmoire (ou des variables commune en lecture et@ou criture. Pn P+ P+ An particulier4 une mmoire partage peut servir communi&uer. 'e mod*le P7$> (Parallel 7andom $cces >achine dont un schma simplifi de fonctionnement est propos ci) contre4 est une gnralisation du mod*le 7$> classi&ue (ou le processeur communi&ue avec la mmoire vive . 'e mod*le P7$> ou mmoire partage est utile pour l'tude du degr de paralllisme d'un probl*me.

'e mod*le P7$>4 et d'autres mod*les drivs tels &ue "I># ("ingle Instruction >ultiple #ata ou >I># (>ultiple Instruction >ultiple #ata est un bon syst*me. Il est cependant asse? loign des syst*mes distribus rels pour plusieurs raisons : "i n (nombre de processeurs est grand4 alors il n'est plus physi&uement possible &ue tout le monde acc*de en mBme temps (unitaire une mBme variable. "i les distances entre les entits sont grandes alors l'acc*s un lien commun (>.P. avec des temps similaires n'est plus possible. #ans le cadre de ce cours4 nous allons choisir le mode point point4 &ui se modlise par un graphe 6 - (!4 A . 'es sommets du graphe reprsentent les entits (processeurs et les arBtes les liens de communications entre les entits ( priori4 il s'agira tou5ours d'un graphe non orient : les liens de communication sont bidirectionnels . Cn supposera de plus &ue 6 est tou5ours conne(e (pas de sommets 1 entits isols ou sous graphes isols .

Particularit du calcul distribu


Il y a des communications et elles ne sont pas gratuites
"oient Pi et P5 deu( programmes distants s'changeant des donnes une fr&uence de + 6h?.
Pi : send ((4 P5 receive (y (-(.y ... P5 : receive (( v - /0( . + send (v4 Pi ...

"achant &ue + 6h? - +, )D s et la vitesse de la lumi*re c - 3 . +, E m@s4 la distance entre P i et P5 doit donc Btre (pour ne pas interfrer sur la vitesse de calcul d'au plus : dist(Pi4 P5 F +,)D 3.+,E - ,43 m. Cette distance n'est videmment pas respectable dans un vrai syst*me distribu4 ce d'autant plus &u'il s'agit ici de suppositions optimales (dans les composants lectroni&ues4 la vitesse des donnes n'atteind pas la vitesse de la lumi*re . 'a plupart du temps4 on consid*rera donc &ue le temps de calcul local est ngligeable devant les temps de communications.

Connaissance partielle
%n processeur doit faire son calcul avec une connaissance4 priori limite4 du syst*me. #ans un syst*me centralis (ou s&uentiel 4 l'tat d'une partie de la mmoire est dtermin par le calcul du processeur uni&ue. An particulier4 une partie de la mmoire ne change pas si le processeur ne le modifie pas. An distribu4 Pi ne contrGle &ue son tat local. 'es donnes rparties sur d'autres processeurs changent sans aucun contrGle de Pi (une sorte d'adversaire &ui modifie les donnes . Parfois Pi connait la topologie du graphe en entier4 parfois seulement ses voisins ou mBme4 ne connait &ue lui)mBme (rseau anonyme : les processeurs ont tous le mBme programme . Cn suppose gnralement &ue les processeurs ont des identits uni&ues et connaissent leurs voisins4 ventuellement le nombre de sommets du graphe.

Exemple : Diffusion d'un message M de x vers y


Il faut pour cela distinguer trois types de programmes : celui &ui s'e(cute sur ( (pour envoyer le message 4 celui &ui s'e(cute sur y (pour recevoir le message et celui &ui s'e(cute sur une machine &ui n'est pas y (pour diffuser 1 transfrer le message reHu au( voisins .
K: Pour tous les voisins v de ( send (>4 v I: 7eceive (> L: 7eceive (> Pour tous les voisins M de L send (>4 M

< I = reHoit le message en un temps fini. Cependant4 des messages peuvent boucler l'infini ( cause de ? &ui rediffuse sans distinction un message reHu tous ces voisins . Cn peut corriger ce probl*me si l'on suppose &ue les processeurs connaissent n (le nombre de processeurs@sommets : on met dans le message > un compteur C initialis n. Cn dcrmente ce compteur cha&ue passage sur un sommet ? et on ne retransmet > &ue si C J ,.

Erreurs
'e cas des erreurs est relativement simple en s&uentiel. "i un lment est dfectueu( (mmoire4 priphri&ue4 processeur4 dis&ue 4 on le change et on reprend@continue@recommence le programme. An distribu4 on peut de plus avoir un lien de communication en panne. Cela peut donc causer de nombreu( probl*mes tels &ue la corruption des messages ou avoir des adversaires &ui changent les messages. 7edmarrer tout le syst*me peut parfois Btre vit en rendant l'algorithme robuste (tolrance au( pannes . Nien videmment4 cette tolrance dpend ausi du rseau (graphe : y a)t)il plusieurs chemins possibles d'un sommet un autreO .

Synchronisme
Cn consid*re deu( mod*les e(tr*mes : "yst*me synchrone : on suppose &ue le dlai de transmission des messages est born. Plus prcisemment4 cha&ue processeur a une horloge locale dont les tops d'horloges ont la proprit suivante : Pun message envoy de v vers un voisin u au top t (de v doit arriver avant le top t . + de uP. #onc4 cela a le mBme effet &u'une horloge globale. 'e cycle de calcul de cha&ue processeur ressemble donc : + : Anvoyer des messages + ou plusieurs voisins / : 7ecevoir des messages de + ou plusieurs voisins 3 : Affectuer le calcul local. 'e calcul local est suppos prendre un temps ngligeable devant l'tape /. #onc le cycle de calcul passe son temps attendre la rception de messages (les rceptions sont blo&uantes . "yst*me asynchrone : au contraire4 l'algorithme est ici dirig par des v*nements. 'es processeurs ne pouvant avoir acc*s une horloge globale pour prendre leur dcision. 'es messages envoys de v u arrivent en un temps fini (si pas de faute mais imprvisible. Par e(emple4 on ne peut pas dduire l'ordre d'arrive des messages venant des voisins ui de v d'apr*s leur ordre d'mission. 6nralement4 un algorithme en asynchrone ressemble : "i v*nement A+4 faire K+ (avec A+ - arrive d'un message d'un certain type : "T$7T4 "TCP4 ... "i v*nement A/4 faire K/ ... Il e(iste4 dans la prati&ue4 des syst*mes intermdiaires4 en connaissant une borne infrieure et suprieure de transmission des messages.

Asynchronisme et non dterminisme


An s&uentiel4 le non dterminisme est li l'usage de bits alatoire (fonction 7$:#C> . "inon4 avec les mBmes entres4 on a les mBmes sorties (puis&ue4 mBme e(cution . An distribu4 on n'a pas besoin de fonction 7$:#C> pour avoir du non dterminisme. Cn peut e(cuter deu( fois le mBme algorithme et sur les mBmes entres et obtenir deu( rsultats distincts. ''e(cution d'un algorithme asynchrone est donc appel scnario. !oici un e(emple simple :
P!+ : "A:# (+4 u !+ % P!/ : "A:# (,4 u !/ P% : 7ACAI!A (( P7I:T ((

Ici4 on ne sait pas si u recoit + ou , (en asynchrone . 'e rsultat du Pprint (P est donc potentiellement diffrent cha&ue e(cution.

Modles du calcul distribu


Cn suppose un mode de communication point point modlis par un rseau (graphe .

Mesure de complexit
An s&uentiel4 il y a deu( mesures de comple(its : temps et espace. 'a chose est plus subtile en distribu.

e temps
#finition en synchrone : 'a comple(it en temps de l'algorithme P sur le graphe 64 not TA>P" (P4 6 est le nombre de tops d'horloges (rondes gnrs par P sur 6 dans le pire des cas (sur toutes les entres lgales possibles stocQes sur les processeurs de 6 entre le dbut du premier processeur &ui dmarre et la fin du dernier processeur &ui s'arrBte. #finition en asynchrone : 'a comple(it en temps de l'algorithme P sur 64 not TA>P"(P4 6 est le nombre d'unit de temps du dpart la fin dans le pire des cas (sur toutes les entres lgales et tous les scnarii 4 cha&ue message prenant un temps unitaire.

Espace
C'est le nombre total de bits utiliss par P sur 6 dans le pire des cas (pour toutes les entres lgales possibles et pour tous les scnarii si l'on est en asynchrone .

Complexit en nom!re de messages


%n message sur un arBte coRte P+P. Cn compte le nombre de messages changs sur 6 par P (not >A""$6A(P4 6 durant l'e(cution de P sur 6 dans le pire des cas.

"uel#ues exemples
Cn consid*re &uatre algorithmes P$4 PN4 PC4 et P# &ui s'e(cutent sur S: (graphe complet n sommets : P$ : envoie un message > de , + PN : envoie un message diffrent >i en parall*le depuis i vers i . +(mod n 4 et ce4 pour tout i PC : envoie un message > depuis , vers +4 puis de + vers /4 ...4 puis itrativement le long d'une chaine i -J i.+ P# : envoie depuis , un mesage >i vers le sommet i. "i l'on regarde la comple(it en temps4 P $4 PN et P# sont de comple(it +4 et P C de comple(it n 1 +. An revanche4 si l'on regarde la comple(it en nombre de messages4 P$ a une comple(it de + et PN4 PC et P# une comple(it n 1 +.

Complexit globale et existancielle


'es notions de comple(its C4 T4 U et o ne seront pas re(pli&ues ici (voir cours P$lgorithmes $vancsP et P$lgorithmes des graphesP 'icence 3 . :ous supposons ac&uises ses notations pour la suite. !oici &uel&ues dfinitions spcifi&ues la comple(it en distribu : Norne suprieure : Pl'algorithme P a4 par e(emple4 une comple(it C(n.logn pour les graphes planairesP F-J pour tout graphe planaire4 Comple(it(P4 6 c.n.logn. Norne infrieure : Pl'algorithme P a4 par e(emple4 une comple(it T(n pour les graphes planairesP F-J il e(iste c tel &ue il e(iste un graphe 6, (et tel &u'il e(iste un scnario 1 en asynchrone tel &ue Comple(it(P4 6 , c.n. 'a borne infrieure est donc une borne e(istancielle. Norne infrieure globale : Pl'algorithme P a une comple(it T(n pour tout grapheP F-J il e(iste c (et un scnario dans le cas asynchrone tel &ue pour tout graphe 64 Comple(it(P4 6 c.n.

Modles reprsentatifs
$vant d'e(pli&uer les diffrents mod*les reprsentatifs4 il est important de noter ici &uel&ues hypoth*ses &ui seront utilises par la suite. Cn suppose : &u'il n'y a aucune faute (pas de liens en panne4 pas de changement de topologie du graphe4 ... &u'il y a une identit uni&ue : les processeurs ont une identit uni&ue (entier sur C(logn bits &ue les calculs locau( sont gratuits Il e(iste alors 3 mod*les reprsentatifs : >od*le 'CC$' : on tudie la nature locale d'une e(cution sur le TA>P" re&uis pour un probl*me. Cn ne se pose pas la &uestion de l'asynchronisme (un mod*le 'CC$' est forcment synchrone et de la congestion (plusieurs messages sur le mBme lien en mBme temps . #ans ce mod*le4 on suppose de plus &ue la taille des messages est illimite4 &ue la communication est synchrone et &ue tout le monde se rveille en mBme temps (mBme top d'horloge . >od*le CC:6A"T : on tudie l'effet du volume des communications. + message - + message de base (C(logn bits. Par e(emple4 on peut considrer la tache : Pdans un arbre4 un sommet interne v veut communi&uer l'identit de ses fils son p*re.P 'es d fils envoient leur identit4 ce &ui ncessite d messages et v envoie ensuite + + les d identits son p*re. Cn obtient un total de /d messages envoys sur 6. #ans le

mod*le CC:6A"T4 on peut Btre amen distinguer le cas synchrone et le cas asynchrone. >od*le $"I:C : on tudie l'effet de l'asynchronisme ('e mod*le $"I:C peut donc Btre vue comme l'inverse du mod*le 'CC$' .

Diffusion et concentration
La diffusion
'a diffusion consiste envoyer4 depuis une source4 le mBme message tous les autres sommets. "oit 6 un graphe avec une source r, et n sommets4 alors tout algorithme N de diffusion sur 6 vrifie : >A""$6A (N4 6 J- n 1 + TA>P" (N4 6 J- ecc (r, (en synchrone ou asynchrone 4 et ou ecc est la plus grande distance partir de r,. Cn notera &ue4 pour tout sommet v4 ecc(v - >a( (dist(v4 ( 4 pour tout (. An notant # le diam*tre d'un graphe4 on a alors

" ecc " . /

#rbre de diffusion
%ne stratgie courante4 pour raliser une diffusion est d'utliser un arbre : on ne diffuse &ue le long des arBtes de l'arbre (arbre de diffusion . Ici4 on va supposer &ue l'on connait un arbre de diffusion T ( savoir : cha&ue sommet connait son p*re et ses fils . ''algorithme de diffusion est alors le suivant : $lgorithme Tcast( r,4 T : "i u V- r,4 7eceive (>4 Pere(u Pour tout fils f de u4 send (>4 f #ans ce cas4 si T est un arbre couvrant de 6 enracin en r, : >A""$6A ( Tcast(r,4 T 4 6 - n 1 + TA>P" (Tcast(r,4 T 4 6 - h (hauteur de l'arbre 1 &ue ce soit en synchrone ou en asynchrone. Cn appelle arbre N9" (Nreath 9irst "earch un arbre de plus court chemin4 c'est dire un arbre T couvrant de 6 enracin en v tel &ue distT(u4 r - dist6(u4 r pour tout u de !(6 . "i T est un arbre de plus court chemins enracin en r ,4 alors Tcast(r,4 T est un algorithme de diffusion optimal en nombre de messages et en temps.

$nnondation
Cn utilise cette techni&ue en l'absence de structure prcalcule comme un arbre de diffusion. ''algorithme d'innondation se rsume ainci : $lgorithme 9'CC# (source r, : "i on est r, : "A:# (>4 v pour tout voisin v de r, Pour tout sommet diffrent de r,4 la rception du premier message sur l'arBte e : on stocQe le message > Cn diffuse le message > sur toutes les autres arBtes incidentes u Pour tout autre message contenant >4 ne rien faire Cet algorithme vrifie les proprits suivantes : >A""$6A (9'CC#4 6 - U(WAW TA>P" (9'CC#4 6 - U(ecc(r, - U(diam(6 "ur une arBte4 il circule au moins un message4 et au plus /. $pr*s t units de temps4 > atteind tous les sommets distances infrieure t de r,. #onc4 TA>P" (9'CC#4 6 -F ecc(r , et pour tout algorithme de diffusion N4 TA>P"(N4 6 J- ecc(r, . 'e probl*me de la diffusion partir d'une source r , est donc &uivalent (en temps et nombre de messages au probl*me de la construction d'un arbre couvrant enracin en r,. "i on sait construire un arbre T4 alors on le construit et on appli&ue Tcast pour diffuser. "i on connait un algorithme de diffusion N depuis r,4 alors il suffit de dfinir le p*re de u comme le voisin v d'ou u a reHu > en premier.

Il y a une grande diffrence entre le mode synchrone et asynchrone &uant la structure de l'arbre T 9'CC# construit partir de l'agorithme 9'CC# : An synchrone4 T9'CC# est un N9" (plus court chemin enracin en r,4 donc avec une hauteur gale ecc(r, . An asynchrone4 T9'CC# peut avoir une hauteur bien suprieure ecc(r , . An ralit4 cette hauteur peut atteindre n 1 +.

Concentration
'e probl*me avec les algorithmes de diffusion vus prcdemment4 est &u'un sommet ne sait pas lors&ue la tache globale est termine. C'est le probl*me de la terminaison (ou dtection locale de la terminaison . 'a solution est de collecter l'information de terminaison des feuilles la racine dans l'arbre de diffusion : il s'agit donc d'une opration de concentration. Puis4 r, rediffuse un message de 9I: tous. #*s &ue u reHoit le message > (de la diffusion 4 il fait : "i c'est une feuille de la diffusion4 il repond par un message $CS son p*re "inon4 il attend de recevoir tous les messages $CS de ses fils4 puis l'envoie son p*re. %n tel algorithme assure les proprits suivantes (en synchrone : >A""$6A (CC:CA:T7A4 T - n 1 + TA>P" (CC:CA:T7A4 T F- hauteur (T An asynchrone4 le temps de diffusion et le temps de concentration peuvent Btre tr*s diffrent (par e(emple sur un graphe complet avec un arbre couvrant de hauteur n 1 + .

Arbres couvrants
#rbre %&'
%n arbre N9" est un arbre T couvrant les sommets d'un graphe 6 de racine r, tel &ue distT((4 r, - dist6((4 r, . Cn a vu au chapitre prcdent l'algorithme 9'CC# permettant de construire un N9" dans le cas synchrone. :ous rappelons ici &ue >A""$6A (9'CC#4 6 - U(WAW et TA>P" (9'CC#4 6 - U(ecc(r , - U(diam(6 . Ces bornes sont les meilleures possibles si les sommets n'ont aucune connaissance sur le graphe 6. :ous allons admettre les propositions suivantes : Pour tout 6 et pour tout algorithme distribu $ &ui calcule un N9" sur 6 (sans connaissance sur 6 alors >A""$6A ($4 6 - (WAW Pour tout 6 et pour tout algorithme distribu $ &ui calcule un N9" sur 6 alors TA>P" ($4 6 - (# . Par cons&uent4 en synchrone4 la meilleure solution pour construire un N9" est l'algorithme 9'CC#. An asynchrone4 9'CC# ne construit pas ncessairement un N9" sur 6. #ans la suite4 on va se concentrer sur le mod*le asynchrone CC:6A"T.

#rbre %&' ( algorit)me distribu de "i*+stra


''ide de cet algorithme est de construire un N9" en travaillant par niveau. $ cha&ue tape4 on essaye d'a5outer les sommets ad5acents au dernier niveau &ui ne sont pas d5 dans l'arbre. #ans l'implmentation distribue4 la racine r , va PsynchroniserP la construction de cha&ue nouveau niveau. $u dpart de cha&ue phase4 r , gn*re un message PpulseP dans l'arbre d5 construit. Cn suppose &u'apr*s p phases4 il y a un N9" T p enracin en r, &ui couvre tous les sommets distance infrieure ou gale p de r,. An particulier4 on suppose &ue cha&ue sommet de T P connait son p*re et ses fils (de T P . $insi4 la phase p . + de l'algorithme #ist#i5Qstra : r, gn*re un message PpulseP &u'il diffuse dans TP $ la rception d'un message PpulseP4 cha&ue feuille de T p envoie un message d'e(ploration PlayerP tous ses voisins diffrent du p*re4 "oit M un sommet &ui reHoit pourla premi*re fois un message PlayerP de v4 alors p*re(M - v et M retourne v un message lui indi&uant &u'il a t choisi comme p*re. Tous les autres sommets essayant d'envoyer par la suite un message M recevront un message P$CSP classi&ue spcifiant &ue le sommet M est d5 dans l'arbre. 'es feuilles M de Tp collectent les messages (P$CSP . PP*reP des messages PlayerP et choisissent comme fils

ceu( &ui ont choisit v comme p*re . 'ors&ue v (feuille de T P a reHu un P$CSP de tout ses voisins4 alors on retourne un P$CS3 son p*re et les sommets internes de Tp font de mBme (concentration vers r, 'ors&ue r, a reHu tous les P$CSP de ses fils4 on dmarre la phase suivante. Cn distingue cependant ici un probl*me ma5eur : bien &ue l'algorithme construise effectivement un N9"4 l'algorithme lui mBme ne se termine pas.

%ne solution consiste ce &ue les feuilles comptent le nombre de nouveau( fils. "'il y en a au moins +4 on envoie + au p*re4 et , sinon. 'es sommets internes font une concentration vers r , en ralisant un C7. 'a racine continue tant &ue le rsultat du C7 de ses fils est diffrent de ,. Cn peut dtecter la terminaison en cha&ue sommet en diffusant depuis r , un message 9I:. $pr*s la phase p4 l'arbre Tp.+ construit la phase p . + est bien un arbre N9" couvrant les sommets distance infrieure ou gale p . + de r,. 'a comple(it en temps la phase p est TA>P" (phase p F- p . / . p. Cn a donc
"

,-MP' "ist"i*+stra ,-MP' p)ase =. " / .


p= ,

'a comple(it en nombre de messages la phase p est >A""$6A (phase - C( WA(T p W . WApW . WAp4 p.+W avec : WA(Tp W reprsente le nombre de message PpulseP . messages de concentration (infrieur n WApW : messages d'e(ploration entre sommets de niveau p dans T WAp4 p.+W : messages d'e(ploration entre sommets de niveau p et p . + dans T Cn obtient alors une comple(it totale :

M-''#/- "ist"i*+stra M-''#/- p)ase =. n0" - / .


p =,

"

Pour rsumer4 on pourra donc dire en conclusion &ue l'algorithme de #i5Qstra construit bien un arbre N9" de 6 enracin en r, et ayant les proprits suivantes : TA>P" (#ist#i5Qstra - C(#Y >A""$6A(#ist#i5Qstra - C(n# . WA(6 W

#rbre %&' ( #lgorit)me de %ellman1&ord


Cette variante est base sur une version optimiste de 9'CC#. Cha&ue sommet v g*re une variable '(v &ui est son niveau dans l'arbre construit par 9'CC#. Cette variable est corrige au fur et mesure de l'e(cution de 9'CC# de faHon maintenir la longueur de la plus courte route de v r,. $lgorithme N9 : '(r, - , et '(v - pour tout v diffrent de r, r, envoie un message 'ayer(, tous ses voisins $ la rception d'un message 'ayer(d d'un voisin M reHu en v. "i d . + F '(v alors p*re(v - M et '(v - d . + et on envoie 'ayer(d . + tous les voisins sauf le nouveau p*re M. ''algorithme de Nellman)9ord vrifie :

d +4 apr*s d units de temps4 tout sommet v distance d de r , a d5 reHu un message 'ayer(d 1 + d'un de ses voisins. #onc '(v - d et p*re(v - M tel &ue '(M - d 1 +. Par cons&uent TA>P" (#istN94 6 - C(# . 'a premi*re valeur borne affecte '(v est au plus n 1 + (la longueur de plus long chemin possible . #onc '(v va Btre modifie auu plus n 1 / fois ('(v ne peut &ue dcroitre . $ cha&ue modification de '(v 4 v envoie deg(v 1 + messages. #onc au total v va envoy au ma(imum n.deg(v . Cn a donc

M-''#/- "ist%& ! / n0deg =. n - /

Par cons&uent4 dans le mod*le asynchrone CC:6A"T4 l'algorithme distribu de Nellman)9ord construit un N9" enracin en r, avec comme comple(it : TA>P" (#istN9 - C(# >A""$6A (#istN9 - C(n.WAW An rsum :

>essages Norne infrieure (et mod*le synchrone #i5Qstra Nellman)9ord >eilleur connu A A . n.# n.WAW A . n.log n
3

Temps # #Y # #.log3n

#rbre "&'
Il s'agit maintenant de visiter tous les sommets d'un graphe et de construire un arbre couvrant en longueur. An s&uentiel l'algorithme #9" fonctionne comme suit : Cn dmarre en r , et pour cha&ue v faire : si v a des voisins non encore visits4 alors on en visite +. "inon4 on revient vers le sommet &ui a visit v en premier. "'il n'y a pas de tel sommet4 la recherche est termine. An s&uentiel4 cela prend un temps C(WAW . An distribu4 un algorithme consiste simuler l'algorithme s&uentiel en utilisant un 5eton. "eul le sommet ayant le 5eton pourra e(cuter des actions. Pour savoir si M4 voisin de v a t visit ou non4 il est ncessaire d'envoyer un message sur l'arBte [M4 v\ (mais on peut le faire &u'une seule fois . 'e temps et le nombre de messages sont donc en C(WAW . >ais on peut amliorer le temps4 en vitant de traverser les arBtes &ui ne sont pas dans l'arbre. "olution : lors&ue v est visit la premi*re fois : Cn g*le le #9" informer tous les voisins &ue v a t modifi (ie4 les voisins de v stocQent Pv visitP . Cela permet de faire &u'ils n'aillent pas le visiter leur tour venu4 pour amliorer les traitements. $ttendre un accus de rception de tous les voisins reprendre l'e(cution $insi4 un sommet va savoir e(actement les sommets voisins restant visiter. 'e 5eton traverse uni&uement les arBtes de l'arbre. Cela prend C(+ en temps par tape et C(deg(v messages. Cn obtient donc une comple(it finale : >A""$6A(#ist#9" - C(WAW TA>P"(#ist#9" - C(n

M', ( Minimum 'tanning ,ree


"oit 6 - (!4 A4 M 4 ou M est une fonction de poids. "oit 6' le sous graphe de 6 et tel &ue ''arbre T est >"T pour 6 si M(T est minimum pour tout arbre T de 6.

2 / ' =

e - / '

2 e .

$ypoth%ses
Cha&ue sommet connait le poids de ses arBtes incidentes. Cn suppose &ue les poids des arBtes sont tous diffrents. Par cons&uent4 >"T est uni&ue. "i tous les poids sont identi&ues4 et toutes les identits des sommets sont identi&ues4 alors aucun algorithme distribu e(iste (avec un nombre fini de messages . Cn admet les proprits suivantes4 pour tout graphe : Tout algorithme distribu calculant un >"T pour 6 sans connaissance (sauf les poids ncessite (WAW messages. Tout algorithme distribu sur le graphe n sommets ncessite (n.logn messages. #finition P9ragmentP : %n arbre T d'un graphe 6 - (A4 !4 M est un >"T fragment de 6 s'il e(iste un >"T T > de 6 tel &ue T est un sous arbre de T>. %n arBte e est sortante du fragment T si e(actement une e(trmit de e est dans T. ''arBte sortante de poids minimum du fragment T est note >;CA(T .

"i e - >;CA(T alors T % [e\ est un fragment. Par cons&uent4 on obtient l'algorithme suivant : 7pter 5us&u' obtenir un arbre couvrant : Choisir un fragment T et a5outer son arBte >;CA(T :ous allons donc maintenant voir deu( algorithmes permettant de calculer un >"T.

Algorithme de &'IM
$u dpart4 on choisit comme fragment un sommet r ,. 'a source r, va synchroniser la construction de T % [e\ avec e -

>;CA(T . 'a source envoie un message PPulseP tous les sommets du fragment T (r , T pour indi&uer &ue la phase p . + a commenc. (T poss*de alors p sommets et cha&ue sommet de T connait ses voisins dans T . Cha&ue sommet dtermine son arBte (u4 v telle &ue v T de poids minimum et informe la racine du rsultat. 'es rsultats sont concentrs en r, et on en profite pour calculer le minimum de ses descendants (pour minimiser le nombre de messages . Il reste alors r, d'ordonner l'a5out de >;CA(T . #'ou l'algorithme #istP7I> : r, gn*re un message PPulseP et le diffuse sur T. Pour la toute premi*re phase4 ce message va aussi informer les sommets de T du nouveau sommet y et de l'arBte e - ((4 y a5oute l'arbre l'tape d'avant. $ la rception d'un message PPulseP4 cha&ue sommet v de T connect dans 6 par e - (v4 y y mar&ue l'arBte e comme interne. 'e sommet y interroge ses voisins pour connaitre ceu( &ui sont dans T et les mar&ue. "i v est une feuille4 il envoie son p*re dans T le message (e4 M(e 4 Le ou e est l'arBte la plus lg*re sortante de v et pas dans T et elle &ue e - (v4 Le . Ces triplets sont concentrs sur T vers r , en calculant le minimum M(e reHu (un sommet interne v T reHoit M+4 M/4... et calcule le minimum 1 y compris ses propres valeurs 1 avant la transmission vers le p*re . 'a racine choisit le triplet (e4 M(e 4 Le avec M(e minimum. 'e minimum est calcule avec les valeurs de r ,. Cet algorithme est correct (il calcule bien un >"T car il appli&ue la r*gle e - >;CA(T . :ous allons maintenant voir sa comple(it. Atudions d'abord la comple(it pour la phase p . + : TA>P" (phase p . + - C(p 4 pour la diffusion et la concentration >A""$6A (phase p . + - /WA(T W . C(deg y - C(p . deg(y Cn obtient alors une comple(it totale :

,-MP' "istP3$M = . p . n/
p= +

n +

M-''#/- "istP3$M = c0 p deg y p . n/ - / =. n/


p= +

n +

Algorithme ($S )Synchrone* : (allager+ $um!let+ Spira ),-./* 0 variante de 1rus2al


$ une certaine tape4 soient 9+4 9/4 ...4 9Q les fragments obtenus (cha&ue sommet de 9 i connait la racine . Cn dtermine >;CA(9i pour cha&ue fragment 9i en utilisant #istP7I> telle &ue e i - >;CA(9i - (vi4 yi . 'e sommet vi va alors envoyer un message Pdemande de fusionP. "i on a par e(emple e+ - e/4 on fusionne 9+ et 9/ par e+ et cela forme un nouveau fragment compos de 9 + % 9/. "inon4 les arBtes ei forment une structure particuli*re. Cn note F9J l'ensemble des fragments et FAJ les arcs induits par les messages Pdemande de fusionP. Cn obtient alors le graphe F6J - (F9J4 FAJ . Cha&ue composante de F6J est un graphe orient (les arcs pointent vers la racine saf &ue la racine est un double fragment 9+ F-J 9/. Tous les fragments d'une mBme composante sont fusionns. Cn dcide &ue la racine du fragment 9+ F-J 9/ ayant le plus petit identifiant devient la racine du nouveau grand fragment. Pour cela4 il faut alors faire une diffusion de v+ et v/ vers tous les fragments rattachs. Cela peut se faire car les sommets e(trmits d'un arc de FAJ ont reHu un message Pdemande de fusionP et vont pouvoir diffuser sur cette arBte la nouvelle racine du grand fragment. Cn continue ainsi 5us&u' obtenir un seul fragment. Cn peut dtecter cette terminaison car tous les voisins des sommets du fragment seront dans l'arbre (il n'y a plus d'arBte >;CA(9 . !oyons maintenant la comple(it de cet algorithme : TA>P" (phase i - C(n >A""$6A (phase i - C(n . WA(6 W - C(WA(6 W 4 ou n reprsente la diffusion concentration dans tous les fragments et WA(6 W la derni*re tape de Prim. Il s'agit maintenant de remar&uer &u'entre la phase i et la phase i . +4 le nombre de fragments est deu( fois plus faible (au moins . Il y a donc logn phases au plus (avec n fragments au dpart . Cn obtient donc une comple(it globale : TA>P"(6]""ynchrone - C (n.logn >A""$6A(6]""ynchrone - C(WA(6 W.logn

Synchronisation
Acrire un algorithme pour un syst*me asynchrone est plus difficile &ue pour un syst*me synchrone. ''ide est donc de transformer automati&uement un algorithme synchrone (pour un syst*me symtri&ue en algorithme asynchrone. Cela va impli&uer un surcoRt en temps et en nombre de messages. >ais4 dans la plupart des cas4 ce surcoRt ne change pas les comple(its.

Mt)odologie
"oit ^s un algorithme synchrone crit pour un syst*me synchrone et _ un synchroniseur. Cn souhaite ^ $ - _( ^s de faHon ce &ue ^$ puisse s'e(cuter sur un syst*me synchrone. 'a simulation doit Btre correcte4 c'est dire &ue l'e(cution de ^$ doit Btre similaire celle de ^s. 'e synchroniseur a / composantes : la composante originale c.o la composante de synchronisation c.s ''ide de base est &ue cha&ue processeur v poss*de un gnrateur de PpulsesP4 P v - ,4 +4 /4 ... 'e processeur v e(cute ^$ la phase p uni&uement si P v - p. An asynchrone4 pour passer de P v - p p . +4 il faut communi&uer avec ses voisins. :otation : t(v4 p - processeur v met sa variable Pv - p. 'e processeur v est la phase p si v est dans la priode `t(v4 p 4 t(v4 p . + `.

Compati!ilit de pulse
"i le processeur v envoie un message PoriginalP > un voisin M durant la phase P v - p alors > est reHu en M durant P M - p.

Excutions similaires
"oit ^" un algorithme synchrone et ^$ - _( ^" une simulation (un algorithme asynchrone combin avec le synchronisation _ . Cn consid*re une e(cution A" - A"(64 I dans un syst*me 6 synchrone et l'e(cution A $ correspondante de ^$ dans le syst*me 6 asynchrone avec les mBmes entres (I - tat initial des processeurs . 'es e(cutions sont similaires si pour tout v et voisin M et la variable locale K en v la phase p J- ,4 on a : 'a valeur stocQe en K au dbut de la phase p dans A$ est la mBme &u'au dbut de la phase p dans A". 'es messages originau( envoys par v M durant la phase p dans A $ (s'il y en a 4 sont les mBmes &ue ceu( envoys de v M durant la phase p de A". 'es messages reHus par v de M durant la phase p dans A $ sont les mBmes &ue ceu( reHus par v de M durant la phase p dans A". 'e rsultat final de v dans A$ est le mBme &ue dans A".

Simulation correcte
^$ est une simulation correcte de ^ " si pour tout graphe 6 et toute entre I4 les e(cutions sont similaires. "i ^ $ _( ^s 4 alors le synchroniseur est dit correct4 et ^$ simule ^s. "i le synchroniseur _ garanti la compatibilit de PpulseP4 alors il est correct. 'a &uestion principale : auand v doit)il incrmenter P!O

Mesures de complexits des sync)roniseurs


Cn note respectivement TA>P"init(_ et >A""$6Ainit(_ le temps et le nombre de messages pour initialiser le composante de synchronisation. Cn note >A""$6Apulse (_ le nombre total de messages envoys par _ durant une phase. Cn note TA>P"gap(_ - ma(v4 p[t(v4 p.+ 1 t(v4 p \. t ma((p - ma(tv(v4 p est le moment ou le dernier processeur passe la phase p. TA>P"pulse(_ - ma(pJ-,[tma((p.+ 1 tma((p \ Clairement4 on souhaite construire un synchroniseur _ avec TA>P" pulse(_ et >A""$6Apulse(_ le plus faible possible. Proprit (pour ^$ - _( ^s : >A""$6A (^$ -F >A""$6Ainit(_ . >A""$6A (^s . TA>P"( ^s .>A""$6Apulse(_ .

+,

TA>P"(^$ -F TA>P"init(_ . TA>P"(^s .TA>P"pulse(_

"eux sync)roniseurs
Synchroniseur alpha
C'est le plus simple. Cn effectue une synchronisation la fin de cha&ue phase p en informant tous ses voisins &u'on a fini la phase p (tous les messages de la phase p ont t reHus . 'e synchroniseur alpha doit Btre envoy d'une racine r, vers tous les sommets (innondation : >A""$6Ainit(alpha - C(WA(6 W TA>P"init(alpha - C(diam(6 >A""$6Apulse(alpha - C(WA(6 W TA>P"pulse(alpha - C(+

Synchroniseur !eta
Il suppose l'e(istance d'un arbre couvrant T. Cha&ue sommet4 lors&u'il apprend &ue tous ses descendants ont termin4 il en informe son p*reO Cn effectue une concentration vers la racine. Ansuite4 la racine diffuse dans l'arbre T le message Pne(t pulseP et tous les sommets incrmentent alors P! : >A""$6Ainit(beta - C(n.WA(6 W TA>P"init(beta - C(diam(6 >A""$6Apulse(beta - C(n TA>P"pulse(beta - C(diam(6 (si T est N9" An fait4 >A""$6Ainit et TA>P"init dpendent de l'arbre (#i5Qstra .

Coloration
'a motivation de la coloration est de casser la symtrie (choisir un leader et crer du paralllisme en distinguant des sommets (>#" : >a(imal #ependant "et .

Problme de coloration
%ne coloration propre d'un graphe 6 - (!4 A est une fonction c : ! ))J : tel &ue si [u4 v\ appartiennent A alors c(u V -c(v . 'e plus petit nombre Q pour &ue 6 soit coloriable (proprement avec Q couleurs est not b(6 et s'appelle le nombre chromati&ue de 6. #ans toute la suite4 on se placera dans le mod*le local.

3duction de palette
Cn va dcrire une procdure basi&ue &ui va rduire le nombre de couleurs de m c . + ou c est le degr ma(imum du graphe. Il est tou5ours possible d'avoir b(6 -F c . +. "i P est un ensemble de couleurs et ; un ensemble de sommets. &$3',4&3-'oit c la plus petite couleur de P qui n'est pas utilise par aucun sommet de 50 3eturn 6c7 "oit Pm - [+4 ...4 m\4 :(v - [voisins de v\ Procedure 3-"UC- 6pour c)aque sommet de 7 Pour i 8 9 : ; < m faire 'i c6 7 8 i alors c6 7 8 &$3',4&3--6=6 7! P9 : >7 $nformer tous les oisins de ce c)oix Proprits : 7A#%CA produit une coloration propre avec au plus c . + couleurs. TA>P" (7A#%CA - m ) c . + Cn remar&ue &ue / sommets voisins de u et v ne peuvent pas Btre actifs en mBme temps (sur le choi( de la couleur car au dpart c(u V- c(v .

++

?1coloration pour les arbres et les grap)ques de degr born


Cn parle de Q)coloration si 6 a une coloration propre avec un nombre couleurs infrieur Q. "i T est un arbre4 alors b(T - /. Cn note : log(i n - loglog...log n (i fois log0n - min[i @ log(i n -F /\ "i c appartient :4 bin(c est la reprsentation binaire standard de c. Wbin(c W - longueur de bin(c (en bits . $ o N est la concatnation des chaines binaires $ et N. @1C.L.36,7 c6 7 8 bin6$"6 77 3pter ( l 8 A c6 7 A 'i est la racine! $ 8 B 'inon! $ 8 min Ci D c6 7EiF G8 c6pere6 77EiFH 6i est le premier bit ou c6 7 et c6pere7 diffrent7 c6 7 8 bin6i7 o c6 7EiF informer tous les oisins *usqu'< l 8 A c6 7 A A(emple : i4 c(v `ie +,+,++, ,,

,4, l-/

,,

+,+,,++

-J

,4+ l-/

-J

:e change plus

,+

,+

+,,,,++

+,,4, l-2

,, l-/

-J

,,

fin

&roprit :
$ cha&ue itration4 c est une coloration propre

&reuve :
"oit u - prec(v (prcdent et soient I4 d les indices choisis par X)CC'C7. "i Iu V- Iv alors bin(Iu V- bin(Iv . #onc la coloration est propre. "i Iu - Iv alors c(u `Iue V- c(v `Ive (car Iu est le premier bit diffrent . "oit S i - W c(v W apr*s la ii*me itration. S, - S - C(logn bits et Si.+ - `partie enti*re suprieure de (log Si e . +. S+ f loglog n. #'ou : "i Si J- 2 alors Si.+ F Si.

&roprit :
"i Si -F `partie enti*re suprieure de (log(i S e . /. Pour tout i tel &ue log(i S J- /. (preuve par induction

&roprit :
7A#%CA produit une X)Coloration.

&reuve :
$ l'tape finale Si -F 3. la derni*re couleur est forme d'une position [,4 +4 /\ et d'un bit. Cela fait donc au plus X possibilits de couleurs.

&assage de 3 / couleurs :
"]I9Tg#C;: : cha&ue sommet (diffrent de la racine se recolorie avec la couleur de son p*re. 'a racine choisit une nouvelle couleur. "]I9Tg#C;: produit une coloration propre et tous les fr*res ont la mBme couleur. '$I;,J3-- ( Pour x appartenant < CK! L! @H faire ( 'J$&,".5=

+/

'i c6 7 8 x! c6 7 8 &$3',4&3--6=6 7! P? 8 C>! ;! ?H7

&roprit :
"IK/T]7AA est une 3)coloration.

&reuve :
Tous les fr*res sont de la mBme couleur. 'ors&ue "]I9Tg#C;: est appli&u4 9I7"Tg97AA termine car le p*re de v et ses fils n'utilisent &ue / couleurs.

4hor%me , :
Il e(iste un algorithme distribu ('CC$' &ui produit une 3)coloration pour tout arbre n sommets en C(log0n temps. 'a techni&ue s'tend au( graphes de degr au plus c. Cn utilise une variante de l'algorithme X)Color. c(v - bin(I o c(v `Ie I - min[i @ c(v `ie V- c(p*re(v `ie\ c(v - (bin(I+ o c(v `I+e4 ...4 bin(Ic o c(v `Ic e I5 - min [i @ c(v `ie V- c(v5 `ie\ ou v5 est le 5i*me voisin de v. "i c(v est sur S)bit c'(v est sur c o (partie enti*re suprieure de (log S . + bits. $pr*s un temps log0(c n f log0n4 on s'arrBte avec une couleur de taille /c bits. Ceci produit les / /c couleurs diffrentes. Pour rduire de m - / /c c . + couleurs4 on utilise 7A#%CA en temps C(//c 1 c - C(//c .

4hor%me 5 :
Il e(iste un algorithme distribu ('CC$' &ui produit une c . + coloration pour tout graphe n sommets et de degr ma(imum c en temps C(log0n . /c . Il e(iste un autre algorithme en C(c.log n .

%orne infrieure pour la ?1coloration d'un cycle


#'apr*s le thor*me +4 on peut calculer une 3)coloration pour un cycle en temps C(log0n . Cn va voir &u'il faut T(log0n temps dans le pire des cas (mauvaise distribution des identits . An temps t4 un sommet ne peut connahtre &ue les identifiants distance infrieure t de lui. 'e sommet v connait un (/t . + uplet ((+4 (/4 ... (/t.+ ;s4 n avec (t.+ - I#(v 4 (t - I#(voisin de v 4 (t)+ - I#(voisin de (t 4 ... ;s4 n - [((+4 ...4 (s @ + -F (i -F n4 (i V- (5\ (couleurs @I# distinctes deu( deu( "oit ^t un algorithme de coloration pour le cycle avec c ma( couleurs et en temps t - t(n . "ans perte de gnralit4 on suppose &ue ^t obit au( / r*gles suivantes : Pendant t phases4 il collecte sa boule de rayon t. $ la fin de cette tape4 v connait M(v ;/t.+4 n . Il choisit sa couleur c(v - i^(M(v ou i^ - ;/t . +4 n )J [+4 ...4 cma(\ (la fonction de couleur de ^t. Cn dfinit le graphe Ns4 n - l'ensemble des arBtes ( (( +4 (/4 ...4 (s 4 ((/4 ...4 (s4 (s.+ tel &ue (+ V- (s.+. Intuitivement4 / s) uplets de ;s4 n sont ad5acents si il est possible de trouver / voisins d'un cycle ( et y pour une certaine distribution des identifiants.

&roprit :
"i ^t produit une coloration propre pour tout cycle alors i^ est une coloration pour N/t.+4 n.

&reuve )par l'a!surde* :


"i M - ((+4 ...4 (/t.+ et M' - ((/4 ...4 (/t./ voisin dans N/t.+4 n tel &ue i^(M - i^(M' . At donc i^ n'est pas une coloration propre pour (t.+ et (t./ d'ou contradiction.

Corollaire :
"i les cycles n sommets sont coloris en t tapes avec cma( couleurs alors le nombre chromati&ue b(N/t.+4 n -F cma(.

&roprit :
b(N/t.+4 n J- log(/t n.

+3

"oit t, le plus petit entier tel &ue log (/t n J 3 : t, - j (log0n 1 3. -J b(N /t.+4 n J 3 -J cma( J 3. ''algorithme n'a pas pu 3) colorier le cycle en temps -F t,.

6!7ectif :
Il faut dmontrer &ue b(N/t.+4 n k log(/t n. #'ou log(/t n l cma(. "i /t k log0n 1 + alors log(/t J 3 log(/t n l 3 -J t J j (log0n 1 + "oit fNs4 n - ( f;s4 n4 fAs4 n avec : f;s4 n - [ ((+4 ...4 (n @ + l (+ l ... l (s l n \ fAs4 n - [ (((+4 ... (s ((/4 ... (s.+ \ 'a version non oriente de fNs4 n est un graphe de Ns4 n.

Dfinition :
"oit ] un graphe orient - (%4 9 . 'e 'I:A de ]4 not #'(] est le graphe avec ensemble de sommets : 9 (ensemble des arcs e4 e' 9 ad5acents dans #'(] si il e(iste v de % tel &ue e arrive en ! et e' part de v.

&roprit :
fN+4 n est le graphe complet n sommets (/ sommets sont connects par un arc dans cha&ue sens .

4hor%me :
Tout algorithme distribu de 3)coloration d'un cycle n sommets ncessite un temps suprieur j (log0n 1 +

Ensembles indpendants Ma imau


#ans ce chapitre4 on considrera le mod*le 'CC$'.

#lgorit)me de base
"oit 6 un graphe > inclu dans !(6 . > est un >I" (>a(imal Independant "et si : Pour tout u V- v de >4 d(u4 v J- / > % [(\ n'est pas indpendant An s&uentiel4 on peut calculer un >I" en temps C(n . m avec un algorithme glouton : % - !(6 4 > - [\ Tant &ue % V- [\ faire : choisir arbitrairement v de % % - % 1 :(! (:(! - [M @ d(v4 M -F +\ > - > % [v\ 'e rsultat de l'algorithme calculant un >I" est matrialis par une variable (locale cha&ue sommet note mb : mb - + si le sommet appartient un >I" mb - , si le sommet n'appartient pas un >I" mb - )+ initialement ''algorithme naif >I"#9" consiste simuler l'algorithme s&uentiel en faisant un parcours #9" des sommets du graphe. Cn parcours tous les sommets et si mb - )+4 alors on choisit u de >I"4 mb-+ et pourtous ces voisins4 mb - ,.

lemme :

>A""$6A (>I"#9" - C(WAW TA>P"(>I"#9" - C(n

Algorithme MIS'A81 :
Il e(iste une variante : >I" 7$:S. ''ide consiste dcider de 5oindre le >I" &ue si tous ces voisins &ui ont une I# plus grand ont d5 dcid de ne pas 5oindre le >I".

+2

Cn peut crire la procdure dCI: comme suit : Procedure M.$= ( 'i tout oisin 2 de u tel que $"627 N $"6u7 et Ob627 8 B alors Ob6u7 8 > en oyer P"-C$"-" >P < tous ses oisins An utilisant cette procdure4 on peut alors crire l'algorithme >I" 7$:S : #lgorit)me M$'3#=Q ( #ppliquer M.$= # la rception d'un P"-C$"-" >P enu de 2 faire ( Ob 8 B -n oyer P"-C$"-" BP < tous ces oisins # la rception d'un P"-C$"-" BP! appeler la procdure M.$=

emme :
>A""$6A (>I"7$:S - C(WAW TA>P" (>I"7$:S - C(n >I"7$:S est bas sur le fait &ue les I# sont diffrents. >I" #9" est bas sur le fait &u'un sommet se rveille.

emme :
Il n'e(iste pas d'algorithme dterministe distribu &ui calcule un >I" sur un cycle anonyme (pas d'I# si tous les sommets se rveillent en mBme temps.

3duction de la coloration au M$'


#ans une coloration4 cha&ue couleur induit un ensemble indpendant. >ais ce n'est pas forcment un >I". Cependant4 il e(iste une procdure &ui trnasforme une m)coloration et produit un >I". C.L.3;M$' ( Pour tout i 8 > < m faire ( 'i c6 7 8 i alors ( 'i aucun oisin de n'a re*oint le M$' ( Ob6 7 8 > $nformer tous les oisins 'inon Ob6 7 8 B

&roprits :
'a procdure CC'C7/>I" construit un >I" en temps C(m . ''indpendance est assure par le fait &ue la procdure mb(v passe + si tous les voisins ne sont pas dans le >I". Il s'agit d'un ensemble ma(imal car tous les sommets sont passs en revue et sont a5outs au >I" si possible. Corollaire : "i en temps t(6 on peut colorier 6 avec f(6 couleurs4 alors en temps C(t(6 . f(6 on peut construire un >I" Corollaire : Pour les arbres et les graphes de degrs borns n sommets4 on peut un >I" en temps C(log0n Thor*me : Tout algorithme distribu &ui construit un >I" sur un cycle n sommets ncessite au moins un temps j(log0n 1 3 . Preuve : Cn sait &ue j (log0n 1 + tapes sont ncessaires pour calculer une 3 coloration sur un cycle. Cn va montrer &ue tout >I" sur un cycle peut Btre transform en 3)coloration en + seule tape. 'es sommets du >I" envoient P/P gauche et se colorie +. 'es sommets &ui n'appartiennent pas au >I" se colorient / s'ils reHoivent le message P/P4 sinon ils se colorient P3P. "i les sommets ne connaissent pas leur droite et gauche4 alors c'est encore possible en une tape. Il suffit d'envoyer / de cha&ue cGt lors&u'un sommet est dans le >I" et le sommet passe +. "inon4 on envoie l'I# ( droite et gauche . "i deu( sommets ad5acents ne sont pas dans le >I" (c'est le seul cas possible 4 celui dont l'I# est la plus petite se colorie

+8

en /4 l'autre en 3 par e(emple.

-nsemble dominant (
> est un ensemble dominant pour le graphe 6 si tout sommet est soit dans >4 soit un voisin dans >. %n >I" est un ensemble dominant. ''ob5ectif est de construire un ensemble dominant de taille la plus petite possible (:P)CC>P'AT . Cn veut construire un ensemble dominant de cardinalit infrieur n@/.

+X