MÉMOIRES TRANSACTIONNELLES

(1)

COURS 4

MÉMOIRES TRANSACTIONNELLES

Par Jean-Pierre Lozi Basé sur les cours de Gaël Thomas

TMPC - MÉMOIRES TRANSACTIONNELLES 1

(2)

RAPPEL : LIMITE À L’ACCELÉRATION

TMPC - MÉMOIRES TRANSACTIONNELLES 2

 Limite : la loi d’Amdahl

 p : pourcentage du code exécutable en parallèle

 (1 – p) : pourcentage du code exécuté en séquentiel

 p / n : exécution du code parallèle sur n cœurs

 Temps d’exécution : (1 - p) + p / n

 Accélération maximale théorique : a = 1/(1 – p + p/n)

 Limite pour n → ∞ : a → 1/(1 – p)

 Application numérique :

p = 0,25 ⇒ a → 1/0,75 = 4 quand n → ∞ (3,7 à 32 cœurs)

p = 0,95 ⇒ a → 1/0,05 = 20 quand n → ∞ (12,55 à 32 cœurs, 17,42 à 128 cœurs)

p = 0,96 ⇒ a → 1/0,05 = 25 quand n → ∞ (14,28 à 32 cœurs : +12.1%, 21,05 à 128 cœurs : +17.2% !)

 Ça vaut le coup de se battre pour paralléliser les quelques pourcents restants!

(3)

SOLUTION NATURELLE

TMPC - MÉMOIRES TRANSACTIONNELLES 3

Prendre les verrous les plus fins possibles...

lock(x)

…

unlock(x)

0% en //

lock(x)

…

unlock(x)

…

lock(y)

…

unlock(y)

50% en //

CAS(x)

…

CAS(z)

…

TAS(y)

95% en //

(4)

LIMITES DU VERROUILLAGE FIN

TMPC - MÉMOIRES TRANSACTIONNELLES 4

 Verrouillage fin complexifie très fortement le code !

 Difficile à maintenir, à faire évoluer.

 Bugs (très !) difficiles à trouver.

 Preuve de programme souvent quasi-impossible à faire (pas de famine, pas de deadlock ?)

 Difficile à composer

 Effet de bord important !

 Protocole d’accès à une variable n’existe souvent que dans la tête du programmeur...

(5)

LIMITES DU VERROUILLAGE FIN

TMPC - MÉMOIRES TRANSACTIONNELLES 4

 Verrouillage fin complexifie très fortement le code !

 Difficile à maintenir, à faire évoluer.

 Bugs (très !) difficiles à trouver.

 Preuve de programme souvent quasi-impossible à faire (pas de famine, pas de deadlock ?)

 Difficile à composer

 Effet de bord important !

 Protocole d’accès à une variable n’existe souvent que dans la tête du programmeur...

 Verrouillage fin : reste très pessimiste...

 Nombre de cœurs augmente ⇒ probabilité de conflit augmente

 Conflit ⇒ cœurs oisifs...

(6)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 5

 Verrouillage pessimiste toujours adéquat à l’heure des multicœurs ?

 Certains parlent d’un concept dépassé...

(7)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 5

 Pourquoi prend-on des verrous ?

 Pour exécuter de façon atomique un ensemble d’instructions...

(8)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 5

 Proposition des mémoires transactionnelles :

 Définir des blocs atomiques

 Les exécuter de façon optimiste, si conflit, on recommence...

(9)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 5

 Proposition des mémoires transactionnelles :

 Définir des blocs atomiques

 Les exécuter de façon optimiste, si conflit, on recommence...

 Avantages attendus :

 Simplifier le code : plus de verrous différents acquis dans un certain ordre, juste blocs atomiques

 Pas de deadlock, pas de famine, composabilité assurée par la plateforme

 Ne bloquer un cœur que si stictement nécessaire (i.e. car conflit)

(10)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 6

 Avec mémoires transactionnelles, blocs atomiques :

 Un bloc atomique est exécuté d’une façon qui apparait atomique...

 Il peut y avoir des entrelacements s’ils n’ont aucun impact (e.g. variables différentes, ou lecture même var).

(11)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 6

 Avec mémoires transactionnelles, blocs atomiques :

 Un bloc atomique est exécuté d’une façon qui apparait atomique...

 Il peut y avoir des entrelacements s’ils n’ont aucun impact (e.g. variables différentes, ou lecture même var).

 Par exemple :

