Rappel sur la synchronisation des processus

1. Chapitre 02 Rappel sur la synchronisation des processus

2. Synchronisation des processus • Introduction • Sections critiques et exclusion mutuelle • Exclusion mutuelle par attente active • Le masquage des interruptions • Les variables de verrouillage • L’alternance stricte • La solution de Peterson • Exclusion mutuelle sans attente active • Les primitives sleep et wakeup • Les sémaphores • Exercices • Les moniteurs

3. Introduction • Sur une plateforme multiprogrammée les processus ont généralement besoin de communiquer pour compléter leurs tâches. • L’exécution d’un processus peut être affecter par l’exécution des autres processus ou il peut affecter lui-même leurs exécutions. La communication interprocessus est assurée généralement via des données partagées qui peuvent se trouver dans la mémoire principale ou dans un fichier. Les accès concurrents (simultanés) à des données partagées peuvent conduire à des incohérences dans les résultats obtenus.

4. Introduction: exemple illustratif Exemple : la spoule d’impression Démon d’impression Processus A … 3 2 1 0 … f2 f1 f0 Répertoire de spoule Variable partagée in=3 Processus B Schéma d’exécution: • B : lire in, • next_free_slot = 3, • entrée3 = fichierB, • in = 4 • A : lire in, • next_free_slot = 3 • Interruption: la CPU bascule vers le processus B • A : entrée3 = fichierA, • in = 4 Problème: le fichierB ne sera jamais imprimé

5. Sections critiques et exclusion mutuelle • Le problème précédent est dû aux conflits d’accès à la même ressource. • La partie du programme à partir de laquelle on accède à la ressource partagée est appelée section (région) critique. Solution: L’exclusion mutuelleest une méthode qui assure qu’un seul processus est autorisé d’accéder à une ressource partagée; les autres processus seront exclus de la même activité. A entre dans sa section critique A quitte sa section critique A B quitte sa section critique B t1 t2 t3 t4 B tente d’entrer dans sa section critique B entre dans sa section critique

6. Sections critiques et exclusion mutuelle • Quatre conditions doivent être vérifier pour assurer l’exclusion mutuelle: • Exclusion Mutuelle: Deux processus ne doivent pas se trouver simultanément dans leurs sections critiques. • Progression : Aucun processus à l’extérieur de sa section critique ne doit bloquer les autres processus. • Attente bornée : Aucun processus ne doit attendre indéfiniment pour entrer dans sa section critique. • Aucune hypothèse : Il ne faut pas faire d’hypothèse quant à la vitesse ou le nombre de processeurs

7. Synchronisation des processus • Introduction • Sections critiques et exclusion mutuelle • Exclusion mutuelle par attente active • Le masquage des interruptions • Les variables de verrouillage • L’alternance stricte • La solution de Peterson • Exclusion mutuelle sans attente active • Les primitives sleep et wakeup • Les sémaphores • Exercices • Les moniteurs

8. Exclusion mutuelle par attente active • Un processus désirant entrer dans une section critique doit être mis en attente jusqu’a ce que la section critique devient libre. • Un processus quittant la section critique doit le signaler aux autres processus. Algorithme d’accès à une section critique : Entrer_Section_Critique () /* attente si SC non libre */ Section_Critique() /* un seul processus en SC */ Quitter_Section_Critique() • L’attente peut être : • Active : la procédure Entrer_Section_Critique est une boucle dont la • condition est un test qui porte sur des variables indiquant la présence • ou non d’un processus en Section critique. • Non active : le processus passe dans l’état endormi et ne sera réveillé que lorsqu’il sera autorisé à entrer en section critique.

9. Solutions de l’exclusion mutuelle par attente active • Solution 1: Masquage des interruptions • Lorsqu’un processus entre en section critique il doit masquer les interruptions. • Lorsqu’ il quitte sa section critique il doit restaurer les interruptions. • C’est une solution matérielle qui permet de résoudre complètement le problème. Mais elle est dangereuse en mode utilisateur s’il oublie de restaurer les interruptions. Pas de commutation de processus

