Chapitre 02

Centre Universitaire de Mila
3 ème année licence LMD Informatique
Module : Systèmes d'exploitation 2
Bessouf Hakim
CHAPITRE 2:
Synchronisation des processus
• Problème de l’exclusion mutuelle

• Synchronisation
• Événements, Verrous
• Sémaphores
• Moniteurs
• Régions critiques.
• Expressions de chemins
Introduction
• Dans certain systèmes informatiques plusieurs processus (threads)
peuvent partager des ressources communes (fichiers, mémoire ..etc)
où chaque processus peut éventuellement lire et écrire. Ces
processus s'exécutent d'une manière concurrente et peuvent accéder
simultanément aux ressources.
• L'accès simultané au ressources peut engendrer des incohérences
dans le système. L'objectif de la synchronisation des processus et
justement d'éviter ces incohérences en utilisant différents
mécanismes de synchronisation.
Introduction
Exemple:
• Dans un système de réservation de billets d'avions. Chaque agence qui veut
réserver un billet d’avions va exécuter le programmes suivant:
-Vérifier si il y a des places libres (Si Nbr_places< max)
-Réserver une places (nbr_places ← nbr_places -1)
On suppose qu'il ne reste qu'une seule place à réserver. Si deux agences
consultent le nombre de places en même temps , les deux agences vont
chacune réserver un billet, on vas donc dépasser le nombre de places
maximale dans l'avion. La variable nbr_places est donc une ressource
critique qui doit être géré avec précautions.
Problème de l’exclusion mutuelle
• Il faut trouver des mécanismes pour interdire que plusieurs processus
lisent ou écrivent simultanément des données partagés.
• L'exclusion mutuelle est une méthode qui permet de garantir qu'un
seule processus à la fois peut lire ou écrire les données partagés.
• Les parties de programme ou on accède a des données ou des
ressources partagées (ressources critiques) est appelé section
critique.
• Si un processus entre dans sa section critique aucun autre processus
ne peut entrer jusqu’à ce qu’il sort de sa section critique. ceci va
permettre d'éviter les problèmes de la concurrence
• Chaque processus qui veut entrer dans
sa section critique doit exécuter un
protocole d'entrée qui permet de
vérifier si la section critique n'est pas
réservée. Si elle n'est pas libre il se
bloque en attendant sa libération.
• Chaque processus qui termine
l'exécution de sa section critique doit
exécuter un protocole de sortie pour
libérer la section critique et permettre
au autres processus d'entrer dans leurs
sections critiques
• La solution proposés pour la section critique doit respecter les conditions
suivantes [ref : « Systèmes d'exploitation » Andrew Tanenbaum] :
1. Exclusion mutuelle: Deux processus ne doivent pas se trouver
simultanément dans leurs SC.
2. Aucune supposition: Il ne faut pas faire des supposition sur la vitesse
d'exécution des processus ou le nombre de processus.
3. Pas d’interblocage: Aucun processus qui se trouve à l'extérieur de sa SC
ne peut bloquer les autres processus.
4. Pas de famine: On doit garantir qu'un processus qui demande d'entrée
en SC doit pouvoir y enter dans un temps fini. La famine se produit
lorsque la solution proposé n'est pas équitable.
Solutions pour l'exclusion mutuelle (section critique)
[ref : « Système d'exploitation mécanismes de base » ,Dr Belkhir
Abdelkader, « Systèmes d'exploitation » Andrew tanenbaum ]
Les solution pour l'exclusion mutuelle peuvent être classées en deux grandes
catégories :
Les solutions basées sur l'attente active : dans ce cas les processus qui
attendent d'entrer en SC reste en exécution et vérifies à chaque fois si la SC
est libre ou non. Ces solution peuvent être logiciels ou matériels.
Les solutions basées sur l'attente passive : dans ce cas les processus qui
attendent d'entrer en SC sont mis dans un état bloqué (le processeur est
libéré) , ils seront réveillés lorsque la section critique deviens libre.
Ces solutions utilise des concepts évolués comme les sémaphores, les région
critiques, et les moniteurs.
Solutions pour l'exclusion mutuelle (section critique)
• Les algorithmes qui suivent cherchent a réaliser l'exclusion mutuelle

entre deux processus Pi et Pj.
• Les algorithmes sont donnés pour le processus Pi.
Solutions logiciels basées sur l'attente active
• «Vide=vrai»=>
pas de processus dans SC
• «Vide = faux» =>
 un processus dans SC
Algorithme 1 (variable verrou)
Processus Pi Processus Pj
Répétez Répétez
 Tant que (vide = faux) faire  Tant que (vide = faux) faire
/*ne rien faire*/ vide = faux /*ne rien faire*/
FinTantque; FinTantque;
vide = faux; vide = faux;
section critique section critique
vide = vrai; vide = vrai;
section non critique section non critique
Jusqu'à (faux) ; Jusqu'à (faux) ;
Répétez Répétez
 Tant que (vide = faux) faire  Tant que (vide = faux) faire
/*ne rien faire*/ vide = vrai /*ne rien faire*/
Répétez Répétez
Tant que (vide = faux) faire Tant que (vide = faux) faire
 vide = faux;  vide = faux;
Répétez Répétez
Tant que (vide = faux) faire Tant que (vide = faux) faire
 section critique  section critique
• Cette solution n'assure pas
l'exclusion mutuelle, il se peut
que deux processus lisent la
variable vide en même temps
et entre tous les deux en SC
«turn = i» =>
processus Pi peut entrer dans SC
- «turn = j» =>
- processus Pj peut entrer dans SC
Algorithme 2 (alternance stricte)
Répétez Répétez
 Tantque (turn ≠ i) faire turn= j  Tantque (turn ≠ j) faire
/*ne rien faire*/ /*ne rien faire*/
turn = j; turn = i;
Répétez Répétez
 Tantque (turn ≠ i) faire turn= j Tantque (turn ≠ j) faire
section critique  section critique
turn = j; turn = i;
Répétez Répétez
 Tantque (turn ≠ i) faire turn= i Tantque (turn ≠ j) faire
turn = j;  turn = i;
Répétez Répétez
Tantque (turn ≠ i) faire turn= i Tantque (turn ≠ j) faire
 section critique section critique
turn = j; turn = i;
section non critique  section non critique
Cette solution garantie l'exclusion
mutuelle mais il se peut qu'un
processus reste bloqué même si la
SC n'est pas occupé (interblocage)
puisque dans cette solution les
processus sont obligés de
s'exécuter en alternance stricte.
• « flag » est un vecteur booléen
dont les cases sont initialisées à
faux.
• «flag[ i ] = vrai » =>
le processus Pi exécute la SC
• «flag[ j ] = vrai » =>
le processus Pj exécute la SC
Algorithme 3
Répétez flag Répétez
 Tantque (flag[ j ]=vrai) i faux  Tantque (flag[ i ]=vrai)
faire /*ne rien faire*/ faire /*ne rien faire*/
FinTantque;
j faux FinTantque;
flag[ i ] = vrai ; flag[ j ] = vrai ;
flag[ i ] = faux ; flag[ j ] = faux ;
Algorithme 3
Tantque (flag[ j ]=vrai) i vrai Tantque (flag[ i ]=vrai)
FinTantque;
j vrai FinTantque;
 flag[ i ] = vrai ;  flag[ j ] = vrai ;
Algorithme 3
Tantque (flag[ j ]=vrai) i vrai Tantque (flag[ i ]=vrai)
FinTantque;
j vrai FinTantque;
 section critique  section critique
• Cette solution n'assure pas
l'exclusion mutuelle, il se peut
que deux processus lisent la
variable flag en même temps et
entrent tous les deux en SC
• «flag[i ] = vrai » =>
le processus Pi désire exécuter SC,
• «flag[j ] = vrai » =>
• le processus Pj désire exécuter
SC
Algorithme 4
flag[ i ] = vrai ; i faux flag[ j ] = vrai ;
Tantque (flag[ j ] =vrai) Tantque (flag[ i ] =vrai)
faire /*ne rien faire*/
j faux faire /*ne rien faire*/
Algorithme 4
 flag[ i ] = vrai ; i vrai  flag[ j ] = vrai ;
Tantque (flag[ j ] =vrai) Tantque (flag[ i ] =vrai)
j vrai faire /*ne rien faire*/
Algorithme 4
flag[ i ] = vrai ; i vrai flag[ j ] = vrai ;
 Tantque (flag[ j ] =vrai)  Tantque (flag[ i ] =vrai)
j vrai faire /*ne rien faire*/
• Cette solution garantie
l'exclusion mutuelle mais peut
faire en sorte qu'il n'y a aucun
processus en SC (interblocage)
et cela si les deux processus
initialisent le flag à vrai en
même temps.
• «flag[i ] = vrai » =>
processus Pi désire exécuter SC,
• «flag[j ] = vrai » =>
processus Pj désire exécuter SC,
Algorithme 5
Répétez Répétez
flag [ i ] = vrai ; flag flag [ j ] = vrai ;
Tantque (flag[ j ] = vrai) faire Tantque (flag[ i ] = vrai) faire
flag[ i ] = faux ; i faux flag[ j ] = faux ;
Tantque (flag[ j ]=vrai) faire j faux Tantque (flag[ i ]=vrai) faire
FinTantque ; FinTantque ;
Algorithme 5
Répétez Répétez
 flag [ i ] = vrai ; flag  flag [ j ] = vrai ;
flag[ i ] = faux ; i vrai flag[ j ] = faux ;
Tantque (flag[ j ]=vrai) faire j vrai Tantque (flag[ i ]=vrai) faire
Algorithme 5
Répétez Répétez
 Tantque (flag[ j ] = vrai) faire  Tantque (flag[ i ] = vrai) faire
Algorithme 5
Répétez Répétez
 flag[ i ] = faux ; i faux  flag[ j ] = faux ;
Tantque (flag[ j ]=vrai) faire j faux Tantque (flag[ i ]=vrai) faire
Algorithme 5
Répétez Répétez
flag[ i ] = faux ; i faux flag[ j ] = faux ;
 Tantque (flag[ j ]=vrai) faire j faux  Tantque (flag[ i ]=vrai) faire
Algorithme 5
Répétez Répétez
 flag[ i ] = vrai ;  flag[ j ] = vrai ;
Algorithme 5
Répétez Répétez
• Cette solution peut faire en
sorte qu'il n'y a aucun processus
en SC (interblocage).
Algorithme 6 (Solution de DEKKER 1965)
Répétez Répétez
flag [ i ] = vrai ; flag [ j ] = vrai ;
Si (turn =j) alors flag Si (turn =i) alors
flag[ i ] = faux; flag[ j ] = faux;
FinSi
i faux FinSi
Tantque (turn = j) faire j faux Tantque (turn = i) faire
flag[ i ] = vrai ; turn= j flag[ j ] = vrai ;
turn = j ; turn = i ;
flag [ i ] = faux ; flag [ j ] = faux ;
Répétez Répétez
 flag [ i ] = vrai ;  flag [ j ] = vrai ;
FinSi
i vrai FinSi
Tantque (turn = j) faire j vrai Tantque (turn = i) faire
Répétez Répétez
FinSi
i vrai FinSi
Répétez Répétez
 flag[ i ] = faux; flag[ j ] = faux;
FinSi
i faux FinSi
flag[ i ] = vrai ; turn= j  flag[ j ] = vrai ;
Répétez Répétez
FinSi
i faux FinSi
 Tantque (turn = j) faire j vrai Tantque (turn = i) faire
Répétez Répétez
FinSi
i vrai FinSi
 flag[ i ] = vrai ; turn= i flag[ j ] = vrai ;
turn = j ;  turn = i ;
Répétez Répétez
 Tantque (flag[ j ] = vrai) faire Tantque (flag[ i ] = vrai) faire
FinSi
i vrai FinSi
Tantque (turn = j) faire j faux Tantque (turn = i) faire
flag[ i ] = vrai ; turn= i flag[ j ] = vrai ;
flag [ i ] = faux ;  flag [ j ] = faux ;
Répétez Répétez
FinSi
i vrai FinSi
flag[ i ] = vrai ; turn= i flag[ j ] = vrai ;
section non critique  section non critique
• Cette solution assure l'exclusion
mutuelle, et ne provoque pas
d'interblocage des processus.
• Même si deux processus veulent
entrer en section critique en
même temps la variable «turn»
va les dissocier.
Algorithme 6 (Solution de PETERSON : 1981)
Répétez Répétez

turn = i ; turn = j ;
i faux
Tantque (turn = i) et Tantque (turn = j) et
(flag[ j ]=vrai) faire j faux (flag[ i ]=vrai) faire
FinTantque; turn= i FinTantque;
flag [ i ] = faux; flag [ j ] = faux;

Répétez Répétez
 flag [ i ] = vrai ; flag  flag [ j ] = vrai ;

i vrai
(flag[ j ]=vrai) faire j vrai (flag[ i ]=vrai) faire
FinTantque; turn= i FinTantque;

Répétez Répétez

 turn = i ;  turn = j ;
i vrai
FinTantque; turn= j FinTantque;

Répétez Répétez

i vrai
 Tantque (turn = i) et  Tantque (turn = j) et

Répétez Répétez

i vrai
Tantque (turn = i) et  Tantque (turn = j) et

Répétez Répétez

i faux
 flag [ i ] = faux; flag [ j ] = faux;

• Cette solution assure l'exclusion
mutuelle, et ne provoque pas
d'interblocage.
• Même si deux processus arrivent en
même temps c'est le premier qui a
initialisé la valeur de turn qui entre
en section critique, puisque turn
prend une seule valeur a la fin du
protocole d'entré en SC soit i soit j
Algorithme 8 (algorithme de la
boulangerie, Leslie Lamport, 1974)
Cette algorithme s'inspire de la façon
dont on gère une boulangerie,
Chaque client qui veut acheter du pain
va prendre un ticket contenant sont
numéro (le numéro maximum + 1)
puis attend son tour pour être servis.
Le tableau NUM_TICKET est initialisé a
0, et le tableau PRENDRE_TICKET est
initialisé a faux. « i » est l'identifiant
du processus qui veut entré en SC.
Solutions matériels basées sur le masquage des interruptions
• Cette méthode peut être utilisé seulement dans le cas des machines
avec un seul processeur. Elle consiste à masquer les interruptions
avant d'entrer en SC puis de les démasquer après l'exécution de la SC.
• Problèmes:
- si un processus se bloque dans sa SC tous le système sera affecté.
- elle ne peut pas être utilisé dans les machine multiprocesseurs.
Solutions matériels basées sur des instruction indivisibles
L'instruction Test_and_set (TAS ou TSL)

C'est une instruction indivisible (elle
s'exécute complètement et ne peut pas
être interrompu) qui prend en
paramètre un booléen. Elle fonctionne
comme suit :
lock est initialisé à faux : aucun
processus n'exécute la section critique.
Pour réaliser l'exclusion mutuelle on
utilise la variable lock comme suit :
Fonction Test_and_Set (var lock:booléen): Processus Pi