Initialement : x = 21 a. atomic {

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

f. atomic { g. tmp = x;

h. tmp = tmp * 2;

i. x = tmp;

j. } Deux ordonnancements possibles :

[b,c,d] puis [g,h,i] (⇒ 44) ou [g,h,i] puis [b,c,d] (⇒ 43)

(12)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 7

 Passer du verrouillage au transactions, très simple :

synchronized(o) { if(!x) {

x = true;

doSomething();

} }

0% en // Parallélisme maximal?

atomic { if(!x) {

x = true;

doSomething();

} }

(13)

LES MÉMOIRES TRANSACTIONNELLES

TMPC - MÉMOIRES TRANSACTIONNELLES 7

 Passer du verrouillage au transactions, très simple :

synchronized(o) { if(!x) {

x = true;

doSomething();

} }

0% en // Parallélisme maximal?

atomic { if(!x) {

x = true;

doSomething();

} }

La transaction lit x. Si x a été modifié par un autre thread pendant la transaction (entre première lecture et fin)

⇒ transaction avortée et on recommence

(14)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

 Problème : comment implémenter les variables de condition ?

synchronized(o) { x = true;

o.notify();

} synchronized(o) {

while(!x) o.wait() }

(15)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

 Notion de retry [Harris05] :

o.notify();

} synchronized(o) {

atomic { while(!x)

retry;

}

atomic { x = true;

}

(16)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

o.notify();

} synchronized(o) {

atomic { while(!x)

retry;

}

atomic { x = true;

}

Transaction attend une modif sur la variable x (read set)

(17)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

o.notify();

} synchronized(o) {

atomic { while(!x)

retry;

}

atomic { x = true;

}

commit : x a été modifié

(18)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

o.notify();

} synchronized(o) {

atomic { while(!x)

retry;

}

atomic { x = true;

}

⇒ réveille toute attente sur x

(19)

MÉMOIRES TRANSACTIONNELLES : ÉVÉNEMENTS

TMPC - MÉMOIRES TRANSACTIONNELLES 8

o.notify();

} synchronized(o) {

atomic { while(!x)

retry;

}

atomic { x = true;

}

⇒ réveille toute attente sur x

(20)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 9

 Bonne propriété : si A et B atomiques, on peut les composer dans un autre bloc atomique !

(21)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 9

 Un exemple : la queue

(22)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 9

atomic move(Queue dst, Queue src) { Elmt e = src.deq();

dst.enq(e);

}

(23)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 9

atomic Elmt deq()

atomic void enq(Elmt e);

dst.enq(e);

}

(24)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 9

atomic Elmt deq()

dst.enq(e);

}

temps

deq() enq()

move()

Instantané ! Instantané !

temps enq()

(25)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

 Supposons que la queue a une taille maximum. Exemple complet :

(26)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

LinkedList<Elmt> queue;

}

(27)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

}

void enq(Elmt e) { atomic {

if(queue.size() == MAX_SIZE) retry;

queue.addFirst(e) }

}

(28)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

}

queue.addFirst(e) }

}

void deq(Elmt e) { atomic {

if(queue.empty()) retry;

return queue.removeLast(e) }

}

(29)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

}

queue.addFirst(e) }

}

} Attend qu’une

des variables lues soit modifiée pour

réessayer

(30)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

}

queue.addFirst(e) }

}

} Attend qu’une

réessayer addFirst(e) a modifié variable lue

dans empty(), après commit, signal !

(31)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 10

class Queue {

}

queue.addFirst(e) }

}

} Attend qu’une

réessayer addFirst(e) a modifié variable lue

dans empty(), après commit, signal !

(32)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 11

 Composition + attente sur événement : pour que ça marche, un retry fait sortir de la transaction englobante !

 Sinon, un retry qui fait échouer enq() pourrait mener à des événements entre deq() et enq()...

atomic Elmt deq()

dst.enq(e);

}

temps

deq() enq()

move()

Instantané ! Instantané !

temps enq()

retry retry

(33)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

 Composition par alternative : possible d’éviter qu’une section atomique avec un retry soit bloquante

 Un peu l’idée d’un trylock : en cas de problème, on abandonne et on fait autre chose

 Avec les mémoires transactionnelles, ça implique qu’on avorte la transaction avant de faire autre chose

(34)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

 Fonctionnement : mot-clé orElse. Par exemple, dequeue non-bloquant :

(35)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

}

(36)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

} }

Exécute premier bloc

(37)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

} }

Exécute premier bloc Si retry

(38)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

} }

Abort, puis exécute le second bloc

