Ch4 AlgoReparti

Cours Informatique Répartie
Chapitre 4
Algorithmiques et Exécutions
Réparties
Première Partie
Les accès concurrents

Algorithmes d’Exclusion
Mutuelle
1

• Problématique :
• On définit des sections critiques
dans plusieurs processus (partie de son code
utilisant une ressource)
• On parle d’exclusion mutuelle quand

un seul processus à la fois a le droit
de rentrer dans sa section critique à
un instant donné
• Solutions matérielles:
• Désactiver les interruptions
(signaux des périphériques)
• Solutions logicielles:
• Sémaphores
2
Accès concurrents dans un

environnement centralisé
 Sémaphores binaires (mutex : mutual

exclusion) qui peuvent prendre les valeurs 0
ou 1 et les sémaphores n-aires
 Le système gère l’entrée à la section

critique en endormant les processus qui
arrivent alors que le sémaphore est
attribué

 Deux primitives: P et V indivisibles

 P(S) permet de prendre le
sémaphore:
Si S>0 Alors S = S-1
Sinon s’endormir
FinSi
3

• V(S) permet de libérer le
sémaphore et un processus bloqué
s’il en existe:
Si un processus est bloqué sur S
Alors le libérer
Sinon S = S+1
FinSi
Les accès concurrents dans un

environnement réparti
• Rappel : On parle d’exclusion mutuelle
quand un seul processus à la fois a le
droit de rentrer dans sa section
critique à un instant donné
• Réparti  à un instant donné ??
• Pas de référentiel de temps commun 

spécification utilisant l’ordre entre les
processus
4

• Un processus bloqué appartient à la
file des processus en attente, une
fois libéré il passe dans celle des
prêts.
• Le système gère des contextes de

processus

• A distance il devient difficile, voir
impossible, de gérer des contextes
des différents processus des
différents sites
• => les solutions telles que sémaphores

ne sont plus applicables
Absence de mémoire partagée
10
5

• Solution : Imposer un ordre sur
l’exécution des sections critiques
• Contraintes supplémentaires:
• Équité (fairness) entre les
processus
• Vivacité (liveness) (ni interblocage

(deadlock), ni famine (starvation) )
11

• Nouvelles Solutions:
• Centralisées: basées sur un
coordinateur
• Réparties: concertation des

processus
• Basées sur l’utilisation d’un jeton

12
6

Solution centralisée
• Un processus est élu coordinateur
• Lorsqu’un processus Pi désire rentrer en

section critique, il envoie une requête au
coordinateur en lui désignant la section en
question et en lui demandant son
autorisation
13

• Si aucun processus n’est dans la section
critique, le coordinateur donne son accord
et envoie une réponse positive à Pi
• Lorsque Pi ressort de la section, il envoie

un message au coordinateur en relâchant
son accès exclusif.
14
7

• Le coordinateur prend alors le premier
élément de la file des demandes en
attente et autorise le processus
correspondant à rentrer en section
critique
15

• On simule donc un système centralisé
• P(S) est remplacé par une requête

bloquante au coordinateur Puis-je?
• V(S) est remplacé par une primitive qui

envoie un message de terminaison au
coordinateur.
16
8

• Avantages:
• Equité: les demandes sont accordées

dans l’ordre de leur réception
• Pas de famine
• Simple à mettre en œuvre

17

• Inconvénients:
• Sollicitation excessive du coordinateur
=> goulot étranglement
• Panne du coordinateur => élire un
nouveau => unicité du nouveau
• Ambiguïté pour les processus de
distinguer entre une panne du
coordinateur et un retard dans la
réponse
18
9
Les accès concurrents Solutions

Réparties
• Avec la solution centralisée, les
inconvénients venaient du coordinateur
=> il faut l’enlever !!!
• Nouvelle contrainte:
• Algorithme symétrique, décentralisé
• Nouveau Problème: Aucune équité n’est
possible car pas d’ordre entre les
demandes d’accès. Risque de famine !
19
Les accès concurrents :

Première Solution Répartie
• Chaque processus connaît les N-1

autres processus qui interagissent
avec lui pour une section critique
• Chaque processus désirant rentrer en

section critique suit deux étapes
20
10

Première Solution Répartie
1. Envoie un message aux N-1 processus Puis-je?
2. Attend les réponses :

• Réception de N-1 réponses : il peut rentrer en
section critique
• Réception de N-2 réponses : ne rentre pas car

un autre est peut-être dans la section critique
(ou perte de sa réponse auquel cas il faut ré-
envoyer la requête)
• Application: Algorithme de Lamport 21

Algorithme de Lamport
• Les canaux de communication entre les
différents sites respectent la
propriété FIFO.
• Chacun des composants du système

