Systmes dexploitation des Ordinateurs.

15

CHAPITRE II : COMMUNICATION & SYNCHRONISATION

Dans ce chapitre nous prsenterons la problmatique de la communication inter-processus et des

accs concurrentes.

2.0 PROBLEMATIQUE :
Lorsque plusieurs processus sexcutent sur un ordinateur , monoprocesseur ou multiprocesseur avec
mmoire commune , ils sont amens partager des variables communes soit volontairement sils
cooprent pour traiter un mme problme, soit involontairement parce quils sont obligs de se
partager les ressources de lordinateur.
Malheureusement, le partage des variables sans prcaution particulire peut conduire des rsultats
imprvisibles.

Exemple : Le compte bancaire

Considrons un compte bancaire , dont le montant est mmoris dans un emplacement mmoire A.
Le programme qui consiste ajouter 100 ce compte pourrait tre le suivant , o N est une variable
locale du programme :

Algorithme Compte
Dbut
Lire(N, A) ;
N :=N+100 ;
Ecrire(N, A)
Fin.

Si maintenant deux processus diffrents consistent en lexcution de ce mme programme, le

processeur sera allou chacun deux dans un ordre quelconque. En particulier, on peut imaginer
lordre suivant :

LOUKAM Mourad

16

Ordre
dexcution
1

Processus P1

Processus P2

Lire(N, A)

Lire(N, A) ;

N :=N+100 ;

Ecrire(N, A) ;

N :=N+100 ;

Ecrire(N, A)

N tant une variable locale du programme, cela implique quil en existe un exemplaire pour chacun
des deux processus. Il sensuit que si la valeur initiale du compte est 1000, on constate quaprs ces
excutions , il est gal 1100 au lieu de 1200. Les deux processus ne sont pas en fait totalement
indpendants. Ils partagent la ressource commune quest la valeur du compte bancaire ladresse A
sur disque. Cette ressource doit avoir un seul point daccs ; cest donc une ressource critique , et les
processus sont en exclusion mutuelle sur cette ressource critique.
Si la variable N est commune aux deux processus, le problme nest pas rsolu pour autant. En effet,
linstruction N :=N+100 nest pas une instruction indivisible . En fait, elle peut tre dcompose en
trois micro-instructions au niveau machine , comme le montre le code suivant :

Load N

Add 100

N :=N+100

Store N

Il est important de savoir que lallocateur du processeur prend en compte les microinstructions et non les instruction du langage volu pour dterminer les moments o il peut
remplacer le processus actif par un autre. On peut donc imaginer le scnario suivant
dallocation du processeur aux deux processus :
Ordre
dexcution
1

Processus P1

Processus P2

Load N

Load N

Add 100

Store N

Add 100

Store N

Ainsi , on voit l aussi que le rsultat obtenu lissue des deux processus est erron.

Systmes dexploitation des Ordinateurs.

17

On voit travers cet exemple que lexcution simultane de programmes (processus) peut conduire
des rsultats errons si des prcautions ne sont pas prises.

Concepts fondamentaux :
Section Critique
Une section critique (SC) est un ensemble dinstruction dun programme qui peuvent engendrer des
rsultats imprvisibles lorsquelles sont excutes simultanment par des processus diffrents.
Dune manire gnrale on peut dire quun ensemble dinstructions peut constituer une section
critique (SC) sil y a des variables partages ; et non dans labsolu. Autrement dit, lexistence de
section critique implique lutilisation de variable partages , mais linverse nest pas vrai.
De ce qui prcde on peut facilement dduire que lexcution simultanes de deux sections
critiques appartenant deux ensembles diffrents et ne partageant pas de variables ne peut poser
aucun problme daccs concurrent.

Ressource critique
On appelle ressource critique tout objet : variable, table, fichier, priphrique, qui peut faire
lobjet dun accs concurrent par plusieurs processus. Par exemple deux processus qui tentent
denvoyer chacun, simultanment, un fichier sur limprimante ; le priphrique imprimante devient
ressource critique pour eux.

Exclusion mutuelle
Les problmes poss par les accs concurrents dcrits au 1.1 montrent que la solution consiste
excuter les sections critiques en exclusion mutuelle (mutex). Cest dire quune SC ne peut tre
entame que si aucune autre SC du mme ensemble nest en excution.
Ainsi, voici donc le principe gnral dune solution garantissant que lexcution simultane de
plusieurs processus ne conduirait pas des rsultats imprvisibles : Avant dexcuter une SC, un
processus doit sassurer quaucun autre processus nest en train dexcuter une SC du mme
ensemble. Dans le cas contraire, il ne devra pas progresser tant que lautre processus naura pas
termin sa SC.
Avant dentrer en SC, le processus doit excuter un protocole dentre. Le but de ce protocole est
de vrifier justement si la SC nest occupe par aucun autre processus.
A la sortie de la SC, le processus doit excuter un protocole de sortie de la SC. Le but de ce
protocole est davertir les autres processus en attente que la SC est devenue libre.

Le schma suivant rsume ce principe de fonctionnement :

LOUKAM Mourad

18

Processus Pi
Dbut

<Instructions hors de la section critique>

Protocole dentre en SC

SC
Protocole de sortie de SC

<Instructions hors de la section critique>

Fin.

Figure 1.1 Structure dun processus qui excute une section critique.

Contraintes respecter pour la ralisation dune exclusion mutuelle :

Pour raliser une exclusion mutuelle , ncessaire pour rsoudre le problme des accs
concurrents, on admet que certaines contraintes doivent tre respectes :
Le droulement : Le fait quun processus ne demande pas entrer en section critique ne doit pas
empcher un autre processus dy entrer. Cette contrainte exclut les mthodes fondes sur un tour
de rle strict.
Lattente finie : Si plusieurs processus sont en comptition pour entrer en SC, le choix de lun deux
ne doit pas tre repouss indfiniment. Autrement dit, la solution propose doit garantir que tout
processus nattend pas indfiniment.
Tous les processus doivent tre gaux vis vis de lentre en SC.

2.1 SOLUTIONS LOGICIELLES POUR LEXCLUSION MUTUELLE :

