Contexte général

• Communication par messages, pas de mémoire partagée

• Pas d’horloge globale
– Chaque site a sa propre horloge
Gestion du temps dans les applications
– Les horloges peuvent dériver les unes par rapport aux
réparties autres
• Exécutions et communications asynchrones
– Un site peut exécuter spontanément un événement
– Un site qui émet un message poursuit son exécution sans
attendre la réception de celui-ci
• Délais de communication quelconques mais finis

Introduction Plan

• A-t-on besoin du temps ? On veut pouvoir • Rappels sur la causalité

– Tracer une exécution – Définition
– debug – Consistance des horloges
– Forte consistance (caractérisation de la causalité)
– Gérer des contraintes d’équité
– ... • Modèles d’horloges
– scalaires
Relation de causalité entre événements – vectorielles
– matricielles
• Pourquoi ne peut-on pas utiliser le temps physique ? • Implémentation d’horloges vectorielles
– Singhal / Kshemkalyani
h + !h
!h : dérive – Fowler / Zwaenepoel
et si !h > D ?
D : délai de
transmission
h h+D
 Rappel sur la précédence causale :
Définition d’une horloge logique
e#f

• ein : nème événement sur le site i • H : ensemble des événements de l’application, muni de
l’ordre partiel #
• ein # ejm ( ein happens before ejm ) ssi : si ( e /# e’ et e’/ # e ) alors e || e’ (concurrence)

– i = j et n < m : précédence locale

• T : domaine de temps, muni de l’ordre partiel <
ou
– $ mes, ein = send(mes) et ejm = receive(mes)
• Horloge logique :
: précédence par message
C: H#T
ou e # C(e)
– $ ekp , ein # ekp et ekp # ejm
: fermeture transitive tel que e # e’ " C(e) < C(e’) (consistance)

Causalité et horloges logiques

• On utilise souvent les horloges pour reconstruire (en

partie) la relation de causalité

• C(e) < C(e’) " ? Modèles d’horloges

– Soit e # e’
– Soit e || e’
• Si
C(e) < C(e’) " e # e’ ( consistance forte )
les horloges caractérisent la causalité

Choisir le type d’horloge en fonction des besoins de l’application

 Horloges scalaires (Lamport [78]) Exemple

• T = entiers naturels N
• Tous les messages portent l’horloge de leur émetteur à
l’instant d’émission (estampillage)
• 2 règles de mise à jour :
– R1 : avant tout événement (interne, émission, réception),
le site i exécute
– Ci = Ci + d (d > 0, généralement d = 1)
– R2 : lorsque le site i reçoit un message portant une
estampille Cmsg, il exécute
– Ci = max (Ci, Cmsg)
– Appliquer R1
– Délivrer le message -> événement «!réception!»

Exemple Exemple

1 1
! !

[1] [1]

!
1
 Exemple Exemple

1 1
! !

[1] [1]

! ! !
2 2 3
[3]

! !
1 1

Exemple Exemple

1 2 1 2
! ! ! !

[1] [2] [1] [2]

! ! ! !
2 3 2 3
[3] [3]

! ! !
1 1 4
 Exemple Exemple

1 2 1 2
! ! ! !

[1] [2] [1] [2]

4 4
! ! ! ! ! !
2 3 2 3
[3] [3]
[5]

! ! ! ! !
1 4 1 4 5

Exemple Exemple

1 2 6 1 2 6
! ! ! ! ! !

[1] [2] [1] [2]

4 4 5
! ! ! ! ! ! !
2 3 2 3
[3] [3]
[5] [5]

! ! ! ! ! !
1 4 5 1 4 5
 Exemple Horloges scalaires et causalité

• Simplement consistantes
1 2 6 7 C(e31) < C(e12) mais e31 || e12
! ! ! !

[1] [2]
• Peuvent être utilisées pour définir un ordre total << sur
les événements
4 5 ei << ej % C(ei) < C(ej) ou [ C(ei) = C(ej) et i < j ]
! ! ! !
2 3
[3] • C(e) = h indique que (h - 1) événements se sont déroulés
[5]
séquentiellement avant e.
! ! !
1 4 5

Horloges vectorielles : définition Algorithme de mise à jour

Fidge, Mattern [88]