utilise une horloge scalaire qu'il
synchronise lors de la réception de
messages (selon les règles de
synchronisation de Lamport)
22
11

• Chacun des composants gère une file

d’attente dans laquelle il ordonne
toutes les requêtes pour entrer en
section (y compris les siennes) selon
la valeur de leurs estampilles
23

• Trois types de messages (estampillés

lors de leur envoi) sont utilisés :
• REQUETE : envoyé lorsqu'un site veut
entrer en section critique
• REPONSE : envoyé par un site qui reçoit

un message du type précédent
• LIBERATION : envoyé par un site

lorsqu'il sort de section critique.
24
12

• Chacun des messages sera

systématiquement envoyé à tous les
autres participants
25

• On notera Hi l’horloge du site Si, et

FILEi la file d’attente de Si (messages
rangés par estampilles croissantes)
• Si Si veut entrer en section critique, il
place sa requête dans FILEi et envoie un
message de type REQUETE à tous les
autres sites.
26
13

(suite)
• Il pourra entrer en section critique

lorsqu’il aura effectivement reçu un
message de type REPONSE de tous les
autres ET que sa requête sera en tête
de FILEi ;
27

(suite)
• Si Sj reçoit un message de type

REQUETE en provenance de Si, il met
à jour son horloge Hj, il place la
requête dans FILEj et envoie à Si un
message de type REPONSE;
28
14

(suite)
• Lorsque Si sort de la section critique,

il envoie à tous les autres sites un
message de type LIBERATION et
retire sa requête de FILEi
29

(suite)
• Si Sj reçoit de Si un message de type

LIBERATION, il met à jour son
horloge et enlève de FILEj le
message de type REQUETE
30
15

Exemple 1:
P0 entre en SC
FILE0={[8,0],[12,2]} FILE0={[12,2]}
FILE0={[8,0]} REPONSE0={0,1,2} REPONSE0={}
0 0 0
REQUETE (8,0) 12,2 REPONSE
REPONSE LIBERATION
8,0
REPONSE
1 2 1 2 1 2
12,2 REPONSE
FILE2={[12,2]} FILE2={[8,0],[12,2]} FILE2={[12,2]}
REPONSE2={0,1,2} REPONSE2={0,1,2}
P2 entre en SC
31

• Lamport garantit que si a de Pi précède

b de Pj alors les messages REQUETE,
REPONSE et LIBERATION de Pi
précèdent ceux de Pj
• Estampillage => absence de famine et

d’interblocage
• Nécessite 3(N-1)
? messages
32
16

Exemple 2:
Les sites S1 et
S2veulent
entrer en
section critique
alors que leurs
horloges
scalaires ont
resp. 3 et 2
comme valeur.
S1 S2 S3 33

Algorithme de Ricart et Agrawala
Amélioration de l’algorithme de Lamport
Principe:
• Quand un processus reçoit un message
REQUETE :
• S’il n’est pas dans la section critique
et ne veut pas rentrer il retourne
simplement un message OK à
l’émetteur
34
17

(suite)
• S’il est déjà en section critique, il ne

répond pas.
• Il mémorise la demande dans une file

d’attente
35

(suite)
• S’il veut rentrer en section critique,

mais ne l’a pas encore fait, il compare
l’estampille du message venant
d’arriver à celle contenue dans le
message qu’il avait envoyé aux autres.
• La plus ancienne (la + petite valeur)

gagne:
36
18

(suite)
• Si le message reçu est plus vieux,

le récepteur répond OK
• Sinon le récepteur mémorise la

demande et n’envoie rien
37

Algorithme (sur chaque site i):
1. Demande d’entrée en section critique par Pi:
• Pi envoie message à tous (y compris Pi): (REQ, i, hi)
2. Réception par Pi de (REQ, j, hj):
• Pi non demandeur: Pi envoie (OK, i, hi) à Pj
• Si Pi en section critique met la requête de Pj en
liste d’attente
• Pi est demandeur :
if (i, hi) < (j, hj) { put (j, FILEi)}
else { Pi envoi (OK, i, hi) à Pj}
• Pi entre en section critique ssi il a reçu un message
OK de tous les autres 38
19

Algorithme (sur chaque site i) suite:
3. Quand Pi sort de la section critique, il

exécute:
for all Pj  FILEi :
{
Pi envoie (OK, i, hi) à Pj;
out(Pj, FILEi)
}
39

• La file FILEi sur le site i collecte toutes les

requêtes postérieures (au sens des estampilles) à
celles de Pi
• La file globale virtuelle est représentée par l’ensemble des
FILEi
• Les processus exécutent leur section critique dans

