[hal-00687556, v1] Algorithme de k-partitionnement auto

Algorithme de k-partitionnement
auto-stabilisant et comp´ etitif †
A. K. Datta1, S. Devismes2, L. L. Larmore1, K. Heurtefeux2et Y. Rivierre2
1School of Computer Science, UNLV, Las Vegas, USA
2VERIMAG, UMR 5104, Universit´
e Joseph Fourier, Grenoble
Nous proposons un algorithme auto-stabilisant qui calcule un k-partitionnement de taille O(n
k)dans un r´
eseau quel-
conque de nprocessus. Lorsque le r´ eseau est un graphe de disques unitaires, le k-partitionnement calcul´ e est au plus
7.2552k+O(1)fois plus grand que le minimum possible. Lorsque le r´ eseau est un graphe de disques quasi-unitaires de
param` etre λ, le k-partitionnement calcul´ e est au plus 7.2552kλ2+O(λ)fois plus grand que le minimum possible.
Keywords: syst` emes distribu´ es, auto-stabilisation, k-partitionnement, comp´ etitivit´ e
1 Introduction
L’auto-stabilisation [Dij74] est un paradigme g´ en´ eral permettant de concevoir des algorithmes distribu´ es
tol´ erant les fautes transitoires. Une faute transitoire est une panne non-d´ efinitive qui alt` ere le contenu du
composant du r´ eseau (processus ou canal de communication) o` u elle se produit. En supposant que les fautes
transitoires n’alt` erent pas le code de l’algorithme, un algorithme auto-stabilisant retrouve de lui-mˆ eme, et
en temps fini, un comportement normal d` es lors que les fautes transitoires ont cess´ e.
Dans cet article, nous proposons un algorithme distribu´ e auto-stabilisant calculant un k-partitionnement
du r´ eseau. Le k-partitionnement d’un graphe (ou d’un r´ eseau) consiste ` a diviser ses nœuds en sous-ensembles
disjoints C1,...,Cx, appel´ es grappes, et ` a identifier un nœud Tˆetei, appel´ etˆ ete, dans chaque grappe Citel
que tout nœud de Ciest au plus ` a distance kde Tˆetei.
Le k-partitionnement est g´ en´ eralement utilis´ e dans les r´ eseaux pour r´ ealiser du routage hi´ erarchique.
Supposons qu’un processus psouhaite communiquer avec un processus qsitu´ e dans une grappe diff´ erente.
Alors, penvoie son message ` a sa tˆ ete de grappe, qui le transmet ensuite ` a la tˆ ete de la grappe de q; enfin,
cette derni` ere envoie le message ` aq.
G´ en´ eralement, on souhaite limiter la taille d’un k-partitionnement, i.e., son nombre de grappes. Cepen-
dant, trouver un k-partitionnement de taille minimum est N P -difficile [GJ79]. Nous proposons de calculer
un k-partitionnement dont la taille est une approximation ‡du minimum possible dans le cas o` u le r´ eseau est
un UDG (graphe de disques unitaires) ou un quasi-UDG (les UDG et quasi-UDG mod´ elisent les topologies
des r´ eseaux de capteurs sans fils). Dans les topologies UDG ou quasi-UDG, chaque nœud est plac´ e dans
le plan. Dans un UDG, deux nœuds sont voisins si et seulement s’ils sont distants d’au plus 1. Dans un
quasi-UDG de param` etre λ≥1, (1) si deux nœuds sont distants d’au plus 1, alors ils sont voisins, et (2)
pour chaque paire de voisins (x,y), la distance entre xet yest au plus λ.
Un algorithme de k-partitionnement est dit X-comp´ etitif s’il calcule un k-partitionnement de taille au plus
Xfois la taille du plus petit possible. L’algorithme auto-stabilisant pr´ esent´ e dans cet article calcule un k-
partitionnement de taille O(n
k)dans un r´
eseau quelconque de nprocessus. Il stabilise en O(n)rondes §et a
un encombrement m´ emoire en O(logn)bits par processus. Notre algorithme est 7.2552k+O(1)-comp´ etitif
lorsque le r´ eseau est un UDG et 7.2552kλ2+O(λ)-comp´ etitif lorsque le r´ eseau est un quasi-UDG de pa-
ram` etre λ.
†Cet article est un r´
esum´ e du rapport technique en ligne : http://www-verimag.imag.fr/TR/TR-2011-16.pdf.
‡. Cette approximation sera formalis´ ee par la notion de X-comp´ etitivit´ e.
§. La notion de ronde mesure le temps d’ex´ ecution rapport´ e au processus le plus lent.
hal-00687556, version 1 - 13 Apr 2012
Manuscrit auteur, publié dans "14èmes Rencontres Francophones sur les Aspects Algorithmiques des Télécommunications (AlgoTel),
La Grande Motte : France (2012)"

