Vous êtes sur la page 1sur 53

Chapitre 4

Les Processus :
L’Exclusion Mutuelle

Mr B. SOUICI et Mme L. BOUZAR


© 2018-2019
-1-
1. L’Exclusion Mutuelle
2. Synchronisation des processus avec sémaphores
3. Outils de synchronisation de haut niveau :
Les moniteurs.

-2-
1. RELATIONS ENTRE PROCESSUS
1.1 Définitions
1.2 Classes de processus parallèles
1.2.1 Les processus indépendants;
1.2.2 Les processus coopérants ou concurrents.

2. L’EXCLUSION MUTUELLE
2.1 Définitions
2.1.1 Ressources d’un processus
2.1.2 Ressources critique
2.1.3 Ressource virtuelle
2.1.4 Section critique
2.1.5 Schéma général de l’utilisation d’une ressource critique
2.2 Réalisation de l’exclusion mutuelle
2.2.1 Hypothèses de travail (Dijkstra)

-3-
2.2.2 Solutions matérielles
2.2.2.1 Machine monoprocesseur
2.2.2.1.1 Les interruptions
2.2.2.1.2 Les instructions spéciales
2.2.2.2 Machine multiprocesseur
2.2.3 Les sémaphores de Dijkstra(1965)
2.2.3.1 Définition
2.2.3.2 Propriétés des sémaphores
2.2.3.3 Définition et initialisation
2.2.3.4 Réalisation de l’exclusion mutuelle avec les sémaphores
2.2.3.5 Implantation des primitives P et V
2.2.3.6 Insuffisances du mécanisme de synchronisation par
sémaphores

-4-
1. RELATIONS ENTRE PROCESSUS
1.1 Définitions
• Processus parallèles :
Des processus séquentiels dont les exécutions chevauchent dans le
temps.
• Exemple : Soient deux processus P1 et P2 dont les exécutions de leur
programme sont représentées par les schémas suivants:

Schéma1

P1 P2

• Exécution séquentielle du programme de P1,


• Ensuite, exécution séquentielle du programme de P2 sur un seul
Processeur.
• P1;P2
-5-
Schéma2
P1 P1 P1 P1
P2 P2 P2

• Exécution séquentielle d’une séquence d’instructions de P1


• ensuite exécution séquentielle d’une séquence d’instructions de P2 sur
un seul processeur.
• ➔ Exécutions alternées de P1 et P2.

Schéma3
P1

P2

• Exécutions parallèles des programmes des processus P1 et P2➔ cette


exécution n’est possible que si l’on dispose de 2 processeurs physiques
-6-
• Comparaison de ces schémas ➔ Introduire la notion de niveau
d’observation qui peut être:
✓ le programme(en entier),
✓ la procédure ou fonction (séquence d’instructions),
✓ l’instruction.
Schéma1

P1 P2

• Le schéma1 représente une exécution séquentielle de 2 processus


quel que soit le niveau d’observation.
• Les événements qui nous intéressent sont :
✓ début(P1), fin(P1);
✓ début(P2) et fin(P2).
avec fin(P1) < début(P2).
-7-
Schéma2
P1 P1 P1 P1
P2 P2 P2

Schéma3
P1
P2

• Le schéma2 et le schéma3 sont des exécutions parallèles de 2


processus séquentiels ?
✓ Si le niveau d’observation est le programme ou la séquence
d’instructions ➔ schéma2  schéma3;
✓ Si le niveau d’observation est l’instruction ➔ schéma2  schéma3;
✓ Dans le schéma2 les instructions s’exécutent de manière
séquentielle sur un seul processeur (U.C), on parle alors de
psœudo-parallèlisme.
-8-
• Dans le schéma3 les instructions des processus P1 et P2 s’exécutent sur
2 processeurs (U.C) distincts : c’est du parallélisme réel.

• Remarque : La distinction entre les différents schémas est liée au


niveau d’observation.

1.2 Classes de processus parallèles


On distingue deux classes de processus parallèles:
1. Les processus indépendants;
2. Les processus coopérants ou concurrents.

-9-
1.2.1 Les processus indépendants
• Aucune interaction entre ces processus,
• Leur contexte sont disjoints : C1  C2 = 
• Ces processus ne se connaissent pas,
• Ils ont des relations de compétition pour l’usage de ressources
physiques communes.

• Définition : Il y a relation de compétition lorsque plusieurs processus