l’ordre des estampilles de leur requêtes d’entrée
• Nécessite combien de messages par demande

d’entrée en section critique ?
(n-1) REQ + (n-1) OK = 2(n-1) messages 40
20

Exemple:
8,0
FILE0={[12,2]} Sortie de section critique
Entrée en section critique FILE0={}
0 0 0
8,0 12,2 OK OK OK
8,0
1 2 1 2 1 2
12,2 OK
Entrée en section
12,2 Pas d’OK de critique
P0 à P2
41

Algorithme de Maekawa
• Chaque processus ne peut donner sa

permission qu'à un seul à la fois
• Le participant à qui cette permission a été

donnée doit la restituer spontanément
une fois qu'il ne l'utilise plus, c'est-à-
dire lorsqu'il sort de sa section critique.
42
21

(suite)
• Chaque site i dispose d'un ensemble RS

(«request set») de sites, RSi, dont il doit
obtenir l'accord avant de pouvoir entrer
en section critique.
• Comme c'est le cas de tous les algorithmes

basés sur la stratégie de l'arbitrage, les
différents ensembles doivent satisfaire la
condition suivante : 43

(suite)
• Cette condition assure que pour tout

couple de sites, un site au moins est
susceptible d'arbitrer les conflits entre
ces deux sites.
44
22

Avantages:
• Pas de famine, pas d’interblocage
• Equité obtenue par utilisation des

estampilles
45

• Inconvénients:
• Si l’un des processus se plante (crashes), il
ne répondra pas aux requêtes => interprété
comme une permission refusée => blocage
• Solution: utilisation de temporisateurs (timers)
• Chaque processus doit gérer la liste des

autres membres (nouvelle entrée, nouvelle
sortie, panne)
• Charge du réseau 46
23

Solutions à jeton
• Objectifs de conception
• Minimiser le nombre de messages des
algorithmes distribués
• Inspirées des solutions d’accès aux

support pour des systèmes physiques
de communication de type anneau à
jeton (Token Ring)
47

Solutions à jeton
• Jeton: configuration unique de bits (a
bit pattern)
• Il y a un jeton et un seul !!!
• Appliquées aux réseaux de

communication en bus avec anneau
(physique) ou sans (anneau logique)
48
24

Solutions à jeton
• Ordonnancement préétabli des
processus 
• Chaque processus doit savoir qui le
suit (ou qui le précède)
• Un processus au plus peut entrer en
section critique à tout instant (le
propriétaire du jeton)
49

Solutions à jeton
Initialisation:
• Créer l’anneau virtuel
• Créer un jeton (et un seul); affecter le

jeton au processus 0
50
25

Solutions à jeton
(Suite)
• Le jeton circule dans l’anneau; il passe

du processus k au processus k+1 (modulo
la taille de l’anneau):
• k reçoit le jeton; il regarde s’il veut rentrer
en section critique
• Si oui il y entre, puis lorsqu’il a terminé, il passe

le jeton à son voisin (pas d’utilisation répétée !!)
• Si non, il passe directement le jeton à son voisin 51

Solutions à jeton
(Suite)
• Un processus ne peut entrer en

section critique que s’il est en
possession du jeton
• Un processus garde le jeton pendant

un temps limité
52
26

Solutions à jeton
• La validité des algorithmes à jeton sur
anneau virtuel repose sur l’intégrité de
l’anneau et sur l’existence et l’unicité
du jeton
• Sûreté: unicité du jeton (cas du
propriétaire qui se plante)
• Vivacité: existence du jeton +
intégrité de l’anneau (fiabilité) +
durée limitée de la section critique
pour chaque processus 53

Solutions à jeton
• Nécessité de maintenir ces propriétés
même en cas de défaillance
54
27

Solutions à jeton
• Maintien de l’intégrité de l’anneau => Auto
surveillance:
• Chaque site surveille son prédécesseur et/ou
son successeur
• Maintien d’un délai de garde
• En cas de détection de défaillance,
reconfiguration puis réinsertion
55

Solutions à jeton
(suite)
• Si besoin, regénération du jeton:
• Détection de la perte
• Délai de garde sur un tour ou jeton de
contrôle
• Choix d’un processus (et d’un seul) pour la
régénération (problème de l’élection)
56
28

Solutions à jeton
• Nécessite 0-N messages:
• Soit N messages dans le cas où le

processus ne possède pas le jeton:
N-1 pour diffuser la requête + 1
pour véhiculer le jeton
• Soit 0 messages dans le cas où il le

possède
57
Les accès concurrents : Algo de

Ricart Agrawala/Suzuki Kasami
• Hypothèses:
• Réseau fortement connecté et voies de
communication fiables
• Délais de transmission variables et

dé-séquencement possible des messages
58
29