• Pour le processus Pi :
• Supposent un nombre fixe N de processus
• T = IN N – A chaque événement (émission, réception, événement interne)
de Pi, incrémentation de VCi[i] :
• Chaque processus i gère un vecteur VCi de taille N • VCi[i] = VCi[i] + 1
– VCi[i] : nombre d’événements du processus i
– VCi[j] : connaissance qu’a i de l’avancement de – A l’émission d’un message m :
l’horloge de j • Le message porte la valeur courante de VCi
• A tout instant, l’état réel d’avancement du système est
donné par – A la réception d’un message m portant une horloge m.VC :
• Mise à jour de l’horloge courante :
& = (VC1[1] , … , VCi[i] , … , VCN[N] )
'! x, VCi[x] = max (VCi[x] , m.VC[x])
mais aucun processus ne peut l’obtenir...
 Exemple Exemple

0
!
0
[1 0 0]

Exemple Exemple

1 1

0 0
! !
0 0
[1 0 0] [1 0 0]

1 !

0 0
! !
0 0

1 1
 Exemple Exemple

1 1 2

0 0 0
! ! !
0 0 0
[1 0 0] [1 0 0] [2 0 0]

1 1 1 1

1 ! 2 ! 1 ! 2 !

0 0 [1 2 0] 0 0 [1 2 0]

0 0
! !
0 0

1 1

Exemple Exemple

1 2 1 2

0 0 0 0
! ! ! !
0 0 0 0
[1 0 0] [2 0 0] [1 0 0] [2 0 0]

1 1 1 1 2

1 ! 2 ! 1 ! 2 ! ! 3

0 0 [1 2 0] 0 0 [1 2 0] 0

0 0
! 1 ! ! 1 !
0 0
2 2
1 1
2 2
 Exemple Exemple

1 2 1 2 3

0 0 0 0 2
! ! ! ! !
0 0 0 0 3
[1 0 0] [2 0 0] [1 0 0] [2 0 0]

1 1 2 1 1 2

1 ! 2 ! ! 3 1 ! 2 ! ! 3

0 0 [1 2 0] 0 0 0 [1 2 0] 0

0 [1 2 3] 0 [1 2 3]
! 1 ! 1 ! ! 1 ! 1 !
0 0
2 2 2 2
1 1
2 3 2 3

Exemple Exemple
4

2
1 2 3 1 2 3
3
0 0 2 0 0 2
! ! ! ! ! ! !
0 0 3 0 0 3
[1 0 0] [2 0 0] [1 0 0] [2 0 0]

1 1 2 2 1 1 2 2

1 ! 2 ! ! 3 4 ! 1 ! 2 ! ! 3 4 !

0 0 [1 2 0] 0 0 0 0 [1 2 0] 0 0

0 [1 2 3] 0 [1 2 3]
! 1 ! 1 ! ! 1 ! 1 !
0 0
2 2 2 2
1 1
2 3 2 3
 Horloges vectorielles et causalité Simplification du test de causalité

• Définissent un ordre partiel sur les événements • Si e a lieu sur le site i, e’ sur le site j :
– tous les vecteurs ne sont pas comparables
– V ||!V’ dénote 2 vecteurs V et V’ non comparables e # e’ % VC(e)[i] " VC(e’)[i]

e || e’ % VC(e)[i] > VC(e’)[i] et

• Caractérisent la causalité :
VC(e’)[j] > VC(e)[j]
– Soit VC(e) l’horloge vectorielle d’un événement e
e # e’ % VC(e) < VC(e’)
e || e’ % VC(e) || VC(e’)

Horloges vectorielles : LA solution ?

• Caractérisent la causalité mais…

– Augmentent la quantité d’information gérée localement
– Augmentent l’information circulant sur le réseau
• Fonction du nombre de processus Implémentation
• Peut-on arriver au même résultat en manipulant moins d’horloges vectorielles
d’information ?
– On ne peut pas diminuer l’information gérée localement
– On peut optimiser l’information envoyée sur le réseau
 Singhal / Kshemkalyani [92] Exemple

• Principe : Gestion incrémentale des horloges vectorielles

– Dans un message envoyé par j à i, j n’inclut que les
composantes de son horloge qui ont été modifiées depuis le
dernier message qu’il a envoyé à i.
– L’estampille du message est une liste de couples (id, val)
tels que :
• VCj[id] a été modifié depuis le dernier message envoyé par j à i
• La valeur courante de VCj[id] est val.
– Pour tout couple (id, val) contenu dans le message de j :
VCi[id] = max (VCi[id] , val)

• Conditions d’application :
– Canaux FIFO

Exemple Exemple

1 1
! !
0 0
0 0
{( 1,1 )} {( 1,1 )}
0 0

0
0 {( 3,1 )}
1
0 !
 Exemple Exemple

1 1
! !
0 0
0 1 0 1
{( 1,1 )} {( 1,1 )}
0 1 0 1
0 0
! 0 ! 0