(39)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

} }

Si retry dans le second bloc (impossible ici), on attend un changement

(40)

MÉMOIRES TRANSACTIONNELLES : COMPOSITION

TMPC - MÉMOIRES TRANSACTIONNELLES 12

Elmt deqNoWait() { atomic {

return deq();

} orElse { return null;

} }

Si retry dans le second bloc (impossible ici), on attend un changement et on recommence la transaction.

(41)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 13

 Deux implémentations possibles : mémoire transactionnelle retardée vs. immédiate

(42)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 13

 Mémoire transactionnelle retardée (deferred update) :

 Ecriture dans une copie locale, propagée en mémoire centrale au commit

 Du travail lors du commit (il faut refaire toutes les modifs), mais aborts peu coûteux (on efface sa copie locale)

 Marche généralement mieux si beaucoup de aborts par rapport aux commits

 Cohérence facile à maintenir

(43)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 13

 Mémoire transactionnelle retardée (deferred update) :

 Ecriture dans une copie locale, propagée en mémoire centrale au commit

 Du travail lors du commit (il faut refaire toutes les modifs), mais aborts peu coûteux (on efface sa copie locale)

 Marche généralement mieux si beaucoup de aborts par rapport aux commits

 Cohérence facile à maintenir

 Mémoire transactionnelle immédiate (direct update) :

 Ecriture directement dans la mémoire centrale, annulation si transaction avorte

 Très peu de travail lors du commit, mais aborts coûteux (on doit annuler tous les changements)

 Marche généralement mieux si beaucoup de commits par rapport aux aborts

 Cohérence plus difficile à maintenir (doit garder les valeurs originales si la transaction avorte)

(44)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

 Mémoire transactionnelle retardée (deferred update) : aborts peu coûteux a. atomic {

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

(45)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Mémoire centrale : x = 20

(46)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Copie locale : x = 20

Read set = { x }

(47)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Copie locale : x = 20 Mémoire centrale :

x = 20

Read set = { x }

(48)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Copie locale : x = 20 Copie locale : x = 40 Mémoire centrale :

x = 20

Read set = { x }

Read set = { x } Write set = { x }

(49)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Copie locale : x = 20 Copie locale : x = 40 Mémoire centrale :

x = 20

commit()

Read set = { x }

(50)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

Copie locale : x = 20 Copie locale : x = 40

commit()

Read set = { x }

(51)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

commit()

Read set = { x }

(52)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 14

b. tmp = x;

c. tmp = tmp + 1;

d. x = tmp;

e. }

h. tmp = tmp * 2;

i. x = tmp;

j. }

abort()

commit()

Read set = { x }

(53)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

 Mémoire transactionnelle immédiate (deferred update) : aborts coûteux (on passe par un log...)

(54)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

x = 3, y = 20, z = 30

(55)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

x = 3, y = 20, z = 30

(56)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

x = 3, y = 20, z = 30 x = 3, y = 20, z = 37 Read set = { y }

(57)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

atomic {

y = x * 2;

} x = 3, y = 20, z = 30

x = 3, y = 20, z = 37 Read set = { y }

(58)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

atomic {

y = x * 2;

} x = 3, y = 20, z = 30

x = 3, y = 20, z = 37

x = 3, y = 6, z = 37 Read set = { y }

Write set = { y }

(59)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

atomic {

y = x * 2;

} x = 3, y = 20, z = 30

x = 3, y = 20, z = 37

x = 3, y = 6, z = 37 Read set = { y }

Write set = { y }

(60)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

atomic {

y = x * 2;

} x = 3, y = 20, z = 30

x = 3, y = 20, z = 37

x = 3, y = 6, z = 37 Read set = { y }

Write set = { y } abort()

(61)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 15

atomic { z = y + 7;

}

atomic {

y = x * 2;

} x = 3, y = 20, z = 30

x = 3, y = 20, z = 37

x = 3, y = 6, z = 37 Read set = { y }

Write set = { y } abort()

x = 3, y = 6, z = 30

(62)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 16

 Mémoire transactionnelle matérielle (HTM) :

 Utilise le cache du processeur pour construire une mémoire transactionnelle retardée

 À la fin d’une transaction, soit lignes de cache propagées, soit invalidées si conflit

 Au niveau du protocole de cohérence de cache

 Avantage : très rapide, inconvénient : taille limitée

Au cache L1 sous Haswell par exemple, donc pas plus de 32Ko, limité pour e.g. une transaction dans une BDD