• Principe:
• Initialement le jeton est affecté à un
processus quelconque
• Le jeton est demandé par le processus Pi à

l’aide d’un message de requête estampillé et
diffusé à tous les autres processus
59

• Principe:(suite)
• Le processus en section critique possède un
privilège matérialisé par un jeton
• Tant qu’un processus garde le jeton, il peut

entrer en section critique sans consulter les
autres si aucune demande ne lui parvient (pas
rigoureusement symétrique)
60
30

• Matérialisation du jeton:
• Jeton: tableau dont le kième élément
mémorise l’estampille de la dernière
visite qu’il a effectuée au processus Pk
61

• Principe:
• Lorsqu’un processus Pj qui possède le jeton, ne
désire plus accéder à la section critique, il cherche
dans le tableau qui matérialise le jeton le premier
processus Pl (l choisi dans l’ordre j+1, …, n, 1, j-1) tel
que l’estampille de la dernière requête de Pl soit
supérieure à l’estampille mémorisée par le jeton lors
de sa dernière visite à Pl.
• Pj envoie alors le jeton à Pl 62
31

Nécessite N messages (ou 0 si re-entrée)
Début
Var: horloge: 0..+ initialisé à 0; (horloge logique)

Jetonpresent: booleen;
dedans: booleen initialisé à faux;
jeton: tableau (1..N) de 0..+ initialisé à 0;
requetes: tableau (1..N) de 0..+ initialisé à 0;
63

Si NON jetonpresent alors

horloge horloge + 1;
diffuser(req, horloge, i)
attendre(jeton);
jetonpresent vrai;
Finsi;
dedans vrai ;
<section critique>
64
32

jeton(i) horloge ;
dedans faux;
pour j de i+1 jusqu’a N, 1 jusqu’a i-1 faire
si requete(j) > jeton(j) et jetonpresent alors
jetonpresent faux;
envoyer(jeton) à j;
finsi;
finpour
Lors de reception(req, k, j) faire
requete(j) max(requete(j), k);
si jetonpresent et non dedans alors
< Fin section critique>
finsi;
fin;
65

à jeton
Avantages:
• équité: un seul processus peut avoir le
jeton à un moment donné
• Pas de famine: sens bien défini de

circulation du jeton
• Un processus doit au pire attendre que
tous les autres rentrent en section
critique avant d’y rentrer lui-même
66
33

à jeton
Inconvénients:
• Perte de jeton => régénération =>
Assurer l’existence et l’unicité du jeton
• Si un des processus se plante (mais la
reprise est plus simple ici)
67
Deuxième Partie
Algorithmes d’Election
34
Problématique
 Plusieurs algorithmes distribués demandent
à un des processus de jouer le rôle de:
◦ Coordinateur
◦ Initiateur
◦ Séquenceur
◦ Etc.
 Terme générique: coordinateur
69
Principe des algo d’election
 En général, les algo d’élection tentent de

trouver le processus ayant le numéro le plus
élevé et le nomme coordinateur
 Les processus sont supposés connaître les

numéros (unique) des uns et des autres
MAIS un processus ne sait pas qui est actif et
qui ne l’est pas !
70
35
 La transmission des messages entre

processus est supposée fiable sans pertes
 MAIS:
◦ Garantir que si une élection commence, elle

se terminera avec l’accord de tous les
processus sur l’identité du nouvel élu
71
 Chaque processus Pi possède une variable

elui qui contient l’identifiant du processus élu.
 Lorsqu’un processus devient un participant à

l’élection il met cette variable à la valeur
spéciale ‘@’ .
 Durant l’exécution d’un algorithme d’élection,

on doit garantir Safety et Liveness
72
36
◦ E1 (Safety): Un processus participant pi a

elui = @ ou elui = P, où P est choisi à la fin
de l’exécution comme le processus en vie
possédant le plus grand identifiant
◦ E2 (liveness): tous les processus pi

participent et donc mettent elui = @
73
L’algorithme du plus fort – The

bully algorithm (Garcia-Molina, 1982)
 Quand un processus Pi s’aperçoit que le

coordinateur ne répond plus aux requêtes, il
provoque une élection =>
1. Pi envoie un message ELECTION à tout
Pj tels que j>i
2. Si personne ne répond, Pi gagne l’élection
et devient le coordinateur (et l’annonce à
tous)
3. Si un site de numéro plus élevé répond,
c’est lui qui prend le pouvoir. Le rôle de Pi
est terminé 74
37

bully algorithm
◦ A tout moment un processus Pj peut

recevoir un message ELECTION de Pi tel
que i<j.
 Quand un tel message arrive, Pj renvoie
