Chap3 SE&Unix

Etude des systmes dexploitation
K. RHOFIR
Systme dexploitation&Unix
2013/14
Plan modifiable
Introduction
Gestion des processus
Synchronisation des processus
Gestion de la mmoire
Gestion des fichiers
Interblocage
Gestion des entres/sorties
.
2013/14
Chap:3
Communication & synchronisation des

processus
2013/14
Communication inter-processus
Jusqu' maintenant nous avons considr les processus comme

des entits isoles n'ayant pour seul objectif que leur excution
sur le processeur, et n'interagissant pas avec le systme ou avec
d'autres processus.
Pourtant, des processus concurrents partagent des donnes (zones de

la mmoire, des fichiers, des ressources communes ) entre eux, dans
lesquels ils peuvent tous lire et crire.
Besoin de communiquer entre processus pour changer des

donnes et informations,
Besoin de synchronisation .
2013/14
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 l'un lit et l'autre crit.
On parle donc de tches coopratives.
2013/14
Des processus ou des threads peuvent s'changer des donnes

par exemple par le pipeline du shell.
Dans ce chapitre nous allons aborder quelques problmes lis
cette communication: (3 problmes)
Comment un processus fait passer des infos un autre (

spcifique pour les processus)?,
S'assurer que 2 processus ou plus ne produisent pas de conflits
lorsqu'ils s'engagent dans des activits critiques,
Squenage en prsence de dpendance.
2013/14
Si laccs concurrent une ressource commune nest pas

contrl, le rsultat de lexcution du programme pourra
dpendre de lordre dentrelacement de lexcution des
instructions
conduit une srie de problmes complexes d'inter-blocage

ou de corruption de donnes qui ncessitent l'instauration de
mthodes de synchronisation et d'exclusion mutuelle. C'est ce
que nous allons tudier
2013/14
Dfinition: Un ensemble de processus est en inter-blocage si

chaque processus attend un vnement que seul un autre
processus de lensemble peut provoquer.
Exemple: situation possible dans un carrefour priorit droite.
2013/14
Exemple 1 de corruption de donnes:

Utilisation du spoule d'impression:
- Les fichiers imprimer sont stockes dans un rpertoire

de spoule
- Chaque tche reoit son arrive un numro dordre
dexcution strictement croissant.
2013/14
Pour administrer ce rpertoire, deux variable globales

partages in et out contiennent respectivement le prochain
numro de tche attribuer, et le prochain numro de tche
imprimer ( toujours in out )
Supposons que, un instant donn, on ait in = 7 et out = 4
2013/14
Si le premier processus effectuer cette squence est interrompu

par lordonnanceur entre la 1re et la 3me instruction, les 2
processus utiliseront le mme numro pour placer leur tche, et
lun des deux travaux sera perdu.
Le dmon d'impression n'en saura jamais rien, et imprimera

uniquement le fichier du dernier processus excuter :
placer_job (local_in);
2013/14
Exemple 2-corruption de donnes

Deux processus P1 et P2
excutent cette mme procdure
et partagent la mme base de
donnes
Ils peuvent tre interrompus

nimporte o
Le rsultat de lexcution
concurrente de P1 et P2 dpend de
lordre de leur entrelacement
Procdure:
* M. X demande une rservation
davion
* Base de donnes dit que
fauteuil A est disponible
* Fauteuil A est assign X et
marqu occup
2013/14
Vue globale d'une excution possible

P1
interruptions
P2
M. X demande une rservation

davion
M.Y demande une
rservation davion
Base de donnes dit X que

fauteuil 30A est disponible
Base de donnes dit Y que

fauteuil 30A est disponible
Fauteuil 30A est assign X et

marqu occup
Fauteuil 30A est assign Y et

marqu occup
2013/14
Objets et sections critiques
Problmes: corruption des donnes.
Solution: faire intervenir un seul processus la fois sur un objet

ou section critique ( exclusion mutuelle)
2013/14
Objet critique
Section critique
Objet auquel ne peuvent

accder deux processus
simultanment.
Suite d'instructions d'un

programme qui vont
manipuler des objets
critiques.
Exemple: fichiers, mmoire

imprimantes, variables...
Exemple: lire in;
Section critique
2013/14
local_in = in;
placer_job (local_in);
in = local_in + 1;
Structure d'un programme
Chaque processus doit donc demander une permission avant dentrer dans une section
critique (SC)
La section de code qui effectue cette requte est la section dentre
La section critique est normalement suivie dune section de sortie
Le code qui reste est la section restante