(63)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 16

 Géré dans les CPUs Intel dernière génération (Haswell) ! Mais buggy dans certains (désactivé...)

(64)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 16

 Mémoire transactionnelle logicielle (STM) :

 Le compilateur modifie les accès pour ajouter des appels aux fonctions de la STM

 Avantage : taille de transactions quelconques, inconvénient : lent...

(65)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 16

 Mémoire transactionnelle logicielle (STM) :

 Le compilateur modifie les accès pour ajouter des appels aux fonctions de la STM

 Avantage : taille de transactions quelconques, inconvénient : lent...

 Mémoire transactionnelle hybride (HyTM) :

 Matérielle tant que le cache suffit, passe en logiciel sinon !

(66)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 17

 Que se passe-t-il en cas d’I/O ? atomic {

if (x > 42)

launchMissile();

}

(67)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 17

 Que se passe-t-il en cas d’I/O ?

 Les entrées/sorties se prêtent très mal aux transactions...

atomic { if (x > 42)

launchMissile();

}

(68)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 17

 Cas spécifiques :

 Ecriture : difficile, voire impossible à mettre dans une transaction

 Lecture : on peut généralement tricher (en jouant avec des tampons par exemple...) atomic {

if (x > 42)

launchMissile();

}

(69)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 17

 Cas spécifiques :

 Ecriture : difficile, voire impossible à mettre dans une transaction

 Lecture : on peut généralement tricher (en jouant avec des tampons par exemple...)

 Des techniques existent, mais coûteuses et complexifient beaucoup les algos.

atomic { if (x > 42)

launchMissile();

}

(70)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 18

 Exemple d’implémentation : une STM retardée avec verrou au commit

d c b a

e

17 13 2 26 83

Cases

mémoire Compteurs

(71)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 18

 Exemple d’implémentation : une STM retardée avec verrou au commit

 Principe :

 Chaque case mémoire possède un compteur

 Lecture : mémorise le compteur

 Ecriture : mémorise la case (nouvelle valeur) et le compteur

 Lors d’une mise à jour :

 Vérifie que les compteurs n’ont pas changé

 Incrémente les compteurs des cases écrites

d c b a

e

17 13 2 26 83

Cases

mémoire Compteurs

(72)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 19

 Fonctionnement : un petit exemple

a. atomic { b. a = a + b;

c. c = a - e;

d. b = c;

83 e. }

7 21 10

8

17 13 2 26 83

Cases Compteurs

Copie locale

d c b a

e

Valeur

Mémoire globale

d c b a

e

(73)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 20

c. c = a - e;

d. b = c;

83 e. }

7 21 10

8

17 13 2 26 83

Cases Compteurs

Copie locale

d c b a

e

Valeur

Mémoire globale

31 17 13

d c b a

e

(74)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 21

c. c = a - e;

d. b = c;

83 e. }

7 21 10

8

17 13 2 26 83

Cases Compteurs

Copie locale

d c b a

e

Valeur

Mémoire globale

23

31 17 13 2

83 d

c b a

e

(75)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 22

c. c = a - e;

d. b = c;

83 e. }

7 21 10

8

17 13 2 26 83

Cases Compteurs

Copie locale

d c b a

e

Valeur

Mémoire globale

23 23

31 17 13 2

83 d

c b a

e

(76)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 23

c. c = a - e;

d. b = c;

83 e. }

7 21 10

8

17 13 2 26 83

Cases Compteurs

Copie locale

d c b a

e

Valeur

Mémoire globale

83 23 23 31

8

18 14 3 26 83 d

c b a

e

Mémoire global au commit

23 23

31 17 13 2

83 d

c b a

e

(77)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 24

 Problème classique : les transactions zombies a. atomic {

b. if(x != null) c. x.f();

d. }

e. atomic { f. x = null;

g. }

ref 17 x

(78)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 25

d. }

g. }

ref 17 x

17

a, b x

(79)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 26

d. }

g. }

ref 17 x

null 17 x

17

a, b x

e, f

(80)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 27

d. }

g. }

ref 17 x

null 17 x

null 18 x

17

a, b x

f g

(81)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 28

d. }

g. }

ref 17 x

null 17 x

null 18 x

17

a, b x

f g

(82)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 29

d. }

g. }

ref 17 x

null 17 x

null 18 x

17

a, b x

f g

c: NullPointerException

(83)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 29

 Problème classique : les transactions zombies

 Solution intuitive : vérifier le compteur d’une variable à chacune de ses lectures...

 Ne suffit pas !