Soit un ensemble de N processus P1, P2, P3, PN-1 possdant chacun une SC dans laquelle le
processus peut occuper une ressource critique. Lexcution de la SC par un processus doit se faire en
exclusion mutuelle, cest dire quen entrant dans sa SC, aucun autre processus nest autoris
excuter sa SC.
Nous prsentons ci-aprs les plus importantes solutions logicielles qui ont t proposes pour raliser
lexclusion mutuelle.

Systmes dexploitation des Ordinateurs.

19

2.1.1 Solutions logicielles pour deux processus

Nous considrons dans cette section le problmes de deux processus concurrents P0 et P1 dont la
structure typique est :

Processus P0
Dbut

Processus P1
Dbut

Protocole dentre la SC

Protocole dentre la SC

Protocole de sortie de la SC

Protocole de sortie de la SC

<section restante>

<section restante>

Fin.

Fin.

Figure 2.1 Cas de deux processus concurrents

La partie <section restante> dsigne lensemble des instructions qui sont aprs la section critique.
Pour utiliser une notation pratique, si Pi dsigne lun des processus alors Pj dsignera lautre
processus.
Pour ce problme prcis de deux processus, plusieurs solutions ont t proposes. Nous les
prsentons ci-aprs.

Solution 1 : Cette solution consiste laisser les deux processus partager une variable entire
commune turn, initialise 0 (ou 1). Si la valeur de turn=i, alors on permet au processus Pi dexcuter
sa SC. Voici lalgorithme de cette solution :

Processus Pi
Dbut
Tantque turn<>i
Faire
Rien
Fait ;

SC

Turn :=j ;
<Section Restante>
Fin.
Figure 2.2 Solution logicielle, base sur le tour, pour le cas de deux processus concurrents

LOUKAM Mourad

20

Commentaire : Cette solution garantit quun seul processus la fois peut se trouver dans sa SC.
Cependant elle exige une alternance stricte ; les processus entrent en SC tour de rle dans un ordre
forc. Autrement dit, cette solution ne vrifie pas le critre du droulement (voir 1.2.4). Par exemple,
si turn=0 et P1 est prt entrer dans sa SC, cela ne lui est pas possible mme si P0 peut se trouver
dans sa section restante.

Solution 2 :
Le problme de la solution 1 est quelle ne garde pas suffisamment dinformations sur ltat de chaque
processus ; elle se rappelle seulement quel processus est autoris entrer en SC. Pour remdier ce
problme, nous pouvons remplacer la variable Turn par le tableau suivant :
Etat : Tableau[0..1] de Boolen.
Le tableau est initialis Faux. Si Etat[i] est Vrai, cette valeur indique que le processus Pi est prt pour
entrer en SC.
Lalgorithme de la solution est :

Processus Pi
Dbut
Etat[i] :=Vrai ;
Tantque Etat[j]
Faire
Rien
Fait ;

SC

Etat[i] :=Faux ;
<Section Restante>
Fin.

Figure 2.3 Solution logicielle, base sur ltat, pour le cas de deux processus concurrents

Dans cette solution, le processus Pi fixe dabord Etat[i] Vrai, signalant ainsi quil est prt entrer en
SC. Ensuite, Pi vrifie ltat du processus Pj en consultant la valeur de Etat[j]. Le processus Pi attend
alors jusqu ce que le processus Pj lui indique quil na plus besoin dentrer dans sa SC (cest dire
jusqu ce que la valeur de Etat[j] devienne fausse). A ce moment l , le processus Pi entre dans sa
SC. En sortant de sa SC, Pi remet son tat Faux, permettant lautre processus dentrer
ventuellement en SC.
Commentaire : Dans cette solution, le principe de lexclusion mutuelle est respect . Toutefois, un
problme se pose si les deux processus mettent leur tat Vrai, puis vont , chacun, itrer sur la
vrification de ltat de lautre processus. On assiste ainsi une boucle sans fin pour les deux

Systmes dexploitation des Ordinateurs.

21

processus (aucun des deux processus ne peut entrer dans sa SC). Le critre de lattente finie nest
donc pas vrifi.

Solution 3 Algorithme de Dekker : La solution 3, appele algorithme de Dekker, combine les ides
des solutions 1 et 2 prcdentes : Les processus partagent 2 variables :
Etat : Tableau[0..1] de Logique ;
Turn : 0..1

Initialement Etat[0]=Etat[1] et la valeur de Turn est initialise 0 ou 1.

Lalgorithme de la solution est le suivant :

Processus Pi
Dbut
Etat[i] :=Vrai ;
Turn :=j ;
Tantque (Etat[j] et Turn=j)
Faire
Rien
Fait ;

SC

Etat[i] :=Faux ;
<Section Restante>
Fin.

Figure 2.4 Solution de Dekker pour le cas de deux processus concurrents

Pour entrer dans la SC, le processus Pi met son tat Etat[i] Vrai et permet lautre processus
dentrer en SC en mettant la variable Turn j. Si les deux processus tentent dentrer en mme temps
en SC, Turn sera fix i et j presque au mme moment. Evidemment, une seule des ces affectation
se produira lautre sera perdue (la seconde affectation crasera la premire valeur). La valeur de Turn
dcidera quel processus entrera dans sa SC.
Commentaire : Cette solution garantit les trois critres :
-

Exclusion mutuelle.
Droulement.
Attente finie.

2.1.2 Solutions logicielles pour plusieurs processus

Lalgorithme de Dekker prcdent apporte une solution au problme de la SC pour deux processus
seulement. Lalgorithme qui suit est une gnralisation du prcdent, il porte le nom de lalgorithme du
LOUKAM Mourad

22

Boulanger. A lorigine, cet algorithme a t conu pour un environnement partag, mais des variantes
existent pour un systme dexploitation centralis.
Cet algorithme sinspire dune technique de scheduling utilise dans les anciennes boulangeries et
magasins. En entrant dans la boulangerie, chaque client reoit un numro. Le client suivant servir est
celui qui aura le plus petit numro.
Lalgorithme du boulanger ne garantit pas que deux processus (clients) ne reoivent pas le mme
numro. Dans ce cas, le client servir est celui qui sera le premier dans lordre alphabtique. Cest
dire que si Pi et Pj ont le mme numro et si i>j, alors on sert dabord Pi avant Pj.
Les structures de donnes utilises par lalgorithme sont :

