Chap3-SE-Synchronisation Et Communication Des Processus

1ième Partie
Etude des systèmes d’exploitation

Plan modifiable
 Introduction
 Gestion des processus
 Synchronisation des processus
 Gestion de la mémoire
 Gestion des fichiers
 Interblocage!!!
2
Chap:3
Communication & synchronisation

des processus
3
Communication inter-processus
Nous avons considéré, jusqu'à maintenant, les processus
comme des entités isolées n'ayant pour seul objectif que
leur exécution sur le processeur, et n'interagissant pas
avec le système ou avec d'autres processus.
Pourtant, des processus concurrents partagent des données
(zones mémoire, des fichiers, des ressources communes …)
entre eux, dans lesquels ils peuvent tous lire et écrire.
 Besoin de communiquer entre processus pour

échanger des données et informations,
 Besoin de synchronisation .
4
 Exemple1:
La commande unix suivante: $cat f1 f2 f3 | grep ''text'‘.
Les 2 processus (cat et grep) partagent le pipe (|) qui est une
sorte de fichier virtuel dans lequel un lit et l'autre écrit.
On parle donc de tâches coopératives.
5
 Des processus (ou des threads) peuvent s'échanger

des données par exemple par le pipeline du shell.
 Dans ce chapitre nous allons aborder quelques
problèmes liés à cette communication: (cas de trois
problèmes)
 Comment un processus fait passer des informations à
un autre (spécifique pour les processus)?,
 S'assurer que deux processus ou plus ne produisent
pas de conflits lorsqu'ils s'engagent dans des activités
critiques,
 Séquençage en présence de dépendance.
6
 Si l’accès concurrent à une ressource commune n’est

pas contrôlé, le résultat de l’exécution du programme
pourra dépendre de l’ordre d’entrelacement de
l’exécution des instructions
 conduit à une série de problèmes complexes d'inter-

blocage ou de corruption de données qui nécessitent
l'instauration de méthodes de synchronisation et
d'exclusion mutuelle. C'est ce que nous allons étudier
7
Définition: Un ensemble de processus est en inter-

blocage si chaque processus attend un événement que
seul un autre processus de l’ensemble peut provoquer.
Exemple: situation possible dans un carrefour à priorité à

droite.
8
Exemple 1 de corruption de données:
Utilisation du spoule d'impression:

- Les fichiers à imprimer sont stockées dans un
répertoire de spoule
- Chaque tâche reçoit à son arrivée un numéro

d’ordre d’exécution strictement croissant.
9
k
Pour administrer ce répertoire, deux variable globales

partagées in et out contiennent respectivement le
prochain numéro de tâche à attribuer, et le prochain
numéro de tâche à imprimer ( toujours in ≥ out )
Supposons que, à un instant donné, on ait in = 7 et

out = 4
10
Si, au même moment, deux processus A et B

souhaitent lancer l’impression d’un fichier, ils doivent
chacun exécuter la séquence suivante:
local_in = in;
placer_job (local_in);
in = local_in + 1;
11
Si le premier processus à effectuer cette séquence est

interrompu par l’ordonnanceur entre la 1ère et la 3ème
instruction, les 2 processus utiliseront le même numéro
pour placer leur tâche, et l’un des deux travaux sera
perdu.
Le démon d'impression n'en saura jamais rien, et

imprimera uniquement le fichier du dernier processus à
exécuter : placer_job (local_in);
12
Exemple 2-corruption de données
 Deux processus P1 et P2 Procédure:
exécutent cette même * M. X demande une
procédure et partagent la
même base de données réservation d’avion
* Base de données dit
 Ils peuvent être interrompus que fauteuil A est
n’importe où disponible
* Fauteuil A est assigné à
 Le résultat de l’exécution X et marqué occupé
concurrente de P1 et P2
dépend de l’ordre de leur
entrelacement
13
Vue globale d'une exécution possible
P1 interruptions P2
M. X demande une
réservation d’avion
M. Y demande une
réservation d’avion
Base de données dit à X que

fauteuil 30A est disponible Base de données dit à Y que
fauteuil 30A est disponible
Fauteuil 30A est assigné à X
et marqué occupé Fauteuil 30A est assigné à Y et
marqué occupé
14
Objets et sections critiques
 Problèmes: corruption des données.
 Solution: faire intervenir un seul processus à la fois sur

un objet ou section critique ( exclusion mutuelle)
15
Objet critique Section critique

