Systèmes d'Exploitation - chp6-synchronisation

Synchronisation des ProcessusSections critiques, Sémaphores

Dr. Ghad a GASMI- Dr. L i l ia SFAXI S l id e 1

Systèmes d’Exploitation2ème Année (GL-RT-I IA-IMI)

Présentation

• Sur une plateforme multiprogrammée, les processus ont généralement besoin de communiquer pour compléter leurs tâches.

• Un processus est dit indépendant, s’il n’affecte pas les autres processus ou ne peut pas être affecté par eux. § Un processus qui ne partage pas de données avec d’autres processus est

indépendant.

• Un processus est dit coopératif s’il peut affecter les autres processus en cours d’exécution ou être affecté par eux. § Un processus qui partage des données avec d’autres processus est un

processus coopératif.

• Les données partagées par les processus coopératifs se trouvent en mémoire principale ou en mémoire secondaire dans un fichier § I l y a alors risque d’incohérence des données.

Dr. Ghad a GASMI - Dr. L i l ia SFAXI S l id e 2

Synchronisation des Processus

Présentation

• L’exécution d’un processus peut être affectée 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.



Exemple Illustratif

Exemple : la spoule d’impression



Processus A

Processus B

… 3 2 1 0

f1f2… f0 Répertoire de spoule

Démon d’impression

Variable partagée in=3

Schéma d’exécution:A : lire in,next_free_slot = 3Préemption: la CPU bascule vers le processus B

B : lire in,next_free_slot = 3,entrée3 = fichierB,in = 4

Problème: le fichierB ne sera jamais imprimé

A : entrée3 = fichierA,in = 4

lire in,next_free_slot = inEntrée[next_free_slot] = fichierin = in +1

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 mutuelle est 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é.

Sl id e 5


A

B

t1 t2 t3 t4

A entre dans sa section critique

B tente d’entrer dans sa section critique

A quitte sa section critique

B entre dans sa section critique

B quitte sa section critique

Dr. Ghad a GASMI - Dr. L i l ia SFAXI

Sections critiques et exclusion mutuelle

• Quatre conditions doivent être vérifiées pour assurer une bonne synchronisation des processus :

1. Exclusion Mutuelle: Deux processus ne doivent pas se trouver simultanément dans leurs sections critiques.

2. Progression : Aucun processus à l’extérieur de sa section critique ne doit bloquer les autres processus.

3. Attente bornée : Aucun processus ne doit attendre indéfiniment pour entrer dans sa section critique.

4. Aucune hypothèse : Il ne faut pas faire d’hypothèse quant à la vitesse ou le nombre de processeurs



EXCLUSION MUTUELLE PAR ATTENTE ACTIVESynchronisation des Processus


Approche de Synchronisation

• Un processus désirant entrer dans une section critique doit être mis en attente jusqu’a ce que la section critique devienne libre.

• Un processus quittant la section critique doit le signaler aux autres processus.

• 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.

Sl id e 8

Exclusion Mutuelle par Attente Active

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()


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.

§ Pas de commutation de contexte§ 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.

Sl id e 9




• Solution 2: Variable de verrouillage§ Un verrou est variable binaire partagée qui indique la présence d’un

processus en section critique.o si verrou=0 alors section critique libre

o si verrou=1 alors section critique occupée

§ Cette solution ne garantit pas l’exclusion mutuelle car le verrou est une variable partagée qui peut constituer aussi une section critique.

Sl id e 10


void entrer_Section_Critique () {

while (verrou == 1) ; /* attente active */verrou=1 ;

}

void quitter_Section_Critique () {

verrou=0 ;}



• Solution 2-bis : Variable de verrou en matériel: TSL (Test and Set Lock) § Aussi appelée TAS pour Test And Set.

§ Est une instruction indivisible: réalisée une seule fois par le matériel.o (1) Lit le contenu de LOCK dans REGISTRE //(1) et (2) sont indivisibleso (2) Ecrit 1 dans adresse mémoire LOCK // (TSL instruction atomique)



|pseudo-assembleurentrer_Section_Critique:

TSL REGISTER, LOCK | copie lock dans reg et la définit à 1CMP REGISTER, #0 | lock etait-elle à 0JNE entrer_SC | si elle était pas à 0, boucleRET | retourne à appelant, entre dans SC

quitter_Section_Critique:MOVE LOCK, #0 | stocke un 0 dans lockRET | retourne à l’appelant

TSL REGISTER, LOCK


• Solution 3: Alternance stricte§ Tour est une variable partagée qui indique le numéro de processus autorisé

à entrer en section critique.

§ 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 la demande.

§ Problème de Progression

Sl id e 12


void entrer_Section_Critique (int process) {

while (Tour!=process) ; /* attente active */}