Choosing : Tableau[0..N-1] de Logique ;

Number : Tableau[0..N1] de Entier ;

Ces structures de donnes sont initialises respectivement Faux et 0.

On utilisera la notation suivante , pour exprimer un ordre entre deux couples dentiers : On notera
(a, b) < (c,d)
si si a<c (ou a=c) et (b<d).

Lalgorithme du Boulanger est alors le suivant :

Processus Pi
Dbut
Choosing :=Vrai ;
Number[i] :=max(Number[0], Number[1], Number[N-1])+1 ;
Choosing :=Faux ;
Pour j :=0 jusqu N-1
Faire
Tantque (Choosing[j])
Faire
Rien ;
Fait ;
Tanque (Number[j]<>0 et ( (Number[j], j)<(Number[i], i))
Faire
Rien ;
Fait
Fait
SC

Number[i] :=0 ;
<Section Restante>
Fin.

Figure 2.5 Lalgorithme du Boulanger.

Systmes dexploitation des Ordinateurs.

23

Cet algorithme assure lexclusion mutuelle. En effet, si Pi est dans sa SC, un processus Pk qui
excute la deuxime instruction tantque pour j=i, trouvera que :
(Number[i]<>0) et ((Number[i], i) <Number[k], k))

Le processus Pk continuera donc itrer dans linstruction tantque jusqu ce que Pi abandonne sa
SC.

2.2 SOLUTIONS MATERIELLES POUR LEXCLUSION MUTUELLE :

On peut raliser lexclusion mutuelle en utilisant , lorsque cela est possible, des instructions matrielles
mises la disposition du programmeur pour raliser certaines tches de faon indivisible.

2.2.1 Masquage des interruptions :

Matriellement une exclusion mutuelle peut tre ralise si on peut interdire les interruptions pendant
quune variable partage est modifie. De cette faon, on pourra tre sr que la squence courante
dinstructions sexcute en ordre sans aucune rquisition. Malheureusement cette mthode nest pas
toujours efficace. En effet, le masquage et le dmasquage des interruptions peut devenir trs vite
pnalisant pour le systme dexploitation.
Il existe une alternative plus intressante cette mthode : les instructions matrielles indivisibles. En
effet, plusieurs constructeurs dordinateurs fournissent des instructions matrielles spciales qui nous
permettent soit de tester et modifier le contenu dun mot-mmoire, soit dchanger le contenu de deux
mots dune manire atomique (indivisible). Nous pouvons utiliser ces deux instructions pour rsoudre
le problme de lexclusion mutuelle de manire relativement simple.

2.2.2 Linstruction Test-and-Set :

Cette instruction permet de tester et de modifier le contenu dune variable dune manire indivisible. Sa
forme gnrale est :

Fonction Test_and_Set (var cible : logique) : Logique

Begin
Test_and_Set :=cible ;
Cible :=Vrai ;
End ;

Figure 2.6 Linstruction Test_and_Set.

Rappelons le caractre indivisible de cette instruction. Cest dire quelle est considre comme une
unit non interruptible. Ainsi si deux instructions Test_and_Set sont excutes simultanment, elles
seront excutes squentiellement dans un ordre quelconque.

LOUKAM Mourad

24

Si la machine supporte linstruction Test_and_Set, alors nous pouvons raliser lexclusion mutuelle en
dclarant une variable boolenne Lock initialise faux, comme le montre la figure suivante :

Processus Pi
Dbut
Tantque Test_and_Set(Lock)=Vrai
Faire
Rien ;
Fait

SC

Lock :=Faux
Fin.

Figure 2.7 Ralisation de lexclusion mutuelle avec linstruction Test_and_Set.

2.2.3 Linstruction Swap :

Cette instruction permet dchanger le contenu de deux mots de manire atomique. Sa forme gnrale
est la suivante :

Procdure Swap (var a, b : Logique)

Dbut
Temp : Logique ;
Temp :=a ;
A :=b ;
B :=Temp
Fin.

Figure 2.8 Linstruction Swap.

On peut raliser lexclusion mutuelle en utilisant linstruction Swap, en dclarant une variable logique
Lock initialise faux et une variable logique locake Key au niveau de chaque processus (voir figure
suivante).

Systmes dexploitation des Ordinateurs.

25

Processus Pi
Dbut
Key :=Vrai ;
Rpter Swap(Lock, Key)
Jusqu Key=Faux ;

SC

Lock :=Faux
Fin ;

Figure 2.9 Ralisation de lexclusion mutuelle avec linstruction Swap.

2.3 LES SEMAPHORES :

Les solutions matrielles et logicielles prsentes dans les sections prcdentes sont difficiles
mettre en uvre pour des problmes de synchronisation complexes. Ainsi, plusieurs outils de
synchronisation volus ont t proposs pour traiter les multitudes de cas de synchronisation.
Dans cette section, nous dfinirons loutil de synchronisation sans doute le plus connu quest le
smaphore. Nous aurons loccasion de voir dautres outils dans le chapitre 4.

Les smaphores ont t introduits par Dijkstra , illustre informaticien hollandais , en 1965.
Dfinition :
Un smaphore S est un ensemble de deux variables :

Une valeur entire Value.

Une file dattente F de processus F

Quant un processus doit attendre un smaphore, il est ajout la file de processus. Une opration
Signal supprime un processus de la file des processus en attente et rveille ce processus.

Ainsi les oprations Wait et Signal peuvent tre dfinies de cette faon :

Primitive Wait (S)