tentent d'utiliser simultanément un objet (ressource) non partageable
ou à accès exclusif (un seul processus peut l'utiliser à la fois).
Exemples : Imprimante , processeur , …
• L’objet commun ne doit pas être modifié par les processus
indépendants : Il doit être le même pour tous.
• Ces objets de conflit constituent ce que l’on appelle ressources
(Processeur, périphériques, ...). - 10 -
• La relation de compétition peut être éliminée si l’on disposait d’un
nombre suffisant de ressources pour satisfaire les besoins des
processus.
• Or, les besoins des processus ne sont pas connus et
on ne peut pas créer dynamiquement des ressources physiques.
• Le résultat de chacun des processus ne peut pas être influencé par les
autres processus.
• Le comportement des processus peut être affecté :
Exemple : temps de résidence; temps d’attente et temps de réponse
dépendent du nombre de processus dans le système.
➢ Deux processus indépendants (P1 et P2) se partageant une
imprimante :
- P2 utilise l’imprimante;
- P1 doit attendre que P2 libère l’imprimante pour pouvoir l’utiliser
➔ P1 a été ralenti par P2.

- 11 -
• Si deux processus p1 et p2 sont indépendants les exécutions suivantes
donnent les mêmes résultats :
✓ p1 // p2, "//" Exécution parallèle,

✓ p1; p2, ";" Exécution séquentielle.

✓ p2; p1.

- 12 -
1.2.2 Les processus concurrents (coopérants)
• Ce sont des processus qui coopèrent pour la réalisation d’un travail
commun (tâche commune).
• Ces processus se partagent et/ou s'échangent des informations.
• Ils se connaissent de manière directe ou indirecte.
• La coopération entre ces processus nécessite une synchronisation de
leurs actions (opérations).
• Les processus concurrents ont 2 types de relations :
✓ Relation de compétition pour l’usage de ressources communes:
Ressources physiques : compétition entre processus
concurrents et/ou indépendants;
Ressources logiques : compétition seulement entre des
processus coopérants.

- 13 -
✓ Relation de coopération:
a) Coopération par partage :
Les processus se connaissent de manière indirecte.
Exemples : Des processus se partageant une base de données de
comptes bancaires (processus versement, processus retrait,
processus consultation,…).

b) Coopération par communication :


Les processus se connaissent directement et s’échangent des
messages :
– Envoyer(message, identificateur du processus),
– Recevoir(message).

- 14 -
2. L’EXCLUSION MUTUELLE
• Mécanisme permettant l'accès exclusif à une ressource commune (ou
ressource partagée).
La ressource peut être : physique ou logique.

2.1 Définitions
2.1.1 Ressources d’un processus
Pour qu'un processus puisse évoluer, il a besoin :
✓ de programmes et de données;
✓ de mémoire destinée à les contenir;
✓ du processeur pour s’exécuter; Ressources

✓ de fichiers et de périphériques.

- 15 -
❖ On distingue deux classes de ressources :
✓ Les ressources physiques :
processeur; mémoire centrale; périphériques; …
✓ Les ressources logiques :
programmes; fichiers; …
❖ Une ressource peut être à un seul point d’accès (à accès exclusif) :
Processeur; imprimante; fichier en écriture; programme non
réentrant; …
Un seul processus, à la fois, peut utiliser la ressource.
❖ Une ressource à plusieurs points d‘accès :
Disque; fichier en lecture; programme réentrant; …
Ce dernier type de ressource peut être utilisé par plusieurs
processus en même temps (simultanément).

- 16 -
❖ Ressource banalisée :
Ressources qui existent en plusieurs exemplaires et le choix de
l’unité allouée n’est pas important pour le processus demandeur :
Imprimantes; pages mémoires; blocs de disques; dérouleurs de
bandes magnétiques; …
❖ Etats d’une ressource
Une ressource est caractérisée par son état :
✓ Libre;
✓ Occupée(la ressource est allouée à un processus).

- 17 -
2.1.2 Ressource critique
C’est une ressource qui ne peut être utilisée que par un seul processus
à la fois :
✓ Ressource à un seul point d'accès;
✓ Ressource à accès exclusif ou
✓ Ressource non partageable.
• Exemples: processeur; imprimante; …

❖ Une ressource critique doit être utilisée en exclusion


mutuelle.
❖ Les processus entrent en compétition pour utiliser une ressource
critique.