section dentre
section critique
section de sortie
section restante
Avec l'hypothse qu'un programme ne contint qu'une seule section critique.
2013/14
Application
2013/14
Race conditions (conditions de course)
Les situations dans lesquelles des processus peuvent tre en ''course'' pour accder
certaines ressources et dont le rsultat dpend de l'ordre d'accs
sont appeles conditions de course ( race conditions) .
=> Non dterminisme: le rsultat est alatoire avec les mmes donnes.
Solution: une section critique SC ne doit tre excute que par un seul
processus la fois ( on dira que le processus est dans sa SC)
2013/14
Critres ncessaires pour solutions valides
Deux processus ne peuvent pas tre en mme temps en section critique

relative une ressource commune.
Aucune hypothse ne doit tre faite sur les vitesses relatives des processus et
sur le nombre de processeurs.
Non interfrence: Si un processus sarrte dans sa section restante ( en
dehors de sa section critique ) , ceci ne devrait pas affecter les autres
processus = ne doit pas les bloquer.
Progrs: absence d'inter-blocage; c--d: si un processus demande dentrer
dans une section critique un moment o aucun autre processus n'en fait la
requte, il devrait tre en mesure dy entrer.
2013/14
Types de solutions
Solutions par logiciel
des algorithmes dont la validit ne sappuie pas sur lexistence
dinstructions spciales.
Solutions fournies par le matriel
sappuient sur lexistence de certaines instructions spciales (du
processeur).
Solutions fournies pas le SE
procure certains appels systmes au programmeur.
2013/14
Remarques
Toutes les solutions se basent sur latomicit de laccs la

mmoire centrale: une adresse de mmoire ne peut tre affecte que
par une instruction la fois, donc par un processus la fois.
Plus en gnral, toutes les solutions se basent sur l existence

dinstructions atomiques, qui fonctionnent comme des SC de base
Atomicit = indivisibilit
2013/14
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 systme multiprocesseur (car seul le processeur qui
excute le processus en SC qui aura dsactiv les interruptions d'horloge)
2013/14
2-Variable verrou:
Une variable de verrouillage est une variable binaire 0 ou 1
partage par les processus, qui va indiquer si un processus est en
section critique ou non.
Si verrou==0
Si verrou==1
SC est libre
SC occupe
2013/14
Algorithme:
entrer_SC()
sortir_SC()
If (verrou==0)
verrou=0;
Verrou=1;
else while(verrou==1) { /*boucler*/}

} /* attente active */
Problme: la variable verrou est elle mme partage

objet critique!!
L'exclusion mutuelle n'est assure que si la variable verrou est protge.
2013/14
3-l'alternance stricte:
On utilise une variable tour partage qui va contenir le numro du
processeur entrer en section critique.
Algorithme pour N processus:

entrer_SC(int NumProcess)
sortir_SC()
While ( tour != NumProcess)
/* attente active */
tour=(NumProcess+1) %N;
}
2013/14
Alternance stricte
Avantages: simple et facile utiliser.
Inconvnients: Risque de famine, si le tour est donn un

processus non intress par la SC.
2013/14
4- Algorithme de Peterson (1981):
On va introduire une nouvelle variable par processus pour savoir s'il
est intress ou non par la SC.
2013/14
Algorithme de Peterson
#define N 2 /* nombre de processus */
/* variables partages 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; /* numro de l'autre processus */
autre = 1-processus;
interesse[processus] = TRUE; /* indiquer son intrt */
tour = processus; /* positionner le drapeau d'accs */
while(tour == processus && interesse[autre] == TRUE); /* attente active*/
}
void quitter_region(int processus) /* numro du processus appelant ici process vaut 0
ou 1 */
{ interesse[processus] = FALSE;
/* indiquer la sortie de la section critique */
}
K. Rhofir @2012/13
Process P0:
autre=1
interesse [0] = vrai;
// 0 veut entrer
tour = 0;
while
(intesse[1]==vrai&&tour=0)
{};
SC
interesse[0] = faux;
// 0 quitte section critique
SR
Process P1:
autre=0;
interesse[1] = vrai;
// 1 veut entrer
tour = 1;
while
(intersse[0]==vrai&&tour=1)
{};
SC
interesse[1] = faux;
// 1 quitte section critique
SR
Algorithme de Peterson vue globale
K. Rhofir @2012/13
L'ide principale de l'algorithme est d'utiliser deux variables

diffrentes :
l'une indiquant que l'on s'apprte 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.
2013/14
Lorsqu'un
processus veut entrer en section critique, il notifie les autres de

