8 L'intégrité et la gestion des transactions
1. Intégrité sémantique
–
respect des contraintes d’intégrité
2. Fiabilité (sûreté)
–
fautes (pannes) matérielles ou logicielles
3. Contrôle de concurrence
–
concurrence sans interférence indésirable
4. Sécurité (confidentialité)
–
accès autorisés
8.1 Concept de transaction
Transaction
–
séquence d'opérations exécutées par un programme
–
opérations pour délimiter
début de transaction (implicite en SQL)
fin de transaction
– confirmer (COMMIT WORK en SQL)
– annuler (ROLLBACK WORK en SQL) –
propriétés ACID (DACIL)
Pseudo-code d'une transaction de transfert bancaire
DébutTransaction ;
Lire( SoldeCompte 1 , s 1 );
s 1 := s 1 -100;
Écrire ( s 1 , SoldeCompte 1 );
SI s 1 < 0
AnnulerTransaction;
SINON
Lire ( SoldeCompte 2 , s 2 );
s 2 := s 2 +100;
Écrire( s 2 , SoldeCompte 2 );
ConfirmerTransaction;
FINSI;
8.2Propriétés d'une transaction (ACID)
A tomicité (atomicity)
– tout ou rien
Opération État de la mémoire
centrale État de la BD
DébutTransaction SoldeCompte
1= $300 SoldeCompte
2= $500 Lire ( SoldeCompte
1, s
1) s
1=300
s
1:= s
1-100 s
1=200
Écrire ( s
1, SoldeCompte
1) SoldeCompte
1= $200 SoldeCompte
2= $500
Interruption Zut!
Scénario de transfert interrompu
C onsistance
(consistency) ou cohérence
Laisse la BD dans un état cohérent
Déférer la vérification d ’une contrainte ?
Etat cohérent
Etat
cohérent
Transaction
Isolation
Sérialisabilité
Exemple de perte de mise à jour (lost update)
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Lire ( SoldeCompte , s )
t
3DébutTransaction
t
4Lire ( SoldeCompte , s )
t
5s = s + 700
t
6Écrire ( s , SoldeCompte ) SoldeCompte = 1700 t
7ConfirmerTransaction
t
8s = s + 200
t
9Écrire ( s , SoldeCompte ) SoldeCompte = 1200
t
10ConfirmerTransaction Saperlipopette!
Exemple de lecture impropre (dirty read) : cas de sommaire inconsistant
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t5 DébutTransaction
t6 Lire(SoldeCompte1, s1) t7 Lire(SoldeCompte2, s2)
t8 total = s1 + s2
t9 Afficher(s1, s2, total) Affiche $200, $500,
$700Oups!
t10 ConfirmerTransaction
t11 Lire(SoldeCompte2, s2) t12 s2:= s2+100
t12 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 Lecture impropre : lecture d ’une
donnée « non confirmée »
Propriétés ACID (suite)
D urabilité (durability)
– effets d ’une transaction confirmée doivent durer malgré pannes
L égalité
– respecter les privilèges
8.3 État d'une transaction
DébutTransaction
–
transaction naît
–
identificateur unique + informations
–
état actif
–
consommation de ressource (verrouillages, journal, …)
choisir le niveau d ’isolation approprié
ConfirmerTransaction
–
état confirmé
–
point de confirmation
enregistrement persistent (journal)
–
libération de ressources
confirmer le plus tôt possible pour éviter de monopoliser les ressources
AnnulerTransaction ou interruption suite à une erreur (faute)
–
état annulé
–
effets doivent être « défaits »
Fin = confirmé ou annulé
Exemples de fautes
Erreur locale à une transaction
Annulation par le SGBD (par exemple suite à la détection d'un interblocage)
Erreur du SGBD
Erreur du système d'exploitation
Panne de matériel
etc.
8.4 Architecture générale pour la gestion des transactions
G e s t i o n n a i r e d e t r a n s a c t i o n T r a n s a c t i o n s
(L ir e , E c r i r e , D é b u t T r a n s a c t io n , C o n f ir m e r T r a n s a c t i o n , A n n u l e r T r a n s a c t i o n)
G e s t i o n n a i r e d e l 'o r d o n n a n c e m e n t
G e s t i o n n a i r e d e r é c u p é r a t i o n
G e s t i o n n a i r e d e
l 'a n t é - m é m o i r e T a m p o n s
G e s t i o n n a i r e d e d o n n é e s
8.5 Contrôle de concurrence
Méthode de contrôle de concurrence
– assurer isolation
– transactions concurrentes
Ordonnancement, histoire, ou exécution (schedule, history, log)
– un scénario particulier d'exécution
– ex :
Temps Transaction T1 Transaction T2 État de la BD
t1 DébutTransaction SoldeCompte = 1000
t2 Lire(SoldeCompte, s)
t3 DébutTransaction
t4 Lire(SoldeCompte, s)
t5 s = s + 700
t6 Écrire(s,SoldeCompte) SoldeCompte = 1700 t7 ConfirmerTransaction
t8 s = s + 200
t9 Écrire(s,SoldeCompte) SoldeCompte = 1200 t10 ConfirmerTransaction Saperlipopette!
Ordonnancement séquentiel (serial schedule)
L’une après l’autre
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Lire ( SoldeCompte , s ) t
3s = s + 700
t
4Écrire ( s , SoldeCompte ) SoldeCompte = 1700 t
5ConfirmerTransaction
t
6DébutTransaction
t
7Lire ( SoldeCompte , s )
t
8s = s + 200
t
9Écrire ( s , SoldeCompte ) SoldeCompte = 1900
t
10ConfirmerTransaction
Ordonnancement sérialisable (serializable)
Equivalent à un ordonnancement séquentiel (lequel ?)
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 DébutTransaction
t5 Lire(SoldeCompte1, s1)
t6 Lire(SoldeCompte2, s2)
t7 total = s1 + s2
t8 Afficher (s1, s2, total) Affiche $300, $500,
$800
t9 ConfirmerTransaction
t10 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500 t11 Lire(SoldeCompte2, s2)
t12 s2:= s2+100
t13 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t14 ConfirmerTransaction
Exemple de perte de mise à jour est non sérialisable
Pas équivalent ni à T 1 , T 2 ou T 2 , T 1
– solde : $1900
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Lire ( SoldeCompte , s )
t
3DébutTransaction
t
4Lire ( SoldeCompte , s )
t
5s = s + 700
t
6Écrire ( s , SoldeCompte ) SoldeCompte = 1700 t
7ConfirmerTransaction
t
8s = s + 200
t
9Écrire ( s , SoldeCompte ) SoldeCompte = 1200
t
10ConfirmerTransaction Saperlipopette!
8.5.1 Enjeux du contrôle de concurrence
Solution bestiale
– interdire les ordonnancements concurrents
mécanisme de section critique
– une transaction longue bloque toutes les autres…
Objectif
– permettre ordonnancements concurrents
– gérer les accès concurrents aux mêmes
données
8.5.2 Sérialisabilité par permutation
Sérialisabilité difficile à vérifier en pratique
Exemple : ordonnancement chanceux !
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction A = 1
t
2Lire ( A, a ) t
3a := a
2t
4DébutTransaction
t
5Lire ( A, a )
t
6Écrire ( a , A) A = 1
t
7a := a + 10
t
8Écrire ( a , A) A = 11
t
9ConfirmerTransaction
t
10ConfirmerTransaction
Sérialisablilité par permutation
Éviter de considérer les calculs
Uniquement les lectures/écritures BD
Opérations non permutables (conflicting)
– Deux opérations de lecture ou d'écriture
dans deux transactions différentes sont
non permutables si elles portent sur la
même donnée et au moins une des deux est
une écriture
Sérialisablilité par permutation
Ordonnancement sérialisable par permutation (conflict serializable schedule)
– opérations non permutables sont
effectuées dans le même ordre relatif
que dans un ordonnancement
séquentiel
Sérialisable par permutation : flèches dans la même direction
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 DébutTransaction
t5 Lire(SoldeCompte1, s1)
t6 Lire(SoldeCompte2, s2)
t7 total = s1 + s2
t8 Afficher (s1, s2, total) Affiche $300, $500,
$800
t9 ConfirmerTransaction
t10 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500 t11 Lire(SoldeCompte2, s2)
t12 s2:= s2+100
t13 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t14 ConfirmerTransaction
Proposition
Sérialisable par permutation sérialisable
Pas l ’inverse
Sommaire inconsistant : non
sérialisable par permutation
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t5 DébutTransaction
t6 Lire(SoldeCompte1, s1) t7 Lire(SoldeCompte2, s2)
t8 total = s1 + s2
t9 Afficher (s1, s2, total) Affiche $200, $500,
$700Oups!
t10 ConfirmerTransaction
t11 Lire(SoldeCompte2, s2) t12 s2:= s2+100
t12 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t14 ConfirmerTransaction
Ordonnancement chanceux
Non sérialisable par permutation mais sérialisable
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction A = 1
t
2Lire ( A, a ) t
3a := a
2t
4DébutTransaction
t
5Lire ( A , a )
t
6Écrire ( a , A ) A = 1
t
7a := a + 10
t
8Écrire ( a , A) A = 11
t
9ConfirmerTransaction
t
10ConfirmerTransaction
8.5.3 Test de sérialisabilité par permutation
Graphe de préséance (precedence graph)
– un sommet pour chacune des transactions T
i– arc T
i T
j
deux opérations non permutables de T
iet T
j
opération de T
iprécède l'opération de T
j Sérialisable par permutation graphe sans cycle
–
tri topologique produit ordre séquentiel équivalent
Graphe de préséance sans cycle
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 DébutTransaction
t5 Lire(SoldeCompte1, s1)
t6 Lire(SoldeCompte2, s2)
t7 total = s1 + s2
t8 Afficher(s1, s2, total) Affiche $300, $500,
$800
t9 ConfirmerTransaction
t10 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500 t11 Lire(SoldeCompte2, s2)
t12 s2:= s2+100
t13 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200
T 1 T 2
Sommaire inconsistant : graphe de préséance avec cycle
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t5 DébutTransaction
t6 Lire(SoldeCompte1, s1)
t7 Lire(SoldeCompte2, s2)
t8 total = s1 + s2
t9 Afficher(s1, s2, total) Affiche $200, $500,
$700 Oups!
t10 ConfirmerTransaction
t11 Lire(SoldeCompte2, s2) t12 s2:= s2+100
t12 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t14 ConfirmerTransaction
T 1 T 2
8.5.4 Principales stratégies de contrôle de concurrence
Verrouillage (locking)
– blocage temporaire des opérations non permutables
– verrouillage des objets touchés
– ~ordre du premier conflit
Estampillage (timestamping)
– ~ ordre des estampilles
– sinon assassinat
– Estampille(T) (timestamp)
identifiant unique et ordre (horloge ou compteur)
Certification (validation)
– optimiste
– vérification des conflits à la fin de la transaction (assassinat )
– ~ ordre du décès
Multiversion
– utiliser des anciennes versions
– éviter blocages ou assassinats
8.5.5 Contrôle de concurrence par verrouillage
Modes de verrouillage
–
Verrouillage exclusif (X, exclusive lock)
Une transaction à la fois
En écriture
–
Verrouillage partagé (P, share lock (S))
En lecture
Matrice de compatibilité
Partagé ( P ) Exclusif (X) Partagé ( P ) oui non
Exclusif ( X) non non
Procédure de verrouillage
Procédure
Ver(B: objet,
M:mode {P ou X})
{demande de verrouillage sur B en mode M pour T}
DÉBUT (section critique)
SI (mode M est compatible avec le mode déjà accordé sur O ou si B n'est pas verrouillé ou
si la transaction possède elle-même le verrouillage) Accorder le verrouillage en mode M à la transaction SINON
Placer la transaction dans la file d'attente pour B Bloquer la transaction
FIN SI
FIN (section critique)
Table de verrouillage
–
verrouillages accordés et demandés
Procédure de déverrouillage
Procédure Dev (B: objet)
DÉBUT (section critique)
Libérer le verrouillage sur B accordé à la transaction T
Accorder le verrouillage à une ou plusieurs transactions (P) en attente sur B et enlever les transactions de la file
Débloquer les transations si possible Fin (section critique)
Politique de gestion des files d ’attentes
– priorités ?
– éviter famine
8.5.5.1 Verrouillage en deux phases
Protocole de verrouillage en deux phases (V2P, two phase locking )
Ver(B,P) ou Ver(B,X) avant Lire(B)
Ver(B,X) avant Écrire(B)
Aucun verrouillage (Ver) après un déverrouillage (Dev)
Proposition
– V2P sérialisable par permutation
27/02/22 © Robert Godin. Tous droits réservés .
32
Exemple non V2P : cas du sommaire inconsistant
Temps Transaction T1 Transaction T2 État de la BD Environnement t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Ver(SoldeCompte1, P)
t3 Lire(SoldeCompte1, s1) t4 s1:= s1-100
t5 Ver(SoldeCompte1, X)
t6 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500 t7 Dev(SoldeCompte1)
t8 DébutTransaction
t9 Ver(SoldeCompte1, P)
t10 Lire(SoldeCompte1, s1)
t11 Ver(SoldeCompte2, P)
t12 Lire(SoldeCompte2, s2)
t13 total = s1 + s2
t14 Afficher(s1, s2, total) Affiche $200,
$500, $700 Oups!
t15 Dev(SoldeCompte1)
t16 Dev(SoldeCompte2)
t17 ConfirmerTransact
ion t18 Ver(SoldeCompte2, P)
t19 Lire(SoldeCompte2, s2) t20 s2:= s2+100
t21 Ver(SoldeCompte2, X)
t22 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600
V2P à l ’oeuvre
Temps Transaction T1 Transaction T2 État de la BD Environnement t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Ver(SoldeCompte1, P)
t3 Lire(SoldeCompte1, s1) t4 s1:= s1-100
t5 Ver(SoldeCompte1, X)
t6 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t7 DébutTransaction
t8 Ver(SoldeCompte1, P) Non accordé!
t9 attente…
t10 Ver(SoldeCompte2, P) t11 Lire(SoldeCompte2, s2) t12 s2:= s2+100
t12 Ver(SoldeCompte2, X)
t14 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t15 Dev(SoldeCompte1)
t16 Dev(SoldeCompte2) t17 ConfirmerTransacti
t18 on Lire(SoldeCompte1, s1) Verrouillage accordé
t19 Ver(SoldeCompte2, P)
t20 Lire(SoldeCompte2, s2)
t21 total = s1 + s2
t22 Afficher(s1, s2, total) Affiche $200,
$600, $800
8.5.5.2 Problèmes dus aux annulations
Interactions
– mécanismes de récupérations
– contrôle de concurrence
Annulation par « défaire »
– écritures pour annuler effets
Annulation en cascade
Annuler T
1 Annuler T
2en cascade
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Lire ( SoldeCompte , s ) t
3s = s + 700
t
4Écrire ( s , SoldeCompte ) SoldeCompte = 1700
t
5DébutTransaction
t
6Lire ( SoldeCompte , s )
t
7s = s + 200
t
8Écrire ( s , SoldeCompte ) SoldeCompte = 1900 t
9Interruption!
Cause : lecture impropre
8.5.5.3 Verrouillage strict et rigoureux en deux phases
Verrouillage en deux phases strict (strict two phase locking)
–
déverrouillages des X après la fin
Verouillage en deux phases rigoureux (rigourous two phase locking)
–
tous les déverrouillages après la fin
Proposition
–
V2P strict empêche lecture impropre (annulations en cascade)
–
Corollaire : V2P rigoureux empêche lecture impropre
8.5.5.4 Récupérabilité
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Lire ( SoldeCompte , s ) t
3s = s + 700
t
4Écrire ( s , SoldeCompte ) SoldeCompte = 1700
t
5DébutTransaction
t
6Lire ( SoldeCompte , s )
t
7s = s + 200
t
8Écrire ( s , SoldeCompte ) SoldeCompte = 1900
t
9ConfirmerTransaction
t
10Interruption!
Non récupérable
–
Annuler T
1 Annuler T
2en cascade
–
T
2est confirmée !
Ordonnancement
récupérable (recoverable schedule)
si T
1lit de T
2–
confirmation de T
1après confirmation de T
2 Proposition
–
Empêche lecture impropre récupérable
( lecture T
1après confirmation T
2 confirmation T
1après confirmation T
2)
Conséquence
–
V2P strict (ou rigoureux) récupérable
5.5.5.5 Approche agressive ou conservatrice de verrouillage
Procotole conservateur
– verrouillage en vrac au tout début
Protocole agressif
– verrouillage le plus tard possible
plus de concurrence
plus d ’interblocages
8.5.5.6 Interblocage
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte = 1000
t
2Ver ( SoldeCompte , P ) t
3Lire ( SoldeCompte , s )
t
4DébutTransaction
t
5Ver ( SoldeCompte , P )
t
6Lire ( SoldeCompte , s )
t
7s = s + 700
t
8Ver ( SoldeCompte , X)
t
9attente… s = s + 200
t
10Ver ( SoldeCompte , X)
attente…
8.5.5.6.1 Détection d'interblocage
Graphe qui attend quoi (QAQ, wait-for graph)
– T
i T
j
si T
iattend pour verrouillage détenu par T
j Proposition
– interblocage cycle dans QAQ
Choix d ’une victime
Mieux que prévention si peu
d ’interblocages
8.5.5.6.2 Détection par temps limite
Si trop de temps en attente
– annuler la transaction
Annulations parfois inutiles
Problème avec longues
transactions
8.5.5.6.3 Prévention d'interblocage
1. Attente ou mort (« wait-die »)
–
Si T
idemande un verrouillage accordé à T
jet T
iest plus vieille (Estampille(T
i) < Estampille(T
j),
alors T
ipeut attendre
sinon elle est annulée
– les jeunes ne peuvent attendre les vieux
2. Assassinat ou attente (« wound-wait »)
–
Si T
idemande un verrouillage accordé à T
jet T
iest plus jeune (Estampille(T
i) > Estampille(T
j),
alors T
ipeut attendre
sinon T
jest annulée
– les jeunes ne peuvent bloquer les vieux
Prévention (suite)
Protocole conservateur
– demandes de verrouillages en vrac au début de la transaction
– cas particulier : verrouillage hiérarchique
Ordre pré-défini
– demandes selon un ordre pré-défini
sur les objets
8.5.5.7 Verrouillage hiérarchique
T 1
T 2
LOCK TABLE Compte IN SHARE MODE SELECT SUM(solde)
FROM Compte
SELECT solde INTO : s
1FROM Compte
WHERE noCompte = 1 FOR UPDATE
Temps Transaction T
1Transaction T
2État de la BD t
1DébutTransaction
t
2Ver ( table Compte , P )
t
3DébutTransaction
t
4Ver ( SoldeCompte
1, X) Non accordé?
Verrouillage d'intention (intent locking)
Intention de verrouiller un composant
Temps Transaction T
1Transaction T
2État de la BD t
1DébutTransaction
t
2Ver ( table Compte , P )
t
3DébutTransaction
t
4Ver ( table Compte , IX) Non accordé
Exemple de hiérarchie
B D
F i c h i e r
1F i c h i e r
2F i c h i e r
nT a b l e
1T a b l e
2T a b l e
mL i g n e
1L i g n e
2L i g n e
kModes de verrouillage hiérarchique
Matrice de compatibilité
Ver ( B , IP ) signifie une intention de verrouiller certains descendants de B en mode P Ver ( B , IX) signifie une intention de verrouiller certains descendants de B en mode X Ver ( B , P ) verrouillage de B en mode P
Ver ( B , PIX) verrouillage de B en mode P et en mode IX Ver ( B , X) verrouillage de B en mode X
Acquis IP IX P PIX X
IP oui oui oui oui non
IX oui oui non non non
P oui non oui non non
PIX oui non non non non
X non non non non non
Protocole de verrouillage
hiérarchique en deux phases (VH2P, hierarchical two phase locking).
1. Verrouiller parent en mode d'intention avant enfant :
–
Ver(parent de B, IX) avant Ver(B, X) ou Ver(B, IX)
–
Ver(parent de B, IX ou IP) avant Ver(B, P) ou Ver(B, IP)
2. Ver(B, P) ou Ver(B, X) avant Lire(B) ou Lire(un descendant de B)
3. Ver(B, X) avant Écrire(B) ou Écrire (un descendant de B)
4. Aucun verrouillage (Ver) après un déverrouillage
(Dev)
8.5.6 Contrôle de concurrence par estampillage
Principe
–
si O
1et O
2non permutables
opérations exécutées dans l'ordre correspondant aux estampilles des transactions
–
sinon zigouiller requérant
Information à maintenir par SGBD
Estampille-L(B): Estampille maximale des transactions ayant lu B
Estampille-E(B): Estampille maximale des transactions ayant écrit B
seulement les plus récentes
Exemple qui respecte le protocole
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500
t2 Lire(SoldeCompte1, s1)
t3 DébutTransaction t4 Lire(SoldeCompte1, s1) t5 s1:= s1-100
t6 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t7 Lire(SoldeCompte2, s2)
t8 total = s1 + s2
t9 Afficher (s1, s2, total) Affiche $300, $500,
$800
t10 ConfirmerTransaction
t11 Lire(SoldeCompte2, s2) t12 s2:= s2+100
t12 Écrire(s2,SoldeCompte2) SoldeCompte1 = $200 SoldeCompte2 = $600 t14 ConfirmerTransaction
- OK :
Estampille(T2) <
Estampille(T1) - V2P?
Lecture rejetée
Temps Transaction T
1Transaction T
2État de la BD
t
1DébutTransaction SoldeCompte
1= $300
SoldeCompte
2= $500 t
2Lire ( SoldeCompte
1, s
1)
t
3DébutTransaction t
4Lire ( SoldeCompte
1, s
1) t
5s
1:= s
1-100
t
6Écrire ( s
1, SoldeCompte
1) SoldeCompte
1= $200 SoldeCompte
2= $500 t
7Lire ( SoldeCompte
2, s
2)
t
8s
2:= s
2+100
t
9Écrire ( s
2, SoldeCompte
2) SoldeCompte
1= $200 SoldeCompte
2= $600 t
10ConfirmerTransaction
t
11Lire ( SoldeCompte
2, s
2) Annulation de T
2 E s t a m p il l e - E (S o l d e C o m p t e 2)E s t a m p il l e (T 2)
T e m p s
Protocole de contrôle de concurrence par estampillage :
demande de lecture
Lire(B, ...) par T
– accepter : Estampille-L(B) :=
Max(Estampille(T), Estampille-L(B)) E s t a m p il l e - E ( B ) E s t a m p il l e ( T )
T e m p s
E s t a m p il l e - E ( B ) E s t a m p il l e ( T )
T e m p s
Protocole de contrôle de concurrence par estampillage :
demande d ’écriture
Écrire(…, B) par T
– sinon accepter : Estampille-E(B) :=
Estampille(T)
E s t a m p il l e - E ( B ) E s t a m p il l e ( T ) E s t a m p il l e - L ( B )
T e m p s
E s t a m p il l e - E ( B ) E s t a m p il l e - L ( B ) E s t a m p il l e ( T )
T e m p s
Sérialiable mais pas toujours récupérable
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t5 DébutTransaction
t6 Lire(SoldeCompte1, s1)
t7 Lire(SoldeCompte2, s2)
t8 total = s1 + s2
t9 Afficher (s1, s2, total) Affiche $200, $500,
$700
Protocole de contrôle de concurrence par estampillage sérialisable par permutation
Ordonnancement séquentiel équivalent :
ordre des estampilles des transactions
Exemple non récupérable :
–
sinon accepter : Estampille-E(B) := Estampille(T)
8.5.6.1 Protocole de contrôle de concurrence par estampillage strict
Retarder Lire(B, ...)tant que la
dernière transaction ayant écrit B n'est pas terminée
– inclure indicateur de fin de transaction
– empêche lecture impropre
– ~verrouillage en lecture
Exemple strict
Temps Transaction T1 Transaction T2 État de la BD Environnement
t1 DébutTransaction SoldeCompte1 = $300
SoldeCompte2 = $500 t2 Lire(SoldeCompte1, s1)
t3 s1:= s1-100
t4 Écrire(s1,SoldeCompte1) SoldeCompte1 = $200 SoldeCompte2 = $500
t5 DébutTransaction
t6 Lire(SoldeCompte1, s1)
t7 Lire(SoldeCompte2, s2) attente
t8 s2:= s2+100 attente
t9 Écrire(s2,SoldeCompte2) attente SoldeCompte1 = $200 SoldeCompte2 = $600 t10 ConfirmerTransaction attente
t11 Lire(SoldeCompte2, s2)
t12 total = s1 + s2
t13 Afficher (s1, s2, total) Affiche $200, $600,
$800
t14 ConfirmerTransaction
8.5.6.2 Règle d'écriture de Thomas
Écrire(…, B) par T
– ignorer si :
E s t a m p il l e - E ( B ) E s t a m p il l e - L ( B ) E s t a m p il l e ( T )
T e m p s
8.5.7 Contrôle de concurrence par certification
Phase 1: lecture
–
écritures locales sans interruption
Phase 2: certification
–
lorsque transaction se termine
vérifie conflit par rapport à l'ordre des estampilles de fin
Phase 3: confirmation
–
si certifiée
les écritures sont faites
–
sinon
transaction annulée
8.5.8 Méthode multiversion
Principe
– Ecrire(…,B)
créer une nouvelle version de B (ou annuler)
– Lire(B, ...)
choisir la « bonne » version pour sérialisabilité
efficacement…
–
versions récentes !
–
versions récentes dans journal ?
8.5.8.1 Contrôle de concurrence par estampillage multiversion
Maintenir pour chaque version B i :
Estampille-E(B i )
estampille du créateur de B
i Estampille-L(B i )
estampille maximale des lecteurs de B
iChoisir la bonne version
E s t a m p il l e - E (B i- 1) E s t a m p il l e - E (B i) E s t a m p il l e (T ) E s t a m p il l e - E (B i+ 1)
T e m p s