A. K. Datta, S. Devismes, L. L. Larmore, K. Heurtefeux et Y. Rivierre
2 Mod` ele
Nous consid´ erons des r´ eseaux bidirectionnels connexes de nprocessus (ou nœuds) o` u chaque processus
peut communiquer directement avec un ensemble restreint d’autres processus appel´ es voisins. Les processus
sont identifi´ es de mani` ere unique. Dans la suite, nous ne distinguerons pas un processus de son identit´ e.
Ainsi, selon le contexte, pd´ esignera soit un processus, soit son identit´ e.
Les processus communiquent par le biais de variables de communication localement partag´ ees (Chaque
processus d´ etient un nombre fini de variables, chacune de domaine fini, dans lesquelles il peut lire et
´
ecrire. De plus, il peut lire les variables de ses voisins.). Les variables d’un processus d´ efinissent son ´ etat.
L’ex´ ecution d’un algorithme est une suite d’´ etapes atomiques : ` a chaque ´ etape, s’il existe des processus
— dits activables — souhaitant modifier leurs ´ etats, alors un sous-ensemble non-vide de ces processus est
activ´ e. En une ´ etape atomique, chaque processus activ´ e lit ses propres variables, ainsi que celles de ses
voisins, puis modifie son ´ etat. Nous supposons ici que les processus sont activ´ es de mani` ere asynchrone en
supposant une ´ equit´ e faible,i.e., tout processus continˆ ument activable est activ´ e en temps fini.
3 L’algorithme
Notre algorithme est une composition parall` ele de deux algorithmes. Le premier calcule un arbre cou-
vrant particulier, le second calcule un k-partitionnement de l’arbre couvrant calcul´ e par le premier algo-
rithme. Les propri´ et´ es de cet arbre couvrant nous permettent d’obtenir la comp´ etitivit´ e de notre algorithme.
Dans une composition parall` ele de deux algorithmes auto-stabilisants : les deux algorithmes s’ex´ ecutent
de mani` ere concurrente, mais le second algorithme utilise les variables de sortie du premier algorithme dans
ses calculs. Ainsi, le second algorithme ne stabilise qu’une fois que le premier a stabilis´ e.
3.1 Arbre couvrant EIM
La premi` ere partie de l’algorithme consiste ` a calculer un arbre couvrant EIM (pour Ensemble Ind´ ependant
Maximal). Un arbre couvrant EIM est un arbre couvrant dont les nœuds de hauteur paire forment un en-
semble ind´ ependant maximal (n.b. la racine de l’arbre est de hauteur 0).
Un ensemble ind´ ependant est un ensemble de nœuds Etel qu’aucun nœud de En’est voisin d’un autre
nœud de E. Un ensemble ind´ ependant Eest dit maximal si aucun de ses sur-ensembles propres n’est un
ensemble ind´ ependant (i.e., l’ajout d’un nœud ` aEdonne un ensemble qui n’est plus ind´ ependant).
Notez que par d´ efinition, tout arbre couvrant EIM, T, a la propri´ et´ e suivante : tout chemin de Tde
FIGURE 1: Arbre couvrant EIM.
longueur `contient au moins d`
2enœuds de I, o`
uIest l’ensemble
ind´ ependant maximal form´ e par les nœuds de hauteur paire de
T. La figure 1 pr´ esente un arbre couvrant EIM. Les arˆ etes sont
repr´ esent´ ees par des fl` eches et les nœuds de hauteur paire sont co-
lori´ es en noir.
Notre calcul auto-stabilisant d’arbre couvrant EIM utilise aussi la composition parall` ele : un premier algo-
rithme calcule un arbre couvrant (pour cela, nous utilisons l’un des nombreux algorithmes auto-stabilisants
de la litt´ erature), le second algorithme utilise les hauteurs des processus de l’arbre calcul´ e par le premier
algorithme pour calculer un arbre couvrant EIM. Cette hauteur est not´ ee p.hauteur pour tout processus p.
Tout processus pmaintient deux variables suppl´ ementaires dans le second algorithme : (1) un bool´ een
p.dominant et (2) un pointeur p` ere p.p`ereEIM qui pointe soit vers psoit vers un de ses voisins.
Lorsque la variable p.dominant est vraie, pest dit dominant, dans le cas contraire, pest dit domin´ e. Une
fois stabilis´ ee, p.dominant est vraie si et seulement si pest ` a une hauteur paire ; et l’ensemble constitu´ e des
processus qtel que q.dominant =vrai est un ensemble ind´ ependant maximal.
La variable p.p`ereEIM d´ esigne le p` ere de pdans l’arbre couvrant EIM : une fois stabilis´ ee, si pest la
racine de l’arbre, alors p.p`ereEIM =psinon p.p`ereEIM =qo` uqest le p` ere de pdans l’arbre EIM.
Pour d´ ecider s’il est dominant ou domin´ e, chaque processus putilise une priorit´ e d´ efinie par le couple
(p.hauteur,p)(le deuxi` eme membre du couple d´ esigne l’identit´ e de p). Le processus pest prioritaire sur
le processus qsi et seulement si (p.hauteur,p)est lexicographiquement plus petit que (q.hauteur,q). En
fonction des priorit´ es, pd´ ecide qu’il est dominant si et seulement si tous ses voisins sont domin´ es ou
moins prioritaires. En utilisant cette r` egle, la racine de l’arbre calcul´ ee par le premier algorithme, not´ ee R,
se d´ esigne dominante . Tous ses voisins deviennent alors domin´ es ,etc. Ainsi les nœuds dominants
finissent par d´ efinir un ensemble ind´ ependant maximal.
hal-00687556, version 1 - 13 Apr 2012

k-partitionnement auto-stabilisant et comp´ etitif
Chaque processus doit aussi choisir un p` ere dans l’arbre de telle mani` ere que les nœuds de hauteur paire
d´ efinissent un ensemble ind´ ependant maximal. Pour cela, Rse d´ esigne comme racine de l’arbre EIM en
assignant R.p`ereEIM ` aR. Les autres processus choisissent comme p` ere dans l’arbre EIM leur voisin le plus
prioritaire parmi ceux ayant un statut dominant/domin´ e diff´ erent du leur. Cette r` egle force une alternance
stricte dominant/domin´ e le long des chemins de l’arbre. Le fait que la racine soit de hauteur 0 et qu’il y ait
une stricte alternance dominant/domin´ e induit que l’arbre couvrant calcul´ e est un arbre EIM.
3.2 k-partitionnement de l’arbre
Nous calculons le k-partitionnement en deux phases. La premi` ere phase consiste ` a calculer un ensemble
d’au plus 1 +bn−1
k+1ctˆ
etes de grappes. La seconde phase consiste ` a calculer une forˆ et couvrante dont chaque
arbre repr´ esente une grappe et a ainsi pour racine l’une des tˆ etes calcul´ ees lors de la premi` ere phase.
Pour cela, chaque nœud putilise trois variables : p.α,p.tˆetegrappe et p.p`eregrappe. La variable p.α
contient un entier entre 0 et 2k,p.tˆetegrappe contient une identit´ e et p.p`eregrappe d´ esigne soit psoit l’un
de ses voisins.
La variable p.αest utilis´ ee pour d´ eterminer si pest une tˆ ete. Une fois que l’algorithme a stabilis´ e, pest
une tˆ ete de grappe si et seulement si p.α=kou p.α<ket p=R(o` uRest la racine de l’arbre EIM). La
variable p.tˆetegrappe contient l’identit´ e de la tˆ ete de grappe de pet p.p`eregrappe d´ esigne le p` ere de pdans
sa grappe (si pest une tˆ ete, alors p.p`eregrappe =p).
Calcul des tˆ etes. Le calcul des tˆ etes est uniquement bas´ e sur le calcul de la variable α. Cette derni` ere est
calcul´ ee de bas en haut dans l’arbre EIM. Une fois l’algorithme stabilis´ e, p.αest ´ egale ` a la distance entre
le nœud pet le nœud le plus ´ eloign´ e qui est ` a la fois dans le sous-arbre de pet dans la mˆ eme grappe que p.
(a) Si p.α<k, alors pest dit minus et deux cas sont possibles : p6=Rou p=R. Dans le premier cas, la
tˆ ete de la grappe contenant pest en dehors du sous-arbre de p,i.e., le chemin menant ` a cette tˆ ete passe
par le p` ere de pdans l’arbre EIM, et la distance entre pet cette tˆ ete est au plus ´ egale ` ak−p.α. Dans
le second cas (p=R), pdoit ˆ etre une tˆ ete de grappe car, par d´ efinition, il n’existe aucun nœud hors de
son sous-arbre.
(b) Si p.α≥k, alors pest dit balaise et la tˆ ete de sa grappe est dans son sous-arbre ` a distance p.α−k.
p.αest calcul´ ee ` a partir des deux fonctions suivantes :
–MaxAl phaMinus(p)est ´ egale ` a la valeur αmaximale des fils minus de p(dans l’arbre EIM). Si p
n’a pas de fils minus , alors MaxAl phaMinus(p) = −1.
–MinAl phaBalaise(p)est ´ egale ` a la valeur αminimale des fils balaise de p(dans l’arbre EIM). Si
pn’a pas de fils balaise , alors MinAl phaBalaise(p) = 2k+1.
`
A partir de ces fonctions, p.αest calcul´ ee comme suit :
– Si MaxAl phaMinus(p) + MinAl phaBalaise(p)>2k−2, alors p.α=MaxAl phaMinus(p) + 1.
– Si MaxAl phaMinus(p) + MinAl phaBalaise(p)≤2k−2, alors p.α=MinAl phaBalaise(p) + 1.
Les valeurs des variables αsont calcul´ ees inductivement ` a partir des feuilles de l’arbre couvrant EIM.
Consid´ erons une feuille f. Par d´ efinition, MaxAl phaMinus(f) + MinAl phaBalaise(f) = −1+2k+1>
2k−2. Ainsi, f.α=−1+1=0. En effet, la distance maximale entre fet un nœud de son sous-arbre qui
est dans la mˆ eme grappe est, par d´ efinition, 0.
Consid´ erons maintenant un nœud interne pet supposons que les valeurs des variables αde tous ses fils
sont correctes. pdoit choisir si sa tˆ ete de grappe est soit (1) dans son sous-arbre (dans ce cas, psera balaise),
soit (2) hors de son sous-arbre (dans ce cas, psera minus). Nous privil´ egions, autant que possible, le choix
(1) pour limiter le nombre de tˆ etes.
Soit qun nœud qui a la mˆ eme tˆ ete de grappe que pet qui appartient au sous-arbre d’un fils minus de p.
D’apr` es (a), le chemin menant de q` a sa tˆ ete de grappe passe par p. Ainsi, pour ne pas cr´ eer de cycle, (*) p
ne doit jamais choisir comme tˆ ete de grappe un nœud appartenant au sous-arbre d’un de ses fils minus. Soit
xle plus ´ eloign´ e des sommets q. Toujours d’apr` es (a), xest ` a distance MaxAl phaMinus(p) + 1 de p. Deux
cas sont alors possibles :
MaxAl phaMinus(p) + MinAl phaBalaise(p)>2k−2.Si pchoisit un nœud yde son sous-arbre comme
tˆ ete de sa grappe (choix (1)), alors d’apr` es (*), le chemin vers ypasse par un fils balaise de pet psera
au moins ` a distance MinAl phaBalaise(p)−k+1 de sa tˆ ete de grappe, d’apr` es (b). Or, dans ce cas, x
sera au moins ` a distance MaxAl phaMinus(p) +MinAl phaBalaise(p)−k+2>2k−2−k+2=kde
hal-00687556, version 1 - 13 Apr 2012

A. K. Datta, S. Devismes, L. L. Larmore, K. Heurtefeux et Y. Rivierre
la tˆ ete y, ce qui viole la d´ efinition du k-partitionnement. Ainsi, pdoit n´ ecessairement choisir une tˆ ete
de grappe hors des sous-arbres de ses fils (choix (2)). D’apr` es (a) et (b), le nœud xest alors le nœud
le plus ´ eloign´ e appartenant ` a la fois au sous-arbre de pet ` a la mˆ eme grappe que p, ce qui implique
que p.α=MaxAl phaMinus(p) + 1.
MaxAl phaMinus(p) + MinAl phaBalaise(p)≤2k−2.Soit zun fils balaise de ptel que z.α=MinAl pha-
Balaise(p). Contrairement au cas pr´ ec´ edent, ppeut choisir un nœud ydu sous-arbre de zcomme tˆ ete
de grappe (choix (1)). En effet, ici, xsera ` a distance MaxAl phaMinus(p) + MinAl phaBalaise(p)−
k+2≤2k−2−k+2=kde y. D’o` u, les nœuds (autres que p) appartenant ` a la fois au sous-arbre de
pet ` a la mˆ eme grappe que psont soit des nœuds des sous-arbres de fils minus de p, soit des nœuds
du sous-arbre de z. Puisque par d´ efinition MinAl phaBalaise(p)>MaxAl phaMinus(p), le nœud le
plus ´ eloign´ e appartenant ` a la fois au sous-arbre de pet ` a la mˆ eme grappe que psera ` a la distance
MinAl phaBalaise(p) + 1 de p,i.e. p.α=MinAl phaBalaise(p) + 1.
0 1 2 3 4
0 1 2 3 4
0 1
5
0
0 0
0
0 1 2 3 4 5 6
1 2 3 4 5 6
FIGURE 2: Exemple de 3-partitionnement.
Construction des grappes. Lors-
qu’un nœud pv´ erifie p.α=k
ou p.α<ket p=R, il se
d´ esigne comme tˆ ete en assignant
p.p`eregrappe et p.tˆetegrappe ` ap.
Ensuite, chaque nœud non-tˆ ete,
q, doit choisir un p` ere dans sa
grappe. Si qest minus, il choisit
son p` ere dans l’arbre couvrant EIM
comme p` ere dans sa grappe. Sinon,
qest balaise et choisit un fils balaise c tel que c.α=q.α−1 comme p` ere de grappe.
De cette mani` ere, les grappes sont structur´ ees en arbres. La derni` ere ´ etape consiste ` a propager, via les
liens p` ere (p`eregrappe), la valeur tˆetegrappe de chaque tˆ ete dans les variables tˆetegrappe des autres nœuds
de son arbre.
La figure 2 montre un 3-partitionnement calcul´ e par notre algorithme : la racine est ` a droite, les entiers
sont les valeurs de α, les tˆ etes sont en noir et les fl` eches repr´ esentent les liens p` ere des grappes .
4 Taille du k-partitionnement
Tout d’abord, toutes les tˆ etes t, sauf ´ eventuellement une, v´ erifient t.α=k(si Rest minus,Rest une
tˆ ete). Donc, toutes les grappes sauf ´ eventuellement une, contiennent au moins knœuds. Ainsi, il y a au plus
1+bn−1
kc=O(n k)grappes, quelle que soit la topologie du r´
eseau.
Nous avons ´ etudi´ e la comp´ etitivit´ e de notre algorithme dans les cas o` u la topologie du r´ eseau est soit
un UDG, soit un quasi-UDG en utilisant un r´ esultat pr´ ec´ edent de Folkman et Graham [FG69]. ` A partir de
ce r´ esultat, nous avons montr´ e que, dans un UDG (connexe), (a) la taille de tout ensemble ind´ ependant est
au plus 2πk2
√3+πk+1fois plus grande que la taille Opt du plus petit k-partitionnement. Or, nous savons
d’apr` es la propri´ et´ e de notre arbre EIM, que toutes les grappes, sauf ´ eventuellement une, contiennent au
moins dk
2enœuds de l’ensemble ind´
ependant maximal Id´ efini par les nœuds de hauteur paire de notre
arbre EIM. Soient nbI=|I|et nbTle nombre de tˆ etes de grappes. Nous avons donc (b) (nbT−1)×dk
2e ≤
nbI−1. D’apr` es (a) et (b), nous d´ eduisons alors que nbT≤1+4πk
√3+2π×Opt. Comme 4π √3≈7.2552,
nous d´ eduisons que notre algorithme est 7.2552k+O(1)-comp´ etitif lorsque le r´ eseau est un UDG. Par une
approche similaire, nous montrons que notre algorithme est 7.2552kλ2+O(λ)-comp´ etitif lorsque le r´ eseau
est un quasi-UDG de param` etre λ.
R´ ef´ erences
[Dij74] E. W. Dijkstra. Self-Stabilizing Systems in Spite of Distributed Control. Commun. ACM, 17 :643–644, 1974.
[FG69] J. H. Folkman and R. L. Graham. An Inequality in the Geometry of Numbers. Canad. Math. Bull., 12 :745–
752, 1969.
[GJ79] M. R. Garey and David S. Johnson. Computers and Intractability : A Guide to the Theory of NP-Completeness.
W. H. Freeman, 1979.
hal-00687556, version 1 - 13 Apr 2012