void quitter_Section_Critique () {

Tour = (Tour+1) %N ;}



• Solution 4: Alternance stricte v2§ Interested est un tableau de booléens partagé ayant une case pour chaque

processus qui veut entrer en SC

§ Initialement, toutes les valeurs du tableau sont à false§ Quand un processus exécute entrer_SC:

o I l met sa variable interested à trueo I l attend si l’autre processus est intéressé

§ Problème d’interblocageo Excès de courtoisie!

Sl id e 13


void entrer_Section_Critique (int process) {

interested[process] = true;while (interested[1-process]) ; /* attente active */

}

void quitter_Section_Critique (int process) {

interested[process]= false;}



• Solution 5: Alternance stricte v2§ Cette solution combine les deux version de l’alternance stricte§ Cette solution assure les quatre conditions de bonne synchronisation. § Mais, le processus qui attend sa section critique consomme du temps

processeur inutilement (attente active).

Sl id e 14


#define FAUX 0#define VRAI 1#define N 2int tour ; /* à qui le tour */int interesse[N] ; /* initialisé à FAUX */void entrer_Section_Critique (int process){

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)

Void quitter_Section_Critique (int process) {(4) interesse[process]=FAUX ;}


Peterson N-processus

# d e f i n e FA L S E 0# d e f i n e N 1 0 / * F i r s t p ro ce s s i s i n d i c ate d w i t h 1 , n ot 0 */i n t t u r n [ N ] ;i n t s t a g e [ N + 1 ] ;

vo i d e n te r R e g i o n ( i n t p ro ce s s ){

i n t i , j ;f o r ( i = 1 ; i < = N - 1 ; i + + ) {

s t a g e [ p ro ce s s ] = i ;t u r n [ i ] = p ro ce s s ;f o r ( j = 1 ; j < = N ; j + +) {

i f ( j = = p ro ce s s )c o n t i n u e ;

w h i l e ( s t a g e [ j ] > = i & & t u r n [ i ] = = p ro ce s s ) ;}

}}


vo i d l e a ve R e g i o n ( i n tp ro ce s s ){

s t a g e [ p ro ce s s ] = FA L S E ;}


EXCLUSION MUTUELLE SANS ATTENTE ACTIVESynchronisation des Processus


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.

Sl id e 17

Exclusion Mutuelle Sans Attente Active


Producteur-Consommateur

• Application des primitives Sleep et Wakeup au modèle Producteur Consommateur:

• 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.

Sl id e 18


Producteur

f1f2… f0 Tampon

Variable partagée compteur=3 Consommateur



Slid e 19


# d e f i n e N 1 0 0 / * t a i l l e d u t a m p o n * /i n t c o m p t e u r = 0 ; / * o b j e t s d a n s t a m p o n * /

v o i d p r o d u c t e u r ( ) {w h i l e ( T R U E )

{p r o d u i r e _ o b j e t ( ) ;i f ( c o m p t e u r = = N ) s l e e p ( ) ;m e tt r e _ o b j e t ( ) ;c o m p t e u r = c o m p t e u r + 1 ;i f ( c o m p t e u r = = 1 )

w a k e u p ( c o n s o m m a t e u r ) ;}

}

v o i d c o n s o m m a t e u r ( ) {w h i l e ( T R U E )

{i f ( c o m p t e u r = = 0 )

s l e e p ( ) ;r e t i r e r_ o b j e t ( )c o m p t e u r = c o m p t e u r – 1 ;i f ( c o m p t e u r = = N - 1 )

w a k e u p ( p r o d u c t e u r ) ;c o n s o m m e r_ o b j e t ( … ) ;

}}



• 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 : o c’est le principal défaut de ce mécanismeo Un signal wakeup envoyé à un processus qui ne dort pas (encore)

est perdu.‣ Considérer le scénario où une préemption a lieu entre le if et le sleep

du producteur, par exemple.

Sl id e 20



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 à laquelleest 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 atomiques suivantes:1. down(s) :

o if (val(s)==0) sleep();

o val(s)--;

2. up(s) :o wakeup();

o s++;

Sl id e 21



Sémaphores

• Pour assurer l’exclusion mutuelle un sémaphore peut être programmé de la manière suivante :

Sl id e 22


initialisation mutex = 1 /* nombre de processus autorisés à entrersimultanément dans la section critique */

down (mutex)<section_critique> up (mutex)

Nom du sémaphore


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.

Sl id e 23



Producteur/Consommateur avec Sémaphores

#define N 100 // tai l le du tampon

semaphore mutex 1 ; // contrôle d ’accès section cr it ique

semaphore vide N; // contrôle les emplacements v ide

semaphore plein 0; // contrôle les emplacements plein

