Chapitre 02

Systèmes d’exploitation 2 (programme covid19) F.
CHEHBOUR
Chapitre 2 : Synchronisation des processus
1. Introduction
Des processus multiple dans le système d’exploitation n’évoluent pas toujours de manière
indépendante. Ils coopèrent pour réaliser une tâche commune. Ils partagent donc les
données, plus généralement des ressources.
Pour mettre en œuvre cette coopération, des mécanismes dits de synchronisation doivent être
fournie par le système d’exploitation. Ces mécanismes permettent d’établir un ordre
d’exécution entre les processus coopérants.
2. Partage des ressources et des données

L’exécution des processus nécessite un certain nombre de ressources logiques (fichier,
données, code…) et physiques (mémoire, processeur, disque, imprimante…).
Une ressource est soit partageable soit non partageable.
Une ressource partageable est une ressource qui possède plusieurs points d’entrée (à
accès multiple, peut être utilisée simultanément par plusieurs processus).
Une ressource non partageable est une ressource à un seul point d’entrée (accès exclusif).
Dans ce cas il est nécessaire d’ordonner l’accès à ce type de ressources pour éviter les
situations incohérentes.
2.1.Exemple de situation incohérente

Le partage de variable sans précaution particulière peut conduire à des situations
imprévisibles.
Soit le programme suivant :
Programme reservation {
If ( place_dispo>0) {
place_dispo -- ;
printf (‘place réservée’) ;
else
printf (‘plus de place’) ;
Département informatique/faculté des sciences/université de Boumerdes.

1
Systèmes d’exploitation 2 (programme covid19) F.CHEHBOUR
Le langage machine correspondant à ce programme est comme suit :
(I1): load R1, place_dispo
(I2): cjump R1, plein
(I3): sub R1 1
(I4): Store R1 place_dispo
(I5): Répondre (‘place réservée’)
(I6): jump fin
(I7): plein : répondre (‘plus de place’)
(I8) : fin : stop
En cas de plusieurs demandes de réservation simultanées; il y aura exécution pseudo-parallèle

de plusieurs processus sur ce même code.
Imaginons le scénario suivant:
Il reste une seule place disponible. Donc place_dispo==1
Soient deux processus P1 et P2
P1 s’exécute jusqu’à I3 ensuite préempté --> R1=1 (I1)
R1≠0 (I2)
R1=0 (I3)
P2 s’exécute jusqu’à la fin --> place_dispo est toujours=1, il réserve une place et se termine
P1 continu son exécution à partir de (I4) --> place_dispo=0
(I5) P1 réserve une place et se termine.
Une même place a été réservée deux fois.
On s’aperçoit qu’éliminer les cas divergeant revient à rendre indivisible (atomique) la

séquence d’exécution de la portion du code contenant la variable partagée.
La variable partagée est appelée ressource critique
La portion du code dans laquelle est manipulée la variable partagée est appelée la section
critique

2
3. La Section Critique
3.1. Définition
La section critique d’un programme donné est une suite d’instructions de ce programme
dont l’exécution est gérée en exclusion mutuelle.
Un processus parmi ceux qui s’exécutent en parallèle ne peut entrer en section critique
(S.C) si l’un des autres s’y trouve déjà.
3.2.Problème de l’exclusion mutuelle

Considérons un système où on a n processus (P1, P2, …Pn) ayant chacun la forme
générale suivante.
P1 P2 . . . Pn
: : :
S.C1 S.C2 S.Cn
: : :
Puisque un seul processus Pi qui est autorisé à exécuter sa section critique (S.Ci ) . Il est
nécessaire de concevoir des protocoles permettant au processus de s’exclurent mutuellement
quant à l’utilisation de la ressource critique.
3.3. La forme générale d’un processus

Le principe général d'une solution garantissant que l'exécution simultanée de plusieurs
processus ne conduirait pas à des résultats imprévisibles est: avant d'exécuter une SC, un
processus doit s'assurer qu'aucun autre processus n'est en train d'exécuter une SC du même
ensemble. Dans le cas contraire, il ne devra pas avancer tant que l'autre processus n'aura pas
terminé sa SC. En d’autres termes, le processus doit exécuter un protocole d’entrée avant
d’entrer à la section critique. Le but de ce protocole est de vérifier si la SC n'est occupée par
aucun autre processus. A la sortie de la SC, le processus doit exécuter un protocole de sortie
de la SC. Le but de ce protocole est d'avertir les autres processus en attente, que la SC est
devenue libre. La forme générale d’un processus devient alors comme suit:

3
Processus Pi
Début
Répéter
<S.R> //Section restante ou instructions hors de la section critique
<Protocole d’entrée>
<S.C>
<Protocole de sortie>
Jusqu’à faux
Fin.
3.4.Les conditions de la section critiques

Toute solution à la section critique doit respecter les quatre conditions suivantes :
 L’exclusion mutuelle : Si un processus est en section critique. Aucun autre processus ne

pourra y accéder.
 La progression (déroulement) : Un processus qui opère en dehors de la S.C (la section
restante) ne peut pas empêcher un autre processus d’entrer en S.C.
 L’absence du blocage mutuelle (absence de l’inter-blocage).
 L’attente bornée : Un processus ayant demandé d’entrer en S.C. doit y accéder au bout
d’un temps fini. Cette condition interdit à certains processus d’exécuter itérativement leurs
S.C. en laissant un processus attendre pendant une durée arbitrairement longue l’entrée
dans sa S.C.
4. Mécanismes d’exclusion mutuelle

4.1.Hypothèses
1. Le système est formé de n processus s’exécutant en parallèle
2. Les vitesses d’exécution des processus sont quelconques.
3. Les instructions de base de langages machine sont indivisibles
4.2.Solutions sans support matériel (les variables d’état)

Ces solutions consistent à utiliser des variables communes partagées entre les processus.
Exemple
4
Considérons deux processus Pi et Pj tel que Pi parallèle à Pj
Tour = i ; /*********variable partagée entre Pi et Pj **********/
Processus Pi Processus Pj
Répéter Répéter
Tant que (tour ≠ 𝒊) {} Tant que (tour ≠ 𝒋) {}
<S.Ci> <S.Cj>
Tour=j Tour=i
<S.R> <S.R>
Jusqu’à faux Jusqu’à faux
L’exclusion mutuelle est assurée car l’accès à la S.C est conditionné par la valeur de la
variable tour qui doit être identique à l’identité du processus. Cependant, la solution engendre
l’alternance quant à l’accès à la section critique et si l’un des processus s’arrête
définitivement, l’autre processus ne pourra jamais entrer en section critique même si l’autre
processus opère en dehors de la S.C. Cette solution n’assure pas la progression.
En réalité, les solutions logiciels (basées sur les variables d’états) ne sont plus utilisées car
susceptibles de consommer le temps CPU en bouclant inutilement (attente active). De plus
leurs généralisation aux cas de plusieurs processus est complexe.
4.3.Solutions matérielles :
Ce sont des solutions qui utilisent un dispositif matériel particulier pour résoudre le problème
de la section critique. Ces solutions sont celles utilisées dans la pratique dans les systèmes
centralisés monoprocesseur.
1) Désarmement des interruptions
On désarme les interruptions pendant toute la durée de la section critique et on les réarme à la
sortie de la section critique. L’unité centrale reste allouée à ce processus jusqu’à la fin de sa
section critique ce qui garantit l’exclusion mutuelle.
Inconvénient
Un processus prioritaire peut être bloqué, d’où la difficulté de mettre cette possibilité dans les
mains des utilisateurs.
2) Instruction Test-And-Set (TAS ou TS)
Instruction élémentaire fournie par le matériel, qui permet de lire et d’écrire (ou de modifier)
le contenu d’un mot mémoire de façon indivisible.

