Algorithme d`Exclusion Mutuelle Distribué pour les Réseaux Ad Hoc
SETIT 2007
4th International Conference: Sciences of Electronic,
Technologies of Information and Telecommunications
March 25-29, 2007 – TUNISIA
- 1 -
Algorithme d’Exclusion Mutuelle Distribué pour les
Réseaux Ad Hoc
Hamza DRID* et Hamamache KHEDDOUCI**
* Laboratoire LORIA. Université Nancy2, France.
[email protected]v-nancy2.fr
** Laboratoire PRISMa. Université Claude Bernard Lyon 1, France.
Résumé: Le problème d’exclusion mutuelle a été considérablement étudié dans les systèmes répartis. Les solutions
proposées pour les réseaux ad hoc sont entièrement basées sur le principe du jeton. L’algorithme que nous proposons
dans ce papier utilise les deux approches de l’exclusion mutuelle : l’anneau à jeton et l’approche des permissions.
L’algorithme s’exécute sur une topologie logique dynamique sur laquelle on distingue deux classes de nœuds. La
première classe est composée des nœuds formant l’anneau qui s’occupe de la gestion du jeton. La seconde contient les
fils de la première classe. L’objectif principal de cette solution vise à diminuer l’impact de la mobilité et réduire le
temps et le nombre de messages échangés pour accéder à la ressource critique lorsqu’il y a une faible concurrence dans
le réseau.
Mots clés: Exclusion mutuelle, Réseaux ad hoc, Algorithmes distribués, Topologie dynamique.
INTRODUCTION
Au cours de ces dernières années le monde des
réseaux sans fil est devenu l’axe de recherche le plus
important en réseaux. L'évolution récente des moyens
de communication sans fil a permis la manipulation de
l’information à travers des unités de calcul portables
ayant des caractéristiques particulières (une faible
capacité de stockage, une source d’énergie
autonome...). Les réseaux mobiles sans fil peuvent être
classés en deux catégories: les réseaux avec
infrastructure qui utilisent généralement le modèle de
la communication cellulaire et les réseaux sans
infrastructure ou les réseaux ad hoc.
Un réseau ad hoc est un réseau sans fil spontané,
auto-organisé, ne reposant sur aucune infrastructure.
Les éléments (nœuds) qui le composent sont
généralement reliés par des ondes radio. Dans un
environnement ad hoc, les mobiles se partagent les
ressources du réseau sans arriver à des situations
d’interblocage ou de conflit. Un conflit peut se
produire lorsque, à un instant donné, un noeud essaie
d’acquérir un nombre de ressources supérieur au
nombre de ressources libres. Cependant, une situation
d’interblocage se caractérise par un état global du
système dans lequel des noeuds demandent des
ressources mais aucun ne parvient à les acquérir.
L’exclusion mutuelle dans les réseaux ad hoc est
considérée comme l’une des solutions de cette
problématique. Pour maintenir l’intégrité d’une
ressource partagée, un algorithme d’exclusion
mutuelle doit vérifier la propriété de vivacité ainsi que
la propriété de la sûreté. Ces deux propriétés
garantissent l’absence des situations d’interblocage ou
de conflit dans un réseau ad hoc.
Cet article est organisé comme suit, La section 1
est consacrée à la description des solutions existantes
du problème d’exclusion mutuelle dans les réseaux ad
hoc. Notre proposition est présentée dans la deuxième
partie. Nous terminons par une conclusion et des
perspectives de travaux futurs.
1. Algorithmes d’exclusion mutuelle dans
les réseaux Ad hoc
Dans un environnement ad hoc, les mobiles se
partagent les ressources présentes dans le réseau.
L’utilisation simultanée d'une ressource partagée par
plusieurs noeuds peut produire une situation
incohérente. En effet, une ressource partagée en
exclusion mutuelle ne doit être accessible que par un
seul processus. Cette ressource est appelée ressource
critique. La partie de programme utilisant la ressource
critique est appelée section critique SC. Un algorithme
d’exclusion mutuelle est donc nécessaire pour rendre
exclusif l’accès à la ressource critique.
SETIT2007
- 2 -
Plusieurs solutions ont été proposées pour les
réseaux filaires. Ces solutions peuvent être regroupées
en deux familles:
• les algorithmes basés sur le jeton : reposent sur
l’unicité du jeton. Le noeud qui le détient exécute sa
section critique.
• les algorithmes basés sur les permissions : pour
entrer en section critique, un processus doit avoir
toutes les permissions indispensables [HSN 02].
Les algorithmes d’exclusion mutuelle dans les
réseaux ad hoc sont obtenus à partir des algorithmes
proposés dans les réseaux filaires en prennent en
compte les caractéristiques de la mobilité. Dans cette
section nous présentons les différents algorithmes
d’exclusion mutuelle existants développés pour les
réseaux Ad hoc.
1.1. Algorithme de J. Walter et S. Kini [WLT 97]
L’algorithme proposé par J. Walter and S. Kini
[WLT 97] est basé sur le principe du jeton. Cet
algorithme utilise des méthodes et des techniques
développées par: Gafni, et. Bertsekas, dans « loop-free
routing protocol in ad hoc network » [GFN 81], ainsi
que d’autres algorithmes présentés dans [RYM 89]
[CHG 90] [DHM 94]. Une topologie logique DAG
(Graphe acyclique orienté) est construite à partir du
réseau physique. Cette dernière maintient la
propriété "orientée destination". Un DAG est orienté
destination si on peut trouver un chemin vers une
destination donnée [GFN 81]. Dans notre cas, la
destination est le nœud qui détient le jeton, ce noeud
est appelé Sink.
Initialement, le nœud possédant le jeton initie la
construction de la topologie logique DAG. Chaque
nœud de cette topologie lui est associé une valeur
appelée altitude. Cette valeur indique la hauteur d’un
noeud par apport à ses voisins. L’orientation des arcs
est définie selon les valeurs d’altitude. Une altitude est
un triplet (A, B, Id) où A et B sont des entiers et Id
représente l’identificateur du nœud [GFN 81]. Le
pointeur est orienté toujours du nœud qui a la plus
grande altitude vers le nœud qui la plus petite altitude.
Les altitude forment un ordre total. Chaque nœud qui
veut entrer en SC envoie une requête vers le nœud qui
détient le jeton. Un nœud intermédiaire maintient une
file d’attente pour enregistrer les requêtes de ses
voisins ainsi que la sienne. Un élément de la file est un
return_path. Le nœud qui reçoit le jeton entre en SC
s’il est à l’en tête de la file d’attente, sinon il transmet
le jeton au nœud voisin. Comme le jeton se déplace, le
nœud qui le reçoit devient le Sink. Par conséquent, ce
dernier doit modifier son altitude pour que sa valeur
soit la plus petite du DAG et que chaque nœud
possède un chemin vers lui.
Un ou plusieurs nœuds peuvent disparaître à cause
de la mobilité, alors les return_path qui s’y réfèrent ne
sont plus valides. Dans le cas normal, lorsqu’un nœud
sort de sa SC, il envoie le jeton au nœud demandeur à
travers return_path. Si le return_path n’est plus
valide, le Sink lance l’algorithme de recherche pour
repérer le nœud déplacé par l’envoie du message de
recherche sur tous ses liens. Chaque nœud qui reçoit
ce message pour la première fois le diffuse sur tous
ses liens entrants. Quand le nœud est trouvé, le jeton
lui est transmis.
1.2. Algorithme de J. Walter, J. Welch et Vaidya
[WLT01]
Une deuxième version de l’algorithme précédent
[WLT 97] a été proposée par J. Walter, J. Welch et
Vaidya [MLP 01]. L’algorithme utilise les mêmes
hypothèses et le même principe, la différence
principale avec l'algorithme présenté dans [WLT 97] se
situe dans le traitement du déplacement des nœuds. En
effet, dans l’algorithme précédent [WLT 97], si un
nœud voisin qui doit recevoir le jeton n’est plus
accessible, alors le nœud possédant le jeton doit lancer
la procédure de recherche du nœud disparu. En
revanche, dans le deuxième algorithme, le nœud non
accessible, en raison de sa mobilité, doit émettre de
nouveau la demande du jeton. Ceci élimine le coût
engendré par le processus de recherche.
1.3. Algorithme R. Baldoni et A. Virgillito [BLD 02]
L’algorithme proposé par R.Baldoni, A.Virgillito
[BLD 02] est basé sur le principe du jeton, il combine
les deux méthodes Token-Asking et la méthode
Circulating-Token. Dans la méthode Token-Asking, si
un nœud veut entrer en SC, il demande le jeton des
autres nœuds. Dans la seconde méthode, le jeton
circule autour d'un anneau logique. Lorsqu’un nœud
reçoit le jeton il entre en SC. L’algorithme utilise le
protocole de routage pour communiquer avec les
autres nœuds du réseau.
L'algorithme passe en permanence entre deux
états : Idle et Coordinator-Change. Au début,
l’algorithme se trouve dans l'état Idle et le
coordinateur C0 correspond au nœud P1. Par ailleurs,
cette information est connue par tous les nœuds. Un
noeud qui veut entrer en section critique doit envoyer
une requête au coordinateur et attendre le jeton. Le
coordinateur insère la demande dans sa file d’attente
PendingRequest (P) selon une discipline P(FIFO ou
avec Priorité ‘plus proche’, etc.). L'algorithme
s’exécute en séquence de rounds (anneau logique) où
il y a alternance des deux états.. Un nouveau round
commence quand l'état du système change vers
Coordinator-Change. Dans un round, un processus est
désigné pour être le coordinateur noté Ck. Le round est
terminé lorsque tous les nœuds du réseau sont visités.
Le nœud qui reçoit le jeton calcule dynamiquement
son successeur et lui envoie le jeton en utilisant la
table booléenne Receivedtoken[] transmise avec le
jeton. Cette table indique les noeuds qui ont déjà reçu
le jeton. Le successeur est calculé selon certains
critères déterministes, principalement la distance
(nombre de sauts) entre l'émetteur et le récepteur du
jeton.
Le rôle principal des états Coordinator-Change et
Idle est de déterminer le début et la fin du round
composé de n-1 nœud, le coordinateur Ck-1 n’est pas
SETIT2007
- 3 -
inclus. Le round commence par le coordinateur Ck, par
conséquent la structure de l'anneau est calculée au
moment où le jeton se déplace entre les nœuds. Le
noeud qui reçoit le jeton doit le transmettre vers son
successeur qui doit être différent de Ck-1 et n’ayant pas
reçu le jeton auparavant. Le dernier nœud de cet
anneau logique transmet le jeton à Ck provoquant ainsi
la transition de l'algorithme vers l'état Idle. Le
prochain coordinateur sera le premier processus dans
la file d’attente du coordinateur courant.
1.4. Algorithme de N. Malpani, N. H. Vaidya et J.
L. Welch [MLP 01]
N. Malpani, N. H. Vaidya et J. L. Welch [MLP 01]
ont proposé un algorithme paramétré avec plusieurs
variantes. Il utilise un anneau logique dynamique de
taille variable. La taille de l'anneau peut changer à
chaque round. Un round est terminé quand tous les
nœuds du réseau sont visités. L’objectif de
l’algorithme est de trouver un round optimal, c'est-à-
dire un round qui passe une et une seule fois par
chaque nœud du réseau. L'idée principale de cet
algorithme se base sur la manière de choisir le
prochain nœud qui va recevoir le jeton.
Plusieurs politiques ont été appliquées pour
déterminer le prochain nœud. Elles sont divisées en
deux classes : les politiques qui utilisent que
l'information locale du voisinage et les politiques qui
utilisent les informations globales de tous les nœuds
du réseau.
Algorithme Fréquemment- Local (LF) : Le jeton est
envoyé au voisin le moins fréquemment visité.
Algorithme Récemment -Local (LF) : Le voisin le
moins récemment visité est choisi comme prochain
noeud.
Algorithme Récemment - globale (GR) : Le jeton
est envoyé vers le nœud le moins récemment visité.
Algorithme Fréquemment - globale GF) : Le jeton
est envoyé vers le nœud le moins fréquemment visité
parmi tous les nœuds du réseau.
Algorithme global avec Visité (GRV et GFV) : Dans
ces variantes, tous les nœuds intermédiaires qui
conduisent vers la destination sont visités par le jeton.
Algorithme recherche Itérative : Un autre
algorithme a été proposé dans [MLP01] afin
d’améliorer les performances futures de l'algorithme
tout en tenant compte du passé. L’algorithme cherche
les chemins Hamiltonien (chaîne passant une et une
seule fois par tous les nœuds du réseau) dans le réseau
pour que le jeton puisse faire un round optimal.
2. Nouvel algorithme d’exclusion mutuelle
mixte basée sur une topologie dynamique
Les différents algorithmes d’exclusion mutuelle
proposés dans les réseaux ad hoc sont entièrement
basés sur le principe du jeton. Certaines solutions
utilisent la topologie physique du réseau et réduisent
le temps et les messages échangés pour entrer en SC.
D'autres imposent une structure logique correspondant
au réseau physique comme un anneau, un arbre, etc.
Pour améliorer les performances, l’algorithme proposé
par Baldoni et Virgillito [BLD 02] ainsi que celui de
Malpani, Vaidya, et Welch [WLT 01] proposent une
solution pour trouver un round optimal, c’est-à-dire un
anneau logique qui passe une et une seule fois par
chaque nœud du réseau. Un round optimal permet
d’optimiser le nombre de messages et le temps de
réponse pour entrer en SC, il dépend de la topologie
physique ainsi que du nombre de nœuds.
L’algorithme que nous proposons utilise les deux
approches de l’exclusion mutuelle : l’approche du
jeton et l’approche des permissions. L’algorithme
s’exécute sur une topologie logique dynamique. Dans
ce cas, on distingue deux classes de nœuds : la
première est composée des nœuds formant l’anneau et
s’occupant de la gestion du jeton et la seconde
contient les fils de la première classe. L’objectif
principal de cette solution vise à diminuer l’impact de
la mobilité ainsi que de réduire le temps et le nombre
de messages pour accéder à la ressource critique
lorsqu’il y a une faible concurrence dans le réseau.
2.1. Principe de l’algorithme
1. Au début, le noeud possédant le jeton initie la
construction de la topologie logique. A la fin de la
construction, nous aurons deux classes de nœuds :
les nœuds formant l’anneau et les fils de ces
derniers. Le jeton passe que par les nœuds de la
première classe, il sauvegarde une table Père_Fils[]
pour qu’un nœud puisse connaître son fils, ainsi que
les nœuds qui ne sont pas encore visités par le jeton.
2. Un noeud Pi appartenant à la Classe_1 ne peut
entrer en SC que s’il possède le jeton. En revanche,
un noeud de la Classe_2, doit envoyer une demande
à son père et attendre la permission de ce dernier. Pi
ajoute la requête de son fils dans sa file d’attente et
lui envoie la permission dès qu’il sort de sa SC.
Pour que Pi puisse envoyer le jeton au nœud
suivant, il doit recevoir un message de libération de
son fils.
3. Des liens peuvent disparaître à cause de la mobilité.
Notre algorithme s’intéresse seulement aux liens de
type Père-Fils. Lorsqu’un noeud Pi reçoit le jeton et
détecte que le lien avec son fils Pj est rompu, il lui
envoie la permission (ceci dans le cas où Pj a
demandé la SC) et ajoute une nouvelle entrée dans
la table Père_Fils[] de façon à ce que Pj devient un
nœud de la Classe_1.
4. Pour maintenir la structure de notre topologie
(Père-Fils),, si un nœud Pi (sans fils) reçoit le jeton
et détecte que l’un de ses voisins Pj ne possède pas
un fils, P
i alors il envoie un message à P
j pour lui
proclamer qu’il est son père.
Dans la topologie logique illustrée dans la Fig.1
(b), nous distinguons deux classes de nœuds : les
nœuds qui s’occupent de la gestion du jeton {2,3,5,6}
et les fils de ces derniers {1,4,8,7}. Cette figure met en
évidence le fait que chaque nœud fils possède un
nœud père mais le contraire n’est pas vrai.
SETIT2007
- 4 -
Fig.1 Topologie Logique Dynamique
2.2. Modélisation du Système
Notre système est composé de N noeuds
indépendants (N≥1). Nous considérons les hypothèses
suivantes :
• Le nombre N des noeuds est connu.
• Tous les nœuds exécutent le même protocole (notre
algorithme).
• La communication est fiable.
• Un nœud ne tombe jamais en panne.
• Les ruptures sont causées seulement par le
déplacement des nœuds.
• Les informations de voisinage sont fournit par le
protocole de routage.
• Aucune partition dans le réseau ne peut apparaître.
2.3. Variables et Messages échangés
Variables locales : Chaque nœud P
i dans le système
maintient les variables locales suivantes:
Pèrei: variable indiquant l’identificateur du nœud
Père. Si Pi = Pèrei signifie que Pi
∈
Classe_1.
Demande_SC : variable booléenne initialisée à faux,
indiquant si Pi a demandé la ressource critique ou
non.
filei : file d’attente du noeud Pi contenant les requêtes
venant du nœud fils.
Messages échangés : Pi communique avec les autres
nœuds par l’envoie de l’un des messages suivants :
Req_Sc(): message envoyé par Pi à son Père pour
demander la SC.
Perm_SC(): message envoyé par Pi à son fils pour
qu’il puisse entrer en SC.
Libr_SC() : message envoyé par Pi à son père dès qu’il
termine de la SC.
Tu_Es_Pére(): message envoyé par Pi à son Fils pour
l’informer que le lien Père-Fils est rompu.
Tu_Mon_Fils() : message envoyé par Pi à Pj pour lui
dire qu’il est son fils tel que: Pi, Pj
∈
CLasse_1.
Jeton (Père_Fils[]): message envoyé par P
i à Pj de la
même classe (classe_1), pour donner le privilège à
Pj. Le message contient une table Père_Fils[] qui
permet de faire la distinction entre les nœuds de la
Classe_1 et ceux de la Classe_2 et qui permet aussi
de savoir quels sont les nœuds visités par le jeton.
Structure de la table Père_Fils[] : Chaque entrée
dans la table Père_Fils[] contient trois champs (Père ;
Fils ; Visité)
Pére : contient l’identificateur du nœud Père. Un père
doit impérativement appartenir à la Classe_1.
Fils : contient l’identificateur du nœud fils. Un fils
doit impérativement appartenir à la Classe_2.
Visité : indique si le nœud père est visité par le jeton
ou non dans le round courant.
Initialement, la valeur Visité de toutes les cases de
la table Père_Fils[] est égale à Faux.
Fig.2 Exemple de La Table Père_Fils[]
2.4. Algorithme générique
A. Demande d’entrée en SC par le nœud Pi
• Pi
∈
classe_1
Pi entre en SC dès qu’il reçoit le jeton.
• Pi
∈
classe_2
Pi envoie le message Req_Sc() à son père pour
demander la SC. Pi entre en SC dès qu’il reçoit la
permission Perm_Sc() de son père.
B. Pi reçoit une demande d’accès en SC de son fils
• Pi
∈
classe_1
1. Pi insert la requête de son fils dans la file d’attente.
2. Pi envoie la permission Perm_SC() dès qu’il
termine de sa SC.
C. Libération de la SC par Pi
• Pi
∈
classe_1
1. Pi change la valeur de sa case Père_Fils[i].
Père_Fils[i] :=(Pi ,Pi.Fils , Vrai)
2. Pi envoie le jeton au prochain nœud dès qu’il
reçoit le message Libr_SC() de son fils et le
prochain nœud est calculé à partir de la table
Père_Fils[].
• Pi
∈
classe_2 :
Pi envoie Libr_SC() à son père.
D. Pi envoie le jeton
• Pi ∈ classe_1
Lorsque Pi veut envoyer le jeton, il doit vérifier s’il
y a des noeuds qui ne sont pas encore visités, si ce
n’est pas le cas Pi met la valeur Père_Fils[i]
->visité de toute les cases de la table Père_Fils[] à
"Faux" pour commencer un nouveau round (nouvel
anneau logique) et envoie le jeton vers le premier
nœud de cette table.
E. Traitement des ruptures:
Chaque nœud sait à quelle classe il appartient. Les
liens sensibles dans notre algorithme sont ceux entre
les nœuds de deux classes différentes et qui ont une
relation de type Père-Fils. Le traitement suivant est
2
1
3
9
65
7 8
4
Faux
Père Fils Visité
2 1
5
3 4
8
6 7
9 Null
Vrai
Faux
Faux
Faux
2
1
3
9
65
7 8
4
2
1
3
9
65
7 8
4
(
a
)
(
b
)
Pi
∈
Classe 1
Pi
∈
Classe 2
Pi
p
ossédan
t
le
j
eton
L
ien
p
h
y
si
q
ue
L
ien
L
o
g
i
q
ue
File d’attente
SETIT2007
- 5 -
effectué lorsqu’un nœud détecte que son lien Père-
Fils est rompu :
• Pi∈Classe_1
Lorsque Pi reçoit le jeton et termine de sa SC:
1. Pi insère une nouvelle entrée dans la table
Père_Fils[] portée avec le jeton
(Père := Pi .Fils ; Fils := null ; Visité =vrai)
2. Pi envoie la permission à son fils si ce dernier a
demandé la SC.
• Pi∈Classe_1
Pi affecte à sa variable locale Père son propre
identificateur lorsque il reçoit le message
Tu_Es_Pére de son Père. Pi devient un nœud de la
Classe_1.
2.5. Description de l’algorithme
2.5.1. lors de la réception du jeton
Comme nous avons dit précédemment, le jeton
visite que les nœuds de la Classe_1. Par conséquent,
quand Pi reçoit le jeton, il rend la valeur de
Père_Fils[i]->.visité à vrai (Fig3 ligne 1), et attend
jusqu’ à ce que la valeur Demande_SC devient Fausse
(libération de la SC) (Fig3 ligne2 ) pour vérifier s’il y
a une requête dans la file d’attente ou non, si c’est le
cas Pi envoie la permission à son fils(Fig3 ligne 3,4).
Lorsque Pi reçoit le jeton (Père_Fils[]) :
{
1) Père_Fils[i]->visité = vrai ;
2) Attendre jusqu’a Demande_SC = faux ;
3) Si Filei Non vide Alors
{
4) Envoyer Perm_SC à Père_Fils[i]->Fils ;
5) Attendre jusqu’a Filei = vide ;
}
6) Lien_rompu(Pi, Père_Fils[i]->Fils ) ;
7) Si ∃ Père_Fils[i]->visité = Faux Alors
{
8) Envoyer le jeton vers le nœud :
Père_Fils[i]->Pere.Suivant()
}
Sinon \\ un nouvel anneau vient de commencer
{
9) ∀ i, Père_Fils[i]->visité := faux
10) Envoyer jeton vers le premier nœud père dans
la table Père_Fils[] ;
}
11) si (Pèrei ≠ Pi )
12) Père_fils[i]->supprimer ;
}
Fig.3 Traitement effectué lors de la réception du jeton
L’étape suivante consiste à vérifier l’existence du
lien entre Pi et son fils. Après cette étape, Pi doit
envoyer le jeton au nœud suivant. Pi consulte la table
Pere_Fils[] pour voir s’il y a un nœud qui n’est pas
encore visités afin de lui envoyer le jeton (Fig3 ligne
6,7). Si ce n’est pas le cas, Pi met la valeur
Père_Fils[i]->visité de toute les entrées de la table à
faux pour commencer un nouveau round (nouvel
anneau logique) (Fig3 ligne 8,9). Quand Pi reçoit le
message Tu_Mon_Fils de l’un de ses voisins, la valeur
de la variable Pèrei devient différente de Pi (Fig4
ligne 3,4). Lorsque Pi reçoit le jeton, il supprime sa
case de la table Père_fils[], pour qu’il ne reçoit pas le
jeton dans le prochain round (Fig3 ligne 11,12)
2.5.2. lors de la réception d’un message de Pi
• Lorsque Pi reçoit un message Tu_Mon_Fils
(Pi
∈
Classe_2) de son voisin Pj, Pi affecte à la
variable Locale Perei l’identificateur du Pj (Fig4
ligne 2,3).
• Lorsque Pi reçoit un message Tu_Es_Pére
(Pi
∈
Classe_2) de son Père Pj, Pi affecte à la
variable Locale Perei son identificateur est devient
un nouveau Père (Fig4 ligne 4,5).
• Lorsque Pi reçoit un message de type Req_SC
(Pi
∈
Classe_1) de son fils, Pi met dans sa file
d’attente l’identificateur de son fils pour qu’il lui
envoie la permission (Fig4 ligne 6,7).
• Lorsque Pi reçoit un message de type Libr_SC (Pi
∈
Classe_1) de son fils, Pi vide sa file d’attente (Fig4
ligne 8,9).
Lorsque Pi reçoit un message de Pj
{
1) Si Pi ≠ Pèrei alors //(Pi ∈Classe_2)
{
2) Cas : msg =Tu_Mon_fils
3) Pèrei := Pj;
4) Cas : msg =Tu_Es_Pere
5) Pèrei := Pi;
}
Sinon //(Pi ∈Classe_1)
{
6) Cas : message = Req_SC
7) Insérer Pj dans Filei ;
8) Cas : message = Libr_SC
9) Vider Filei
}
}
Fig.4 Traitement effectué lors de la réception d’un
message
2.5.3. Description des fonctions
2.5.3.1 Demande_SC()
Quand un nœud Pi demande la SC, il place la
valeur Demande_SC à vrai (Fig5 ligne 1), si Pi
appartient à la Classe_1, il entre en SC dès qu’il reçoit
le jeton (Fig5 ligne 5), sinon il doit envoyer un
message Req_SC() à son père et attend la permission
Perm_SC() pour qu’il puisse entrer en SC (Fig5 ligne
3,4). Lorsque Pi termine de sa SC, il fixe la valeur
Demande_SC à faux (Fig5 ligne 7,8) et envoie
Perm_SC() à son père si Pi
∈
Classe_2 (Fig5 ligne 9).
2.5.3.2 Lien_rompu (Pi, Fils )
Cette fonction est utilisée pour vérifier si le lien
entre Pi et son Fils est rompu. Pi ajoute une nouvelle
entrée (Fils, null, vrai) dans la table Père_fils[](Fig6
ligne 2), ensuite, Pi envoie un message de type
Tu_Es_Père à son ancien Fils pour l’informer qu’il est
devenu un Père (Fig6 ligne 3). La fonction Fusion ()
est appelée pour maintenir la topologie dynamique
(Fig6 ligne 4).
6
7
1
/
7
100%