Sl id e 24


v o i d p r o d u c t e u r ( ) {w h i l e ( T R U E ) {

p r o d u i r e _o b j e t ( ) ;d o w n (v i d e ) ;d o w n (m u t e x ) ;m e tt r e _ o b j e t ( ) ; // S Cu p (m u t e x ) ;u p ( p l e i n)

}}

v o i d c o n s o m m a t e u r ( ) {w h i l e ( T R U E ) {

d o w n ( p l e i n) ;d o w n (m u t e x ) ;r e t i r e r_o b j e t ( ) // S Cu p (m u t e x ) ;u p (v i d e ) ;c o n s o m m e r_ o b j e t ( … ) ; }

}


EXERCICESSynchronisation des Processus


Ex1: Synchronisation et Ordonnancement

• Q1 : Round robin ( tourniquet) avec q=5ms

• Q2 : Round robin ( tourniquet) avec q=5ms + Synchronisation Peterson

Slid e 26

Exercices

Prêt à l’instant t=

Durée d’exécution

P0 0 ms 23 ms

P1 1 ms 17 ms

P2 2 ms 15 ms


SR+SC

Date d’entrée en section critique t=

P0 23 ms 3 ms

P1 17 ms 7 ms

P2 15 ms X


Durée d’exécution ensection critique

P0 0 ms 13ms

P1 1 ms 10 ms

P2 2 ms X




P0 0 ms 23 ms

P1 1 ms 17 ms

P2 2 ms 15 ms

0 5

P0

P1

P2

10 15 20 25 30 35 40

40 45 50 52 55


• Round robin ( tourniquet) avec q=5ms

Exercices


0

P0

P1

P2

10 15 30

40 45 50 58





P0 0 ms 23 ms 3 ms 12 ms

P1 1 ms 17 ms 7 ms 10 ms

P2 2 ms 15 ms X X

SC AA

5 20 25 35 40

55


• Round robin ( tourniquet) avec q=5ms• Peterson è Attente active

Exercices



• Round robin ( tourniquet) avec q=5ms• Sommeil et activation

Exercices

0 5

P0

P1

P2

10 15 20 22 27 32 37

40 42 47 5552





P0 0 ms 23 ms 3 ms 12 ms

P1 1 ms 17 ms 7 ms 10 ms

P2 2 ms 15 ms X X

SC

40


Ex2: 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

Sl id e 30

Exercices

Basededonnées



Semaphore mutex 1 // contrôle l ’accés à nb_lectSemaphore db 1 // contrôle l ’accés à la base de donnéesint nb_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

l ire_la_BD(); //accés à la BDutil iser_données (); //Section restante

}}//r e d a c t e u rv o i d e c r i t u r e ( ) {

w h i l e ( t r u e ) { c r é e r_ d o n n é e s ( ) ;

e c r i r e _ d a n s _ l a _ B D}

}

Sl id e 31

Exercices



Semaphore mutex 1 // contrôle l ’accés à nb_lectSemaphore db 1 // contrôle l ’accés à la base de données

int nb_lect = 0 ; // var partagées entre lecteurs pour // compter le nombre de lecteurs accédant // actuel lement à la BD

//lecteurvoid lecture(){

whi le (true) { //boucle sans f indown (mutex); // la modif de la var. partagée nb_lectnb_lect ++; // est une section cr it ique entre lecteursif (nb_lect == 1) down (db); //si le premier lecteur

up(mutex); // l ibère l ’accés exclusif à nb_lectl ire_la_BD(); //accés à la BDdown(mutex);nb_lect --;i f (nb_lect == 0) up (db); //si le dernier lecteurup (mutex)

uti l iser_données (); //Section restante}

}

Sl id e 32

Exercicesv o i d e c r i t u r e ( ) {

w h i l e ( t r u e ) { // b o u c l e s a n s f i nc r é e r_ d o n n é e s ( ) ; // S e c . R e s t .d o w n ( d b ) ; e c r i r e _ d a n s _ l a _ B D ( ) ; // a c c é s B Du p ( d b ) ;

}}


Ex3: 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 du 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 rentre chez lui.

• 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.

Sl id e 33

Exercices



• Résoudre le pb en évitant les conditions de concurrence

• Utilisation de 3 sémaphores et un compteur§ Semaphore Clients 0;

o //bloque le coiffeur s’i l n’y a pas de clients

§ Semaphore Mutex 1;o //accés exclusif à la zone critique

§ Semaphore Coiffeurs 0;o //bloque le client si le coiffeur est occupé avec un //autre client

§ Int Attente = 0 ;o //Le nombre de clients en attente

Sl id e 34

Exercices