5
Function Test_and_set (var x : boolean): Boolean

Begin
Test_and_set= x;
X=true;
end;
Programmation de la section critique

Var
boolean lock= false ;
Processus Pi
Début
Répéter
Tant que Test_and_set (lock) {}
<S.Ci>
Lock=false ;
<S.R>
Jusqu’à faux
4.4.Les sémaphores
Pour contrôler les accès à un objet partagé, Dijkstra (en 1965) a suggéré l'utilisation d'un
nouveau type de variables appelées les sémaphores.
Définition : Un sémaphore S, est une variable entière associée à une file d’attente f(s), la
variable S peut prendre des valeurs positives, nulles ou négatives. Cependant sa valeurs
initiale est toujours positive ou nulle. La politique de gestion de la file d’attente f(s) est
quelconque, mais elle est en général FIFO. Un sémaphore est manipulé EXCLUSIVEMENT
par les trois primitives suivantes :
 INIT (s, n)
Debut
S := n ;
f(s) := Ø
Fin ;

6
 P(S)
Debut
S := S-1;
Si S < 0 alors état (P) := bloqué % p est le processus qui exécute p(s) %
Mettre le processus P dans f(s);
[appel au scheduler pour choisir un autre processus]
Fsi
Fin ;
 V(S)
Debut
S := S+1;
Si ( S < = 0) alors faire sortir un processus de f(s) ; %soit q ce processus%
- Etat (q) := prêt;
Fsi
Fin
Remarque : l’exécution de P et V est atomique.
4.4.1. Les différents types de sémaphores
A. Sémaphore binaire
Un sémaphore binaire est un sémaphore dont la valeur initiale est égale à 1. Il est
utilisé en général dans l’exclusion mutuelle. La forme générale d’un programme est :
Processus Pi
Debut
P(S) ;
<S.Ci> ;
V(S) ;
fin
B. Sémaphore privé.
La valeur initiale d’un sémaphore privé est 0. Ce type de sémaphore est utilisé par un
processus quand il désire se bloquer volontairement.
7
Exemple.
Soit deux processus P1 et P2 coopérant entre eux pour réaliser un travail constitué de
deux parties. Le processus P1 doit terminer la première partie avant que le processus
P2 n’entame la deuxième.
Solution :
Sémaphore s init à 0 ;
Processus P1 Processus P2
début début
<Réaliser la première partie> P(S) ;
V(S) ; <Réaliser la deuxième partie>
Fin. Fin.
C. Sémaphore compteur
La valeur initiale d’un sémaphore compteur est > 1. Il est utilisé quand il s’agit d’accéder
à une ressource à ‘n’ points d’accès. Dans ce cas la valeur initiale du sémaphore est n et la
forme générale d’un processus est la suivante :
Sémaphore s init à n ;
Processus Pi
Début
P(S) ;
<Utiliser la ressource> ;
V(S) ;
Fin.
Les n premiers processus franchissent P(S) sans se bloquer. Le (n+1)nième processus, si les
n premiers processus sont en cours de l’utilisation de la ressource, sera bloqué (s vaut -1).
De même que les autres processus qui arrivent après. Quand un processus termine
d’utiliser la ressource (il exécute v(S)) ; il libère le premier processus bloqué. ---> Nous
avons au plus n processus qui accèdent simultanément à la ressource partagée.
Exercice
Synchroniser à l’aide des sémaphores ; l’accès à un parking possédant n places et ayant
une porte d’entrée et une porte de sortie qui ne laissent passer qu’une seule voiture à la
fois.