un message OK à Pi pour lui indiquer qu’il
est en vie et qu’il va prendre le contrôle.
 Pj organise alors (à son tour) une élection
75
L’algorithme du plus fort –

The bully algorithm
◦ Tous les processus finissent par abandonner,

SAUF UN qui prend le rôle de nouveau
coordinateur.
 Il annonce sa victoire en envoyant un
message à tous les processus, les informant
qu’il est dorénavant le nouveau coordinateur
76
38

bully algorithm
1 1 1
2 2 2 2 2 2
4 ELECTION 4 OK 4
5 5 5
ELECTION
0 6 0 6 0 6
7 3 7 3 7 3
7 ancien Coord
1 1
2 2 2 2
4 4
5 5
0 6 0 6
COORDINATEUR
7 3 7 3 77

bully algorithm
◦ Pour chaque processus, l’algorithme définit un temps

d’attente maximum T entre l’envoi d’un message
ELECTION et la réception du message OK:
T = 2Ttrans + Tprocess où
 Ttrans: délai max de transmission du message
 Tprocess: délai de traitement du message
 Si aucune réponse
TTrans.n’arrive durant ce temps T, le
processus déduit que le processus en question est
en panne TTrans.
TProcess.
78
39

bully algorithm
 Nécessite au pire O(N 2) et au mieux

N-1 messages
 Garantie la condition E2 (vivacité)

grâce à la fiabilité de transmission des
messages
 Résiste bien aux pannes des processus

(mais pb choix des délais de garde)
79

bully algorithm
 MAIS E1 (sûreté) n’est plus garantie si:

 Un processus qui se plante est remplacé par
un processus avec le même identifiant =>
peut décider qu’il a l’identifiant le plus
grand au même moment où un autre
processus s’autoproclame élu => 2 élus
 Pas d’ordre dans la délivrance des messages !!!!
 La valeur de T n’est pas adéquate (trop

petite)
80
40
Algorithmes pour élection dans

un anneau: Algo1
 Fondé sur l’utilisation d’un anneau mais sans
jeton !!!
 Hypothèses
 Processus physiquement ou logiquement ordonnés de
façon que chacun connaisse l’identité de son
successeur
 L’identité des sites est unique
 Pas de pannes
 Les messages circulent dans un seul sens
(uniquement pour l’élection)
81

un anneau: Algo1
Principe
 Pi s’aperçoit que le coordinateur ne
fonctionne plus, il construit un
message ELECTION contenant son
propre numéro et l’envoie à son
successeur Pj.
 Pj à son tour, ajoute son propre
numéro et envoie le message à son
successeur.
82
41

un anneau: Algo1
Principe (suite)
 Au bout d’un moment, Pi reçoit ce
message, il le change en
COORDINATEUR et le met en
circulation une nouvelle fois pour
désigner le coordinateur (i.e., le
membre de la liste dont le numéro
est le plus grand)
83

un anneau: Algo1
1 [2,3,4,5,6,0,1]
0 2 1
0 2
[2]
[6]
7 Transformés en messages
3 7
3 de désignation du coordinateur
[2,3] Puis remis en circulation
6 4 6 4 jusqu’à nouveau tour
5
5
Messages d’élection
◦ Nombre de messages: 2N où N est le nombre de
processus actifs
◦ Simplicité MAIS Gaspillage de la bande passante
(gros messages) surtout si plusieurs élections
simultanées
84
42
Algorithmes pour élection

dans un anneau: Algo2
Principe
 Lorsque Pi reçoit un message
(ELECTION, Pj):
 Si i ≠ j alors
 Si i>j alors pi émet à son voisin
(ELECTION, Pi)
 Si i<j alors Pi émet à son voisin
(ELECTION, Pj)
 Si i=j (le message a fait le tour de

l’anneau et Pi est l’élu) alors Pi émet un
message de (ELU, i) à son voisin 85

Principe (suite)
 Lors de la réception d’un message

(ELU, j) par Pi
 Si i=j tous les sites connaissent l’élu 
fin de l’élection
 Sinon Pi relaye le message à son voisin
86
43

 Diminuer la taille des messages échangés
(vs Algo1)
 Simple
 Pour N sites, le nombre de messages

échangés est:
 2N si Pi débute l’élection et devient l’élu
 3N-1 si Pi débute l’élection et celui qui
émet vers Pi devient l’élu
 Gaspillage aussi de la bande passante dans le
cas de plusieurs élections simultanées 87
Algorithmes pour anneau

Algo de Chang et Roberts
 Extinction progressive des messages par

filtrage
 Initialement tous les processus sont marqués

non participants à l’élection.
 Tout processus Pi peut commencer