- 18 -
2.1.3 Ressource virtuelle
Exemple : machine monoprocesseur :
➢ Un seul processeur pour l’ensemble des processus
➢ Le processeur est une ressource non partageable ➔
un seul processus peut l’utiliser à la fois.
❖ Les processus entrent en compétition pour utiliser le processeur.
❖ Ce problème de compétition, peut être évité s’il y avait autant de
processeurs réels que de processus or :
1. On ignore le nombre de processus dans le système (création
dynamique),
2. Pour des raisons économiques, on ne peut pas avoir autant de
processeurs que de processus. ➔
On introduit la notion de ressources virtuelles :

- 19 -
❖ On va supposer qu’il y a autant de « copies imaginaires » du
processeur réel que de processus.
❖ Ces « copies imaginaires » du processeur sont appelées processeurs
virtuels ou ressources virtuelles.
❖ Pour toute ressource physique on associe autant de ressources
virtuelles qu’il y a de processus demandeurs de cette ressource réelle.
❖ Le problème de compétition pour l'accès aux ressources
physiques est réglé par le système à l’aide de programmes
appelés : l’allocateurs de ressources.
❖ Exemple : le Processeur
✓ C’est l’ordonnanceur qui choisit un processus de la « file prêt »
et lui affecte le processeur(ou le fait passer à l’état actif) ➔
Les processus à l’état prêt sont virtuellement en exécution.
✓ L’utilisateur ne se préoccupe pas de l’allocation du processeur.
- 20 -
❖ La notion de ressource virtuelle permet de séparer :
✓ Le problème de compétition pour l’utilisation de ressources
physiques qui concerne les deux classes de processus :
il y a compétition entre processus indépendants et processus
concurrents;
✓ Du problème de coopération qui est à la charge de l’utilisateur:
la coopération entre processus concurrents dépend de la logique
des programmes des différents processus.

❖ Remarque : Dans la suite du cours nous ne nous intéressons qu’au


problème de coopération entre processus.

- 21 -
2.1.4 Section critique
La coopération entre processus concurrents nécessite l'usage d'objets
communs ou ressources communes.
Exemple: Considérons 2 processus P1 et P2 s'exécutant sur une
machine monoprocesseur et pouvant consulter et modifier une base
de données des comptes C.C.P.

P1 : versement P2 : Retrait
a1: lire (compte1, n° 999999) a2: lire (compte2, n° 999999)
b1: compte1 = compte1 + 10000 b2: compte2 = compte2 - 5000
c1: réécrire (compte1, n° 999999) c2: réécrire (compte2, n°999999)

On suppose que le compte C.C.P N° 999999 contient la somme


20000 unités monétaires.
Les 2 processus peuvent lire le compte en même temps,
par contre l’écriture simultanée sur le compte n’est pas autorisée.
- 22 -
Résultats des exécutions des programmes de processus P1 et P2:

1) On suppose que les instructions des 2 processus s'exécutent dans


l'ordre suivant:

a1 < a2 < b1 < b2 < c1 < c2. (< : avant)

P1 : Versement P2 : Retrait
a1: compte1=20000
a2: compte2=20000
b1: compte1 = 20000 + 10000
= 30000
b2: compte2 = 20000 – 5000
= 15000
c1: Compte N° 999999 = 30000
c2: compte N° 999999 = 15000
Résultat final: Compte N° 999999 = 15000 ➔
Ce résultat n'est pas correct.
- 23 -
2) On suppose que les instructions des 2 processus s'exécutent dans
l'ordre suivant:

a2 < a1 < b2 < b1 < c2< c1.


P1 : Versement P2 : Retrait
a2: compte2=20000
a1: compte1=20000
b2: compte2 = 20000 – 5000
= 15000
b1: compte1 = 20000 + 10000
= 30000
c2: compte N° 999999 = 15000
c1: Compte N° 999999 = 30000
Résultat final: Compte N° 999999 = 30000 ➔
ce résultat n'est pas correct

Les 2 résultats sont faux.


- 24 -
• Comment éviter cette incohérence ?
✓ Exécuter la séquence d'instructions de P1 et la séquence
d'instructions de P2 de manière indivisible ou atomique.
✓ On aura:
➢ P1(a1 < b1 < c1) < P2(a2 < b2 < c2) ou
➢ P2(a2 < b2 < c2) < P1(a1 < b1 < c1)

1) P1 ensuite P2 : (a1 <b1 < c1) < (a2 <b2 <c2)

