Université Aboubekr BELKAID

‫كلية العلوم – تيجاني هدام‬

Faculté des Sciences – Tidjani HAddam
‫قسم اإلعالم اآللي‬
Département d’informatique

Chapitre N°4: synchronisation par

moniteur

Mr BENAISSA Mohamed

E-mail : benaissa_samir@yahoo.fr

Année universitaire 2020-2021

1
 Université Aboubekr BELKAID
‫كلية العلوم – تيجاني هدام‬
Faculté des Sciences – Tidjani HAddam
‫قسم اإلعالم اآللي‬
Département d’informatique

synchronisation par moniteur

Introduction aux concepts du moniteur

Propriétés d’un moniteur

Primitives d’un moniteur

Structure principale d’un moniteur

Problème de producteur consommateur

Problème de lecteur rédacteur

2
Introduction aux Concepts du moniteur

• Permet de résoudre le problème de synchronisation des processus.

• Permet de regrouper des variables ainsi que les procédures agissant sur
ces variables
• Assure l’exclusion mutuelle sur les procédures du moniteur

• Synchronisation assurée par des primitives :

wait(x: condition)
signal(x: condition)

3
Les moniteurs

• Ils sont définis par :

– des données internes (appelées aussi variables d'état partagées)

– des primitives d'accès aux moniteurs et des procédures(points d'entrée)
– une ou plusieurs files d'attentes

4
 Structure d’un moniteur

Moniteur : nom-moniteur
//déclaration des varibles partagées
Schéma de moniteur
Procédure entrer P1()
Debut

Fin

Procédure entrer P2
Debut

Fin
Procédure entrer Pn
Debut

Fin

debut
Initialisation des variables
fin
5
 Propriétés d’un moniteur

• L’accès aux procédures du moniteur se fait en exclusion mutuelle.

• Le moniteur tout entier est implémenté comme une section critique.

• Un seul processus peut être actif à la fois dans un moniteur.

• les variables de type condition sont utilisés pour la synchronisation entre les
processus

6
Primitives d’un moniteur

Les variables conditions

• Une variable condition : est une variable

- qui est définie à l’aide du type condition;

- qui a un identificateur mais, qui n'a pas de valeur (contrairement à un
sémaphore).

• Une condition
- ne doit pas être initialisée
- ne peut être manipulée que par les primitives Wait() et Signal().
- est représentée par une file d'attente de processus bloqués .

Remarque

Chaque variable condition représente une file d'attente.

7
Primitives d’un moniteur

• La primitive Wait ( x : condition )

bloque automatiquement le processus qui l'exécute.

• La primitive Signal (x: condition)

réveille un processus de la file d'attente de la condition spécifiée, si cette file
d'attente n'est pas vide; sinon elle ne fait absolument rien.

syntaxe
Wait( x: condition ) ;
Signal(x: condition);

x est un variable de type condition déclarée comme variable locale

x exprime une file d’attente

• La fonction Empty (c:codition) : booléen : teste si la file d'attente

associée à une condition x est vide ou non.

Si la fonction empty() retourne vrai => la file d’attente est vide

Sinon la file d’attente contient des processus. 8
Exemple : gestion l’accès à un ressource critique

Moniteur R-C
Var occupé : booléen
x : condition

Procédure entrer
Début
si occupé allors wait(x);
(sinon implicite)
occupé : = vrai;
Fin
Procédure sortie Processus Pi

Début Début
occupé := faux; Appel procédure d’un moniteur
signale(x); R-c.entrer;
Fin < section critique>
R-c.sortie;
Début
Occupé := faux; (initialisation) fin
Fin
9
problème de producteur consommateur par moniteur

Les sections critiques du problème du producteur et du consommateur sont

les opérations de dépôt et de retrait du tampon partagé.

Moniteur prod-cons Procédure consommation( v: message)

Var cpt : entier; Début

prod, cons : condition; Si cpt = 0 alors wait(cons)

Procédure production( v: message) Cpt = cpt - 1;

retirer (v);
Début Signale (prod);
Si cpt = N alors wait(prod)
fin
Cpt = cpt + 1;
Déposer (v);
Début
Signale (cons);
Cpt:= 0 (initialisation le tampon est vide)
fin
fin
10
Appel les procédures de moniteur

Processus producteur Processus consommateur

Var m : message Var m : message

Debut Debut

Produire(m); Prod-cons.consommation(m);
Prod-cons.production(m); Consommer(m);

fin fin

11
problème de lecteur/rédacteur par moniteur

Contraintes de problème lecteur/rédacteur

1- à la fin d’une écriture, le lecteur sont prioritaire par rapport aux rédacteurs.

2- lorsque un lecteur est en cours d’éxecution, et qu’il y a des rédacteurs en

attendre alors tout les nouveaux lecteurs arrivant doivent attendre.

Processus lecteur Processus rédacteur

Demande de lecture Demande d’écriture

<lire le fichier> <écrire dans le fichier>

Fin de lecture Fin d’écriture

12
Moniteur lecteur-rédacteur

Var
écriture: booléen;
Red, lect : condition;
nl : entier (compter le nombre de processus lecteur)

Procédure demande lecture

Début
Si ( (écriture) ou (not empty(red)) )alors wait(lect);

nl : = nl + 1;

Signale(lect);

fin

13
Procedure fin-lecture

Debut

nl:= nl – 1;
Si nl = 0 alors signale (red);

fin

Procedure fin-écriture
Procedure demande écriture
Debut
Debut Écriture := faux;
si (écriture) ou (nl >0) alors wait(red); Si not empty (lect) alors signale (lect)
Ecriture := vrai; else signale (red);
fin
fin

14
 Fonctions Posix sur les moniteurs

Fonction Description

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)

Initialisation d’une variable condition 

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

Attente sur la variable  wait(condition)

pthread_cond_signal(pthread_cond_t *cond)
Réveil potentiel d’un thread  signale(condition)

15
 Université Aboubekr BELKAID
‫كلية العلوم – تيجاني هدام‬
Faculté des Sciences – Tidjani HAddam
‫قسم اإلعالم اآللي‬
Département d’informatique

Mr BENAISSA Mohamed

E-mail : benaissa_samir@yahoo.fr

Année universitaire 2021-2021

16