Synchronisation des processus Abdelouahed Gherbi Hiver 2014 1
Plan Race condition Section critique Solutions au problème de la section critique Les sémaphores Problèmes de synchronisation classiques 2
Introduction Les processus sont souvent coopérants sont affectés par ou affectent d autres processus dans le système Les processus coopérants peuvent partager directement un espace d adressage Échanger des données via des fichiers ou passage de messages Les accès concurrents au données partagées peuvent engendrer des données inconsistantes (non cohérentes) Objectif de ce cours Étudier les mécanismes de synchronisation et coordination des processus concurrents et coopérants 3
Race condition Nous avons développé un modèle du système qui consiste en Un ensemble de processus (et threads) Asynchrones et concurrents Partagent des données Exemple : Producteur consommateurs 4
Race condition Exemple : Producteurs-consommateurs Solution possible while (true) { /* Produire un item */ while (((in + 1) % BUFFER_SIZE ) == out) ; /* Rien à faire Pas de buffer disponible*/ buffer[in] = item; in = (in + 1) % BUFFER SIZE; while (true) { while (in == out) ; // Rien à faire rien à consommer // Prendre un item du buffer item = buffer[out]; out = (out + 1) % BUFFER SIZE; } Processus producteur } Processus consommateur Inconvénient de la solution ci-dessous? 5
Race condition Attente active (busy waiting) Les processus testent continuellement une condition Les processus ne progressent pas mais utilisent la CPU On ne peut utiliser que (BUFFER_SIZE -1) places dans le buffer 6
Race condition On veut une solution qui permet d utiliser (remplir) le tapon complètement On peut utiliser un entier count qui garde le nombre des éléments pleins dans le buffer. Initialement, count est mis à 0. Il est incrémenté par le producteur et décrémenté par le consommateur. On obtient : while (true) { /* produire un item */ while (count == BUFFER_SIZE) ; // Rien faire buffer [in] = nextproduced; in = (in + 1) % BUFFER_SIZE; count++; } Processus producteur while (true) { while (count == 0) ; // Rien faire nextconsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; } /* Consommer l item Processus consommateur 7
Race condition Les routines des deux processus sont correctes séparément Ne fonctionnent pas correctement en concurrence. Pourquoi? while (true) { /* produire un item */ while (count == BUFFER_SIZE) ; // Rien faire buffer [in] = nextproduced; in = (in + 1) % BUFFER_SIZE; count++; } Processus producteur while (true) { while (count == 0) ; // Rien faire nextconsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; } /* Consommer l item */ Processus consommateur 8
Race condition Les routines des deux processus sont correctes séparément Ne fonctionnent pas correctement en concurrence. Pourquoi? On met le focus sur les instructions manipulant la variable partagée count while (true) { /* produir un item */ while (count == BUFFER_SIZE) ; // Rien faire buffer [in] = nextproduced; in = (in + 1) % BUFFER_SIZE; count++; } Processus producteur while (true) { while (count == 0) ; // Rien faire nextconsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; } /* consommer l item */ Processus consommateur 9
Race Condition count++ peut être implémenté en langage machine comme suit register1 = count register1 = register1 + 1 count = register1 count-- peut être implémenté comme suit : register2 = count register2 = register2-1 count = register2 Exécution concurrente de count++ et count-- est équivalente à une exécution séquentielle dans laquelle les instructions machines sont enchevêtrés (interleaved) dans un ordre arbitraire On considère l exécution (enchevêtrée) suivante avec count = 5 initialement : Instruction Description Résultat Initialement count = 5 S0 Producteur exécute register1 = count register1 = 5 S1 Producteur exécute register1 += 1 register1 = 6 S2 Consommateur exécute register2 = count register2 = 5 S3 Consommateur exécute register2 -=1 Register2 = 4 S4 Producteur exécute count = register1 count = 6 S5 Consommateur exécute count = register2 count = 4 10
Race condition On arriverait à cet état incorrect car on a permis aux deux processus de manipuler la variable partagée count en concurrence sans aucun contrôl Dans cette situation : Plusieurs processus accèdent et manipulent la même donnée en concurrence (parallèle) Le résultat de l exécution dépends de l ordre dans lequel se font les accès Cette situation est appelée race condition Pour éviter les race conditions On doit garantir qu un seul processus peut manipuler à la fois la variable partagée count Les processus doivent être synchronisés (coordonnés) 11
Section critique On considère un système de plusieurs processus : P0, P1, P2, Chaque processus a un segment de code où il manipule (change) des variables communes Mise à jour de tables, des listes chaînées, etc. Écriture sur un fichier Ce segment de code est appelé section critique do { entry section critical section Une caractéristique importante des sections critiques : Exclusion Mutuelle Quand un processus s exécute dans sa section critique aucun autre processus ne doit être autorisé d exécuter sa section critique Il ne peut pas y avoir deux processus dans leurs sections critiques simultanément Le problème de la section critique consiste à concevoir un protocol que les processus peuvent utiliser pour coopérer Chaque processus doit demander la permission d entrer dans sa section critique (Section d entrée) La section critique est suivi ed une section de sortie Le reste du code : section restante exit section remainder section } while (TRUE); Structure générale d un processus typique [1] 12
Solutions pour le problème de la SC Solutions logicielles pour le problème de la section critique Solutions algorithmiques Exemples : Solution de Peterson, Solution de Dekker Limitées à deux processus Pas de garantie de bonne fonctionnements sur toutes les architectures Solutions matérielles Masquage des interruptions Pas faisable sur des architectures multiprocesseurs Peut perturber le bon fonctionnement du système (mise à jour de l horloge) Instructions spéciales (supportées par le matériel) Test and set (difficile dans un multiprocesseur) Permutation (swap) atomique Complexes à utiliser par les programmeurs 13
Les sémaphores Un sémaphore est un outil de synchronisation de processus (threads) Un Sémaphore S : est une variable entière (integer) peut être manipulée seulement avec deux opérations indivisibles (atomiques) wait() et signal() Nom d origine : P() et V() Les définitions de wait() et signal() sont comme suit : wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; } 14
Les sémaphores On distingue deux types de sémaphores : Sémaphore à compteur (counting semaphore) valeur entière qui varie sur un intervalle non restreint Sémaphore binaire (binary semaphore) valeur entière entre 0 et 1 seulement Appelé aussi les verrous mutex (mutex locks) 15
Les sémaphores Le sémaphores à compteur peuvent être utilisés pour contrôler l accès à une ressource ayant un nombre fini d instances (exemplaires) Le sémaphore est initialisé au nombre de ressources disponibles Si un processus veut utiliser une ressource Exécute une opération wait() sur le sémaphore (décrémente le compte) Si un processus libère une ressource Exécute l opération signal() sur le sémaphore (incrémente le compte) Quand le compte du sémaphore est zéro toutes les ressources sont utilisées Tout processus qui a besoin d une ressource va bloquer jusqu à ce que le compte devient non nulle 16
Les sémaphores On utilise les sémaphores binaires (mutex) pour traiter le problème de section critique entre plusieurs processus comme suit : Semaphore mutex = 1; // initialisé à 1 do { wait (mutex); // Critical Section signal (mutex); // remainder section } while (TRUE); do { entry section critical section exit section remainder section } while (TRUE); 17
Les sémaphores On peut également utiliser les sémaphores pour une variété de problèmes de synchronisation Exemple : Un processus P1 exécute une instruction S1 et un processus P2 exécute une instruction S2 S2 doit être exécutée par P2 seulement quand S1 a été exécutée par P1 Comment réaliser cette synchronisation en utilisant les sémaphores? 18
Les sémaphores On peut également utiliser les sémaphores pour une variété de problèmes de synchronisation Exemple : Un processus P1 exécute une instruction S1 et un processus P2 exécute une instruction S2 S2 doit être exécutée par P2 seulement quand S1 a été exécutée par P1 P1 et P2 doivent utiliser un sémaphore commun Semaphore synch = 0; S1; signal(synch); wait(synch); S2; // processus P1 // processus P2 19
Implémentation des sémaphores On reconsidère la définition des opérations sur un sémaphore wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; } Il est claire qu il y a un inconvénient important de la définition des sémaphore. Lequel? 20
Implémentation des sémaphores Inconvénient important de la définition des opérations sur un sémaphore Attente active (busy waiting) Tant qu un processus est dans sa SC, les autres processus qui essayent d entrer dans leurs SCs doivent boucler continuellement Ceci est un problème dans un système multiprogrammé utilisant une seule CPU Gaspillage des cycles CPU Ce type de sémaphore est appelé spinlock Les processus tournent «spin» tant qu ils attendent Spinlocks ont un avantage : Lequel? 21
Implémentation des sémaphores Inconvénient important de la définition des opérations sur un sémaphore Attente active (busy waiting) Tant qu un processus est dans sa SC, les autres processus qui essayent d entrer dans leurs SCs doivent boucler continuellement Ceci est un problème dans un système multiprogrammé utilisant une seule CPU Gaspillage des cycles CPU Ce type de sémaphore est appelé spinlock Les processus tournent «spin» tant qu ils attendent Spinlocks ont un avantage : pas de commutation de contexte quand les locks sont utilisés pour de courtes périodes, ils sont avantageux Les spinlocks sont employés sur les systèmes multiprocesseurs 22
Implémentation des Sémaphores On modifie la définition des opération wait()et signal() pour éliminer le problème de l attente active Quand un processus exécute l opération wait() Il décrémente la valeur du sémaphore Si la valeur du sémaphore est positive (ou nulle) : il continue Si la valeur du sémaphore est négative : il doit se bloquer (sera mis dans une file d attente associée au sémaphore et son état passe à en attente (waiting), le processus libère la CPU) Un processus bloqué en attente d un sémaphore S doit être redémarré (réveillé) par un autre processus qui exécute l opération signal() sur ce sémaphore Ce processus passe de l état en attente (waiting) à l état prêt (ready) 23
Implementation de wait: } Implémentation des Sémaphores wait(semaphore *S) { S->value--; if (S->value < 0) { ajouter ce processus à S->list; } block(); Implementation de signal: // l opération block suspends le processus qui // l invoque : c est un appel système typedef struct{ int value; struct processs *list; } semaphore ; signal(semaphore *S) { S->value++; if (S->value <= 0) { Enlever un processus P de S->list; wakeup(p); // reprends l exéction du processus bloqué // c est un appel système } } 24
Implémentation des Sémaphores Retour sur l exclusion mutuelle en utilisant les sémaphores Trois processus A, B et C accèdent à une ressource commune protégée par un sémaphore lock 25
Problèmes avec les sémaphores On considère un système de deux processus P0 et P1 P0 et P1 utilisent les sémaphores S et Q initialisés à 1 P 0 P 1 wait (S); wait (Q);...... signal(s); signal(q); wait (Q); wait (S); signal(q); signal(s); Que peut on constater? 26
Problèmes avec les sémaphores On considère un système de deux processus P0 et P1 P0 et P1 utilisent les sémaphores S et Q initialisés à 1 P 0 P 1 wait (S); wait (Q);...... signal(s); signal(q); wait (Q); wait (S); signal(q); signal(s); Inter-blocage (deadlock) Deux processus ou plus en attente infinie d un événement qui peut être causé seulement par un parmi les processus en attente 27
Problèmes avec les sémaphores Autre problème potentiel Politique de gestion de la file d attente du sémaphore Que ce passe-t-il si la file d attente associée à un sémaphore est gérée selon la politique LIFO? Famine (Starvation) Un blocage infini : un processus peut ne jamais être retiré de la file du sémaphore dans lequel il est suspendu 28
Exercice 01 29
Problèmes de synchronisation classiques On présente des problèmes classiques de synchronisation de processus Ces problèmes sont utilisés pour tester toute proposition nouvelle d une technique ou un mécanisme pour la synchronisation des processus On considère les problèmes Producteur-consommateur avec un tampon borné Lecteurs rédacteurs Les philosophes On utilise les sémaphore comme outil de synchronisation 30
Producteur-consommateur avec un tampon borné Les processus producteur et consommateur interagissent via : Un tampon (buffer) de taille N Règles de synchronisation : Tant qu il y a une place vide, le producteur peut l utiliser pour y mettre un item produit Tant qu il y a une place pleine (contient un item), le consomateur peut le prendre Le producteur et le consomateur ne peuvent pas utiliser le buffer en même temps Initialement : il y a N emplacement vides dans lesquels le producteur peut mettre les items qu il produit Il y a donc 0 emplacement pleins (contenant un item) Déclaration : Semaphore mutex = 1 Semaphore full = 0 Semaphore empty = N 31
Producteur-consommateur avec un tampon borné Un tampon (buffer) de N places Semaphore mutex = 1 Semaphore full = 0 Semaphore empty = N. do { // produire un item wait (empty); wait (mutex); // ajouter l item au buffer signal (mutex); signal (full); } while (TRUE); Structure du processus producteur do { wait (full); wait (mutex); // Prendre l item du buffer signal (mutex); signal (empty); // consommer l item } while (TRUE); Structure du processus consommateur 32
Problème des lecteurs rédacteurs Une base de données (fichier) est partagée par plusieurs processus concurrents Lecteurs (Readers) processus qui lisent seulement dans la base de données; il ne font pas des opérations de mise à jour Rédacteurs (Writers) processus qui peuvent lire et écrire Problème (version originale) Plusieurs processus lecteurs peuvent lire en même temps. Un seul processus rédacteur peut accéder à base de données à la fois (accès exclusif pour les rédacteurs) Autres versions du problème (avec priorité) Les lecteurs n attendent que s il y a un rédacteur est entrain d utiliser la ressource Une fois un processus rédacteur est prêt aucun autre lecteur ne peut commencer à lire Une solution pour ces deux versions peut engendrer une famine 33
Problème des lecteurs rédacteurs Dans cette solution, on utilise ces structures de données Semaphore mutex = 1 Semaphore wrt = 1 int readcount = 0 do { wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ; signal (mutex) // Lecture wait (mutex) ; readcount-- ; if (readcount == 0) signal (wrt) ; signal (mutex) ; do { wait (wrt) ; // Ecriture signal (wrt) ; } while (TRUE); Structure générale d un processus rédacteur } while (TRUE); Structure générale d un processus lecteur 34
Problème des philosophes Un problème de synchronisation classique Pas nécessairement pour sa valeur pratique Pas parce que les informaticiens haïssent les philosophes!! Un modèle d allocation de ressources entre processus sans inter blocage ni famine 5 philosophes passent leur vie à penser et manger Sont assis autour d une table Il y a 5 baguettes (chopsticks) sur la table Quand un philo a faim, il (elle) essaye de prendre les deux baguettes les plus proches à lui (entre lui et ses voisins) Un philo peut prendre une baguette à la fois (il ne peut prendre un qui est déjà pris) Ayant les deux baguettes en sa possession le philo peut alors manger Après avoir fini, le philo libère les deux baguettes et recommence à penser Problème des philosophes [1] 35
Problème philosophes Une solution simple On utilise un sémaphore (mutex) pour ressource commune (baguette) Un processus philo essaye de prendre une baguette en exécutant l opération wait()sur le sémaphore correspondant Il libéré la baguette en exécutant l opération signal() do { wait ( chopstick[i] ); wait ( chopstick[ (i + 1) % 5] ); // eat signal ( chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think } while (TRUE); Les processus partagent la structure de données suivante Semaphore chopstick [5] = 1; Structure d un processus philosphe i Quel est le problème avec cette solution? 36
Utilisation incorrecte des sémaphores Si les sémaphores sont utilisés incorrectement ils peuvent engendrer des erreurs très difficiles à détecter et reproduire Cas : les processus intervertissent l ordre des opérations wait()et Signal() signal(mutex); Section critique wait(mutex); Dans cette situation plusieurs processus peuvent entrer dans leurs SC en même temps Cas : Un processus remplace signal() par wait() wait(mutex); Section critique wait(mutex); Ici on aura inter-blocage 37
Exercice 02 38
Références [1] SILBERSCHATZ, A. et P.B. GALVIN, Operating System Concepts. 8 th Edition, Addison Wesley. 39