0 0
0 {( 3,1 )} 0 {( 3,1 )}
1 1
0 ! 0 !

0
0 {( 4,1 )}
0
1 !

Exemple Exemple

1 1
! !
0 0
0 1 1 0 1 1
{( 1,1 )} {( 1,1 )}
0 1 2 0 1 2
0 1 0 1
! 0 ! 0 ! 0 ! 0

0 0 0
0 {( 3,1 )} 0 {( 3,1 )} 0 {( 3,2 )}
1 1 2
0 ! 0 ! 0 !

0 0
0 {( 4,1 )} 0 {( 4,1 )}
0 0
1 ! 1 !
 Exemple Exemple

1 1
! !
0 0
0 1 1 1 0 1 1 1
{( 1,1 )} {( 1,1 )}
0 1 2 3 0 1 2 3
0 1 2 0 1 2
! 0 ! 0 ! 0 ! 0 ! 0 ! 0

0 0 0 0 0
0 {( 3,1 )} 0 {( 3,2 )} 0 {( 3,1 )} 0 {( 3,2 )} 0
1 2 1 2 3
0 ! 0 ! 0 ! 0 ! 1 !

0 0
0 {( 4,1 )} 0 {( 4,1 )}
0 0
1 ! 1 !

Exemple Exemple

1 1
! !
0 0
0 1 1 1 0 1 1 1 1
{( 1,1 )} {( 1,1 )}
0 1 2 3 0 1 2 3 4
0 1 2 0 1 2 4
! 0 ! 0 ! 0 ! 0 ! 0 ! 0 1 !

0 0 0 0 0 0 0 0
{( 3,1 )} {( 3,4 ), {( 3,1 )} {( 3,4 ),
0 0 {( 3,2 )} 0 0 0 0 {( 3,2 )} 0 0
4
(4,1)} 4
(4,1)}
1 2 3 1 2 3
0 ! 0 ! 1 ! 1 ! 0 ! 0 ! 1 ! 1 !

0 0
0 {( 4,1 )} 0 {( 4,1 )}
0 0
1 ! 1 !
 Implémentation de la méthode S/K Implémentation (suite)

• Quelle information maintenir sur chaque site ?
– Celle qui permet à j de savoir quelles composantes de son
vecteur d’horloge envoyer à i :
• Horloge vectorielle de dernière émission vers i
• Sous quelle forme ?
• Matrice ?
– La colonne i est le vecteur d’horloge du dernier envoi à i
PB : stockage local en N2
• Vecteurs ?
– On peut stocker les dates d’émission sous forme scalaire : LS
– On stocke aussi les dates (scalaires) de modification de chacune
des composantes du vecteur d’horloge : LU
! 2 vecteurs sur chaque site en plus de l’horloge vectorielle
• Pourquoi des dates scalaires ?
– Tous les événements à considérer ont lieu sur le même
site j
" ils sont identifiés de manière unique par VCj[j]
• Gestion des dates d’émission : vecteur LS
– LS : Last Sent
– LSj[i] = valeur de VCj[j] lors du dernier envoi de j à i
• Gestion des dates de modification : vecteur LU
– LU : Last Update
– LUj[k] = valeur de VCj[j] lors de la dernière modification
de VCj[k]

Identification des valeurs émises Exemple

0
0
p2
0
p2
0 p2
• j envoie à i toutes les composantes k de VCj telles que : 0 0 0 0
1 2 3 4 ?
LUj[k] > LSj[i] 0 ! 0 ! 1 ! 1 !

sous la forme (k, VCj[k]) {( 4,1 )}

• Exemple : calcul des valeurs envoyées par p3

LU3[3] = 4
LS3[2] = 2 LU3[4] = 3
0 0
p2
0 0 p2
p2
0 0 0 0
Valeur des vecteurs pour l’événement e34 :
1 2 3 4 ? LU3[3] > LS3[2]
0 0 1 1 0 0 0
! ! ! ! LU3[4] > LS3[2]
2 0 0
LS3= LU3= VC3=
{( 4,1 )} 0 4 4 " envoi de { (3, VC3[3]),
0 3 1 (4, VC3[4])}
 Efficacité de la méthode Perte sur la causalité

1
• Efficace si les interactions entre processus sont localisées :
0 !
!
– Chaque processus ne communique qu’avec un petit nombre
m1 2
d’autres processus 0

" le nombre d’entrées modifiées est faible 3