8
5. Synchronisation des modèles classiques de communication

interprocessus
Dans S.E, en plus de leur compétition pour l’acquisition des ressources, les processus peuvent
coopérer pour réaliser des tâches communes. Cette coopération nécessite la communication.
Pour réaliser cette communication, il est nécessaire d’utiliser des outils de synchronisation
permettant de coordonner les processus dans leur communication.
La communication interprocessus peut être assurée soit par,
 Partage de variable à travers une zone mémoire commune (les segments de
mémoire partagés). La synchronisation est à la charge de l’utilisateur.
 Echange de messages grée par le système d’exploitation (les files de messages)
à travers les deux primitives : send (message), receive (message)
5.1.Communication par partage de variable

Chaque processus peut lire ou écrire dans cette zone et plusieurs peuvent réaliser cette
opération en concurrence ce qui nécessite l’utilisation des outils de synchronisation.
I. Le modèle producteur/ consommateur
Les processus producteurs produisent de l’information, consommée par les processus

consommateurs. L’exécution concourante des producteurs et des consommateurs repose sur
l’utilisation d’un ensemble de buffers intermédiaires, remplis par les producteurs et vidés par
les consommateurs.
Les producteurs sont en compétition, les consommateurs aussi.
Exemples
1. Le processus clavier produit des caractères qui sont consommés par le processus
d’affichage à l’écran.
2. Le pilote de l’imprimante produit des lignes de caractères, consommées par
l’imprimante
3. Un compilateur produit des lignes de codes consommés par l’assembleur.
Le problème de producteur consommateur admet deux variantes : si le tampon n’est pas