S e m a p h o r e C l i e n t s 0 ;S e m a p h o r e M u t e x 1 ;S e m a p h o r e C o i f f e u r s 0 ;I n t A tt e n t e = 0 ;

// C o i f f e u rv o i d c o i f f e u r ( ) {

w h i l e ( 1 ) {d o w n ( C l i e n t s ) ;

d o w n ( M u t e x ) ;

A tt e n t e = a tt e n t e – 1 ;

u p ( C o i f f e u r s ) ;

u p ( M u t e x ) ;

C o u p e r_ c h e v e u x ( ) ;}

}

Sl id e 35

Exercices

// C l i e n tv o i d c l i e n t ( ) {

d o w n ( M u t e x )

i f ( A tt e n t e < C h a i s e s ) {A tt e n t e = a tt e n t e + 1u p ( C l i e n t s )u p ( M u t e x )

d o w n ( C o i f f e u r s )O b t e n i r_ c o u p e

}

e l s e {u p ( M u t e x )

}}


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) ?

Sl id e 36

Exercices

P2 {procedure A2 ;Up(S1) ;Down(S2) ;procedure B2 ;

}

Semaphore S1 0Semaphore S2 0P1 {

procedure A1 ;Up(S2) ;Down(S1) ;procedure B1 ;

}


Ex4: 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§ 2 sémaphores et un compteur

Sl id e 37

Exercices

P2 {procedure A2 ;Up(S1) ;Down(S2) ;procedure B2 ;

}

Semaphore S1 0Semaphore S2 0P1 {

procedure A1 ;Up(S2) ;Down(S1) ;procedure B1 ;

}


Ex5: Dîner des Philosophes

• Cinq philosophes se trouvent autour d'une table ;• Chacun des philosophes a devant lui un plat de spaghetti ;• A gauche de chaque assiette se trouve une fourchette• Un philosophe n'a que trois états possibles :

§ penser pendant un temps indéterminé ;§ être affamé (pendant un temps déterminé et fini sinon i l y a famine) ;§ manger pendant un temps déterminé et fini .

• Des contraintes extérieures s'imposent à cette situation :§ quand un philosophe a faim, i l va se mettre dans l 'état « affamé » et attendre que les

fourchettes soient l ibres ;§ pour manger, un philosophe a besoin de deux fourchettes : celle qui se trouve à sa

droite, et celle qui se trouve à sa gauche ;§ si un philosophe n'arrive pas à s'emparer d'une fourchette, i l reste affamé pendant un

temps déterminé, en attendant de renouveler sa tentative.

• Le problème consiste à trouver un ordonnancement des philosophes tel qu'ils puissent tous manger, chacun à leur tour, sans provoquer d’interblocage!


Exercices

Ex5: Dîner des Philosophes

C o n s t i n t N = 5 ; //n b r d e p h i l o s o p h e s

S e m a p h o r e s [ N ] = { 0 , 0 , 0 , 0 , 0 } ;S e m a p h o r e M u t e x = 1 ; i n t e t a t [ N ] = { P E N S E , P E N S E , … } ;

// P h i l o s o p h e

v o i d p h i l o s o p h e ( i n t i ) {w h i l e ( 1 ) {

p e n s e r ( ) ;p r e n d r e _ f o u r c h e tt e s ( i ) ;m a n g e r ( ) ;p o s e r_ f o u r c h e tt e s ( i ) ;

}}


Exercicesv o i d p r e n d r e _ f o u r c h e t t e s ( i n t i ) {

d o w n ( m u t e x ) ;e t a t [ i ] = FA I M ;i f ( e t a t [ i + 1 % N ] = = M A N G E | | e t a t [ i - 1 % N ] = = M A N G E ) {

u p ( m u t e x ) ;d o w n ( s [ i ] ) ;

} e l s e {e t a t [ i ] = M A N G E ;u p ( m u t e x ) ;

}}

v o i d p o s e r_ f o u r c h e t t e s ( i n t i ) {d o w n ( m u t e x ) ;i f ( e t a t [ i + 1 % N ] = = FA I M & & e t a t [ i + 2 % N ] ! = M A N G E ) {

e t a t [ i + 1 % N ] = M A N G E ;u p ( s [ i + 1 % N ] ) ;

}i f ( e t a t [ i - 1 % N ] = = FA I M & & e t a t [ i - 2 % N ] ! = M A N G E ) {

e t a t [ i - 1 % N ] = M A N G E ;u p ( s [ i - 1 % N ] ) ;

}u p ( m u t e x ) ;

}

Références

Dr. Ghad a GASMI- Dr. L i l ia SFAXI S l id e 40

• Wassim Youssef, Les systèmes d’exploitation, Cours ISI, 2015

Technology

Systèmes d'Exploitation - chp6-synchronisation