10. Solutions de l’exclusion mutuelle par attente active Solution 2: Variables de verrouillage Un verrou est variable binaire partagée qui indique la présence d’un processus en section critique. si verrou=0 alors section critique libre si verrou=1 alors section critique occupée voidentrer_Section_Critique () { while (verrou == 1) ; /* attente active */ verrou=1 ; } Void quitter_Section_Critique () { verrou=0 ; } • Cette solution ne garantie pas l’exclusion mutuelle car le verrou est une variable partagée qui peut constituer aussi une section critique.

11. Solutions de l’exclusion mutuelle par attente active Solution 3: Alternance stricte Tour est une variable partagée qui indique le numéro de processus autorisé a entrer en section critique. voidentrer_Section_Critique (intprocess) { while (Tour!=process) ; /* attente active */ } Void quitter_Section_Critique () { Tour = (Tour+1) %N ; } L’alternance stricte est une solution simple et facile a implémenter. Mais, un processus qui possède Tour peut ne pas être intéressé immédiatement par la section critique et en même temps il bloque un autre processus qui demandeur. Problème de progression

12. Solutions de l’exclusion mutuelle par attente active Solution 4: Solution de Peterson #define FAUX 0 #define VRAI 1 #define N 2 int tour ; /* à qui le tour */ intinteresse[N] ; /* initialisé à FAUX */ voidentrer_Section_Critique (intprocess) { int autre ; (1) autre = 1-process ; (2) interesse[process]=VRAI; /* process est intéressé */ (3) tour = process ; /* demander le tour */ while (tour == process && interesse[autre] == VRAI) ; } (A)(B) Voidquitter_Section_Critique () { (4) interesse[process]=FAUX ; } Cette solution assure complètement l’exclusion mutuelle. Mais, le processus qui attend sa section critique consomme du temps processeur inutilement (attente active).

13. Synchronisation des processus • Introduction • Sections critiques et exclusion mutuelle • Exclusion mutuelle par attente active • Le masquage des interruptions • Les variables de verrouillage • L’alternance stricte • La solution de Peterson • Exclusion mutuelle sans attente active • Les primitives sleep et wakeup • Les sémaphores • Exercices • Les moniteurs

14. Exclusion mutuelle sans attente active L’idée est qu’un processus qui ne peut pas entrer en section critique passe à l’état bloqué au lieu de consommer le temps processeur inutilement. Il sera réveillé lorsqu’il pourra y entrer. Les primitives Sleep et Wakeup: Le système d’exploitation offre deux appels système: 1. Sleep (dormir) qui bloque le processus appelant. 2. Wakeup (réveiller) qui réveille le processus donné en argument.

15. Exclusion mutuelle sans attente active Application des primitives Sleep et Wakeup au modèle Producteur Consommateur: Producteur … f2 f1 f0 Tampon Consommateur Variable partagée compteur=3 • Deux processus (le producteur et le consommateur) coopèrent en partageant un même tampon: • Le producteur produit des objets qu’il dépose dans le tampon. • Le consommateur retire des objets du tampon pour les consommer.

16. Exclusion mutuelle sans attente active #define N 100 /* taille du tampon */ int compteur = 0 ; /* objets dans tampon */ void producteur () { while (TRUE) { produire_objet() ; if (compteur == N) sleep () ; mettre_objet() ; compteur = compteur + 1 ; if (compteur == 1) wakeup(consommateur) ; } } void consommateur () { while (TRUE) { if (compteur == 0) sleep() ; retirer_objet() compteur = compteur – 1 ; if (compteur == N-1) wakeup (producteur) ; consommer_objet(…) ; } }

17. Exclusion mutuelle sans attente active • Analyse de cette solution : • L’accès à la variable compteur n’est pas protégé, ce qui peut entraîner des incohérences dans les valeurs prises par cette Variable. • Réveils perdus : c’est le principal défaut de ce mécanisme. Un signal wakeup envoyé à un processus qui ne dort pas (encore)est perdu.