{(1,1)}
! ! ! 0
• Mais perte d’information au niveau de la causalité : m2
{(2,3)}
– Un processus qui reçoit deux messages en provenance 2
1
d’émetteurs différents ne peut pas établir la relation de ! ! ! ! 3
causalité entre leurs émissions 0
4
ce n’est pas forcément un problème… 1

Perte sur la causalité Perte sur la causalité (suite)

1 1

0 ! 0 !
! !
0 m1 2 0 m1 0

3 3
{(1,1)} {(1,1)}
! ! ! 0 ! ! ! 0
m2 m2
{(2,3)} {(2,3)}
2 2
1 1
! ! ! ! 3 ! ! ! ! 3
0 0
4 4
1 1

m1 # m2
 Perte sur la causalité (suite) Fowler / Zwaenepoel

1
• Gestion de vecteurs de dépendance
0
! ! – Un vecteur de dépendance n’est pas une horloge vectorielle
m1 0
0 – Mais il permet de les reconstruire
3
{(1,1)} • Principe :
! ! ! 0
– Chaque processus gère un vecteur D de taille N
m2
{(2,3)} – Lors d’une émission de message, un processus y inclut la
2
1 dernière valeur de sa composante locale Di[i]
! ! ! ! 3
0 – Lors de la réception par i d’un message en provenance de j
4 contenant la valeur d :
1

Di[j] = max (Di[j], d)

m1 || m2

Exemple Exemple

1
!
0
0 {1}
0
 Exemple Exemple

1 1
! !
0 0
1
0 {1} 0 {1}
0 0 1
0
! 0

0 0
0 {1} 0 {1}
1 1
0 ! 0 !

Exemple Exemple

1 1
! !
0 0
1 1 1
0 {1} 0 {1}
0 1 0 1 2
0 0 1
! 0 ! 0 ! 0

0 0
0 {1} 0 {1}
1 1
0 ! 0 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !
 Exemple Exemple

1 1
! !
0 0
1 1 1 1 1
0 {1} 0 {1}
0 1 2 0 1 2 3
0 1 0 1 2
! 0 ! 0 ! 0 ! 0 ! 0

0 0 0 0
0 {1} 0 {2} 0 {1} 0 {2}
1 2 1 2
0 ! 0 ! 0 ! 0 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !

Exemple Exemple

1 1
! !
0 0
1 1 1 1 1 1
0 {1} 0 {1}
0 1 2 3 0 1 2 3
0 1 2 0 1 2
! 0 ! 0 ! 0 ! 0 ! 0 ! 0

0 0 0 0 0 0 0
0 {1} 0 {2} 0 0 {1} 0 {2} 0 0 {4}
1 2 3 1 2 3 4
0 ! 0 ! 1 ! 0 ! 0 ! 1 ! 1 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !
 Exemple Analyse de l’information

1
!
0 • Interprétation de Di[k]
1 1 1 1
0 {1} – Indice du dernier événement sur le site k dont dépend
1 2 3 4
0 directement l’événement considéré sur le site i
0 1 2 4
2
! 0 ! 0 ! 0 0 ! ! !
2
! ! 1
0 0 0 0
0 {1} 0 {2} 0 0 {4} ! !
1 2 3 4
0 ! 0 ! 1 ! 1 !
• Perte de l’information liée à la transitivité
0 – Di[k] stocke l’information en provenance directe de k
0 {1} – i ne peut pas apprendre par l’intermédiaire de j l’état
0
d’avancement de k
1 !

Reconstruction des horloges vectorielles Exemple

1
1 1 ! 2
• Evénement e sur le site i 2 2 0
VCold = 0 VCi = 0 0
• Algorithme itératif : 0 0
0 0 {2}
1 2
VCi(e) = Di(e) ! 2 2 !

Répéter 0 0

– VCold(e) = VCi(e) 0 0
{2}
– Pour chaque composante non nulle VCi(e)[k] : 0 0

• VCi(e) = sup (VCi(e) , Dk(ekVCold[k] )) 1 2

! 1 1 !
Jusqu’à VCi(e) = VCold(e)
0
• Algorithme exécutable uniquement «!off-line!» 0 {1}
0
1 !
 Exemple Exemple
1 1
1 1 ! 2 1 1 ! 2
2 2 0 2 2 0
VCold = 0 VCi = 0 0
VCold = 0 VCi = 0 0
0 0 {2} 0 00 {2}
0 0 0 0
1 2 1 22
! 2 2 ! ! 2 22 !

0 0 0 00

0 0 0 0
0 0
{2} 0 0
{2}
1 2 1 2
! 1 1 ! ! 1 1 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !

Exemple Exemple
1 1
1 11 ! 2 1 11 ! 2
2 22 0 2 22 0
VCold = 0 VCi = 20 0
VCold = 0
2 VCi = 20 0
0 0 {2} 0 0 {2}
0 00 0 00
1 2 1 2
! 2 2 ! ! 2 2 !

0 0 0 0

0 0 0 0
0 0
{2} 0 0
{2}
1 2 1 2
! 1 1 ! ! 1 1 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !
 Exemple Exemple
1 1
1 11 ! 2 1 11 ! 2
2 22 0 2 22 0
VCold = 0
2 VCi = 20 0
VCold = 0
2 VCi = 20 0
0 0 {2} 0 0 {2}
0 00 0 1
00
1 2 1 2
! 2 2 ! ! 2 2 !

0 0 0 0

0 0 0 0
0 0
{2} 0 0
{2}
1 2 1 2
! 1 1 ! ! 1 1 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !

Exemple Exemple
1 1
1 11 ! 2 1 11 ! 2
2 22 0 2 22 0
VCold = 0
2 VCi = 20 0
VCold = 0
2 VCi = 20 0
0 0 {2} 0 0 {2}
1
0 1
00 1
0 1
00
1 2 1 2
! 2 2 ! ! 2 2 !

0 0 0 0

0 0 0 0
0 0
{2} 0 0
{2}
1 2 1 2
! 1 1 ! ! 1 1 !

0 0
0 {1} 0 {1}
0 0
1 ! 1 !
 Exemple Efficacité de la méthode
1
1 11 ! 2
2
• Minimisation de la somme d’information gérée :
22 0
VCold = 0
2 VCi = 20 0
– Un vecteur par processus
0 0 {2}
1
0 1
00 – Un scalaire par message
1 2
! 2 2 !

0 0 • Inapplicable si l’application doit systématiquement

0 0
reconstruire les horloges vectorielles
{2}
0 0 • Exemple d’application :
1 2
!
– Calcul de points d’arrêt distribués
! 1 1

0
0 {1}
0
1 !

Horloges matricielles Algorithme de mise à jour

Fischer, Michael [82]

• Pour le processus Pi :
• Supposent un nombre fixe N de processus – A chaque événement (émission, réception, événement interne)
• T = IN N2 de Pi, incrémentation de MTi[i, i] :
• MTi[i, i] = MTi[i, i] + 1
• Chaque processus i gère une matrice MTi de taille N ( N
– MTi[i, i] : nombre d’événements du processus i – A l’émission d’un message m :
– MTi[i, •] : horloge vectorielle du processus i • Le message porte la valeur courante de MTi
– MTi[k, l] : connaissance qu’a i de ce que le processus k
sait de l’avancement de l’horloge de l – A la réception d’un message m, émis par j et portant une
horloge m.MT :
min ( MTi[k, l] ) " t " i sait que tous les processus savent • Mise à jour de l’horloge courante :
k que l’horloge de l a atteint la valeur t '! 1 " x " n, MTi[i, x] = max (MTi[i, x] , m.MT[j, x])
'! 1 " x, y " n, MTi[x, y] = max (MTi[x, y] , m.MT[x, y])
 Horloges matricielles et causalité Conclusions

• Les horloges matricielles caractérisent la causalité • La causalité est la relation qui permet d’analyser une
application répartie
• Quel intérêt par rapport aux horloges vectorielles ? – Pas d’exécutions identiques
– Utilisées pour caractériser l’information obsolete : – Nécessité de tracer le lien entre les événements
• Log répartis
• Bases de données réparties • Le type d’horloge dépend de l’application
– Consistance forte ? Horloges vectorielles
• Calcul d’état global
– Consistance simple ? Horloges scalaires
• Section critique équitable

Et concrètement ? Horloges scalaires

A
baisse de
pression
• [1] jauge
augmentation
B d'activité pompe
[2]
• [3]•
[5]
1 tuyau + •
[4] B'
• observateur
A'

1 jauge
• L’observateur reçoit 2 messages
1 pompe baisse de
A
pression
• jauge – Baisse de pression : émis à la date [1]
augmentation
1 observateur B d'activité pompe
– Augmentation d’activité : émis à la date [3]
• •
• • observateur
L’augmentation d’activité n’est pas la cause de la baisse de pression
B' A'
 Horloges vectorielles

1
0 1
0 • 2
jauge
0
1
1
• • pompe

0 1
1 observateur
2
• • 2
2
1

• L’observateur reçoit 2 messages

– Baisse de pression : émis à la date [1 0 0]
– Augmentation d’activité : émis à la date [1 2 0]

La baisse de pression est cause de l’augmentation d’activité