ses intentions en positionnant correctement son entre dans le tableau
interesse[ ], puis il s'approprie le prochain tour.
Si
les 2 processus appellent enter_region simultanment, tous deux vont

stocker leur numro de processus dans tour
Cest
lopration 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 linstruction while,
- Le processus 0 ne lexcute pas et entre en SC.
- Le processus 1 boucle et nentre pas en SC tant que le processus 0 na
pas quitt la sienne
K. Rhofir @2012/13
Lacunes des solutions logiciel

Difficiles a programmer!
Les processus qui requirent lentre dans leur SC sont
occups attendre (busy waiting); consommant ainsi du
temps processeur
Pour de longues sections critiques, il serait prfrable de

bloquer les processus qui doivent attendre...( les endormir)
2013/14
Solution matrielles
En tudiant de prs les problmes lis l'exclusion mutuelle et la

corruption de donnes qui peut en dcouler, 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 aprs que la premire

l'ait lue,
le premier se trouve dans un tat incohrent, et peut, ensuite

provoquer des actions nfastes (comme l'exemple du spoule
d'impression).
2013/14
Solution matrielles
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
2013/14
Solution matrielles
L'instruction: TSL RX, LOCK
Test and Set Lock, ( tester et dfinir le verrou ) qui fonctionne ainsi:
Elle charge le contenu du mot mmoire LOCK dans le registre RX, et
en mme temps, elle met la valeur LOCK 1.
Cette instruction est garantie comme tant atomique, c'est--dire que
l'arrive d'une interruption ne sera acquitte par le processeur que
lorsque l'opration du TSL sera termine
Le processeur dispose de petites zones de mmoire trs rapides, appeles
registres
35
2013/14
Avantage de linstruction TSL

elle occupe le bus pendant toute son excution. De ce simple
fait, elle empche d'ventuels autres processeurs d'accder en
mme temps au mot mmoire LOCK.
Lorsque LOCK est 0, nimporte quel processus peut la
positionner 1 via TSL et entrer en SC, la fin de la SC, le
processus repositionne LOCK 0 laide dune instruction
move.
Du fait de latomicit, les fonctions entrer_region() et
quitter_region() peuvent tres crites en assembleur de la
faon suivante :
K. Rhofir @2012/13
Solution matrielles
entrer_region:
TSL registre, lock
CMP registre,#0
BNZ entrer_region
RET
quitter_region:
MOVE LOCK, #0
RTS
| copier lock dans registre, et

| mettre lock 1
| lock tait-elle 0 ?
| si diffrent boucler ( aller
| au dbut et refaire le test
| retourne l'appelant; entre en
| section critique
| crire 0 dans lock

| retourne l'appelant; entre
| en section restante
K. Rhofir @2012/13
Solutions avec attente passive

Problme:
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 systme temps rel.
Si H est entrain de raliser une opration d' E/S et B entre en SC. H
termine son E/S
lu prioritaire va tre excut avant que B ne
sorte de sa SC donc H va boucler indfiniment.
2013/14
Solution:
Endormir un processus en attente et le rveiller ds que la
ressource est libre, pour cela , il y a 2 appels systme:
Sleep() pour endormir le processus appelant
Wakeup(...) pour rveiller le processus pass en argument
2013/14

Exemple: problme producteur/consommateur
Tampon de taille fixe
Producteur
Consommateur
Problmes:
Tampon plein et producteur veut rajouter un lment

Tampon vide et consommateur veut retirer un lment
Exclusion mutuelle, un seul processus doit manipuler le tampon la fois
2013/14

Algorithme
Soit N la taille du tampon.
On va jouer sur le nombre d'lments dans le tampon qu'on va stocker
dans une variable compteur
#define N 100
/* nbre demplacement ds tampon */
int compteur = 0 ;
/* nbre dobjets ds tampon */
void producteur () {
while (TRUE) {
produire_element() ;
if (compteur == N) sleep () ;
mettre_element() ;
compteur = compteur + 1 ;
if (compteur == 1) wakeup(consommateur)
}
}
void consommateur () {
while (TRUE) {
if (compteur == 0) sleep() ;
retirer_element();
compteur = compteur 1 ;
if (compteur == N-1)
wakeup (producteur) ;
}
}
2013/14
Analyse de cette solution :

1. Laccs la variable compteur nest pas protg (objet critique), ce
qui peut entraner des incohrences dans les valeurs prises par
cette variable
2. Rveils perdus : cest le principal dfaut de ce mcanisme. Un
signal wakeup envoy un processus qui ne dort pas (encore) est
perdu.
Une Solution ce problme 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)
2013/14
Smaphores
Pour contrler les accs un objet partag E. W. Dijkstra proposa
en 1965 un nouveau type de variables appeles: smaphores. Ils
sont maintenant largement utiliss dans les systmes
d'exploitation modernes.
Dfinition:
Un smaphore est un compteur entier qui dsigne le nombre
d'accs disponible une certaine ressource.
Chaque smaphore un nom et une valeur initiale.
Les smaphores sont manipuls par des oprations:
P() (dsign aussi par down() ou wait ) dcrmente la smaphore.

V() ( dsign par up() ou signal ) incrmente la smaphore.
2013/14
Smaphores
La commande P(), dcrmente le smaphore.
La commande V() incrmente la valeur du smaphore si elle est

strictement suprieure zro, puis rend la main l'appelant
Si la valeur du smaphore vaut zro, le processus bascule en mode

bloqu jusqu' ce que la valeur du smaphore redevienne positive et que
le processus soit rveill par le systme.
Lors de son rveil, le processus dcrmente la valeur du smaphore et

continue son excution.
2013/14
Smaphores
Exemple: semaphore: sem_t dans la norme POSIX
#include <semaphore.h>
Semaphore S=2; /* 2 accs disponibles*/
Processus P1{
P(S);
/* dcrmenter S, S=1*/
SC_P1;
/* P1 entre en section critique*/
V(S);
/* incrmenter S, S=2*/
}
Les oprations P() et V() doivent tre implements de faon atomique par le SE avec TSL
2013/14
Smaphores
Solution du problme producteur /consommateur
On aura besoin de 3 smaphores :
1- mutex: pour assurer l'exclusion mutuelle initialis 1
2- occupe: compte le nombre d'emplacements occups initialis 0, il

sert bloquer/dbloquer le consommateur
3- libre: compte le nombre d'emplacements libres initialis N, il sert
bloquer/dbloquer le producteur.
2013/14
Smaphores
#define N 100
/* nombre de places dans le tampon */
Semaphore mutex = 1 ; /* contrle d'accs au tampon */

semaphore libre = N ;
Semaphore occupe = 0;
/* nb de places libres */
/* nb de places occupes */
void producteur (void) {

Int element ;
while (TRUE) { produire_element (&element) ;
P (libre) ;
P (mutex) ;
mettre_element (element) ;
V (mutex) ;
V (occupe) ;
/* produire l'lment suivant */
/* dc. nb places libres */

/* entre en section critique */
/* mettre l'lment dans le tampon */
/* sortie de section critique */
/* inc. nb place occupes et wakeup consommateur*/
}
}
2013/14
Smaphores
void consommateur (void)
{
int element ;
while (TRUE) {
P (occupe) ;
/* dc. nb emplacements occups */
P (mutex) ;
/* entre section critique */
prelever_element (element) ;
V (mutex) ;
V (vide) ;
/* retire un lement du tampon */
/* sortie de la section critique */

/* inc. nb emplacements libres */
}
}
2013/14
Smaphores
Remarque
semaphore S;
P(S) dcrmente le smaphore S si S>0 sinon blocage du

processus appelant.
V(S) incrmente le smaphore S si aucun processus n'est
bloqu par P(S), sinon l'un d'entre eux sera choisi pour tre
lu
2013/14
Problme propos par Dijkstra en 1965 est le suivant :

5 philosophes sont assis autour dune table ;
5 plats de spaghettis (un devant chaque philosophe) ;
5 fourchettes situes entre chaque plat.
Soit le philosophe mange, soit il rflchit (il repose alors ses fourchettes)
Pour manger, ils ont besoin de deux fourchettes ;
Quand un philosophe dsire 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 rflchir).
Trouver une solution en proposant un algorithme.
2013/14
Procdure phi losophe ( i : entier )

