EX4C Systèmes d exploitation. Séance 6 Synchronisation

Transcription

1 EX4C Systèmes d exploitation Séance 6 Synchronisation Sébastien Combéfis vendredi 21 novembre 2014

2 Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution Pas d Utilisation Commerciale Pas de Modification 4.0 International.

3 Objectifs Décrire et comprendre la synchronisation de processus Comprendre le problème de la section critique Solution software : Algorithme de Peterson Solutions hardware : Test and Set, Compare and Swap Solutions apportées par l OS Sémaphore et moniteur Exemples de problème de synchronisation 3

4 Partage de données Deux processus peuvent partager des données Par exemple avec une zone de mémoire partagée Un processus peut être retiré du CPU à tout moment Des conditions de course peuvent se produire Lorsque plusieurs processus manipulent des données partagées 4

5 Condition de course Le producteur ajoute un élément au buffer s il reste de la place w h i l e ( t r u e ) w h i l e ( c o u n t e r == BUFFER_SIZE) b u f f e r [ i n ] = next_produced ; i n = ( i n + 1) % BUFFER_SIZE ; c o u n t e r ++; Le consommateur retire un élément du buffer s il y en a w h i l e ( t r u e ) w h i l e ( c o u n t e r == 0) next_consumed = b u f f e r [ out ] ; out = ( out + 1) % BUFFER_SIZE ; c o u n t e r ; 5

6 Traduction en langage machine La variable counter est partagée entre les processus Supposons que la valeur de counter soit 5 counter modifiée de manière concurrente par les deux processus counter++ R 1 := counter R 1 := R counter := R 1 counter-- R 2 := counter R 2 := R 2 1 counter := R 2 6

7 Entrelacement des instructions Instructions entrelacées lors d une exécution concurrente T 0 producteur R 1 := counter R 1 = 5 T 1 producteur R 1 := R R 1 = 6 T 2 consommateur R 2 := counter R 2 = 5 T 3 consommateur R 2 := R 2 1 R 2 = 4 T 4 producteur counter := R 1 counter = 6 T 5 consommateur counter := R 2 counter = 4 Il faut interdire la modification concurrente de counter La solution est de synchroniser les processus 7

8 Opération atomique Une opération atomique ne peut être interrompue Elle doit être exécutée dans son entièreté Les opérations counter++ et counter-- doivent être exécutées de manière atomique 8

9 Le problème de la section critique Soit un système avec n processus en compétition P 1,..., P n Chaque processus possède une section critique Le processus accès aux ressources partagées dans cette section Lorsqu un processus rentre dans sa section critique, aucun autre ne peut rentrer dans la sienne Un processus doit obtenir l autorisation 9

10 Structure des processus Section d entrée : demande pour entrer en section critique Section de sortie : fin de l utilisation des ressources partagées do section d entrée // section critique section de sortie // section restante w h i l e ( t r u e ) ; 10

11 Conditions d une solution Trois conditions doivent être satisfaites pour solutionner le problème de la section critique 1 Exclusion mutuelle Si un processus est dans sa section critique, aucun autre processus ne peut être dans la sienne 2 Progression Si aucun processus n est en section critique et certains veulent rentrer dans la leur, la sélection de qui va pouvoir y rentrer ne peut être postposée indéfiniment 3 Attente limitée Entre la demande pour rentrer dans sa section critique et l autorisation, seul un nombre limité d autres processus pourront rentrer dans la leur 11

12 Première partie Solutions software

13 Solution 1 : Attente active I Une variable partagée initialisée à zéro int turn = 0; do w h i l e ( t u r n!= i ) // section critique t u r n = j ; // section restante w h i l e ( t r u e ) ; 13

14 Solution 1 : Attente active II Attente active Les processus passent leur temps à vérifier la valeur de turn Les processus ne peuvent rien faire de productif en attendant Inconvénients Les processus doivent s alterner de manière stricte Un processus qui plante bloque le suivant Ne satisfait pas à la condition de progression 14

15 Solution 2 Deux variables partagées initialisées à false bool flag [2]; flag [0] = flag [1] = false ; do w h i l e ( f l a g [ j ] ) f l a g [ i ] = t r u e ; // section critique f l a g [ i ] = f a l s e ; // section restante w h i l e ( t r u e ) ; Ne satisfait pas à la condition d exclusion mutuelle 15

16 Solution 3 On indique a priori l intention de rentrer en section critique Risque d interblocage : condition de progression pas satisfaite do f l a g [ i ] = t r u e ; w h i l e ( f l a g [ j ] ) // section critique f l a g [ i ] = f a l s e ; // section restante w h i l e ( t r u e ) ; 16

17 Solution 4 Risque de «courtoisie mutuelle» do f l a g [ i ] = t r u e ; w h i l e ( f l a g [ j ] ) f l a g [ i ] = f a l s e ; // attente f l a g [ i ] = t r u e ; // section critique f l a g [ i ] = f a l s e ; // section restante w h i l e ( t r u e ) ; 17

18 Algorithm de Peterson Chaque processus reçoit son tour dans sa section critique do f l a g [ i ] = t r u e ; t u r n = j ; w h i l e ( f l a g [ j ] && t u r n == j ) // section critique f l a g [ i ] = f a l s e ; // section restante w h i l e ( t r u e ) ; 18

19 Deuxième partie Solutions hardware

20 Désactivation des interruptions Désactivation des interruptions Approche prise par les kernel non-préemptif Le processeur est limité dans sa capacité d entrelacement Problème avec le multiprocessing Le temps que le message de désactivation passe prend du temps 20