borné, seul le consommateur doit attendre, quand le tampon est vide. Si le tampon est
borné, il faut en plus, garantir que le producteur attend lorsque le tampon est plein.
Cas : tampon de taille n
La communication se fait à travers un tampon de taille n (n cases)

9
0 1 n-1
. . . . . . .
Le consommateur
Le producteur (prélève de l’info.)
(dépose de
l’info.)
Les objets ou les articles sont consommés dans l’ordre où ils ont été produits (FIFO). Les
processus utilisent deux primitives.
1. Deposer (article)
2. Prelever (article)
 Le producteur ne peut déposer que s’il y a au moins une case vide.

 Le consommateur ne peut prélever que s’il y a au moins une case pleine.
 Le consommateur doit prélever un article une seule fois.
 L’E.M doit être assurée au niveau de la même case.
a. Un seul producteur/ un seul consommateur.
Var
nbplein :=0 : sémaphore permet de bloquer le consommateur dans le cas où le tampon

est vide.
Nbvide :=n : sémaphore compte le nombre de case vide.
Processus producteur Processus Consommateur

Debut Debut
Répéter Répéter
P(Nbvide) ; P(Nbplein) ;
Deposer (art); prelever(art);
V(Nbplein) ; V(Nbvide) ;
Fin Fin
Le producteur et le consommateur n’opèrent jamais sur la même case car les objets
sont consommés dans l’ordre où ils ont été produits.
Le producteur et le consommateur ne se bloquent jamais en même temps.

10
La gestion du tampon est circulaire. On utilise deux pointeurs
t : pointe la 1ière case pleine.
q : pointe la 1ière case vide. t q
Deposer (art) prelever (art)
Debut debut
T[q] := art ; art := T[t] ;
q := (q+1) mod n ; t :=(t+1)mod n ;
fin ; fin ;
b. Plusieurs producteurs/ plusieurs consommateurs
Dans ce cas il est nécessaire de rendre l’accès au tampon en exclusion mutuelle dans
chaque famille de processus. C-à-d. les opération déposer (art) et prélever (art) doivent
être réalisées en exclusion mutuelle.
Var
nbplein :=0 : sémaphore permet de bloquer le consommateur dans le cas où le tampon

est vide.
Nbvide :=n : sémaphore compte le nombre de case vide
mutex_p, mutex_c : semaphore init à 1 ;
Processus producteur Processus Consommateur

Debut Debut
Répéter Répéter
P(Nbvide) ; P(Nbplein) ;
P(mutex_p) ; P(mutex_c) ;
Deposer (art) ; prelever(art);
V(mutex_p) ; V(mutex_c) ;
V(Nbplein) ; V(Nbvide) ;
Fin Fin
II. Modèle des lecteurs/ rédacteurs

11
Ce problème représente le cas particulier où l’objet partagé par les différents

processus n’est accessible que par deux catégories d’opérations : les lectures et les
écritures. Un tel objet peut être un enregistrement d’un fichier, un fichier tout entier ou
même une base de données.
Exemples :
 La gestion des comptes bancaires
 Le système de réservation dans les compagnies aériennes.
Dans les deux cas les seules opérations réalisées sont des combinaisons de
consultation et de mise à jour des enregistrements.
a. Pas de priorité explicite
Var
Entier nl := 0 ; % pour compter le nombre de lectures en cours %
Semaphore mutex :=1 ; % pour assurer l’accès exclusif à la variable partagée nl %
Semaphore w :=1 ; % pour assurer l’accès exclusif au fichier entre les lecteurs et les
rédacteurs et entre plusieurs rédacteurs %
Processus lecteur Processus Rédacteur

Debut Debut
Répéter Répéter
P(mutex) ; P(w) ;
Nl := nl+1 ; <ecriture>;
Si (nl==1) alors P(W) fsi V(w) ;
V(mutex) ; Jusqu’à faux
<lecture> ; Fin
P(mutex) ;
Nl := nl-1 ;
Si (nl==0) alors V(W) fsi
V(mutex) ;
Jusqu’à faux
Fin
Commentaires :
1) Le fichier est considéré comme une ressource critique pour un rédacteur, c’est – à
–dire, si un rédacteur est en cours, aucun lecteur, ni rédacteur ne peut y accéder
(utilisation du sémaphore w).
2) Plusieurs lecteurs peuvent avoir lieu en même temps (utilisation du compteur nl).
3) Seul le premier lecteur qui arrive teste l’occupation de la section de la section
critique par un rédacteur éventuel. Les autres lecteurs accèdent directement si le
premier réussit l’accès, sinon ils se bloquent au niveau de mutex.