Objet auquel ne peuvent Suite d'instructions d'un
accéder deux processus programme qui vont
simultanément. manipuler des objets
critiques.
Exemple: fichiers, mémoire

imprimantes, variables... Exemple: lire in;
local_in = in;
Section critique placer_job(local_in);
in = local_in + 1;
16
Structure d'un programme
 Chaque processus doit donc demander une permission avant d’entrer dans
une section critique (SC)
 La section de code qui effectue cette requête est la section d’entrée
 La section critique est normalement suivie d’une section de sortie
 Le code qui reste est la section restante
section d’entrée
section critique
section de sortie
section restante
Avec l'hypothèse qu'un programme ne contient qu'une seule section

critique.
17
Application
18
Race conditions (conditions de course)
 Les situations dans lesquelles des processus peuvent être en ''course'
pour accéder à certaines ressources et dont le résultat dépend de
l'ordre d'accès sont appelées
conditions de course ( race conditions) .
=> Non déterminisme: le résultat est aléatoire avec les mêmes données.
 Solution: une section critique SC ne doit être exécutée que par un

seul processus à la fois ( on dira que le processus est dans sa SC)
19
Critères nécessaires pour solutions valides
 Deux processus ne peuvent pas être en même temps en section

critique relative à une ressource commune.
 Aucune hypothèse ne doit être faite sur les vitesses relatives des
processus et sur le nombre de processeurs.
 Non interférence: Si un processus s’arrête dans sa section
restante ( en dehors de sa section critique ) , ceci ne devrait pas
affecter les autres processus = ne doit pas les bloquer.
 Progrès: absence d'inter-blocage; c-à-d: si un processus demande
d’entrer dans une section critique à un moment où aucun autre
processus n'en fait la requête, il devrait être en mesure d’y entrer.
20
Types de solutions
 Solutions par logiciel

des algorithmes dont la validité ne s’appuie pas sur l’existence
d’instructions spéciales.
 Solutions fournies par le matériel
s’appuient sur l’existence de certaines instructions spéciales (du

processeur).
 Solutions fournies pas le SE
procure certains appels systèmes au programmeur.
21
Remarques
 Toutes les solutions se basent sur l’atomicité de l’accès à

la mémoire centrale: une adresse de mémoire ne peut être
affectée que par une instruction à la fois, donc par un
processus à la fois.
 Plus en général, toutes les solutions se basent sur

l ’existence d’instructions atomiques, qui fonctionnent
comme des SC de base
Atomicité = indivisibilité
22
Solutions logicielles
1-Masquage des interruptions d'horloge:

Un processus qui entre en section critique masque les
interruptions d'horloge jusqu'à ce qu'il sort de sa SC.
INCONVENIENTS:
 Solution dangereuse; si c'est un programme utilisateur il y a risque
de ne pas enlever le masquage.
 Non efficace dans le cas d'un système multiprocesseur (car seul le
processeur qui exécute le processus en SC qui aura désactivé les
interruptions d'horloge)
23
2-Variable verrou:
« Une variable de verrouillage est une variable binaire 0 ou
1 partagée par les processus, qui va indiquer si un
processus est en section critique ou non.»
 Si verrou==0 SC est libre
 Si verrou==1 SC occupée
24
Algorithme:
entrer_SC()
sortir_SC()
{
{
If
(verrou==0)
verrou=0;
Verrou=1;
}
else while(verrou==1) { /*boucler*/}
} /* attente active */
Problème: la variable verrou est est elle même partagée objet

critique!! L'exclusion mutuelle n'est assurée que si la variable
verrou est protégée.
25
3-l'alternance stricte:
On utilise une variable tour partagée qui va contenir le
numéro du processus à entrer en section critique.
Algorithme pour N processus:
entrer_SC(int NumProcess)
sortir_SC()
{
{
While ( tour != NumProcess) /*attente active*/
tour=(NumProcess+1) %N;
}
}
26
Alternance stricte
Avantages: simple et facile à utiliser.
Inconvénients: Risque de famine, si le tour est donné à

un processus non intéressé par la SC.
27
 4- Algorithme de Peterson (1981):

 On va introduire une nouvelle variable par processus