a1: compte1=20000
P1 b1: compte1 = 20000 + 10000 = 30000
c1: Compte N° 999999 = 30000

a2: compte2 = 30000


P2 b2: compte2 = 30000 – 5000 = 25000
c2: Compte N° 999999 = 25000
- 25 -
2) P2 ensuite P1 : (a2 <b2 < c2) < (a1< b1 < c1)

a2: compte2=20000

P2 b2: compte2 = 20000 - 5000 = 15000


c2: Compte N° 999999 = 15000

a1: compte1 = 15000

P1 b1: compte1 = 15000 + 10000 = 25000


c1: Compte N° 999999 = 25000

Résultat final: Compte N° 999999 = 25000 ➔


Les 2 résultats sont corrects.

- 26 -
❖ Les programmes des processus P1 et P2, ont été exécutés en
exclusion mutuelle car ils modifient un une ressource commune : le
compte C.C.P.
❖ Les programmes des processus P1 et P2 constituent des sections
critiques.
❖ On appelle section critique d'un processus, la phase pendant laquelle
le processus utilise la ressource critique.
❖ Une section critique est une action indivisible ou atomique qui
dépend du type de la ressource utilisée.
❖ Exemple:
L’action « imprimer fichier » doit être indivisible pour la ressource
imprimante.
❖ Tout processus qui tente d’exécuter une section critique doit parfois être
retardé(bloqué) le temps qu’un autre processus exécutant sa propre
section critique soit sorti.
- 27 -
❖ Remarques:
➢ Les notions d'exclusion mutuelle et de section critique ne s'appliquent
qu'aux processus utilisant une même ressource critique.
➢ Action indivisible : Cela signifie que si un processus utilise une
ressource critique dans sa section critique, aucun autre processus
concerné par le partage de cette ressource ne peut interrompre
l’utilisation de la ressource critique, jusqu’à ce que le processus qui
détient la ressource la libère volontairement à la fin de sa section
critique.
➢ Indivisible n'implique pas « ininterruptible » (ou non interruptible) :
Un processus peut être interrompu au niveau de sa section critique par
un processus plus prioritaire que lui ou par une interruption horloge (en
fin de quantum). Cependant, la ressource critique ne peut pas être
retirée au processus interrompu et affectée à un autre processus.
Les processus se partageant cette ressource doivent attendre jusqu’à la
libération de la ressource critique. - 28 -
2.1.5 Schéma général de l'utilisation d'une ressource
critique

Demande de la ressource critique Demande d'entrée en section critique


Utilisation de la
Section Critique
ressource critique
Libération de la ressource critique Sortie de la section critique

Toute ressource critique doit être utilisée en exclusion


mutuelle.

- 29 -
2.2 Réalisation de l’exclusion mutuelle
2.2.1 Hypothèses de travail (Dijkstra)
❖ Les vitesses relatives des processus sont quelconques et inconnues.
❖ On suppose que tout processus sort de sa section au bout d’un temps
fini.
❖ L’ordre d’accès à la ressource est quelconque (ordre d’exécution de la
section critique).
❖ La solution doit avoir les propriétés suivantes:
a) A tout instant un processus au plus peut se trouver en section
critique (exclusion mutuelle).
b) Si plusieurs processus sont bloqués en attente de la ressource
critique alors qu’aucun processus ne se trouve en section critique
l’un d’eux doit pouvoir y entrer au bout d’un temps fini (éviter les
blocages indéfinis).
c) Si un processus est bloqué en dehors d’une section critique, ce
blocage ne doit pas empêcher l’entrée d’un autre processus en
section critique(permettre la progression).
d) La solution doit être la même pour tous les processus
(pas de priorité : équité ➔ éviter la privation ).
- 30 -
2.2.2 Solutions matérielles
2.2.2.1 Machine monoprocesseur
2.2.2.1.1 Les interruptions
❖ Sur une machine monoprocesseur l'exclusion mutuelle peut être
assurée en masquant les interruptions; ➔
Evite au processus actif de perdre le processeur, pendant l'exécution
de sa section critique.
❖ Exemple :
✓ Interruption horloge en fin de quantum ou
✓ Arrivée ou Réveil d'un processus plus prioritaire.

1- Entrée en section critique Masquer les interruptions