Dbut
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 dabord la fourchette de droite ;
Puis ensuite, celle de gauche. Est-ce logique?
Si on prend un Smaphore par fourchette ;
Problme:
Que se passe-t-il si tous les philosophes ont faim en mme temps ?
2013/14
Si on prend un Smaphore par fourchette ;

Chaque philosophe tente de prendre dabord la fourchette de droite ;
Puis ensuite, celle de gauche. Pourquoi?
Problme:
Que se passe-t-il si tous les philosophes ont faim en mme temps ?
Explications :
Le test et la modification de la valeur dun smaphore se font de manire
atomique ; entre deux test/modification, il peut y avoir commutation de contexte.
Donner les tats pour les philosophes.
Description
On dfinit 3 tats pour les philosophes :
Pense ;
Faim (en attente de manger) ;
Mange
2013/14
Les tats des philosophes sont placs dans un tableau tats.

Lorsquun philosophe veut manger :
1. Il passe dans ltat Faim;
2. Vrifie quaucun de ces voisins ne mange ;
3. Si cest le cas, il passe lui-mme dans ltat Mange ;
4. Sinon, il est bloqu.
Pour sassurer de ne pas tre interrompu pendant cette phase :
utilisation dun smaphore S.
Lorsquun philosophe termine de manger
Lorsquun philosophe a faim et nest pas en mesure de manger, il est
bloqu ;
Pour bloquer les philosophes, on utilise un smaphore pour chacun :
Tableau de smaphores T.
Lorsquun philosophe termine de manger :
Il passe dans ltat Pense
Vrifie si son voisin de gauche est bloqu :
Si cest le cas, il vrifie sil peut le dbloquer ;
Idem avec le voisin de droite.
2013/14
Procdure philosophe(i : entier)