l’algorithme. Il se marque lui-même
participant, place son identifiant i dans un
message (ELECTION, i) et l’envoi à son
successeur
88
44

 Quand un processus Pi reçoit un message
(ELECTION, j):
Si j > i, il transmet le message sans le changer
Si j<i, et Pi n’est pas participant, il se déclare
candidat, place i dans le message et le transmet à son
successeur
Sinon, il ignore le message (déjà participant)
Si i=j, Pi=Pj devient le coordinateur: il se marque
comme non participant et envoi un message ELU à son
voisin.
 Sipk reçoit un message ELU, il se marque non

participant et met sa variable eluk = i
89

Candidature (site Pi):
candidati = true
send(succ[i], ELECTION, i)
Reception sur Pi du message (ELECTION, j)
switch
j>i: send(succ[i], ELECTION, j) //j prioritaire
j<i: if not candidati //j non prioritaire
candidati = true
send(succ[i], ELECTION, i)
j=i: send(all, ELU, i) //site i élu
90
45

 E1 vérifiée: tous les processus sont
comparés puisqu’un processus doit
recevoir son identifiant en retour
avant d’envoyer un message ELU
 E2 vérifiée aussi: anneau garanti sans

perte
91

 Pi déclenche une élection
 Il se propose CANDIDAT et envoie
deux messages à ses voisins de droite
et de gauche
 Si l’estampille de Pi est supérieure à
celle de ses deux voisins, il envoie un
message aux voisins de ses voisins
jusqu’à faire le tour de l’anneau
93
46

 Si un processus Pj dans l’anneau a une
estampille supérieure à celle de Pi, Pi
sera déclaré battu et c’est Pj qui
comparera son estampille avec tous
les autres
 Gagner du temps et des messages en

allant dans les deux sens dans
l’anneau => Parallélisme
94

5
3 2
7 8
4 6
1
1 2 3 4 5 6 7 8
(candidature, 5, 0, 1)
(candidature, 5, 0, 1)
(réponse, vrai, 5)
temps 95
47
Élection dans un anneau avec

pannes de sites
 Les sites appartiennent à l’ensemble des sites
opérationnels (Qop) après une reprise, mais ils
ne doivent pas perturber l’environnement
durant une élection
 Quand un site démarre et qu’une élection est

en cours, les autres sites peuvent avoir une
information incomplète
 Pour joindre Qop, il faudrait relancer une

nouvelle élection, la dernière annulant les
précédentes 96

pannes de sites
 Problème de l’adressage
 Tous les sites doivent pouvoir s’échanger des
messages malgré les pannes éventuelles de
sites
 Retrait d’un site  problème d’adresse du
site suivant de l’anneau !!!
 Solutions possibles:
 Mise à jour répartie de la liste des
sites  Qop
 Ordre logique des adresses IP
 Réinsertion d’un site  messages aux voisins97
48

pannes de sites
 Problème de l’attente indéfinie des sites
 Pour déterminer si le destinataire d’un

message est en panne, il faut:
 Une borne T limitant le délai de

transmission (T est le délai pour faire
un tour de l’anneau par exemple)
 Un système d’accusé de réception
98

pannes de sites
Autre problème à résoudre
 A la réception de (ELECTION, j), Pi se
substitut à l’élu si i>j, et quand Pi se revoit
dans le message (ELU, i), le message a fait
un tour.
 Que se passe-t-il si Pélu tombe en panne

après s’être substitué dans le message ?
 Problème: Qui purge l’anneau ? L’élu ?

Comment s’arrête une élection ?
99
49
Troisième Partie
Détection de la terminaison
La problématique
 A priori, il est assez simple de détecter qu’un algorithme distribué

ait fini son exécution: il suffirait de tester que chaque processus
constituant cet algo est en interruption
 Ex: Un algo constitué de deux processus p1 et p2, chacun

demandant des données de l’autre. Instantanément, un processus
peut être soit actif soit passif
p1 p2
passif Message passif

Pour p1 =>
Va l’activer
 A l’instant t, p1 et p2 sont passifs mais p2 a envoyé
un message à p1 qui va l’activer => l’algo n’est donc pas terminé
101
50
La problématique
 Un processus passif ne peut redevenir actif que sur la

réception d’un message en provenance d’un autre
processus, et bien sure, seuls les processus actifs
peuvent émettre de tels messages
 Il faut donc pouvoir affirmer, après l’exécution d’un

algorithme de détection de la terminaison, que tous les
processus constituant l’application sont bel et bien
passifs, et qu’ils le resteront.
 2 méthodes:
◦ Sans jeton: constitution d’un état global
◦ Avec jeton
102
Application de l’algo de Chandy

et Lamport
 Chandy et Lamport => constitution de l’état global
 Rappel:
◦ Un processus Q reçoit le marqueur demandant l’état global
pour la première fois, il considère le processus qui lui a
envoyé le marqueur comme son prédécesseur.
◦ Lorsque Q a fini sa part de l’algo (enregistrer son état et l’état
de ses voies de communication jusqu’à prochain marqueur),
il envoie à son prédécesseur un message DONE.
◦ Par récursivité, lorsque l’initiateur de l’algo de Chandy et
Lamport reçoit un message DONE de tous ses successeurs,
il sait que l’état global est construit (que la « photo » est
prise)
103
51

et Lamport
 Le problème:
◦ L’état global définit aussi les messages en transit sur
les voies de communication
◦ Messages susceptibles d’activer des processus
passifs
◦ => on ne peut pas conclure de la terminaison de
l’exécution de l’application répartie si messages en
transit =>
BESOIN D’UN ETAT GLOBAL OU LES VOIES DE

COMMUNICATION SONT VIDES !!!
104

et Lamport
Petite modification de l’algo de Chandy et Lamport:
◦ Lorsqu’un processus Q finit sa part de l’algo, il envoie soit
un message DONE ou un message CONTINUE.
 Il envoie un message DONE ssi:
1. Tous les successeurs de Q ont retourné un message
DONE, et
2. Q n’a reçu aucun message entre le moment où il a
enregistré son état et le moment où il a reçu le
marqueur de toutes ses voies de communication
rentrantes
 Dans tous les autres cas il envoie un message
CONTINUE à son prédécesseur
◦ Lorsque le processus initiateur ne reçoit que des messages
DONE, l’exécution est terminée => terminaison détectée
105
52

et Lamport
 Principe du calcul diffusant :

◦ Les marqueurs parcourent l’arbre jusqu’à arriver
aux feuilles puis reviennent en arrière jusqu’à la
racine
 PLUS les messages DONE et CONTINUE
106
Terminaison sur un anneau
 Dijkstra, Feijen et Van Gasteren (1983)
 Processus rangés dans un certain ordre

faisant intervenir leur identité: P0, P1, …, Pi,
…, Pn-1, P0
 Communications unidirectionnelles (de Pi
vers Pi-1 ) pour l’execution de l’algo de
detection de la terminaison MAIS SINON
messages quelconques
 Detection de la terminaison initialisée par un
processus particulier, soit P0
107
53

 Principe:
◦ Faire circuler un jeton sur l’anneau
des processus, de telle façon que,
lancé par P0 lorsqu’il est passif, le
jeton est transmis à Pn-1 qui ne le
transmettra à Pn-2 que lorsqu’il sera
devenu lui-même passif, et ainsi de
suite.
108
 Problème : FAUSSE TERMINAISON

Jeton circule dans
le sens P0, P8, …, 1 P2 envoie un
P1 0 2 message à P7 => P7
va redevenir actif
8
3
P0, P8, P7, P6, sont
devenus passifs 7
suite au passage du 4
jeton 6 5
109
54
 Un processus Pj qui n’a pas encore été visité par le

jeton ne sait pas dans quel processus celui-ci se
trouve: il ne peut donc pas savoir si le processus Pk
auquel il envoie le jeton a été visité ou pas
 Pk qui était passif a reçu le jeton et l’a transmis à Pk-1

deviendra actif en recevant un message du processus
Pj non encore visité par le jeton
 Pk peut à son tour rendre actifs d’autres processus déjà

visités par le jeton
110

 Solution:
Jeton et processus valués par une couleur: ils sont blancs ou
noirs
 Initialement le jeton et tous les processus sont blancs
 Un processus devient noir lorsqu’il envoie un message à
un processus doté d’une identité supérieure à la sienne
 Lorsqu’un processus reçoit le jeton il attend d’être passif
puis le transmet en fonction de sa propre couleur:
 S’il est blanc il transmet le jeton sans modifier la
couleur de ce dernier
 S’il est noir il transmet un jeton noir
 P0 détectera la terminaison si le jeton reçu est blanc et s’il
est lui-même blanc sinon P0 initialisera une autre détection
111
55

lors de
réception de (message, m) faire
état actif; fait;
émission de (message, m) vers j faire
si mon-numéro < j alors coulproc noir fsi;
envoyer (message, m) à j; fait;
réception de (jeton, cj) de i+1 faire
jetonpresent vrai;
couljeton cj;
si mon-numéro = 0 alors
si coulproc = blanc et couljeton = blanc alors terminaison détectée
sinon relancer détection fsi; fsi; fait;
émission de (jeton, cj) vers i-1 possible seulement si etat = passif et jetonpresent faire
si coulproc = noir alors couljeton noir fsi;
jetonpresent faux;
envoyer (jeton, couljeton) à i-1;
coulproc blanc; fait
attente de (message, m) ou fin faire
112
état passif; fait;
Détection de la Terminaison
(pas d’anneau)
 Objectifs: Admettre une topologie quelconque pour les