< Section critique >
2- Sortie de la section critique Démasquer les interruptions
- 31 -
❖ Cette solution doit être utilisée avec précaution car elle peut affecter le
temps de réponse du système.
❖ La section critique doit être la plus courte possible :
Certaines interruptions de même niveau peuvent être déclenchées
plusieurs fois successivement pendant l'exécution de la section
critique, et elles ne sont mémorisées qu'une seule fois.

❖ Exemple : Une interruption horloge(Timer) non traitée en temps


voulu peut retarder l'horloge du système.

- 32 -
2.2.2.1.2 Les instructions spéciales
➢ Certains processeurs offrent des instructions spéciales permettant de
lire et modifier un mot ou cellule mémoire de manière indivisible (ou
atomique).
➢ L'instruction la plus connue est TAS(m).
➢ Cette instruction (ou d’autres instructions équivalentes) permet de
résoudre le problème de l’exclusion mutuelle par attente active.
a) Test And Set ou TAS(m)
• La consultation et la modification de m sont réalisées par une seule
instruction indivisible.
• Cette instruction existe sur certaines machines (Motorola 68000).

- 33 -
a.1) Fonctionnement de TAS

TAS(m):
bloquer l’accès à la cellule mémoire m;
lire le contenu de m;
si m = 0 alors
m := 1;
compteur_ordinal := compteur_ordinal + 2;
sinon
compteur_ordinal := compteur_ordinal + 1;
finsi;
Libérer l’accès à la cellule mémoire m;
fin_de_TAS.

- 34 -
a.2) Emploi de TAS:
Soit v la variable commune protégeant la ressource critique.
Initialisation v:=0; (v=0➔Ressource libre; v=1➔Ressource occupée)

Etiq : TAS(v); Co
1- Entrée en section critique
Aller à Etiq; Co+1

< Section critique > Co+2

2- Sortie de la section critique v := 0; Co+n

- 35 -
Forme algorithmique de TAS :
Fonction TAS(booléen m) booléen;/* exécutée de manière atomique*/
booléen sm;
Début
sm := m; /* sauvegarder m dans sm */
m := vrai; /* positionner m à vrai */
retourner sm; /* retourner l’ancienne valeur de m : sm */
fin_de_TAS.

Utilisation de TAS:
Soit v la variable booléenne commune protégeant la ressource critique;
v initialisée à faux.
v=faux ➔Ressource libre; v=vrai ➔Ressource occupée.

Initialisation v:= faux;


1- Entrée en section critique Tantque TAS(v) faire rien finfaire
< Section critique >
2- Sortie de la section critique v := faux;
- 36 -
b) Instruction LOCK XCHG des processeurs Intel 80x86
Le préfixe LOCK permet de rendre l'instruction XCHG qui suit indivisible.
LOCK XCHG Registre, mémoire
Initialisation :
MOV v,0
Demande d’entrée en section critique :
boucle: MOV AL,1 ; AL =1
LOCK XCHG AL,v ; échange du contenu de AL avec celui de v
; à la fin de l'exécution de l'instruction :
; v=1 et AL = ancienne valeur de v.
CMP AL, 0 ; tester section critique libre :
; si v était égale à 0;
JNE boucle ; si section critique occupée aller à boucle.

< Section Critique >


Sortie de la section critique :
MOV v, 0 ; libérer la section critique
- 37 -
Forme algorithmique équivalente à l’instruction LOCK XCHG des
processeurs Intel 80x86 :

Swap (V, R) /* Swap exécuté de manière atomique*/


Booléen T;
Début
T := V;
V := R;
R := T
fin_de_Swap;

Utilisation de Swap:
Soit v la variable commune protégeant la ressource critique et
r (registre) une variable locale.

Initialisation v := faux; r := vrai;


Repeter
1- Entrée en section critique Swap(v,r)
Jusqu’à r=faux;
< Section critique >
2- Sortie de la section critique v := faux; - 38 -
2.2.2.2 Machine multiprocesseur
Sur une machine multiprocesseur :
• Le masquage des interruptions seul est insuffisant pour assurer
l'exclusion mutuelle entre des processus s'exécutant sur des
processeurs différents;
• Les instructions spéciales seules sont insuffisantes pour assurer
l'exclusion mutuelle entre des processus s'exécutant sur des
processeurs différents.
• Solution : Combiner les interruptions et une instruction spéciale
(TAS).
❖ La solution comprend deux étapes consistant à :
1. Permettre à un seul processeur d'accéder à la section critique;
2. Permettre à un seul processus s'exécutant sur ce processeur
d’exécuter sa section critique.