Dbut
S.value :=S.value-1 ;
Si S.value<0
Alors
Bloquer le processus /*Mettre son tat attente
Ajouter le processus bloqu la File F
Finsi
Fin.

Figure 2.13 La primitive Wait avec file dattente

LOUKAM Mourad

26

Primitive Signal (S)

Dbut
S.value :=S.value+1 ;
Si S.value<=0
Alors
Enlever un processus de la File F
Rveiller le processus choisi
Finsi
Fin.

Figure 2.14 La primitive Signal avec file dattente.

De ce qui prcde, on peut facilement proposer un schma de synchronisation de n processus voulant

entrer simultanment en SC, en utilisant les deux oprations Wait et Signal. En effet, il suffit de faire
partager les n processus un smaphore mutex , initialis 1, appel smaphore dexclusion mutuelle.
Chaque processus Pi a la structure suivante :

Processus Pi
Dbut
Wait(mutex) ;
SC
Signal(mutex)
Fin.

Figure 2.12 Utilisation des primitives Wait et Signal.

Pour voir davantage lefficacit des smaphores comme outil de synchronisation, considrons
lexemple suivant : Deux processus P1 et P2 excutent respectivement deux instructions S1 et S2.

Processus P1
Dbut
S1
Fin.

Processus P2
Dbut
S2
Fin.

Si on souhaite que S2 ne doit sexcuter quaprs lexcution de S1, nous pouvons

implmenter ce schma en faisant partager P1 et P2 un smaphore commun S, initialis 0
et en insrant les primitives Wait et Signal de cette faon :

Systmes dexploitation des Ordinateurs.

27

Processus P1
Dbut
S1 ;
Signal(S)
Fin.

Processus P2
Dbut
Wait(S) ;
S2
Fin.

Comme S est initialis 0, P2 excutera S2 seulement une fois que P1 aura appel Signal(S).
Remarque : Thoriquement, un smaphore peut tre initialis nimporte quelle valeur entire, mais
gnralement cette valeur est positive ou nulle.

2.4 QUELQUES PROBLEMES DE SYNCHRONISATION CLASSIQUES

2.4.1 Le problme du Producteur-Consommateur :
Le problme de Producteur-Consommateur est un problme de synchronisation classique
reprsentant toute une classe de situations o un processus, appel Producteur, dlivre des
messages (informations) un processus Consommateur dans un tampon (par exemple, un
programme qui envoie des donnes sur le spool de l'imprimante). La figure suivante rsume bien ce
type de problme.

Producteur

Consommateur

ZoneP

ZoneC

buffer

N-1

Figure 3.1 Schma du problme de Producteur-Consommateur

Le Producteur produit un message dans la ZoneP, puis le dpose dans le buffer. Le Consommateur
prlve un message du Buffer et le place dans la ZoneC o il peut le consommer.
Pour des raisons pratiques, on considrera que le buffer est de N cases, numrotes de 0 N-1, et
organis de faon circulaire. Le Producteur dpose les messages par un bout du buffer alors que le
consommateur les consomme au fur et mesure par lautre bout.

On peut crire sommairement les codes de chacun des deux processus : Producteur et
Consommateur.

LOUKAM Mourad

28

Processus Producteur
Dbut
Produire(Message) ;
Dposer(Message)
Fin.

Processus Consommateur
Dbut
Prlever(Message) ;
Consommer(Message)
Fin.

Le problme du Producteur-Consommateur consiste trouver comment synchroniser les deux

processus de sorte que :
-

Le Producteur ne dpose une information que si le buffer nest pas plein.

Le Consommateur ne prlve une information que si le buffer nest pas vide.
Le Consommateur nessaie pas de consommer une information qui est en train dtre produite par
le Producteur.

Solution 1 (fausse) :
Dans une premire approche du problme, on utilisera trois variables :

Counter : Nombre dlments prsents dans le buffer.

In : Indice du dernier lment entr.
Out : Indice de llment prt tre consomm.
Buffer
X

Out

In

Le schma de fonctionnement des deux processus, Producteur et Consommateur, peut tre le

suivant :

Processus Producteur
Dbut
Cycle
Produire un message dans ZoneP
Tantque Counter=N
Faire
Rien
Fait ;
Buffer[In] :=ZoneP ;
In :=In+1 mod N ;
Counter :=Counter+1
Fin Cycle
Fin.

Systmes dexploitation des Ordinateurs.

29

Processus Consommateur
Dbut
Cycle
Tantque Counter=0
Faire
Rien
Fait
ZoneC :=Buffer[Out] ;
Out :=Out+1 mod N ;
Counter :=Counter-1 ;
Consommer le message de ZoneC
Fin Cycle
Fin.

Cette solution est videmment fausse, puisquelle ne garantit pas une exclusion mutuelle entre les
deux processus pour le partage de la variable commune Counter. En effet, cette variable peut tre
modifie par un processus, alors que lautre est en train de la consulter ; ce qui peut provoquer des
rsultats incohrents.

Solution 2 (correcte) :
Dans cette solution, on utilise deux smaphores :

Empty : compte le nombre de cases vides.

Full : compte le nombre de cases pleines.

On initialise Empty N et Full 0.

Le schma de synchronisation des deux processus est comme suit :

Processus Producteur
Dbut
Cycle
Produire un message dans ZoneP
Wait(Empty)
Buffer[In] :=ZoneP ;
In :=In+1 mod N
Signal(Full)
Fin Cycle
Fin.

LOUKAM Mourad

30

Processus Consommateur
Dbut
Cycle
Wait(Full)
ZoneC :=Buffer[Out] ;
Out :=Out+1 mod N ;
Signal(Empty) ;
Consommer le message de ZoneC
Fin Cycle
Fin.

Cette solution assure correctement la synchronisation des processus Producteur et Consommateur. Si

le Buffer est plein, le Producteur est bloqu jusqu ce quune case devienne disponible, ce moment
l il est rveill par le processus Consommateur. Inversement, le Consommateur est bloqu tant que
le Buffer est vide ; il est rveill par le Producteur ds quun message a t dpos.

Gnralisation P producteurs et C consommateurs :

On sintresse maintenant au cas plus gnral, o nous avons P producteurs et C consommateurs. Un
examen simple de la solution prcdente fait apparatre clairement que dans ce cas les variables In et
Out deviennent des ressources critiques pour les processus. En effet, plusieurs processus producteurs
peuvent vouloir modifier simultanment la variable In, et plusieurs processus Consommateurs peuvent
vouloir modifier la variable Out. Il y a lieu donc de les rendre accessibles uniquement en exclusion
mutuelle.
On utilise pour ce problme 4 smaphores :

Empty : compte le nombre de case vides.

Full : compte le nombre de cases pleines.
MutexProd : smaphore dexclusion mutuelle pour protger la variable In
MutexCons : smaphore dexclusion mutuelle pour protger la variable Out.

MutexProd et MutexCons sont initialis 1. Le schma de synchronisation des processus Producteurs

et Consommateurs est :

Processus Producteur
Dbut
Cycle
Produire un message dans ZoneP
Wait(Empty)
Wait(MutexProd) ;
Buffer[In] :=ZoneP ;
In :=In+1 mod N ;
Signal(MutexProd) ;
Signal(Full)
Fin Cycle
Fin.

Systmes dexploitation des Ordinateurs.

31

Processus Consommateur
Dbut
Cycle
Wait(Full)
Wait(MutexCons) ;
ZoneC :=Buffer[Out] ;
Out :=Out+1 mod N ;
Signal(MutexCons) ;
Signal(Empty) ;
Consommer le message de ZoneC
Fin Cycle
Fin.

2.4.2 Le problme des Lecteurs-Rdacteurs :

Un fichier de donnes est partag entre plusieurs processus concurrents. Certains de ces processus
dsirent lire le contenu du fichier, nous les appellerons : Lecteurs. Les autres processus veulent
modifier le contenu du fichier, nous les appellerons : Rdacteurs.
Si plusieurs processus lecteurs accdent au fichier simultanment, il ne produira aucun effet
indsirable. Par contre, si un rdacteur et dautres processus (lecteurs ou rdacteurs) accdent
simultanment au fichier, un rsultat erron peut se produire. En clair, un moment donn on ne doit
avoir que lune des deux situations suivantes :

Un seul rdacteur est en train de modifier le fichier

Un ou plusieurs lecteurs sont en train de lire le contenu du fichier

De ce qui prcde, on peut dduire que chaque processus Rdacteur doit avoir un accs exclusif au
fichier. Pour raliser simplement cette contrainte on utilisera un smaphore dexclusion mutuelle Wrt,
initialis 1.
Le code dun processus Rdacteur est donc :

Processus Redacteur
Dbut
Wait(Wrt)
/* Ecrire dans le fichier
Signal(Wrt) ;
Fin.

Pour crire le code dun processus Lecteur, nous nous intresserons au cas o on donnerait une
certaine priorit aucun processus Lecteurs. Cest dire quaucun Lecteur nattend, moins quun
rdacteur nait dj obtenu la permission pour utiliser le fichier.
Cette solution utilise les variables suivantes :

Wrt : smaphore dexclusion mutuelle qui assure laccs exclusif dun rdacteur au fichier.

LOUKAM Mourad

32

Readcount : variable entire contenant le nombre de Lecteurs actuellement dans le fichier.

Mutex : smaphore dexclusion mutuelle pour protger laccs la variable commune ReadCount.

Ces variables sont initialises :

Wrt =1, ReadCount=0, Mutex=1

Processus Lecteur
Dbut
Wait(Mutex) ;
ReadCount :=ReadCount+1 ;
Si ReadCount=1
Alors
Wait(Wrt)
Finsi ;
Signal(Mutex) ;
/* Lire dans le fichier
Wait(Mutex) ;
ReadCount :=ReadCount-1 ;
Si ReadCount=0
Alors
Signal(Wrt)
Finsi
Signal(Mutex)
Fin.

Le lecteur trouvera la fin de ce chapitre un exercice proposant une rflexion sur les diffrentes
variantes du problme de Lecteur-Rdacteur : priorit aux rdacteurs, priorit gale entre les lecteurs
et les rdacteurs etc.

2.4.3 Le problme des philosophes :

Cinq philosophes passent leur temps penser et manger. Les philosophes partagent une table
circulaire commune entoure de cinq (5) chaises, chacune appartenant lun deux. Chaque
philosophe dispose dun bol de riz. La table est fournie avec 5 baguettes uniquement (voir figure).
Quand un philosophe pense, il ninteragit pas avec les autres philosophes. De temps en temps, un
philosophe a faim et essaie de prendre deux baguettes pour manger : une baguette sa droite et une
autre sa gauche.
Un philosophe peut prendre seulement une baguette la fois. Evidemment, il ne peut pas prendre une
baguette qui est dans la main dun voisin. Quand un philosophe affam possde les deux baguettes, il
peut manger tant quil voudra. Quand il a fini de manger, il dpose ses deux baguettes et recommence
penser.

Systmes dexploitation des Ordinateurs.

33

Philosophe 2

Philosophe 1
Philosophe 3

Philosophe 4

Philosophe 0

Figure 3.2 Schma du problme des philosophes.

Le problme des philosophes est un problme classique de synchronisation. Il reprsente une grande
classe de problmes daccs concurrents. Cest une reprsentation simple du besoin dallouer
plusieurs ressources plusieurs processus tout en vitant le problme de linterblocage ou de la
famine.

Solution 1 (fausse) :
Une premire approche du problme des philosophes consiste modliser soit ltat des baguettes
(occupe/non occupe), soit ltat des philosophes (mange/ne mange pas).
En modlisant ltat des baguettes, on dclare un tableau Libre :
Libre : Tableau[0..4] de Logique
O Libre[i]=Vrai si la baguette i est libre, Libre[i]=Faux si la baguette est occupe. Le tableau Libre est
initialis Vrai.

Cette solution est donne ci-aprs :

LOUKAM Mourad

34

Processus Philosophe i
Dbut
Cycle
Penser ;
Tantque Libre[i]=Faux ou Libre[i+1 mod N]=Faux
Faire
Attendre
Fait ;
Libre[i ]:=Faux ; Libre[i+1 mod N] :=Faux ;
Mange ;
Libre[i] :=Vrai ; Libre[i+1 mod N] :=Vrai
Fin Cycle
Fin.

En modlisant ltat des philosophes, on dclare un tableau Mange :

Mange : Tableau[0..N] de Logique
O, Mange[i]=vrai si le philosophe i mange, Mange[i]=Faux sinon. Le tableau Mange est initialis
Faux.
Le schma de cette solution est donn ci-aprs :

Processus Philosophe i
Dbut
Cycle
Penser ;
Tantque (Mange[i-1 mod N=Vrai) ou (Mange[i+1 mod N]=Vrai)
Faire
Attendre
Fait ;
Mange[i] :=Vrai ;
Manger ;
Mange[i] :=Faux ;
Fin Cycle
Fin.

Cette solution nest videmment pas acceptable en raison de son inefficacit (attente active).

Systmes dexploitation des Ordinateurs.

35

Solution 2 (avec des smaphores) :

Une autre premire approche du problme des philosophes consiste utiliser des smaphores. Pour
cela, on utilise un tableau Chopstick :
Chopstick : Tableau[0..4] de smaphore.

Tous les lments de Chopstick sont initialiss 1. Le code dun processus Philosophe devient donc :

Processus Philosophe i
Dbut
Cycle
Penser ;
Wait(Chopstick[i]) ;
Wait(Chopstick[i+1 mod N]) ;
Manger ;
Signal(Chopstick[i]) ;
Signal(Chopstick[i+1 mod N]) ;
Fin Cycle
Fin.

Bien que cette solution garantisse que deux voisins quelconques ne mangent pas simultanment, elle
doit nanmoins tre rejete car elle peut conduire une situation dinterblocage. En effet, supposons
que les cinq philosophes aient faim en mme temps et que chacun saisisse sa baguette de gauche.
Tous les lments de Chopstick seront donc gaux 0. Quand chaque philosophe essayera de saisir
sa baguette de droite, il sera retard pour toujours.

Solution 3 (correcte) :
Une solution correcte du problme des philosophes utilise les variables suivantes :

Un tableau Etat[0..4] dont chaque lment peut avoir lune des valeurs : Pense, Faim, Mange.
Un tableau de smaphore S[0..4] dont chacun est initialis 1.
Un smaphore dexclusion mutuelle Mutex, initialis 1.

Le code de cette solution est donn ci-aprs.

Processus Philosophe i
Dbut
Cycle
Penser ;
Prendre_baguette(i) ;
Manger ;
Poser_Baguette(i)
Fin Cycle
Fin.

Les diffrentes procdures appeles par cette solution, sont dtailles ci-aprs :
LOUKAM Mourad

36

Prendre_Baguette( i)
Dbut
Wait(Mutex) ;
Etat[i] :=Faim ;
Test(i) ;
Signal(Mutex) ;
Wait(S[i])
Fin.

Poser_Baguette( i)
Dbut
Wait(Mutex) ;
Etat[i] :=Pense ;
Test(i+1 mod N) ;
Test(i-1 mod N) ;
Signal(Mutex) ;
Fin.

Test( i)
Dbut
Si Etat[i]=Faim et Etat[i+1 mod N]<>Mange
et Etat[i-1 mod N]<>Mange)
Alors
Etat[i] :=Mange ;
Signal(S[i])
Finsi
Fin.

2.5 LES OUTILS DE SYNCHRONISATION AVANCES

2.5.1 Les moniteurs :
Le type moniteur est une autre structure de synchronisation de haut niveau invent par Hoare en 1973.
Prsentation :
Un moniteur se caractrise par un ensemble doprateurs dfinis par le programmeur. La
reprsentation dun type moniteur consiste en des dclarations de variables dont les valeurs
dfinissent ltat dune instance de type, ainsi que du corps des procdures ou des fonctions qui
implmentent les oprations sur le type.

Type <nom du moniteur> = Monitor

//Dclaration des variables
Procedure entry P1()
Begin

End ;
Procedure entry P2()
Begin

End ;
Procedure entry PN()
Begin

End ;
Begin

End.

//Code dinitialisation

Figure 4.1 Structure dun moniteur.

La structure dun moniteur peut tre dcrite ainsi en utilisant la syntaxe de Pascal Concurrent (un
langage variante du Pascal et ddi la programmation concurrente).

Systmes dexploitation des Ordinateurs.

37

La structure dun moniteur a ceci de particulier : Il ny a quun seul processus la fois qui peut tre actif
dans le moniteur. Le programmeur nest donc pas oblig de coder cette contrainte de synchronisation
explicitement. Le schma suivant dcrit ce fonctionnement ;
File dattente
dentre

Donnes partages

Oprations

Code dinitialisation

Figure 4.2 Vue schmatique dun moniteur.

Dans un moniteur, on peut dclarer des variables particulires : les variables conditionnelles qui
permettent dexprimer des contraintes de synchronisation. La dclaration de ces variables peut se faire
ainsi par exemple :
Var x, y : condition ;

Les seules oprations quon peut faire sur une variable conditionnelle sont : wait et signal. Voici la
smantique de chacune des deux oprations :

x.wait : cette opration provoque la suspension du processus qui la appel. Il ne sera ractiv
que par une opration x.signal lance par un autre processus.

x.signal : cette opration permet de reprendre lexcution dun processus suspendu. Sil nexiste
aucun processus suspendu, cette opration na aucun effet.

Remarque :
Il existe une diffrence fondamentale entre lopration wait applicable aux variables
conditionnelles et celle applicable sur un smaphore : La premire est toujours bloquante : le
processus qui lexcute est automatiquement bloqu, alors que la seconde nest bloquante
quen fonction de la valeur du smaphore.

On peut schmatiser le fonctionnement dun moniteur avec variables conditionnelles de cette faon :

LOUKAM Mourad

38

File dattente
dentre

Donnes partages
x
y

Oprations

Code dinitialisation

Figure 4.3 Moniteur avec variables conditionnelles.

Lorsque lopration x.signal est appele par un processus P et il existe un processus suspendu Q
associ la condition x, deux cas sont envisager puisquil ne doit y avoir quun seul processus au
niveau du moniteur :
1. P attend jusqu ce que Q abandonne le moniteur ou attend une autre condition.
2. Q attend jusqu ce que P abandonne le moniteur ou attend une autre condition

Application au problme de la ressource unique :

Un moniteur contrle lallocation dune ressource unique entre plusieurs processus concurrents.

Systmes dexploitation des Ordinateurs.

39

Type Ressource_Allocation= Monitor

Var
Busy : Boolean ;
X : condition
Procedure entry Acquerir
Begin
If busy then x.wait ;
Busy :=True
End ;
Procedure entry LIberer
Begin
Busy :=False ;
x.signal
End ;
Begin
Busy :=False
End.

En utilisant une instance R du moniteur Ressource_Allocation, le code dun processus P devient :

Processus
Dbut
R.Acquerir
//Acder la ressource
R.Liberer
Fin.

Application au problme des philosophes :

Reprenons le problme des philosophes en utilisant les moniteurs. Pour cela dclarons les variables
suivantes :

Etat : Tableau[0..4] de (Faim, Pense, Mange)

Self : Tableau[0..4] de Condition

La solution proposer doit garantir les rgles suivantes :

Le philosophe i ne peut fixer la variable etat[i] mange que si ses deux voisins (i-1 mod
5) et (i+1 mod 5) ne sont pas en train de manger.

Le philosophe i peut se retarder quand il a faim mais il est incapable dobtenir les baguettes dont il
a besoin.

La structure de moniteur utilise pour la synchronisation des philosophes est :

LOUKAM Mourad

40

Type Diner_Philosophe= Monitor

Var
Etat : Array[0..4] of (Pense, Faim, Mange) ;
Self : Array(0..4] of Condition ;
Procedure entry Prendre_Baguette(i : 0..4)
Begin
Etat[i] :=Faim ;
Test(i) ;
If Etat[i]<>Mange
Then Self[i].wait ;
End ;
Procedure entry Poser_Baguette(i : 0..4)
Begin
Etat[i] :=Pense ;
Test(i-1 mod 5) ;
Test(i+1 mod 5)
End ;
Procedure entry Test(k : 0..4)
Begin
If Etat[k-1 mod 5]<>mange and Etat[k]=Faim and Etat[k+1 mod 5]<>Mange
Then Begin
Etat[k] :=Mange ;
Self[k] .signal
End
End ;
Begin
For i=0 to 4 do Etat[i] :=Pense
End.

En utilisant une instance dp du moniteur Diner_Philosophe, le code dun processus philosophe

devient :

Processus Philosophe i
Dbut
Cycle
Penser ;
Dp.prendre_Baguette(i)
Manger ;
Dp.Poser_Baguette(i) ;
Fincycle
Fin.

2.5.2 Les rgions critiques :

Prsentation : Une rgion critique est un autre outil de synchronisation de haut niveau.
Dans une rgion critique, toute variable v de type T partage par plusieurs processus doit
tre dclare avec le mot rserv shared :

Systmes dexploitation des Ordinateurs.

41

Var v : shared T ;
On peut accder la variable V uniquement dans une instruction region de la forme suivante :
region v when B do S ;

Cette expression signifie que, pendant que lon excute linstruction S, aucun autre processus ne peut
accder la variable v. Lexpression B est une expression logique dont dpend laccs la variable v.
Quand un processus essaye dentrer dans la rgion critique, il value lexpression B ; si sa valeur est
vraie il pourra excuter linstruction S, sinon il sera retard jusqu ce que la valeur de B devienne vraie
et quaucun autre processus nest en train daccder la variable v.

Application : Problme du Producteur-Consommateur avec buffer limit.

On utilisera une variable Buffer partage de type Record :
Var Buffer : Shared Record
Tableau : Array[0..n-1] of Element ;
Count, In, Out : Integer
End ;
Le producteur et le consommateur utilisent la rgion critique en excutant respectivement les codes
suivants :

Processus Producteur
Dbut
While True
Do Begin
Produire un message dans ZoneP

Processus Consommateur
Dbut
While True
Do Begin
Region Buffer when count>0
Do Begin
ZoneC :=Buffer[Out] ;
Out :=Out+1 mod N ;
Counter :=Counter-1 ;
End ;

Region Buffer when Count<n

Do Begin
Buffer[In] :=ZoneP ;
In :=In+1 mod N ;
Counter :=Counter+1
End ;

Consommer le message de ZoneC

End
End

Fin.
Fin.

Etat initial

LOUKAM Mourad

Etat final

42

Une expression de chemin pour laquelle il est possible de trouver un graphe tel que le mme nom de
procdure ne figure pas sur plus d'un arc issu du mme nud est appel chemin simple.
Un chemin simple peut tre mis en uvre par gnration d'oprations P et V sur smaphores.
Application :
Soit un tampon pouvant contenir un message unique. Des processus garnissent ou vident ce tampon
dans un ordre imprvisible.
class TamponUnique;
var mess : Message;
path dposer; retirer end
procedure dposer(m:Message);
begin
mess := m
end; {de dposer}
procedure retirer:Message;
begin
retirer := mess
end; {de retirer}
begin
mess := nil
end; {de TamponUnique}

2.6 LA COMMUNICATION INTER-PROCESSUS :

La communication interprocessus (interprocess communication, IPC) consiste transfrer des
donnes entre les processus. Par exemple, un navigateur Internet peut demander une page un
serveur, qui envoie alors les donnes HTML.
La communication interprocessus peut se faire de diffrentes manires : mmoire partage, mmoire
mappe, tubes, files et socket.

La mmoire partage permet aux processus de communiquer simplement en lisant ou crivant

dans un emplacement mmoire prdfini.

La mmoire mappe est similaire la mmoire partage, except qu'elle est associe un fichier.

Les tubes permettent une communication squentielle d'un processus l'autre.

Les files FIFO sont similaires aux tubes except que des processus sans lien peuvent
communiquer car le tube reoit un nom dans le systme de fichiers.

Les sockets permettent la communication entre des processus sans lien, pouvant se trouver sur
des machines distinctes.

Ces types d'IPC diffrent selon les critres suivants:

Ils restreignent ou non la communication des processus lis (processus ayant un anctre
commun), des processus partageant le mme systme de fichiers ou tout ordinateur connect
un rseau.

Un processus communiquant n'est limit qu' la lecture ou qu' l'criture de donnes.

Systmes dexploitation des Ordinateurs

43

Le nombre de processus pouvant communiquer.

Les processus qui communiquent sont-ils synchroniss par l'IPC ? par exemple, un processus
lecteur s'interrompt-il jusqu' ce qu'il y ait des donnes lire ?.

2.6.1 MEMOIRE PARTAGEE

Une des mthodes de communication interprocessus les plus simples est d'utiliser la mmoire
partage. La mmoire partage permet deux processus ou plus d'accder la mme zone mmoire
comme s'ils avaient leurs pointeurs dirigs vers le mme espace mmoire. Lorsqu'un processus
modifie la mmoire, tous les autres processus voient la modification.

La mmoire partage est la forme de communication interprocessus la plus rapide car tous les
processus partagent la mme mmoire. Elle vite galement les copies de donnes inutiles.
Pour utiliser un segment de mmoire partage, un processus doit allouer le segment. Puis, chaque
processus dsirant accder au segment doit l'attacher. Aprs avoir fini d'utiliser le segment, chaque
processus le dtache. un moment ou un autre, un processus doit librer le segment.
Sous Unix, un processus alloue un segment de mmoire partage en utilisant shmget ( SHared
Memory GET , obtention de mmoire partage). Son premier paramtre est une cl entire qui
indique le segment crer. Le second paramtre indique le nombre d'octets du segment. Le troisime
paramtre est un ensemble dindicateurs binaires dcrivant les options demandes : sagit-il dun
nouveau segment ou un segment existant quil faut attacher , permissions de lecture/criture, etc.
Inconvnient :
Les segments de mmoire partage permettent une communication bidirectionnelle rapide entre
n'importe quel nombre de processus. Chaque utilisateur peut la fois lire et crire. Cependant, le
principe de lexclusion mutuelle, ncessaire en cas daccs concurrent, nest pas garanti avec ce mode
communication.

2.6.2 MEMOIRE MAPPEE

La mmoire mappe permet diffrents processus de communiquer via un fichier partag.
Pour mettre en correspondance un fichier ordinaire avec la mmoire d'un processus, on utilise l'appel
mmap ( Memory MAPped , Mmoire mappe). Le premier paramtre est l'adresse de location du
fichier . Le second paramtre est la longueur de l'espace de correspondance en octets. Le troisime
paramtre dfinit la protection de l'intervalle d'adresses mis en correspondance.

2.6.3. TUBES
Un tube est un dispositif de communication qui permet une communication sens unique. Les
donnes crites sur l' extrmit d'criture du tube sont lues depuis l' extrmit de lecture . Les
tubes sont des dispositifs squentiels; les donnes sont toujours lues dans l'ordre o elles ont t
crites. Typiquement, un tube est utilis pour la communication entre deux threads d'un mme
processus ou entre processus pre et fils.
Dans un shell, le symbole | cre un tube. Par exemple, cette commande provoque la cration par le
shell de deux processus fils, l'un pour ls et l'autre pour less:
ls | less

LOUKAM Mourad

44

Le shell cre galement un tube connectant la sortie standard du processus ls avec l'entre standard
de less. Les noms des fichiers lists par ls sont envoys less dans le mme ordre que s'ils taient
envoys directement au terminal.
La capacit d'un tube est limite. Si le processus rdacteur crit plus vite que la vitesse laquelle le
processus lecteur consomme les donnes, et si le tube ne peut pas contenir de donnes
supplmentaires, le processus rdacteur est bloqu jusqu' ce qu'il y ait nouveau de la place dans le
tube. Si le lecteur essaie de lire mais qu'il n'y a plus de donnes disponibles, il est bloqu jusqu' ce
que ce ne soit plus le cas. Ainsi, le tube synchronise automatiquement les deux processus.
La cration dun tube se fait grce la fonction pipe. Elle admet comme paramtre un tableau de deux
entiers. L'appel pipe stocke le descripteur de fichier en lecture l'indice zro et le descripteur de
fichier en criture l'indice un.
Exemple de cration dun tube :
int pipe_fds[2];
int fr;
int fw;
pipe (pipe_fds);
fr = pipe_fds[0];
fw = pipe_fds[1];

2.6..4 LES FILES FIFO

Une file premier entr, premier sorti (first-in, first-out, FIFO) est un tube qui dispose d'un nom dans le
systme de fichiers. Tout processus peut ouvrir ou fermer la file FIFO; les processus raccords aux
extrmits du tube n'ont pas avoir de lien de parent. Les FIFO sont galement appels canaux
nomms.
On peut crer une FIFO via la commande mkfifo.

Pour crer une FIFO par programmation, utilisez la fonction mkfifo. Le premier argument est
l'emplacement o crer la FIFO; le second paramtre spcifie les permissions du propritaire du tube,
de son groupe et des autres utilisateurs.
L'accs une FIFO se fait de la mme faon que pour un fichier ordinaire

2.6.5 LES SOCKETS

Un socket est un dispositif de communication bidirectionnel pouvant tre utilis pour communiquer
avec un autre processus sur la mme machine ou avec un processus s'excutant sur d'autres
machines. Les programmes Internet comme Telnet, rlogin, FTP, talk et le World Wide Web utilisent
des sockets.
Pour crer un socket, il faut indiquer trois paramtres: le style de communication, l'espace de
nommage et le protocole.
Un style de communication contrle la faon dont le socket traite les donnes transmises et dfinit le
nombre d'interlocuteurs. Lorsque des donnes sont envoyes via le socket, elles sont dcoupes en
morceaux appels paquets. Le style de communication dtermine comment sont grs ces paquets et
comment ils sont envoys de l'metteur vers le destinataire.

Systmes dexploitation des Ordinateurs

45

Le style connexion garantit la remise de tous les paquets dans leur ordre d'mission. Si des
paquets sont perdus ou mlangs cause de problmes dans le rseau, le destinataire demande
automatiquement leur retransmission l'metteur.

Le style datagramme ne garantit pas la remise ou l'ordre d'arrive des paquets. Des paquets
peuvent tre perdus ou mlangs cause de problmes dans le rseau.
L'espace de nommage d'un socket spcifie comment les adresses de socket sont crites. Une
adresse de socket identifie l'extrmit d'une connexion par socket. Par exemple, les adresses de
socket dans l'espace de nommage local sont des noms de fichiers ordinaires. Dans l'espace de
nommage Internet , une adresse de socket est compose de l'adresse Internet (galement appele
adresse IP) d'un hte connect au rseau et d'un numro de port. Le numro de port permet de faire
la distinction entre plusieurs sockets sur le mme hte.
Un protocole spcifie comment les donnes sont transmises. Parmi ces protocoles, on peut citer
TCP/IP; les deux protocoles principaux utiliss pour Internet, le protocole rseau AppleTalk; et le
protocole de communication locale d'UNIX.

LOUKAM Mourad