a. atomic { b. if(x != null) c. x.f();

d. }

g. }

ref 17 x

null 17 x

null 18 x

17

a, b x

f g

c: NullPointerException

(84)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 30

a. atomic { b. t1 = x;

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

Initialement : x = 4, y = 5

5 83

Invariant de transaction : x != y (Sinon division par zéro)

 Ne suffit pas !

y

(85)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 31

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

 Ne suffit pas !

(86)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 32

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

217 17 x

4 83

y f, g, h

 Ne suffit pas !

(87)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 33

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

217 17 x

4 83 y

217 18 x

4 84 y

 Ne suffit pas !

i

f, g, h

(88)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 34

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

217 17 x

4 83 y

217 18 x

4 84 y

 Ne suffit pas !

i

f, g, h

(89)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 35

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

217 17 x

4 83 y

217 18 x

4 84

y i

84

c : t1 = 4, y

t2 = 4

 Ne suffit pas !

f, g, h

(90)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 36

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

4 17 i. }

x

5 83 y

17

a,b : t1 = 4 x

217 17 x

4 83 y

217 18 x

4 84

y i

Problème : pas de lecture de x avant le commit, donc on ne regarde pas son compteur

d ⇒ division par zéro!

84

c : t1 = 4, y

t2 = 4

 Ne suffit pas !

f, g, h

(91)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 Vérifier le compteur à chaque lecture pas suffisant

On ne peut pas non plus vérifier tous les compteurs du read set à chaque lecture, trop lent...

(92)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 Solution possible : horloge globale pour la mémoire + horloge locale pour chaque transaction.

(93)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 Début transaction : copie horloge globale dans horloge locale

(94)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 À chaque lecture : vérifie que compteur de la variable < horloge locale

 Prouve que toutes valeurs lues dans un état valide avant le début de la transaction

 Pas de mélange avec nos modifs temporaires

 On ne stocke pas le compteur

(95)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 À chaque écriture : pareil qu’avant, sauf qu’on ne stocke pas le compteur

(96)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 37

 À chaque écriture : pareil qu’avant, sauf qu’on ne stocke pas le compteur

 Commit :

 S’il existe un compteur du RS/WS > horloge locale, annule transaction (conflit)

 Pour toute variable écrite, met son compteur à horloge globale

 Incrémente horloge globale

(97)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 38

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

90

(98)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 39

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

90 90

f

(99)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 40

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

100

90 90

Autres

transactions en //

f

(100)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 41

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

100

90 90

Autres

a

f

(101)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 42

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

b : t1 = 4

100

90

x

90

Autres

a

f

(102)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 43

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

b : t1 = 4 x 217

4

y g, h

100

90

x

90

Autres

a

f

(103)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 44

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

b : t1 = 4 x 217

4 y

217 100 x

4 100 y

g, h

i

100

90

101 x

90

Autres

a

f

(104)

MÉMOIRES TRANSACTIONNELLES : IMPLÉMENTATION

TMPC - MÉMOIRES TRANSACTIONNELLES 45

c. t2 = y;

d. p = 1/(t1-t2) e. }

f. atomic { g. x = 217;

h. y = 4;

i. }

4 17 x

5 83 y

b : t1 = 4 x 217

4 y

217 100 x

4 100 y

g, h

i

100

90

101

c : conflit!

x

90

Autres

a

f

(105)

MÉMOIRES TRANSACTIONNELLES : CONCLUSION

TMPC - MÉMOIRES TRANSACTIONNELLES 46

 Implémentation : pas si simple...

 On a vu un exemple d’un algorithme naïf, nombreuses implémentations possibles

(106)

MÉMOIRES TRANSACTIONNELLES : CONCLUSION

TMPC - MÉMOIRES TRANSACTIONNELLES 46

 Simplification de la programmation concurrente

 Concept simple

 Plus de problème de deadlock, de famine

 Transactions composables

(107)

MÉMOIRES TRANSACTIONNELLES : CONCLUSION

TMPC - MÉMOIRES TRANSACTIONNELLES 46

 Concept simple

 Et niveau performances ?

 STM lentes.

 HTM peuvent être plus rapides que verrous...

(108)

MÉMOIRES TRANSACTIONNELLES : CONCLUSION

TMPC - MÉMOIRES TRANSACTIONNELLES 46

 Concept simple

 Et niveau performances ?

 STM lentes.

 HTM peuvent être plus rapides que verrous...

 Vient d’apparaître dans les CPUs Intel Haswell. Le futur ?