communications et ne pas se limiter à un anneau
 Le jeton doit:
1. d’une part visiter tous les processus et
2. d’autre part s’assurer qu’il n’a plus de messages en
transit
 Le jeton doit donc parcourir chaque arc du réseau que

forme les processus et leurs voies de communication
113
56
(pas d’anneau)
 Hypothèse: réseau fortement connecté
 Il existe un circuit C qui comprend chaque

arc du réseau au moins une fois
=> Il suffit de remplacer un tel circuit par un

anneau!!!!
114
(pas d’anneau)
 Le jeton véhicule une valeur j qui indique que les
processus visités lors des j dernières traversées des
voies de communication (arcs de C) sont restés en
permanence passifs (i.e. ces processus étaient blancs
lorsque le jeton les a atteint).
 On suppose que sur le circuit C précalculé et que les
deux fonctions suivantes sont prédéfinies:
◦ Fonction taille(C: circuit ) resultat entier => donne la
taille du circuit
◦ Fonction successeur (C:circuit, i:1..n) resultat 1..n =>
pour le processus Pi qui l’execute le nom du successeur
sur le circuit
 Le jeton detectera la terminaison lorsque l’on aura

j=taille(C )
115
57
(pas d’anneau)
 Declaration des variables pour chaque processus:
var couleur: (blanc, noir) initialisé à noir; associé au

processus
etat: (actif, passif) initialisé à actif;
jetonpresent : booleen initialisé a faux
nb : entier initialisé à 0 : sert à mémoriser la valeur
associée au jeton entre sa réception et sa
réémission
 Messages de deux types message et jeton

116
L’algorithme
lors de
réception de (message, m) faire
état actif;
couleur noir; fait;
attente de (message, m) faire
état passif; fait;
réception de (jeton, j) faire
nb j; jetonpresent vrai;
si nb = taille(C ) et couleur = blanc; alors
terminaison détectée;
fsi;
fait;
117
58
L’algorithme
émission de (jeton, j) possible seulement si

etat = passif et jetonpresent faire
si couleur = noir alors nb 0;
sinon nb j + 1; fsi;
envoyer (jeton, nb) à successeur (C, i);
couleur blanc;
jetonpresent faux;
fait;
118
59

Ch4 AlgoReparti

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ch4 AlgoReparti

Uploaded by

Copyright:

Available Formats

Cours Informatique Répartie

Les accès concurrents

Les accès concurrents

• On parle d’exclusion mutuelle quand

Les accès concurrents

Accès concurrents dans un

 Sémaphores binaires (mutex : mutual

 Le système gère l’entrée à la section

Accès concurrents dans un

 Deux primitives: P et V indivisibles

Accès concurrents dans un

Les accès concurrents dans un

• Réparti  à un instant donné ??

• Pas de référentiel de temps commun 

Les accès concurrents dans un

• Le système gère des contextes de

Les accès concurrents dans un

• => les solutions telles que sémaphores

Les accès concurrents dans un

• Vivacité (liveness) (ni interblocage

Les accès concurrents dans un

• Réparties: concertation des

• Basées sur l’utilisation d’un jeton

Les accès concurrents

• Lorsqu’un processus Pi désire rentrer en

Les accès concurrents

• Lorsque Pi ressort de la section, il envoie

Les accès concurrents

Les accès concurrents

• On simule donc un système centralisé

• P(S) est remplacé par une requête

• V(S) est remplacé par une primitive qui

Les accès concurrents

• Equité: les demandes sont accordées

• Simple à mettre en œuvre

Les accès concurrents

Les accès concurrents Solutions

Les accès concurrents :

• Chaque processus connaît les N-1

• Chaque processus désirant rentrer en

Les accès concurrents :

2. Attend les réponses :

• Réception de N-2 réponses : ne rentre pas car

• Application: Algorithme de Lamport 21

Les accès concurrents

• Chacun des composants du système

Les accès concurrents

• Chacun des composants gère une file

Les accès concurrents

• Trois types de messages (estampillés

• REPONSE : envoyé par un site qui reçoit

• LIBERATION : envoyé par un site

Les accès concurrents

• Chacun des messages sera

Les accès concurrents

• On notera Hi l’horloge du site Si, et

Les accès concurrents

• Il pourra entrer en section critique

Les accès concurrents

• Si Sj reçoit un message de type

Les accès concurrents

• Lorsque Si sort de la section critique,

Les accès concurrents