booléen  Tantque (TAS(lock) = vrai)
faire
b : booléen ; /*ne rien faire*/
Début FinTantque
 b ← lock ; section critique
lock = faux ;
lock ← vrai ;
section non critique
retourner(b);
Fin ;
TAS =
lock = faux
b = faux

faire
Début FinTantque
b ← lock ; section critique
lock = faux ;
 lock ← vrai ;
retourner(b);
Fin ;
TAS =
lock = vrai
b = faux

booléen Tantque (TAS(lock) = vrai)
faire
Début FinTantque
b ← lock ;  section critique
lock = faux ;
lock ← vrai ;
 retourner(b);
Fin ;
TAS = faux
lock = vrai
b = faux
Fonction Test_and_Set (var lock:booléen): Processus Pj

faire
Début FinTantque
 b ← lock ; section critique
lock = faux ;
lock ← vrai ;
retourner(b);
Fin ;
TAS =
lock = vrai
b = vrai

faire
Début FinTantque
lock = faux ;
 lock ← vrai ;
retourner(b);
Fin ;
TAS =
lock = vrai
b = vrai

faire
Début FinTantque
lock = faux ;
lock ← vrai ;
 retourner(b);
Fin ;
TAS = vrai
lock = vrai
b = vrai
L'instruction SWAP:
Une instruction indivisible qui
permute deux variable données en
paramètre, elle s'exécute comme suit:
Pour effectuer l'exclusion mutuelle on
utilise deux variables, Une variable
globale lock initialisé a faux et une
variable locale key pour chaque
processus. Les deux variables sont
utilisés comme suit :
• Les solutions logiciels et matériels basé sur l'attente active vu
précédemment, malgré elles fonctionnes, elle sont inefficaces, un
processus ne pouvant pas entrer en SC va rester en exécution et
utilise l'unité centrale inutilement, et ralenti aussi l'accès à la
mémoire à cause des accès répétés aux variables de synchronisation.
• D'autre solutions plus efficaces au problème de l'exclusion mutuelle
qui sont basées sur l'attente passive seront présentées dans les
sections suivantes.
Solutions basées sur l’attente passive (verrou)
• Ces solution permettent de libérer le processeur quand les processus sont
bloqués, parmi ces solutions on cite : les verrous, les sémaphores, les
régions critiques et les moniteurs.
- Les verrous:
• Des structures de données partagées par le système d’exploitation.
• Un verrou est représenté par une variable booléenne «libre» et une file
d'attente des processus.
• Au début la variable libre est initialisé à vrai et la file d’attente des
processus est vide.
• On peut accéder a un verrou seulement en utilisant les deux
opérations indivisibles (deux primitives) « prendre » et « libérer » qui
sont implémentés comme suit :
• Pour réaliser l’exclusion mutuel a l’aide d’un verrou on procède
comme suit :
Solutions basées sur l’attente passive (sémaphore)
• Les sémaphores sont des outils qui permettent de mettre en œuvre
des problème de synchronisation complexes. Un sémaphore est
représenté par une variable entière « value » et une file d'attente des
processus . On peut accéder à la variable entière S.value seulement
en utilisant les deux opérations indivisibles (deux primitives) Wait : P
et Signal : V
Solutions basées sur l’attente passive (sémaphore)
• La valeur (s.value) d’un sémaphore est initialisé à 0 ou à une valeur
positive.
• La file d’attente des processus est initialement vide.
• Pour mettre en œuvre des problèmes de synchronisation on peut
utiliser plusieurs sémaphores à la fois.
Remarque importante :
• Pour implémenter les sémaphores et les verrous dans les machines
monoprocesseurs ont peut utiliser le masquage des interruptions, par
contre dans les machines multiprocesseurs le masquage des
interruptions n’est pas approprié , des solutions matériels comme les
instruction SWAP et TAS sont donc nécessaire
Exclusion mutuel par sémaphore
• Pour réaliser l'exclusion mutuel entre n processus on peut utiliser un
sémaphore (appelé généralement mutex) initialisé à 1
• Le programme d'un processus Pi est comme suit :
Précédence des tâches par sémaphores
• Les sémaphores peuvent être utilisés pour synchroniser les systèmes
de tâches.
• On considère un système de tâche composé de deux tache T1 et T2.
T1 doit être exécuté avant T2. Ce système peut être synchronisé par
un sémaphore S initialisé à 0. Le système sera composé de deux
processus (un processus pour chaque tâche). Les deux processus sont
comme suit :
Précédence des tâches par sémaphores
• Exemple : On veut réaliser le système de tâche
représenté par le graphe de précédence suivant :
• Pour mettre en œuvre ce système on utilise 6
sémaphore S2,S2,S3,S4,S5,S6 tous initialisés à 0. Le
système sera composé de 6 processus comme suit:
Coopération entre N processus(sémaphore)
• Les sémaphores peuvent être utilisé pour faire en sorte qu'un nombre
précis de processus seulement coopèrent ensemble.
Exemple (parking)
• On suppose qu'on a N emplacements au parking,
• N conducteur seulement peuvent stationner leurs voitures.
• On peut régler ce problème en utilisant les sémaphores.
Coopération entre N processus(sémaphore)
- Chaque voiture est représenté par un processus
- On utilise une variable sémaphore appelé «parking» initialisée à N.
• Pour entrer dans le parking chaque processus exécute le protocole
suivant :
Rendez-vous entre deux processus (sémaphore)
• On peut établir un point de synchronisation (rendezvous) entre deux
processus. Pour cela on utilise deux sémaphores, un pour chaque
processus:
• On utilise deux variables sémaphore S1 et S2 initialisées à 0.
Modèle producteur/consommateur (sémaphore)
• Un processus Producteur • Première solution: utilisation d'un
crée à chaque fois un sémaphore d'exclusion mutuel
messages, le place dans une initialisé à 1
variable tampon, et un
processus Consommateur
récupère le message et le
traite.
• Un processus Producteur • Deuxième solution: utilisation de
crée à chaque fois un deux sémaphores, s_vide initialisé à 1
messages, le place dans une pour vérifier si le tampon est vide et
variable tampon, et un s_plein initialisé à 0 pour vérifier si le
processus Consommateur tampon est plein.
récupère le message et le
traite.
• Cas tampon de N
emplacement:
Un sémaphore s_vide
initialisé à N
Un sémaphore s_plein
initialisé à 0
Une variable i initialisé a 0
Une variable j initialisé a 0
• Cas M producteurs , K consommateurs et un tampon de N emplacement
• mutex1 et mutex2 pour garantir
qu'un seul producteur à la fois
accède à la variable « i » et qu'un
seul consommateur à la fois accède
à la variable « j ».
• Un sémaphore s_vide initialisé à N
• Un sémaphore s_plein initialisé à 0
• Un sémaphore mutex1 initialisé à 1
• Un sémaphore mutex2 initialisé à 1
• Une variable i initialisé à 0
• Une variable j initialisé à 0
Modèle du Lecteur / Rédacteur
• Dans ce modèle plusieurs processus veulent accéder à une ressource
commune. Un exemple d'utilisation est l'accès à un fichier partagé.
Plusieurs lecteurs peuvent accéder simultanément au fichier puisque la
lecture ne modifie pas les données, mais un seul rédacteur à la fois peut
accéder au fichier.
• Pour lire le fichier, un lecteur exécute la fonction Lire_fichier() ;
• Pour écrie dans le fichier, un rédacteur exécute la fonction Ecrire_fichier() ;
• On utilise une variable nbr_lec pour déterminer le nombre de lecteurs
utilisant le fichier à un instant données et deux sémaphores : mutex pour
garantir l'exclusion mutuel de la variable « nbr_lec » et S_fichier pour
déterminer si le fichier est libre ou non.
Modèle du Lecteur / Rédacteur
Les régions critiques
• Les programme basé sur les sémaphore sont très difficile à corriger, la
détection des erreurs dans le programme est très difficile.
• Des programme qui sembles correctes donnes parfois des résultats
imprévisibles qui sont inacceptable.
• Les régions critique sont un moyen de programmation qui facilite
l'utilisation des variables partagés.
• Les variables partagés sont déclarés par un mot clé shared et la partie
du code ou on utilise ces variables (section critique) est déclaré en
utilisant le mot clé region
Les régions critiques
• Seulement un processus à la fois peut exécuter la partie
region, l'exclusion mutuel dans une région est garantie.
• En utilisant une programmation structuré les erreurs
de programmation peuvent être détectés par les
compilateurs.
• Les région critiques sont réalisées en utilisant des
sémaphores mutex d'exclusion mutuel.
• Les appels P(mutex) avant d'exécuter la region critique
et V(mutex) après l'exécution de la region critique
seront automatiquement générés par le compilateurs.
• L'inconvénient des régions critique est qu'il sont limités
et ne permettent pas de réaliser des synchronisation
complexe.
Les moniteurs
• les moniteurs sont une amélioration des
régions critique. Un moniteur peut être
vu comme une classe qui rassemble à la
fois les données partagés et le code pour
accéder à ces données (section critique).
• A un instant donnée un seul processus
peut être actif dans le moniteur (un seul
processus à la fois exécute les procédures
du moniteur). L'exclusion mutuelle à
l’intérieur du moniteur est donc garantie.
Les moniteurs
• En utilisant les moniteur un seul
client à la fois peut mettre à jour le
solde du compte. La cohérence des
données est donc assuré.
• Le moniteur peut suspendre
l'exécution d'un processus et le
mettre dans une file d'attente si un
autre processus exécute une
procédure du moniteur.
Les variables conditions(Moniteur)
• L'exclusion mutuelle dans le moniteur n'est pas suffisante, on a
besoin d'un mécanisme qui permet de bloquer et débloquer les
processus. Par exemple si on veut traiter le problème du
producteur/consommateur on a besoin d'un mécanisme pour
suspendre les producteurs si le tampon et plein et aussi pour
suspendre les consommateurs si le tampon et vide.
• Dans les moniteurs on peut déclarer des variables spéciales appelés
variables conditions. Ces variables n'ont pas de valeurs et ne sont pas
initialisées, ils ont deux opération permises wait et signal.
Les variables conditions(Moniteur)
• L'opération wait suspend l'exécution du processus appelant et le met
dans une file d'attente des processus suspendus.
• L'opération signal réveil un processus suspendu de la file d'attente.
• s'il n' y a aucun processus dans la file l'opération signal n'a aucun
effet à l'inverse de la primitive V (s) des sémaphore qui enregistre
l'appel en ajoutant 1 au sémaphore.
producteurs/consommateurs
avec un tampon de N cases.
• Remarque importante:
• Une question se pose lorsque un
processus P éveil un autre processus Q
dans le moniteurs en exécutant une
instruction signal, on aura donc deux
processus dans le moniteurs (P et Q) mais
un seul doit pouvoir s'exécuter.
• On a donc deux possibilité :
• 1) P attend que Q quitte le moniteur (ou
se bloc dans une autre condition),
• 2) Q attend que P quitte le moniteur (ou
se bloc dans une autre condition).
Les moniteurs
• La première alternative (Q attend P) semble raisonnable puisque P est
déjà en exécution, mais dans ce cas la condition pour laquelle on a
réveillé Q peut changer, la deuxième solution semble donc plus
approprié.
• par la suite on va faire en sorte qu'un processus réveil un autre
processus à la fin de son exécution ou lorsque il vas se bloquer dans
une condition.
Les moniteurs
• Pour implémenter les moniteurs on utilise les sémaphores comme suit :
1) On utilise un sémaphore mutex initialisé à 1 qui permet de garantir l'exclusion
mutuelle pour l'accès aux procédures du moniteur. On ajoute à chaque
procédure du moniteur un P(mutex) au début et un V(mutex) à la fin,
2) Pour chaque variable condition C on associe un sémaphore SC initialisé à 0
pour suspendre les processus qui exécutent un wait d'une condition et libérer
ces processus quant on exécute un signal, on lui associe aussi un entier nbr_C
pour compter le nombre de processus bloqués dans la condition C.
3) Un autre sémaphore SM (sémaphore moniteur) initialisé à 0 pour suspendre
les processus dans le moniteur après l'exécution d'un signal, Ainsi qu'un entier
nbr_SM pour compter le nombre de processus bloqués dans le sémaphore SM.
Les moniteurs
• Une procédure du moniteur est implémenté comme suit:
Les moniteurs
• Une condition est déclaré comme suit :
• Un wait est implémenté comme suit :