pour savoir s'il est intéressé ou non par la SC.
28
Algorithme de Peterson
#define N 2 /* nombre de processus */
/* variables partagées par tous les process */
int tour; /* à qui le tour */
int interesse[N]; /* initialisé à FALSE */
void entrer_region(int processus) /* process appelant vaut 0 ou 1 */
{
int autre; /* numéro de l'autre processus */
autre = 1-processus;
interesse[processus] = TRUE; /* indiquer son intérêt */
tour = processus; /* positionner le drapeau d'accès */
while(tour == processus && interesse[autre] == TRUE); /* attente active*/
}
void quitter_region(int processus) /* numéro du processus appelant ici
processus vaut 0 ou 1 */
{ interesse[processus] = FALSE;
/* indiquer la sortie de la section critique */
} 29
Process P0: Process P1:
autre=1 autre=0;
interesse [0] = vrai; interesse[1] = vrai;
// 1 veut entrer
// 0 veut entrer
tour = 0; tour = 1;
while while
(intesse[1]==vrai&&tour=0) (intersse[0]==vrai&&tour=1
{}; {/*attente*/};
SC SC
interesse[0] = faux; interesse[1] = faux;
// 0 quitte section critique // 1 quitte section critique
SR SR
Algorithme de Peterson vue globale

30
L'idée principale de l'algorithme est d'utiliser deux variables

différentes :
L'une indiquant que l'on s'apprête à utiliser une ressource

commune (interesse[ ]), et l'autre (tour) qui, comme
dans le cas de l'alternance, indique le processus qui
utilisera la ressource au prochain tour.
31
Lorsqu'un processus veut entrer en section critique, il notifie les
autres de ses intentions en positionnant correctement son entrée
dans le tableau interesse[ ], puis il s'approprie le prochain tour.
Siles 2 processus appellent enter_region simultanément, tous

deux vont stocker leur numéro de processus dans tour
C’estl’opération de stockage la plus tardive qui est prise en

compte.
Supposons que le processus soit stocké en dernier tour=1.
Lorsque les 2 processus arrivent à l’instruction while,
- Le processus 0 ne l’exécute pas et entre en SC.
- Le processus 1 boucle et n’entre pas en SC tant que le
processus 0 n’a pas quitté la sienne
32
Lacunes des solutions logiciel

 Difficiles a programmer!
 Les processus qui requièrent l’entrée dans leur SC
sont occupés à attendre (busy waiting);
consommant ainsi du temps processeur
 Pour de longues sections critiques, il serait

préférable de bloquer les processus qui doivent
attendre...( les endormir)
33
Solution matérielles
En étudiant de près les problèmes liés à l'exclusion

mutuelle et la corruption de données qui peut en
découler, on constate que le point critique se trouve
entre la lecture d'une variable et son écriture.
Si un changement de contexte intervient entre ces deux

actions,
et un autre processus écrit dans la variable après que la

première l'ait lue,
le premier se trouve dans un état incohérent, et peut,

ensuite provoquer des actions néfastes (comme
l'exemple du spoule d'impression).
34
Cette analyse a conduit, sur certaines

architectures, à introduire une commande
atomique au niveau du langage d'assembleur,
permettant à la fois de lire et d'écrire une
variable en une instruction
35
L'instruction: TSL RX, LOCK

Test and Set Lock, ( tester et définir le verrou ) qui fonctionne
ainsi:
Elle charge le contenu du mot mémoire LOCK dans le
registre RX, et en même temps, elle met la valeur LOCK à 1.
Cette instruction est garantie comme étant atomique, c'est-à-
dire que l'arrivée d'une interruption ne sera acquittée par le
processeur que lorsque l'opération du TSL sera terminée
Le processeur dispose de petites zones de mémoire très

rapides, appelées registres
36
Avantage de l’instruction TSL
elle occupe le bus pendant toute son exécution. De ce
simple fait, elle empêche d'éventuels autres processeurs
d'accéder en même temps au mot mémoire LOCK.
Lorsque LOCK est à 0, n’importe quel processus peut la

positionner à 1 via TSL et entrer en SC, à la fin de la SC, le
processus repositionne LOCK à 0 à l’aide d’une instruction
move.
Du fait de l’atomicité, les fonctions entrer_region() et
quitter_region() peuvent êtres écrites en assembleur de la
façon suivante :
37
TSL registre, lock entrer_region:

| copier lock dans registre, et
| mettre lock à 1
CMP registre,#0 | lock était-elle à 0 ?
BNZ entrer_region | si différent boucler ( aller
| au début et refaire le test
RET | retourne à l'appelant; entre en
| section critique
quitter_region:
MOVE LOCK, #0 | écrire 0 dans lock
RTS | retourne à l'appelant; entre
| en section restante
38
Solutions avec attente passive
Problème:
Attente active: Consommation des ressources du processeur.
Un processus qui est en attente, effectue une boucle while,
gaspillant ainsi du temps processeur inutilement.
Exemple: supposons qu'on a 2 processus H avec une haute
priorité et B avec une basse priorité, dans le cas d'un système
temps réel.
Si H est entrain de réaliser une opération d' E/S et B entre en
SC. H termine son E/S élu prioritaire
va être exécuté avant que B ne sorte de sa SC donc
H va boucler indéfiniment.
39
Solution:
Endormir un processus en attente et le réveiller dès
que la ressource est libre, pour cela , il y a 2 appels
système:
Sleep() pour endormir le processus appelant
Wakeup(...) pour réveiller le processus passé en
argument
40
Exemple: problème producteur/consommateur
Tampon de taille fixe

Product Consomm
eur ateur
Problèmes:
 Tampon plein et producteur veut rajouter un élément

 Tampon vide et consommateur veut retirer un élément
 Exclusion mutuelle, un seul processus doit manipuler le tampon à la fois
41
Algorithme
Soit N la taille du tampon.
On va jouer sur le nombre d'éléments dans le tampon qu'on va stocker dans
une variable compteur
#define N 100 /* nbre d’emplacement ds tampon */

int compteur = 0 ; /* nbre d’objets ds tampon */
void producteur () { void consommateur () {

while (VRAI) { while (TRUE) {
produire_element(…) ; if (compteur == 0) sleep() ;
if (compteur == N) sleep () ; retirer_element(…);
mettre_element(…) ; compteur = compteur – 1 ;
compteur = compteur + 1 ; if (compteur == N-1)
if (compteur == 1) wakeup (producteur) ;
wakeup(consommateur) }
} }
}
42
Analyse de cette solution :

1. L’accès à la variable compteur n’est pas protégé (objet
critique), ce qui peut entraîner des incohérences dans
les valeurs prises par cette variable
2. Réveils perdus : c’est le principal défaut de ce
mécanisme. Un signal wakeup envoyé à un processus
qui ne dort pas (encore) est perdu.
Une Solution à ce problème consiste à rajouter dans la table du
processus un bit d'attente d'éveil (wakeup waiting bit), lorsqu'un
wakeup est envoyé à un processus non encore endormi ce bit est
positionné, si le processus tente de se mettre en sommeil et si le bit
est positionné, il va le mettre à 0 et reste éveillé.(valable pour 2
processus)
43
Sémaphores
Pour contrôler les accès à un objet partagé E. W. Dijkstra

proposa en 1965 un nouveau type de variables
appelées: sémaphores. Ils sont maintenant largement
utilisés dans les systèmes d'exploitation modernes.
Définition:
 Un sémaphore est un compteur entier qui désigne le
nombre d'accès disponible à une certaine ressource.
 Chaque sémaphore à un nom et une valeur initiale.
 Les sémaphores sont manipulés par des opérations:

 P() (désigné aussi par down() ou wait ) décrémente la
sémaphore.
 V() ( désigné par up() ou signal ) incrémente la
sémaphore.
44
Sémaphores
La commande P(), décrémente le sémaphore.
La commande V() incrémente la valeur du sémaphore si

elle est strictement supérieure à zéro, puis rend la main à
l'appelant
Si la valeur du sémaphore vaut zéro, le processus bascule en

mode bloqué jusqu'à ce que la valeur du sémaphore
redevienne positive et que le processus soit réveillé par le
système.
Lors de son réveil, le processus décrémente la valeur du

sémaphore et continue son exécution.
45
Sémaphores
Exemple: semaphore: sem_t dans la norme POSIX

#include <semaphore.h>
Semaphore S=2; /* 2 accès disponibles*/
Processus P1{
P(S); /* décrémenter S, S=1*/
SC_P1; /* P1 entre en section critique*/
V(S); /* incrémenter S, S=2*/
}
Les opérations P() et V() doivent être implémentées de façon

atomique par le SE avec TSL
46
Sémaphores
Solution du problème producteur /consommateur
On aura besoin de 3 sémaphores :

1- mutex: pour assurer l'exclusion mutuelle initialisé à 1
2- occupe: compte le nombre d'emplacements occupés
initialisé 0, il sert à bloquer/débloquer le consommateur
3- libre: compte le nombre d'emplacements libres initialisé
à N, il sert à bloquer/débloquer le producteur.
47
Sémaphores
#define N 100 /* nombre de places dans le tampon */
Semaphore mutex = 1 ; /* contrôle d'accès au tampon */
semaphore libre = N ; /* nb de places libres */
Semaphore occupe = 0; /* nb de places occupées */
void producteur (void) {
Int element ;
while (TRUE) { produire_element (&element) ; /* produire l'élément suivant */
P (libre) ; /* déc. nb places libres */
P (mutex) ; /* entrée en section critique */
mettre_element (element) ; /* mettre l'élément dans le tampon */
V (mutex) ; /* sortie de section critique */
V (occupe) ; /* inc. nb place occupées et wakeup consommateur*/
}
}
48
Sémaphores
void consommateur (void)
{
int element ;
while (TRUE) {
P (occupe) ; /* déc. nb emplacements occupés */
P (mutex) ; /* entrée section critique */
prelever_element (element) ; /* retire un élement du tampon */
V (mutex) ; /* sortie de la section critique */
V (vide) ; /* inc. nb emplacements libres */
}
}
49
Sémaphores
Remarque
semaphore S;
 P(S) décrémente le sémaphore S si S>0 sinon
blocage du processus appelant.
 V(S) incrémente le sémaphore S si aucun
processus n'est bloqué par P(S), sinon l'un d'entre
eux sera choisi pour être élu
50
Problème proposé par Dijkstra en 1965 est le suivant :
 5 philosophes sont assis autour d’une table ;
 5 plats de spaghettis (un devant chaque philosophe) ;
 5 fourchettes situées entre chaque plat.
 Soit le philosophe mange, soit il réfléchit (il repose alors ses
fourchettes)
 Pour manger, ils ont besoin de deux fourchettes ;
 Quand un philosophe désire manger, il tente de prendre la fourchette
à sa droite et la fourchette à sa gauche, dans un ordre quelconque ;
 Un philosophe mange pendent un moment donné, puis repose ses
fourchettes (pour réfléchir).
Trouver une solution en proposant un algorithme.
51
Procédure phi losophe ( i : entier )
Début
TantQue ( vrai ) Faire
penser ( )
prendre_fourchet tes ( i )
manger ( )
poser_fourchet tes ( i )
FinTantQue
Fin
Quelle sont les ressources critiques?

On suppose que chaque philosophe tente de prendre d’abord la fourchette de droite ;
Puis ensuite, celle de gauche. Est-ce logique?
Si on prend un Sémaphore par fourchette ;
Problème:
Que se passe-t-il si tous les philosophes ont faim en même temps ?
52
Si on prend un Sémaphore par fourchette ;
Chaque philosophe tente de prendre d’abord la fourchette de droite ;
Puis ensuite, celle de gauche. Pourquoi?
Problème:
Que se passe-t-il si tous les philosophes ont faim en même temps ?
Explications :
Le test et la modification de la valeur d’un sémaphore se font de manière
atomique ; entre deux test/modification, il peut y avoir commutation de contexte.
Donner les états pour les philosophes.
Description
On définit 3 états pour les philosophes :
Pense ;
Faim (en attente de manger) ;
Mange
53
Les états des philosophes sont placés dans un tableau états.
Lorsqu’un philosophe veut manger :
1. Il passe dans l’état Faim;
2. Vérifie qu’aucun de ces voisins ne mange ;
3. Si c’est le cas, il passe lui-même dans l’état Mange ;
4. Sinon, il est bloqué.
Pour s’assurer de ne pas être interrompu pendant cette phase :
utilisation d’un sémaphore S.
Lorsqu’un philosophe termine de manger
Lorsqu’un philosophe a faim et n’est pas en mesure de manger, il est
bloqué ;
Pour bloquer les philosophes, on utilise un sémaphore pour chacun :
Tableau de sémaphores T.
Lorsqu’un philosophe termine de manger :
Il passe dans l’état Pense
Vérifie si son voisin de gauche est bloqué :
Si c’est le cas, il vérifie s’il peut le débloquer ;
Idem avec le voisin de droite.
54
Procédure philosophe(i : entier)
TantQue ( vrai) Faire
penser ( )
prendre_fourchettes ( i )
manger ( )
poser_fourchettes ( i )
FinTantQue
Procédure test(i : entier)

gauche <− ( i + N − 1) modulo N
droite <− ( i + 1) modulo N
Si ( etats( gauche ) != mange ) et ( etats ( droite ) != mange ) et
( etats ( i ) == faim ) Alors
etats ( i ) <− mange
V(T[ i ] )
FinSi
55
Procédure prendre fourchette(i : entier)
P(S) / / Entrée en section critique
etats ( i ) <− faim / / On passe dans l ’état faim
test ( i ) / / On tes te s i on peut passer dans l ’état manger
V(S) / / Sortie de section critique
P(T [ i ] ) / / On bloque s i on n’a pu prendre les fourchet tes
Procédure poser fourchette(i : entier)

P(S) / / Entrée en section critique
etat s ( i ) <− pense / / On repasse dans l ’état pense
/ / On tes te s i l e v o i s i n de gauche peut manger
gauche <− ( i + N − 1) modulo N
t e s t ( gauche )
/ / On teste si le voisin de droite peut manger
droite <− ( i + 1) modulo N
test ( droite )
V(S) / / Sortie de section critique
56

Chap3-SE-Synchronisation Et Communication Des Processus

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

Chap3-SE-Synchronisation Et Communication Des Processus

Transféré par

Droits d'auteur :

Formats disponibles

1ième Partie

Etude des systèmes d’exploitation

Communication & synchronisation

 Besoin de communiquer entre processus pour

On parle donc de tâches coopératives.

 Des processus (ou des threads) peuvent s'échanger

 Si l’accès concurrent à une ressource commune n’est

 conduit à une série de problèmes complexes d'inter-

Définition: Un ensemble de processus est en inter-

Exemple: situation possible dans un carrefour à priorité à

Exemple 1 de corruption de données:

Utilisation du spoule d'impression:

- Chaque tâche reçoit à son arrivée un numéro

Pour administrer ce répertoire, deux variable globales

Supposons que, à un instant donné, on ait in = 7 et

Si, au même moment, deux processus A et B

Si le premier processus à effectuer cette séquence est

Le démon d'impression n'en saura jamais rien, et

Base de données dit à X que

Objets et sections critiques

 Problèmes: corruption des données.

 Solution: faire intervenir un seul processus à la fois sur

Objet critique Section critique

Exemple: fichiers, mémoire

Avec l'hypothèse qu'un programme ne contient qu'une seule section

 Solution: une section critique SC ne doit être exécutée que par un

 Deux processus ne peuvent pas être en même temps en section

 Solutions par logiciel

s’appuient sur l’existence de certaines instructions spéciales (du

procure certains appels systèmes au programmeur.

 Toutes les solutions se basent sur l’atomicité de l’accès à

 Plus en général, toutes les solutions se basent sur

1-Masquage des interruptions d'horloge:

else while(verrou==1) { /*boucler*/}

Problème: la variable verrou est est elle même partagée objet

Avantages: simple et facile à utiliser.

Inconvénients: Risque de famine, si le tour est donné à

 4- Algorithme de Peterson (1981):

Algorithme de Peterson vue globale

L'idée principale de l'algorithme est d'utiliser deux variables

L'une indiquant que l'on s'apprête à utiliser une ressource

Siles 2 processus appellent enter_region simultanément, tous

C’estl’opération de stockage la plus tardive qui est prise en

Lacunes des solutions logiciel

 Pour de longues sections critiques, il serait

En étudiant de près les problèmes liés à l'exclusion

Si un changement de contexte intervient entre ces deux

et un autre processus écrit dans la variable après que la

le premier se trouve dans un état incohérent, et peut,

Cette analyse a conduit, sur certaines

L'instruction: TSL RX, LOCK

Le processeur dispose de petites zones de mémoire très

Lorsque LOCK est à 0, n’importe quel processus peut la

TSL registre, lock entrer_region:

Exemple: problème producteur/consommateur

Tampon de taille fixe

 Tampon plein et producteur veut rajouter un élément

#define N 100 /* nbre d’emplacement ds tampon */

void producteur () { void consommateur () {

Analyse de cette solution :

Pour contrôler les accès à un objet partagé E. W. Dijkstra

 Les sémaphores sont manipulés par des opérations:

La commande V() incrémente la valeur du sémaphore si

else while(verrou==1) { /boucler/}