Programmation Concurrente Chapitre 2 : Synchronisation 1. Présentation du problème 2. Synchronisation par sémaphore 3. Synchronisation par événement 4. Le problème des lecteurs et des rédacteurs 1
1. Présentation du problème 1.1 Nécessité de la synchronisation Exemple 1 : le processus p transmet de l'information au processus q en écrivant dans un fichier f consulté par q ; processus p processus q...... écrire(f) ; lire(f) ;...... Contrainte de synchronisation : la lecture de f par q ne peut pas commencer avant la fin de l'écriture de f par p On veut obtenir, quelle que soit l'exécution, que : fin de écrire(f) précède début de lire(f) point de synchronisation Point de synchronisation : point auquel est associée une condition de franchissement qui dépend d'un autre processus 2
1. Présentation du problème Exemple 2 : rendez-vous entre processus soit N processus p 1, p 2,, p N ; on définit pour chaque processus un point, appelé point de rendez-vous, que le processus ne peut franchir avant que tous les autres processus aient atteint leur propre point de rendez-vous ; p i : début-i ; point de p j : début-j ; suite-i ; rendez-vous suite-j ; Contrainte de synchronisation : On veut obtenir, quelle que soit l'exécution, que :! i, j " [1..N] fin de début-i précède début de suite-j Point de rendez-vous = point de synchronisation 3
1. Présentation du problème Expression des contraintes de synchronisation! Ordre de précédence sur certains points dans l'exécution des processus! Point de synchronisation + condition associée au franchissement de ce point Satisfaction des contraintes de synchronisation Permettre à un processus : - de se bloquer en attendant de pouvoir franchir un point de synchronisation i.e. en attendant qu'une condition soit satisfaite - d'activer un autre processus quand une condition est satisfaite 4
2. Synchronisation par sémaphore P permet à un processus d'attendre avant de franchir un point de synchronisation V permet de signaler à un autre processus qu'une condition est satisfaite Exemple 1 : signal : semaphore initial (0) processus p processus q...... écrire(f) ; V(signal) ; P(signal) ; lire(f) ; point de synchronisation signal : sémaphore privé - valeur initiale = 0 au processus q - seul q peut exécuter P(signal) - les autres processus exécutent V(signal) 5
2. Synchronisation par sémaphore Exemple 2 : rendez-vous entre N processus Variable partagée n pour compter les processus arrivés au rendez-vous Condition de franchissement du point de rendez-vous : n=n n : entier initial (0) ; p i : début-i ; p j : début-j ; n:=n+1 ; n:=n+1 ;... point de... rendez-vous suite-i ; suite-j ; 6
Exemple 2 : rendez-vous entre N processus Utilisation d'un sémaphore tous-là qui permet aux processus arrivés en avance d'attendre ; le dernier arrivé réveille tous les autres ou réveil en chaîne n : entier initial (0) ; tous-là semaphore initial (0) ; p i : début-i ; n:=n+1 ; si n < N alors P(tous-là) ; n:= n-1 ; si n > 0 alors V(tous-là) ; suite-i ; + exclusion mutuelle 7
2.1 Schéma général de synchronisation par sémaphores privés mutex : semaphore initial (1) ; semprivé : semaphore initial (0) ; Franchissement du point de synchronisation : Variante P(mutex) ; Var privée au processus Modification et test de variables ; v : booléen initial (faux) ; si non blocage alors V(semprivé) ; P(mutex) ; V(mutex) ; Modification et test de variables ; P(semprivé) ; si blocage alors v:= vrai ; V(mutex) ; Processus activateur : si v alors P(semprivé) ; P(mutex) ; Modification et test de variables suivis éventuellement de V(semprivé) ; V(mutex) ; 8
Application du schéma Exemple 2 : rendez-vous entre processus p i : début-i ; n : entier initial (0) ; mutex : semaphore initial (1) ; tous-là : semaphore initial (0) ; P(mutex) ; n:=n+1 ; si n=n alors V(tous-là) ; V(mutex) ; P(tous-là) ; P(mutex) ; n:=n-1 ; si n > 0 alors V(tous-là) ; V(mutex) ; suite-i ; Variante Var privée au processus P(mutex) ; n:=n+1 ; v : booléen initial (faux) ; si n < N alors v:= vrai ; V(mutex) ; si v alors P(tous-là) ; l'exclusion mutuelle est inutile car les processus exécutent cette séquence un par un 9
Variantes des opérations Pet V classiques :! P(S1, S2,..., Sn) : franchissement de tous les sémaphores ou de aucun P(S1, S2,..., Sn) # P(S1) ; P(S2) ;... P(Sn) V(S1, S2,..., Sn) = V(S1) ; V(S2) ;... V(Sn)! PCOND(S) : exécute P(S) si pas bloquant Attention : interblocage si mal utilisé 10
3. Synchronisation par événement Type événement => 2 opérations indivisibles (atomiques) - attendre [wait] - signaler [notify] Effet des opérations attendre et signaler? Evénement mémorisé sémantique identique à celle des sémaphores Evénement non mémorisé => condition, voir moniteur (java) e : événement-non-mémorisé ; - attendre(e) : le processus appelant se bloque en attente de e - signaler(e) : sans effet si aucun processus n'attend e (l'événement est perdu) sinon réveille un processus qui attend e - signalertous(e) : réveille tous les processus qui attendent e 11
Exemple 1 : autorisation-lecture : événement-mémorisé ; p:... q :... écrire(f) ; attendre(autorisation-lecture) ; signaler(autorisation-lecture) ; lire(f) ;...... Exemple 2 : rendez-vous entre N processus n : entier initial (0) ; tous-là : événement-non-mémorisé ; p i : début-i ; < n:=n+1 ; exclusion mutuelle <... > si n < N > alors attendre(tous-là) ; signaler(tous-là) ; suite-i ; Voir Moniteurs (Java) 12
4. Le problème des lecteurs et des rédacteurs 4.1 Présentation du problème Problème classique de synchronisation : On considère un objet partagé entre plusieurs processus concurrents Certains des processus veulent seulement lire la valeur de l'objet : ce sont les lecteurs D'autres processus veulent la mettre à jour (lire et écrire) : ce sont les rédacteurs (écrivains) 13
Exemple : Objet partagé : un fichier de comptes bancaires Un processus lecteur P1 : lit la valeur des comptes B1 et B2 et l'imprime Un processus rédacteur P2 : fait un transfert de B1 vers B2 Initialement : B1 = 500, B2 = 700 P1 : Lire B1 : 500 P2 :... Lire B1 : 500 Soustraire 200 Ecrire B1 : 300 Lire B2 : 700 Ajoute 200 Ecrire B2 : 900 Lire B2 : 900 Résultat de P1 : Valeurs finales : B1 = 300, B2 = 900 B1 = 500, B2 = 900 Incohérent! 14
4.2 Modélisation du problème Lecteurs : Rédacteurs : demande de lecture ; demande d'écriture ; lecture ; stratégie écriture ; fin de lecture ; fin d'écriture ; Concurrence entre les lecteurs et les rédacteurs : - aucune limitation pour des lecteurs concurrents - exclusion mutuelle entre rédacteurs - exclusion mutuelle entre rédacteur et lecteur Problème courant dans les bases de données : voir contrôle de concurrence dans les systèmes transactionnels 15
Stratégies de service possibles Quelle priorité entre les lecteurs et les rédacteurs? 1. Pas de priorité des lecteurs sur les rédacteurs ou inversement ordre d'arrivée des demandes : ordre de service : L1 L2 R3 L4 (L1,L2) ; R3 ; L4 2. Priorité aux lecteurs si et seulement un lecteur est en train de lire ordre d'arrivée des demandes : ordre de service : L1 L2 R3 L4 (L1,L2,L4) ; R3 Privation possible des rédacteurs R1 R2 L3 R1 ; R2 ; L3 3. Priorité des lecteurs sur les rédacteurs Privation possible des rédacteurs ordre d'arrivée des demandes : ordre de service : R1 R2 L3 L4 R1 ; (L3,L4) ; R2 4. Priorité des rédacteurs sur les lecteurs Privation possible des lecteurs ordre d'arrivée des demandes : ordre de service : L1 R2 L3 R4 L1 ; R2 ; R4 ; L3 16