Les moniteurs
• Un signal est implémenté comme suit :
La structure générale d’un moniteur. X et Y sont des variables condition
(ref : OPERATING SYSTEMS PROCESS SYNCHRONIZATION , Jerry Breecher).
Les expressions de chemins
(Ref : « The specification of process synchronization by path expressions » R.H
Campbell et A.N Heibermann university of Newcastle 1974 )
• Les expressions de chemin permettent de spécifier tout les besoins de
la synchronisation d'un ensemble d'opération d'une classe en un seul
endroit. C'est au compilateur de synchroniser chaque opération selon
la spécification d'un programmeur en déclarant des sémaphores et en
ajoutant des P et des V au début et a la fins des opérations. Une
expression de chemin s'écrit comme suit :
PATH expression END;
• Une expression contient les noms des opérations et les opérateurs de
chemin. les opérateurs de chemin sont : « , ; { } ».
Selection ,
Sequence ;
Exécution simultané { }
a , b : Veut dire que le système peut exécuter
a , soit b.
a ; b : veut dire que pour exécuter b ont doit d'abord exécuter a
(séquence),
{expression} : On peut avoir un nombre illimité d’exécution
concurrentes de l'expression.
• Exemple:
• PATH write END; A un instant donné on peut exécuter qu’un seul write (exclusion
mutuelle des write).
• PATH read, write END; A un instant donné on peut exécuter soit un read, soit un
write.
• PATH deposer ; retirer END; Pour exécuter un retirer il faut d’abord exécuter un
déposer.
• PATH p ; (q, r) ; s END; Les opérations de séquencement et de sélection sont
combiné.
• PATH {read} END; On peut exécuter plusieurs operations read en concurrence.
• PATH {read}, write END; On peut exécuter plusieurs read en concurrence ou un
seul write.
• Le compilateur va ajouter les opérations P et V des sémaphores
automatiquement en suivant les étapes suivantes :
• Etape 1:
Le sémaphore S est initialisé à 1
• Etape 2:
Le sémaphore S est initialisé à 0
• Le sémaphore S est initialisé a 1