18. Les sémaphores Pour remédier au problème es réveils en attente (les wakeup perdus), l’idée est d’employé une variable entière appelée: Sémaphore à laquelle est associée une file d’attente des processus bloqués. sémaphore=0  aucun réveil n’est mémorisé sémaphore>0  un ou plusieurs réveils sont en attente • Un sémaphore s est manipulé par les opérations : • down(s): - décrémente la valeur de s si s>0, • - si s=0, alors le processus est mis en attente. • up(s): - incrémente la valeur de s, • - si un ou plusieurs processus sont en attente sur ce sémaphore, l'un d'entre eux est réveillé,

19. Les sémaphores • Pour assurer l’exclusion mutuelle un sémaphore peut être programmé de la manière suivante : initialisation mutex = 1/* nombre de processus autorisés à entrer simultanément dans la section critique */ down (mutex) <section_critique> up (mutex) Nom du sémaphore

20. Les sémaphores • Application au modèle Producteur / Consommateur : • Trois sémaphores sont nécessaires: • plein: compte le nombre de places occupées • vide : compte le nombre de places libres • Mutex : assure que le producteur et le consommateur n'accèdent jamais en même moment à la mémoire tampon.

21. RappelProducteur/Consommateur avec sémaphores #define N 100 // taille du tampon semaphoremutex1 ; // contrôle d’accès section critique semaphorevide N; // contrôle les emplacements vide Semaphoreplein 0; // contrôle les emplacements plein • void producteur () { • while (TRUE){ • produire_objet() ; • down(vide); • down(mutex); • mettre_objet() ; //SC • up(mutex); • up(plein) • } • } • void consommateur () { • while (TRUE){ • down(plein); • down(mutex); • retirer_objet() //SC • up(mutex); • up(vide); • consommer_objet(…) ; • } • }

22. Synchronisation des processus - Exercices Ordonnancement & Synchronisation Pb des Lecteurs/rédacteur Pb du coiffeur endormi Autres utilisations des sémaphores & problèmes classiques

23. Exercice 1 Q1 : Round robin ( tourniquet) avec q=5ms Q2 : Round robin ( tourniquet) avec q=5ms + Synchronisation Peterson

24. Q1 P0 P1 P2 10 15 20 25 30 35 40 0 5 40 50 52 55 45 Round robin ( tourniquet) avec q=5ms

25. Q2 SC AA P0 P1 P2 5 10 15 20 25 30 35 40 0 40 50 55 58 45 Round robin ( tourniquet) avec q=5ms Peterson  Attente active

26. Q3 SC P0 P1 P2 0 5 10 15 20 22 27 32 37 40 40 42 47 52 55 Round robin ( tourniquet) avec q=5ms Sommeil et activation

27. Lecteurs/Rédacteur • Une base de données peut être accessible par un seul rédacteur ou N lecteurs en même temps • Exclusion mutuelle entre le rédacteur et les N lecteurs • Donner le pseudo code d’un processus lecteur et celui du processus rédacteur Base de données

28. Lecteurs/Rédacteur Semaphoremutex1 // contrôle l’accés à nb_lect Semaphoredb1 // contrôle l’accés à la base de données intnb_lect = 0 ; // var partagées entre lecteurs pour // compter le nombre de lecteurs accédant // actuellement à la BD //lecteur void lecture(){ while (true) { //boucle sans fin lire_la_BD(); //accés à la BD utiliser_données (); //Section restante } } //redacteur voidecriture(){ while (true) { créer_données (); ecrire_dans_la_BD } }

29. Lecteurs/Rédacteur Semaphoremutex1 // contrôle l’accés à nb_lect Semaphoredb1 // contrôle l’accés à la base de données intnb_lect = 0 ; // var partagées entre lecteurs pour // compter le nombre de lecteurs accédant // actuellement à la BD //lecteur void lecture(){ while (true) { //boucle sans fin down (mutex); // la modif de la var. partagée nb_lect est une nb_lect ++; // section critique entre lecteurs if (nb_lect == 1) down (db); //si le premier lecteur up(mutex); // libère l’accés exclusif à nb_lect lire_la_BD(); //accés à la BD down(mutex); nb_lect --; if (nb_lect == 0) up (db); //si le dernier lecteur up (mutex) utiliser_données (); //Section restante } }