12
b. Priorité aux lecteurs
Processus lecteur Processus Rédacteur

Debut Debut
Répéter Répéter
P(mutex) ; P(mutex2) ;
Nl := nl+1 ;
Sinl==1 alors P(W) fsi P(w) ;
V(mutex) ; <ecriture>;
<lecture> ; V(w) ;
P(mutex) ; V(mutex2) ;
Nl := nl-1 ;
Sinl==0 alors V(W) fsi Jusqu’à faux
V(mutex) ; fin
Jusqu’à faux
Fin
Mutex2 empêche les rédacteurs d’attendre au niveau de w afin de donner la priorité

aux lecteurs dont le 1ier attend au niveau de w car une écriture est en cours.

13

Chapitre 02

Transféré par

Informations du document

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

Systèmes d’exploitation 2 (programme covid19) F.

Chapitre 2 : Synchronisation des processus

2. Partage des ressources et des données

Une ressource est soit partageable soit non partageable.

2.1.Exemple de situation incohérente

Soit le programme suivant :

printf (‘place réservée’) ;

printf (‘plus de place’) ;

Département informatique/faculté des sciences/université de Boumerdes.

Le langage machine correspondant à ce programme est comme suit :

(I1): load R1, place_dispo

(I2): cjump R1, plein

(I4): Store R1 place_dispo

(I5): Répondre (‘place réservée’)

(I6): jump fin

(I7): plein : répondre (‘plus de place’)

(I8) : fin : stop

En cas de plusieurs demandes de réservation simultanées; il y aura exécution pseudo-parallèle

Imaginons le scénario suivant:

Il reste une seule place disponible. Donc place_dispo==1

Soient deux processus P1 et P2

P1 s’exécute jusqu’à I3 ensuite préempté --> R1=1 (I1)

P1 continu son exécution à partir de (I4) --> place_dispo=0

(I5) P1 réserve une place et se termine.

Une même place a été réservée deux fois.

On s’aperçoit qu’éliminer les cas divergeant revient à rendre indivisible (atomique) la

La variable partagée est appelée ressource critique

Département informatique/faculté des sciences/université de Boumerdes.

3.2.Problème de l’exclusion mutuelle

3.3. La forme générale d’un processus

Département informatique/faculté des sciences/université de Boumerdes.

<S.R> //Section restante ou instructions hors de la section critique

3.4.Les conditions de la section critiques

 L’exclusion mutuelle : Si un processus est en section critique. Aucun autre processus ne

4. Mécanismes d’exclusion mutuelle

4.2.Solutions sans support matériel (les variables d’état)

Considérons deux processus Pi et Pj tel que Pi parallèle à Pj

Tour = i ; /*********variable partagée entre Pi et Pj **********/

1) Désarmement des interruptions

2) Instruction Test-And-Set (TAS ou TS)

Département informatique/faculté des sciences/université de Boumerdes.

Function Test_and_set (var x : boolean): Boolean

Programmation de la section critique

boolean lock= false ;

Tant que Test_and_set (lock) {}

Département informatique/faculté des sciences/université de Boumerdes.

Remarque : l’exécution de P et V est atomique.

4.4.1. Les différents types de sémaphores

Département informatique/faculté des sciences/université de Boumerdes.

5. Synchronisation des modèles classiques de communication

5.1.Communication par partage de variable

I. Le modèle producteur/ consommateur

Les processus producteurs produisent de l’information, consommée par les processus

Les producteurs sont en compétition, les consommateurs aussi.

Le problème de producteur consommateur admet deux variantes : si le tampon n’est pas

Cas : tampon de taille n

La communication se fait à travers un tampon de taille n (n cases)

Département informatique/faculté des sciences/université de Boumerdes.

 Le producteur ne peut déposer que s’il y a au moins une case vide.

a. Un seul producteur/ un seul consommateur.

nbplein :=0 : sémaphore permet de bloquer le consommateur dans le cas où le tampon

Nbvide :=n : sémaphore compte le nombre de case vide.

Processus producteur Processus Consommateur

Le producteur et le consommateur ne se bloquent jamais en même temps.

Tour = i ; /*variable partagée entre Pi et Pj **/