• Etape 3
Les opérations de
synchronisation avant et après
les tâches sont ajouté aux
procédures des tâches
• Exemple : On veut synchroniser le système pour exécuter les taches
A,B et C selon l’expression de chemin suivante :
• Les procédures A, B et C sont transformé
automatiquement par le compilateur
comme suit:
• Remarque :
• Il existe d’autres formalismes d’expression
de chemin qui permettent de fixer le
nombre d’occurrences parallèle mais il ne
serons pas abordé dans ce cours.
• 2.1 Introduction
• 2.2 Problème de l’exclusion mutuelle
• 2.3 Solutions pour l'exclusion mutuelle (section critique)
• 2.3.1 Solutions logiciels basées sur l'attente active
CHAPITRE 2
• 2.3.2 Solutions matériels basées sur le masquage des interruptions
• 2.3.3 Solutions matériels basées sur des instruction indivisibles
• 2.3.4 Solutions basées sur l’attente passive
• 2.4 Les verrous
• 2.5 Les sémaphores
• 2.5.1 Exclusion mutuel par sémaphore
• 2.5.2 Précédence des tâches
• 2.5.3 Coopération entre N processus
• 2.5.4 Rendez-vous entre deux processus
• 2.5.5 Modèle du producteur / consommateur
• 2.5.6 Modèle du Lecteur / Rédacteur
• 2.6 Les régions critiques
• 2.7 Les moniteurs
• 2.7.1 Les variables condition
• 2.8 Les expressions de chemins