- 39 -
✓ Masquer les interruptions pour ne permettre qu’à un seul processus de
s'exécuter sur un processeur donné,
✓ Utiliser une instruction spéciale telle que TAS pour résoudre les conflits
entre processeurs ➔ autoriser un seul processeur à exécuter la
section critique d’un processus.

Remarque:
On doit d'abord masquer les interruptions et ensuite demander
l'entrée en section critique à l'aide de l'instruction TAS. ➔
Eviter les attentes actives inutiles (mauvaise utilisation du processeur).

- 40 -
Début

masquer les interruptions;

boucle : TAS(m); /* attente active */


Aller à boucle;
Section Critique;
m=0; /* libérer de la section critique */

démasquer les interruptions;

Le reste du programme
Fin;
Remarque: Il y a attente active pendant la durée de l'exécution de la
section critique.
- 41 -
Solution utilisant TAS et ensuite les interruptions
Début
boucle : TAS(m);
Aller à boucle;
Point interruptible; ex: it horloge (fin de quantum)

masquer les interruptions

Section Critique;

démasquer les interruptions;

m:=0;

Le reste du programme ...


Fin;
La section critique est libre et aucun processus ne peut l’utiliser car elle
est déjà allouée à un processus qui n’a pas le processeur(à l’état prêt). - 42 -
Propriétés des instructions spéciales :
❖Avantages :
Les instructions spéciales peuvent être utilisées sur les machines
monoprocesseur et multiprocesseurs se partageant une mémoire
commune.

Remarque : Sur un multiprocesseurs, on utilise les instructions


spéciales avec les interruptions.

- 43 -
❖Inconvénients :
➢ Les instructions spéciales utilisent l’attente active. ➔ mauvaise
utilisation du temps processeur .
➢ Il ya risque de privation : Si plusieurs processus demandent à entrer
en section critique, le choix du processus à accèder en section
critique est arbritaire ➔ Un processus peut passer plusieurs fois
alors qu’il ya des processus qui attendent l’entrée en section critique
(propriété (d) n’est pas respectée).

➢ Il y a un risque d’interblocage :
Considérons une machine monoprocesseur avec un ordonnancement
avec priorité. Deux processus p1 et p2 avec p2 plus prioritaire que
p1.
Les 2 processus se partagent une ressource critique et accèdent à
cette ressource à l’aide d’une intruction spéciale (ex: TAS).

● A l’instant t : Arrivée de P1 (processus moins prioritaire)


✓ P1 demande et entre en section critique. - 44 -
● A l’instant t+1: Arrivée de P2 (plus prioritaire que P1)
✓ L’ordonnanceur retire le processeur à P1 et l’affecte à P2.
✓ P2 (occupe le processeur) demande d’entrée en section :
il ne peut pas entrer car la ressource critique est occupée par P1
qui est à l’état prêt.

 P1 n’a pas le processeur (occupé par P2) pour continuer son


exécution,
 P2 n’a pas la ressource critique (occupée par P1) pour
continuer son exécution.

 Situation d’interblocage.

Les instructions spéciales doivent être utilisées avec beaucoup


de précautions.
- 45 -
2.2.3 Les sémaphores de Dijkstra(1965)
2.2.3.1 Définition
❖ Un sémaphore est une structure de données composée :
✓ d’une variable entière e(s),
✓ d’une file d’attente f(s).
❖ La variable e(s) ne peut prendre que des valeurs entières positives,
négatives ou nulles.
❖ La valeur initiale d’un sémaphore est un entier supérieur ou égal à zéro.
❖ La politique de gestion de la file d’attente f(s) est laissée au choix de
l’utilisateur: ( Cours et TD : file f(s) gérée en FIFO ).
❖ A la création d’un sémaphore sa file doit être vide.
❖ Les opérations sur les sémaphores se font par l’intermédiaire de deux
primitives notées :
✓P (Proberen en hollandais: tester),
✓V (Verhogen: incrémenter).
- 46 -
P(s) V(s)
Début Début
e(s) := e(s) - 1; e(s) := e(s) + 1;
si e(s) < 0 alors si e(s) <= 0 alors
Mettre le processus actif Sortir un processus bloqué
dans la file f(s) de la file f(s)
(bloquer le processus) (réveiller un processus )
Finsi Finsi
Fin_de_P Fin_de_V

Les primitives P et V doivent être exécutées en exclusion mutuelle car