21 Test and set I Lire et modifier une valeur de manière atomique test_and_set exécutée de manière atomique Simule une instruction hardware disponible b o o l t e s t _ a n d _ s e t ( b o o l e a n t a r g e t ) b o o l r v = t a r g e t ; t a r g e t = t r u e ; r e t u r n r v ; 21

22 Test and set II Protection des sections critiques à l aide de verrous Une variable partagée initialisée à false bool lock = false ; do w h i l e ( t e s t _ a n d _ s e t (& l o c k ) ) // section critique l o c k = f a l s e ; // section restante w h i l e ( t r u e ) ; 22

23 Compare and swap I Comparer deux valeurs et les échanger de manière atomique compare_and_swap exécutée de manière atomique Simule une instruction hardware disponible b o o l compare_and_swap ( i n t v a l, i n t exp, i n t newval ) i n t temp = v a l ; i f ( v a l == exp ) v a l = newval ; r e t u r n temp ; 23

24 Compare and swap II Protection des sections critiques à l aide de verrous Une variable partagée initialisée à 0 int lock = 0; do w h i l e ( compare_and_swap (& l o c k, 0, 1)!= 0) // section critique l o c k = 0 ; // section restante w h i l e ( t r u e ) ; 24

25 Troisième partie Solutions OS

26 Mutex lock Mutex Lock (MUTual EXclusion) Problème d attente active Deux opérations possibles Acquisition du verrou : acquire Libération du verrou : release Exécution atomique des deux fonctions a c q u i r e ( ) w h i l e (! a v a i l a b l e ) a v a i l a b l e = f a l s e ; r e l e a s e ( ) a v a i l a b l e = t r u e ; 26

27 Sémaphore Variable entière utilisée pour la signalisation Un processus se bloque en l attente d un signal Plusieurs processus en attente se mettent dans une file Deux opérations atomiques possibles Se mettre en attente d un signal : wait Produire un signal : signal w a i t ( S ) w h i l e ( S <= 0) S ; s i g n a l ( S ) S++; 27

28 Synchronisation de processus Utilisation d un sémaphore pour synchroniser deux processus Si les instructions S 2 de P 2 ne doivent pas être exécutées avant les instructions S 1 de P 1 S 1 ; s i g n a l ( synch ) ; w a i t ( synch ) ; S 2 ; 28

29 Élimination de l attente active Après un wait, le processus doit être bloqué File d attente associée au sémaphore w a i t ( semaphore S ) S >v a l u e ; i f ( S >v a l u e < 0) add ( S >l i s t, P ) ; b l o c k ( ) ; s i g n a l ( semaphore S ) S >v a l u e ++; i f ( S >v a l u e <= 0) P = remove ( S > l i s t ) ; wakeup (P ) ; 29

30 Interblocage Deux processus bloqués, chacun en l attente de l autre P 0 w a i t ( S ) ; w a i t (Q) ;... s i g n a l ( S ) ; s i g n a l (Q) ; P 1 w a i t (Q) ; w a i t ( S ) ;... s i g n a l (Q) ; s i g n a l ( S ) ; 30

31 Moniteur Un moniteur est une structure de données plus haut niveau Un seul processus à la fois peut être actif dans le moniteur monitor nom // v a r i a b l e s p a r t a g é e s... // f o n c t i o n s function P1 (... )... function P2 (... ) function i n i t (... )... 31

32 Condition Type spécial de variable appelée condition Deux opérations possibles sur une condition x Se mettre en attente sur la condition : x.wait() Libère un processus en attente : x.signal() 32

33 Quatrième partie Exemples de problèmes

34 Bounded-buffer problem Variables partagées i n t n ; semaphore mutex = 1, empty = n, f u l l = 0 ; Producteur et consommateur do // produce item w a i t ( empty ) ; w a i t ( mutex ) ; // add item s i g n a l ( mutex ) ; s i g n a l ( f u l l ) ; w h i l e ( t r u e ) ; do w a i t ( f u l l ) ; w a i t ( mutex ) ; // remove item s i g n a l ( mutex ) ; s i g n a l ( empty ) ; // consume item w h i l e ( t r u e ) ; 34

35 Readers-Writers problem I Une base de données partagée entre des readers et des writers Le reader ne fait que lire des données Le writer peut lire et écrire des données Deux variations 1 Un reader ne peut pas attendre, sauf si un writer est occupé 2 Lorsqu un writer est prêt, il aura très vite l accès 35

36 Readers-Writers problem II Variables partagées semaphore rw_mutex = 1, mutex = 1 ; i n t read_count = 0 ; Writer et reader do w a i t ( rw_mutex ) ; // w r i t i n g s i g n a l ( rw_mutex ) ; w h i l e ( t r u e ) ; do w a i t ( mutex ) ; read_count++; i f ( read_count == 1) w a i t ( rw_mutex ) ; s i g n a l ( mutex ) ; // r e a d i n g w a i t ( mutex ) ; read_count ; i f ( read_count == 0) s i g n a l ( rw_mutex ) ; s i g n a l ( mutex ) ; w h i l e ( t r u e ) ; 36

37 Dining philosopher do w a i t ( c h o p s t i c k [ i ] ) ; w a i t ( c h o p s t i c k [ ( i + 1) % N ] ) ; // e a t s i g n a l ( c h o p s t i c k [ i ] ) ; s i g n a l ( c h o p s t i c k [ ( i + 1) % N ] ) ; // t h i n k w h i l e ( t r u e ) ; 37