Systèmes d'Exploitation - chp6-synchronisation

Synchronisation des Processus
Sections critiques, Sémaphores
Dr. Ghada GASMI- Dr. Lilia SFAXI Slide 1
Systèmes d’Exploitation
2ème Année (GL-RT-IIA-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
§ Il y a alors risque d’incohérence des données.

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 = 3
Pré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 = in
Entrée[next_free_slot] = fichier
in = 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é.
Slide 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. Ghada GASMI- Dr. Lilia 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 ACTIVE

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.
Slide 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.
Slide 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.
Slide 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 indivisibles
o (2) Ecrit 1 dans adresse mémoire LOCK // (TSL instruction atomique)
|pseudo-assembleur
entrer_Section_Critique:
TSL REGISTER, LOCK | copie lock dans reg et la définit à 1
CMP REGISTER, #0 | lock etait-elle à 0
JNE entrer_SC | si elle était pas à 0, boucle
RET | retourne à appelant, entre dans SC
quitter_Section_Critique:
MOVE LOCK, #0 | stocke un 0 dans lock
RET | 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
Slide 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 Il met sa variable interested à true
o Il attend si l’autre processus est intéressé
§ Problème d’interblocage
o Excès de courtoisie!
Slide 13
{
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).
Slide 14
#define FAUX 0
#define VRAI 1
#define N 2
int tour ; /* à qui le tour */
int interesse[N] ; /* initialisé à FAUX */
{
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
#define FALSE 0
#define N 10 /* First process is indicated with 1, not 0 */
int turn[N];
int stage[N + 1];
void enterRegion(int process)
{
int i, j;
for (i = 1; i <= N - 1; i++) {
stage[process] = i;
turn[i] = process;
for ( j = 1; j <= N; j++) {
if ( j == process)
continue;
while (stage[ j] >= i && turn[i] == process) ;
}
}
}
void leaveRegion(int
process)
{
stage[process] = FALSE;
}

EXCLUSION MUTUELLE SANS ATTENTE ACTIVE

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.
Slide 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.
Slide 18
Producteur
f1f2… f0 Tampon
Variable partagée compteur=3 Consommateur

Slide 19
#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(…) ;
}
}

• 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écanisme
o 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.
Slide 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 à 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 atomiques suivantes:
1. down(s) :
o if (val(s)==0) sleep();
o val(s)--;
2. up(s) :
o wakeup();
o s++;
Slide 21

Sémaphores
• Pour assurer l’exclusion mutuelle un sémaphore peut être programmé
de la manière suivante :
Slide 22
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

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.
Slide 23

Producteur/Consommateur avec Sémaphores
#define N 100 // taille du tampon
semaphore mutex 1 ; // contrôle d’accès section critique
semaphore vide N; // contrôle les emplacements vide
semaphore plein 0; // contrôle les emplacements plein
Slide 24
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(…) ;
}
}

EXERCICES

Ex1: Synchronisation et Ordonnancement
• Q1 : Round robin ( tourniquet) avec q=5ms
• Q2 : Round robin ( tourniquet) avec q=5ms +
Synchronisation Peterson
Slide 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
Durée
d’exécution
SR+SC
Date d’entrée en
section critique t=
P0 23 ms 3 ms
P1 17 ms 7 ms
P2 15 ms X
Prêt à
l’instant t=
Durée d’exécution en
section critique
P0 0 ms 13ms
P1 1 ms 10 ms
P2 2 ms X

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
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
Prêt à
l’instant t=
Durée
d’exécution
Date d’entrée en
section critique t=
section critique
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
• Peterson è Attente active
Exercices

• Sommeil et activation
Exercices
0 5
P0
P1
P2
10 15 20 22 27 32 37
40 42 47 5552
Prêt à
l’instant t=
Durée
d’exécution
Date d’entrée en
section critique t=
section critique
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
Slide 30
Exercices
Base de données

Semaphore mutex 1 // contrôle l’accés à nb_lect
Semaphore 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 actuellement à la BD
//lecteur
void lecture(){
while (true) { //boucle sans fin
lire_la_BD(); //accés à la BD
utiliser_données (); //Section restante
}
}
//redacteur
void ecriture(){
while (true) {
créer_données ();
ecrire_dans_la_BD
}
}
Slide 31
Exercices

Semaphore mutex 1 // contrôle l’accés à nb_lect
Semaphore 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
// actuellement à la BD
//lecteur
void lecture(){
down (mutex); // la modif de la var. partagée nb_lect
nb_lect ++; // est une 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
}
}
Slide 32
Exercices
void ecriture(){
créer_données (); //Sec.Rest.
down (db);
ecrire_dans_la_BD(); //accés BD
up (db);
}
}

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.
Slide 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’il 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
Slide 34
Exercices

Semaphore Clients 0;
Semaphore Mutex 1;
Semaphore Coiffeurs 0;
Int Attente = 0 ;
//Coiffeur
void coiffeur() {
while(1){
down(Clients);
down(Mutex);
Attente = attente – 1;
up(Coiffeurs);
up(Mutex);
Couper_cheveux();
}
}
Slide 35
Exercices
//Client
void client() {
down(Mutex)
if (Attente < Chaises) {
Attente = attente + 1
up(Clients)
up(Mutex)
down(Coiffeurs)
Obtenir_coupe
}
else{
up(Mutex)
}
}

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) ?
Slide 36
Exercices
P2 {
procedure A2 ;
Up(S1) ;
Down(S2) ;
procedure B2 ;
}
Semaphore S1 0
Semaphore S2 0
P1 {
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
Slide 37
Exercices
P2 {
procedure A2 ;
Up(S1) ;
Down(S2) ;
procedure B2 ;
}
Semaphore S1 0
Semaphore S2 0
P1 {
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 il y a famine) ;
§ manger pendant un temps déterminé et fini.
• Des contraintes extérieures s'imposent à cette situation :
§ quand un philosophe a faim, il va se mettre dans l'état « affamé » et attendre que les
fourchettes soient libres ;
§ 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, il 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
Const int N = 5; //nbr de
philosophes
Semaphore s[N]={0,0,0,0,0};
Semaphore Mutex=1;
int etat[N]= {PENSE,PENSE,…} ;
//Philosophe
void philosophe(int i) {
while(1){
penser();
prendre_fourchettes(i);
manger();
poser_fourchettes(i);
}
}
Exercices
vo i d p re n d re _fo u rch ette s ( i n t i ) {
d ow n (m u tex) ;
et at [ i ] = FA I M ;
i f (et at [ i + 1 % N] = = M A NGE | | et at [ i - 1 % N] = = M A NGE ) {
u p (m u tex) ;
d ow n ( s [ i ]) ;
} e l s e {
et at [ i ] = M A NGE ;
u p (m u tex) ;
}
}
vo i d p o s e r_fo u rch ette s ( i n t i ) {
d ow n (m u tex) ;
i f (et at [ i + 1 % N] = = FA I M & & et at [ i + 2 % N] ! = M A NGE ) {
et at [ i + 1 % N] = M A NGE ;
u p ( s [ i + 1 % N ]) ;
}
i f (et at [ i - 1 % N] = = FA I M & & et at [ i - 2 % N] ! = M A NGE ) {
et at [ i - 1 % N] = M A NGE ;
u p ( s [ i - 1 % N]) ;
}
u p (m u tex) ;
}

Références
• Wassim Youssef, Les systèmes d’exploitation, Cours ISI, 2015

Systèmes d'Exploitation - chp6-synchronisation

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Más de Lilia Sfaxi

Más de Lilia Sfaxi (20)

Systèmes d'Exploitation - chp6-synchronisation