elles se partagent :
– la variable qui contient la valeur du sémaphore et
– la file d'attente du sémaphore.
- 47 -
2.2.3.2 Propriétés des sémaphores
❖ Un sémaphore ne peut être initialisé à une valeur inférieure à 0(zéro),
mais sa valeur peut devenir négative après un certain nombre
d’opérations P.
❖ La valeur d’un sémaphore donne le nombre de processus pouvant
exécuter simultanément leur section critique :
✓ C’est à dire, si une ressource est partageable avec k points d’accès,
la valeur initiale du sémaphore protégeant cette ressource est
égale à k.
✓ Exemple:
• Si un fichier est partagé, en lecture, entre n processus ➔
• valeur initiale du sémaphore protégeant ce fichier est alors
égale n.

- 48 -
❖ A tout instant la valeur e(s) d'un sémaphore s est donnée par la
relation suivante :
e(s) = e0(s) - nP + nV;
✓ e0(s) : valeur initiale du sémaphore s,
✓ nP: nombre d'exécutions de P sur le sémaphore s;
✓ nV: nombre d'exécutions de V sur le sémaphore s;

❖ Si la valeur d’un sémaphore est inférieure à zéro ➔ Sa valeur absolue


est égale au nombre de processus bloqués dans sa file f(s).
e(s)<0 ➔ f(s) = |e(s)| processus bloqués.

- 49 -
2.2.3.3 Définition et initialisation
On utilise la forme algorithmique suivante :
sémaphore nom_du sémaphore init valeur;

2.2.3.4 Réalisation de l’exclusion mutuelle avec les


sémaphores
• Un sémaphore d’exclusion mutuelle est toujours initialisé à 1 (un).
• Soit mutex le sémaphore d’exclusion mutuelle initialisé à 1.

1. Définition et Initialisation Sémaphore mutex init 1;


2. Entrée en section critique P(mutex);
< Section critique > < Section critique >
3. Sortie de la section critique V(mutex);

- 50 -
2.2.3.5 Implantation des primitives P et V
❖ Les primitives P et V doivent être indivisibles :
Un seul processus peut exécuter une primitive p ou v sur un
sémaphore s donné (p et v exécutées en exclusion mutuelle).
a) Sur une machine monoprocesseur : masquer les interruptions.
b) Sur une machine multiprocesseur deux étapes sont nécessaires :
1. Garantir qu'un seul processeur peut exécuter une primitive :
Utilisation de l'instruction TAS ou d'une instruction équivalente.
2. Masquer les interruptions avant de demander l'entrée dans la
section critique protégée par l'instruction TAS (c’est à dire
masquer les interruptions avant d'exécuter l'instruction TAS).
❖ Remarque: Il y a attente active pendant la durée de l'exécution de la
primitive P ou V.
❖ Les primitives, les variables d'état et les files d'attente doivent être
protégées (utilisation des primitives par appel au superviseur).
- 51 -
Initialisation de la variable commune m à 0 : m=0;

Primitive P(s) Primitive V(s)

Début Début
1) Masquer les interruptions; 1) Masquer les interruptions;

2) boucle : TAS(m); 2) boucle : TAS(m);


Aller à boucle; Aller à boucle;

Programme P(s) Programme V(s)

3) m := 0; /* libérer section critique */ 3) m := 0; /* libérer section critique */

4) Démasquer les interruptions; 4) Démasquer les interruptions;


Fin de P(s); Fin de V(s);

- 52 -
2.2.3.6 Insuffisances du mécanisme de synchronisation par
sémaphores
✓ Mécanisme de bas niveau ➔ Programmation difficile et risque d’erreur
important(oubli d’un P ou un V difficilement détectable).
✓ La primitive V ne permet de réveiller (activer) qu'un seul processus de la
file d'attente du sémaphore.
✓ Le processus qui a exécuté V ne choisit pas le processus à réveiller ➔
Il ne connait pas le processus réveillé.
✓ Le processus (réveillé) ou activé ne connaît pas le processus qui l'a
réveillé ➔ Ce mécanisme permet une action indirecte sur les processus.
Remarques :
➢ La primitive v mémorise l'événement : la variable du sémaphore est
incrémentée même si aucun processus n'attend cet événement.
➢ Un événement non mémorisé est perdu si aucun processus n’est en
attente de cet événement. Exemple: Message de la radio.
- 53 -

Vous aimerez peut-être aussi