Chapitre 02

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 02

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 02

Transféré par

Droits d'auteur :

Formats disponibles

Centre Universitaire de Mila

3 ème année licence LMD Informatique

Module : Systèmes d'exploitation 2

Synchronisation des processus

• Problème de l’exclusion mutuelle

• Les algorithmes qui suivent cherchent a réaliser l'exclusion mutuelle

flag [ i ] = vrai ; flag flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

 flag [ i ] = vrai ; flag  flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

flag [ i ] = vrai ; flag flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

flag [ i ] = vrai ; flag flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

flag [ i ] = vrai ; flag flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

flag [ i ] = vrai ; flag flag [ j ] = vrai ;

Jusqu'à (faux) ; Jusqu'à (faux) ;

L'instruction Test_and_set (TAS ou TSL)

Fonction Test_and_Set (var lock:booléen): Processus Pi

Fonction Test_and_Set (var lock:booléen): Processus Pi

Fonction Test_and_Set (var lock:booléen): Processus Pi

Fonction Test_and_Set (var lock:booléen): Processus Pj

Fonction Test_and_Set (var lock:booléen): Processus Pj

Fonction Test_and_Set (var lock:booléen): Processus Pj

• Un wait est implémenté comme suit :

• Le sémaphore S est initialisé a 1

Vous aimerez peut-être aussi