Consensus Tous les processeurs doivent se mettre d`accord

Consensus
Tous les processeurs doivent se mettre d’accord sur
une sortie en se basant sur leurs entrées qui ne sont
pas nécessairement les mêmes.
Exemple : Dans une base de données distribuées il
faut se mettre d’accord sur un commit ou un abort
d’une transaction.
Ce qui est important est que tous les processeurs arrivent à la même conclusion. La décision prise est
moins importante.
En l’absence des défaillances, les processeurs peuvent voter et se mettre d’accord sur la valeur majoritaire.
Les processeurs doivent se mettre d’accord sur une
valeur qui a un rapport avec les entrées - sinon le
problème est trivial - tout le monde décide 0.
1
Le problème : Le processeurs non défaillants doivent
se mettre d’accord sur la valeur d’un bit.
n processeurs p0, . . . , pn−1
xi est l’entrée du processeur pi
yi est la sortie du processeur pi (i.e. la décision prise
par pi) Note : une décision est non réversible.
yi = y pour tout i où pi est non défaillant.
2
Une solution au problème doit satisfaire les conditions
suivantes :
- termination - chaque processeur qui fonctionne
correctement doit prendre une décision (affecter
une valeur à yi)
- accord - tous les processeurs qui fonctionnent correctement décident de la même valeur (affecter la
même valeur à yi)
- validité - si tous les processeurs proposent la même
valeur v (xi = v pour tout i) alors chaque processeur
qui fonctionne correctement doit décider de cette
valeur (yi = v).
3
Modèle A :
- systéme synchrone
- commmunication par échange de messages
- chaque processeur peut envoyer un message à
chacun des autres processeurs (topologie du réseau)
- au plus f processeurs qui crash (Si un processeur
crash, un ensemble aléatoire de ses messages
est envoyé juste avant qu’il ne crash.)
- pas de défaillances en communication
4
Mesures de l’efficacité de la solution
- nombre de phases nécessaires (en fonction de f )
- taille maximum d’un message
- la f -robustesse - nombre maximum de processeurs
qui peuvent être défaillant (en fonction de n)
5
Algorithme 0
Algorithme exécuté par le processeur pi, i 6= 1
Phase 1
1 Ne rien envoyer
2 Recevoir une valeur x1 de p1
3 y i = x1
Algorithme exécuté par le processeur p1
Phase 1
1 Envoyer x1 à tout le monde
2 Ne rien recevoir
3 y i = x1
L’Algorithme 0 est-il correct?
Validité et Accord : oui
Termination : Non - si p1 crash, il n’envoie pas de
message (ou seulement quelques-uns) et les autres
ne recoivent aucune valeur et donc ils ne peuvent rien
décider.
6
Algorithme 1
Algorithme exécuté par processeur pi
1
2
3
3
Phase 1
Envoyer xi à tous les autres processeurs
Recevoir la valeur xj de pj , pour tout j 6= i
Calculer la valeur, x, qui apparaît le plus souvent
parmi les valeurs reçues
yi = x.
L’Algorithme 1 est-il correct?
Termination et validité : oui
Accord : non - L’ensemble des valeurs reçues par
chaque processeur n’est pas necessairement la même.
(Quand un processeur tombe en panne, il envoie un
sous-ensemble de ces messages.)
Exemple : les valeurs reçues par des proceseurs. Seuls
processeurs p1, p3 et p4 sont non défaillants.
processeur 1 :
processeur 3 :
processeur 4 :
0 0 0 1 1 - - - - 0 0 0 1 1 - - - - - 0 - 1 1 0 0 1 1 7
Algorithme 2
Algorithme exécuté par processeur pi
1
2
3
4
Phase 1
Envoyer xi à tous les autres processeurs
Recevoir la valeur xj de pj , j 6= i
Calculer x, la plus petite valeur reçu
yi = x
Est-ce que l’Algorithme 2 est correct?
Termination et Validité : oui
Accord : Non - tous les processeurs qui fonctionnent
correctement ne décident pas de la même valeur. Soit
vj le (seul) processeur qui propose la plus petite valeur.
Si vj est défaillant et il envoie xj à certains processeurs
mais pas à tous, xj sera choisi par certains processeurs
mais pas tous.
8
Algorithme Consensus Simple
Vi est l’ensemble de valeurs vus par le processeur pi
Algorithme exécuté par processeur pi
1
2
3
4
Initialement Vi = {xi}
Pendant phase k
Envoyer toutes les valeurs v ∈ Vi qui n’ont pas encore été envoyées par pi à tous les processeurs
Recevoir un ensemble de valeurs Sj de pj , j 6= i
Ajouter tous les valeurs de Sj à Vi
Si k = f + 1 alors yi = min(Vi)
Note : Les processeurs connait f .
9
Exemple : processeur 3 est défaillant. Il envoie un
message a processeur 1 pendant phase 1 et il crash.
proc
x
1
9
2
8
phase 1
proc 1 envoie
proc 2 envoie
proc 3 envoie
proc 4 envoie
3
7
9
8
7
9
4
9
a
a
a
a
tout
tout
proc
tout
le monde
le monde
1 et il crash
le monde
proc 1 recoit 8, 7 et 9
proc 2 recoit 9 et 9
proc 4 recoit 9 et 8
phase 2
proc 1 envoie 7 et 8 a tout le monde
proc 2 envoie 9 a tout le monde
proc 4 envoie 8 a tout le monde
proc 1 recoit 9 et 8
proc 2 recoit 7 et 8
proc 4 recoit 7, 8 et 9
tout le monde decide 7
10
L’Algorithme 3 est correct !
Termination : oui. L’algorithme termine après f + 1
phases.
Validité : oui. Si toutes les valeurs proposées sont les
mêmes, tous les ensembles Vi contiennent une seule
valeur qui sera la minimum.
Proposition (Accord) : Pour chaque paire de processeurs
pi et pj qui fonctionnent correctement, Vi = Vj à la
fin de la phase f + 1.
Justification : Il suffit de montrer que, si x ∈ Vi à la fin
de la phase f + 1, alors x ∈ Vj à la fin de la phase
f + 1, pour chaque Vi, Vj non défaillant.
Soit r la première phase où x a été reçue par un
processeur pi non défaillant. x est ajoutée à Vi dans
la phase r (r = 0 si x = xi).
Cas 1: r ≤ f . Alors pi envoie x à tout le monde
pendant la phase r + 1 ≤ f + 1. Donc x est ajouté
à Vj pendant la phase r + 1 ≤ f + 1. A la fin de la
phase f + 1, tous les processeurs non défaillant ont
x.
11
Cas 2: r = f + 1. Soit pj un processeur non défaillant qui recoit x pour la première fois pendant la
phase f + 1. Pendant la phase 1 x a été envoyée par
un processeur pi1 , pendant la phase 2 par pi2 etc.
jusqu’à la phase f + 1 où x a été envoyé à pj par
pif +1 . Chaque processeur envoie une valeur particulière au plus 1 fois, donc les processeurs pi1 . . . pif +1
sont tous distincts. Au moins un de ces processeurs
est non défaillant. Mais ce processeur ajoute x à son
ensemble pendant une phase ≤ f < r = f + 1 qui
est une contradiction (on a dit qu’aucun processeur
recoit x avant la phase r).
12