30. Lecteurs/Rédacteur Semaphoremutex1 // contrôle l’accés à nb_lect Semaphoredb1 // contrôle l’accés à la base de données intnb_lect = 0 ; // var partagées entre lecteurs pour // compter le nombre de lecteurs accédant // actuellement à la BD //redacteur voidecriture(){ while (true) { //boucle sans fin créer_données (); //Section restante down (db); ecrire_dans_la_BD(); //accés à la BD up (db); } }

31. Coiffeur endormi • Un coiffeur possède un salon avec un siège de coiffeur et une salle d’attente comportant un nombre fixe F de fauteuils. • S’il n’y a pas de client, le coiffeur se repose sur son siège de coiffeur. • Si un client arrive et trouve le coiffeur endormi, il le réveille, s’assoit sur le siège de coiffeur et attend la fin de sa coupe de cheveux. • Si le coiffeur est occupé lorsqu’un client arrive, le client s’assoit et s’endort sur une des chaises de la salle d’attente ; si la salle d’attente est pleine, le client repasse plus tard. • Lorsque le coiffeur a terminé une coupe de cheveux, il fait sortir son client courant et va réveiller un des clients de la salle d’attente. • Si la salle d’attente est vide, il se rendort sur son siège jusqu’à ce qu’un nouveau client arrive.

32. Coiffeur endormi • Résoudre le pb en évitant les conditions de concurrence • Utilisation de 3 sémaphores et un compteur • Semaphore Clients 0; • //bloque le coiffeur s’il n’y a pas de clients • SemaphoreMutex 1; • //accés exclusif à la zone critique • Semaphore Coiffeurs 0; • //bloque le client si le coiffeur est occupé avec un //autre client • Int Attente = 0 ; • //Le nombre de clients en attente

33. Coiffeur endormi Semaphore Clients 0; SemaphoreMutex 1; SemaphoreCoiffeurs 0; Int Attente = 0 ; //Coiffeur void coiffeur() { while(1){ Attente = attente – 1; Couper_cheveux(); } } • //Client • void client() { • if ( ) { • Attente = attente + 1 • Obtenir_coupe • } • else { • } • }

34. Coiffeur endormi Semaphore Clients 0; SemaphoreMutex 1; SemaphoreCoiffeurs 0; Int Attente = 0 ; //Coiffeur void coiffeur() { while(1){ down(Clients); down(Mutex); Attente = attente – 1; up(Coiffeurs); up(Mutex); Couper_cheveux(); } } • //Client • void client() { • down(Mutex) • if (Attente < Chaises) { • Attente = attente + 1 • up(Clients) • up(Mutex) • down(Coiffeurs) • Obtenir_coupe • } • else { • up(Mutex) • } • }

35. Réfléchissons ! • Soient les deux processus P1 et P2 suivants. Ils se partagent deux sémaphores S1 et S2 initialisés à 0. • Quelle synchronisation a-t-on imposée sur les exécutions des procédures A1, A2, B1 et B2 (càd, quel ordre d’exécution) ? SemaphoreS1 0 SemaphoreS2 0 P1 { procedure A1 ; Up(S2) ; Down(S1) ; procedure B1 ; } P2 { procedure A2 ; Up(S1) ; Down(S2) ; procedure B2 ; }

36. Barrière de synchronisation • Les Ai s’exécutent toujours avant les Bi, quelque soit l’ordre de l’exécution des processus P1 et P2 • Ex: Ecrire le code à fin d’imposer la même synchronisation pour N processus en utilisant : • N sémaphores • 2sémaphores et un compteur SemaphoreS1 0 SemaphoreS2 0 P1 { procedure A1 ; Up(S2) ; Down(S1) ; procedure B1 ; } P2 { procedure A2 ; Up(S1) ; Down(S2) ; procedure B2 ; }