TantQue ( vrai) Faire
penser ( )
prendre_fourchettes ( i )
manger ( )
poser_fourchettes ( i )
FinTantQue
Procdure 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
2013/14
Procdure prendre fourchette(i : entier)

P(S) / / Entre 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 na pu prendre les fourchet tes
Procdure poser fourchette(i : entier)
P(S) / / Entre 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
2013/14

Langue

Chap3 SE&Unix

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

Chap3 SE&Unix

Transféré par

Droits d'auteur :

Formats disponibles

Etude des systmes dexploitation

Communication & synchronisation des

Jusqu' maintenant nous avons considr les processus comme

Pourtant, des processus concurrents partagent des donnes (zones de

Besoin de communiquer entre processus pour changer des

la commande unix suivante: $cat f1 f2 f3 | grep ''text''

Des processus ou des threads peuvent s'changer des donnes

Comment un processus fait passer des infos un autre (

Si laccs concurrent une ressource commune nest pas

conduit une srie de problmes complexes d'inter-blocage

Dfinition: Un ensemble de processus est en inter-blocage si

Exemple: situation possible dans un carrefour priorit droite.

Exemple 1 de corruption de donnes:

- Les fichiers imprimer sont stockes dans un rpertoire

Pour administrer ce rpertoire, deux variable globales

Supposons que, un instant donn, on ait in = 7 et out = 4

Si le premier processus effectuer cette squence est interrompu

Le dmon d'impression n'en saura jamais rien, et imprimera

Exemple 2-corruption de donnes

Ils peuvent tre interrompus

Vue globale d'une excution possible

M. X demande une rservation

M.Y demande une

Base de donnes dit X que

Base de donnes dit Y que

Fauteuil 30A est assign X et

Fauteuil 30A est assign Y et

Problmes: corruption des donnes.

Solution: faire intervenir un seul processus la fois sur un objet

Objet auquel ne peuvent

Suite d'instructions d'un

Exemple: fichiers, mmoire

Exemple: lire in;

Structure d'un programme

La section de code qui effectue cette requte est la section dentre

La section critique est normalement suivie dune section de sortie

Le code qui reste est la section restante

Avec l'hypothse qu'un programme ne contint qu'une seule section critique.

Critres ncessaires pour solutions valides

Deux processus ne peuvent pas tre en mme temps en section critique

Toutes les solutions se basent sur latomicit de laccs la

Plus en gnral, toutes les solutions se basent sur l existence

Solution dangereuse; si c'est un programme utilisateur il y a risque de ne pas

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

Problme: la variable verrou est elle mme partage

Algorithme pour N processus:

While ( tour != NumProcess)

Inconvnients: Risque de famine, si le tour est donn un

Algorithme de Peterson vue globale

L'ide principale de l'algorithme est d'utiliser deux variables

l'une indiquant que l'on s'apprte utiliser une ressource

processus veut entrer en section critique, il notifie les autres de

les 2 processus appellent enter_region simultanment, tous deux vont

lopration de stockage la plus tardive qui est prise en compte.

Lacunes des solutions logiciel

Pour de longues sections critiques, il serait prfrable de

En tudiant de prs les problmes lis l'exclusion mutuelle et la

Si un changement de contexte intervient entre ces deux actions,

et un autre processus crit dans la variable aprs que la premire

le premier se trouve dans un tat incohrent, et peut, ensuite

Cette analyse a conduit, sur certaines architectures,

Avantage de linstruction TSL

| copier lock dans registre, et

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