Vous êtes sur la page 1sur 8

Cours de Systmes dExploitation

Licence dinformatique Synchronisation et Communication inter-processus


Hafid Bourzoufi

Universit de Valenciennes - ISTV

Cours de Systmes dExploitation

Licence dInformatique

Introduction
Les processus concurrents sexcutant dans le systme dexploitation peuvent tre des processus coopratifs ou indpendants. Un processus est indpendant sil naffecte pas les autres processus ou ne peut pas tre affect par eux. Un processus qui ne partagent pas de donnes avec dautres processus est indpendant Un processus est coopratif sil peut affecter les autres processus en cours dexcution ou tre affect par eux Un processus qui partage des donnes avec dautres processus est un processus coopratif Les donnes partages par les processus coopratifs peuvent se trouver en mmoire principale ou en mmoire secondaire dans un fichier Les accs concurrents des donnes partages peuvent produire des incohrences de donnes comme le montre lexemple ci-dessous : Exemple Considrons la procdure suivante de mise jour dun compte bancaire dun client. Pour simplifier, on considre quun compte est implment par un simple fichier qui contient le solde courant du client: Procedure crediter_compte( entier numero_client, entier somme) entier solde ; debut solde=lire_dans_fichier(numero_client); /* lecture du solde dans le fichier du client */ solde = solde + somme ; ecrire_dans_fichier(numero_client, solde) ; /* crire dans le fichier le nouveau solde */ fin; Supposons maintenant que cette mme procdure est excute simultanment par deux processus P0 et P1 dans un systme dexploitation temps partag. Sans faire aucune hypothse sur la dure du quantum, on peut faire les excution suivantes : P0 : crediter_compte( 1233, 1000) solde = lire_dans_fichier(1233) ; solde = lire_dans_fichier(1233) ; /* P0 bloqu car P1 sexcute */ solde=solde+1000 ; Ecrire_dans_fichier(1233,solde) ; /* P1 bloqu car P0 sexcute */ P1 : crediter_compte( 1233, 500)

solde=solde+500 ; Ecrire_dans_fichier(1233,solde) ;

Comme le montre cet exemple, le rsultat final nest pas le rsultat escompt (le client a perdu 500F dans cet affaire L ).
Universit de Valenciennes - ISTV 2

Cours de Systmes dExploitation

Licence dInformatique

Sections critiques
Le problme dans le programme prcdent est d aux conflits daccs au mme fichier. Ces accs sont en lecture et en criture. Evidemment, il ne peut y avoir de conflit si les accs aux donnes ne sont quen lecture seule. On appelle section critique la partie dun programme o se produit le conflit daccs Comment viter ces conflits daccs ?
Il faut trouver un moyen dinterdire la lecture ou lcriture des donnes partages plus dun processus la fois Il faut une exclusion mutuelle qui empche les autres processus daccder des donnes partages si celles-ci sont en train dtre utilises par un processus Dans lexemple prcdent, il faut obliger le processus P1 attendre la terminaison de P0 avant dexcuter son tour la mme procdure

Pour une bonne coopration entre processus


Pour que les processus qui partagent des objets (donnes en mmoire centrale ou dans fichiers) puissent cooprer correctement et efficacement, quatre conditions sont ncessaires : 1. Exclusion mutuelle : deux processus ne peuvent tre en mme temps en section critique 2. Famine : aucun processus ne doit attendre trop longtemps avant dentrer en section critique 3. Interblocage (deadlock) : aucun processus suspendu en dehors dune section critique ne doit bloquer les autres dy entrer . La dernire section sera consacre ltude de ce problme 4. Aucun hypothse ne doit tre faite sur les vitesses relatives des processus

Universit de Valenciennes - ISTV 3

Cours de Systmes dExploitation

Licence dInformatique

Exclusion mutuelle par attente active


q Un processus dsirant entrer dans une section critique doit tre mis en atente

si la section critique devient libre


q Un processus quittant la section critique doit le signaler aux autres processus q Protocole daccs une section critique :

<entrer_Section_Critique> /* attente si SC non libre */ <Section_Critique> /* Un seule processus en SC */ <Quitter_Section_Critique>


q Lattente peut tre :

Active : la procdure entrer_Section_Critique est une boucle dont la condition est un test qui porte sur des variables indiquant la prsence ou non dun processus en Section critique Non active : le processus passe dans ltat endormi et ne sera rveill que lorsquil sera autoris entrer en section critique procdures entrer_Section_Critique et

Que contiennent les quitter_Section_Critique ?

1re Solution : Masquage des interruptions


q Le moyen le plus simple est que chaque processus puisse masquer les

interruptions avant dentrer en section critique linterruption horloge qui permet dinterrompre un processus lorsquil a puis son quantum (temps CPU), serait ignore plus de commutation de processus
q Lorsquun processus quitte la section critique, doit restaurer les interruptions q Solution dangereuse en mode utilisateur :

Si dans un processus, le programmeur a oubli de restaurer les interruptions, cest la fin du systme L

Universit de Valenciennes - ISTV 4

H.Bourzoufi

Cours de Systmes dExploitation

Licence dInformatique

2me solution : les variables de verrouillage


q Un verrou est une variable binaire partage qui indique la prsence dun

processus en Section Critique : si verrou = 0 alors la section critique est libre si verrou = 1 alors la section critique est occupe
q Procdure entrer_Section_Critique () :

void entrer_Section_Critique () { if (verrou == 0) verrou=1 ; else while (verrou == 1) ; /* attente active */ verrou=1 ; }
q Procdure quitter_Section_Critique ()

void quitter_Section_Critique () { verrou=0 ; }


q Lexclusion mutuelle nest assure que si le test et le positionnement du

verrou est ininterruptible (sinon le verrou constitue une section critique) Pour cela il faut disposer dune instruction (test and set) qui teste et modifie le contenu dun mot en mmoire centrale de faon indivisible.

3me Solution : lalternance


q On utilise une variable partage (tour) qui mmorise le numro du processus

autoris entrer en section critique


q Exemple dutilisation pour N processus :

void entrer_Section_critique (int MonNumero) { while (tour != monNumero) ; /* attente active */ } void quitter_Section_critique () { tour=(monNumero +1) % N ; /* au suivant ! */ }

q Avantage : simple et facile utiliser q Inconvnient : problme de famine, un processus possdant tour, peut ne

pas tre intress immdiatement par la section critique


Universit de Valenciennes - ISTV 5 H.Bourzoufi

Cours de Systmes dExploitation

Licence dInformatique

Solution de Peterson (1981)


q Pour le cas de deux processus P0 et P1 :

#define FAUX #define VRAI #define N int tour ; int interesse[N] ;

0 1 2 /* qui le tour */ /* initialis FAUX */

void entrer_Section_Critique (int process) /* n de processus : 0 ou 1*/ { int autre ; autre = 1-process ; interesse[process]=VRAI ; /* indiquer quon est intress */ tour = process ; /* lever le drapeau */ while (tour == process && interesse[autre] == VRAI) ; } void quitter_Section_Critique(int process) { interesse[process]=FAUX ; }

Pourquoi lexclusion mutuelle est assure par cette solution?

Rponse : Considrons la situation o les deux processus appellent entrer_Section_Critique simultanment. Les deux processus sauvegarderont leur numro dans la variable tour. La valeur sauvegarde en dernier efface la premire. Le processus qui entrera en SC est celui qui a positionn la valeur tour en premier.

q Cette solution malgr quelle fonctionne bien, elle prsente un gros

inconvnient : elle base sur lattente active ; un processus ne pouvant entrer en SC utiliserait lUC inutilement .

Universit de Valenciennes - ISTV 6

H.Bourzoufi

Cours de Systmes dExploitation

Licence dInformatique

Solution vitant lattente active


q Ide : un processus ne pouvant entrer en section critique, passe dans un tat

endormi, et sera rveill lorsquil pourra y entrer. ncessite un mcanisme de rveil Le SE fournit deux appels systme : Sleep (dormir) qui suspend le processus appelant Wakeup (rveiller) qui rveille le processus donn en argument

Application au modle Producteur/Consommateur

Tampon de taille

Producteur

Consommateur

Les deux processus cooprent en partageant un mme tampon

Le producteur produit des objets quil dpose dans le tampon Le consommateur retire des objets du tampon pour les consommer

Conflits Le producteur veut dposer un objet alors que le tampon est dj plein Le consommateur veut retirer un objet du tampon alors que celui-ci est vide Le producteur et le consommateur ne doivent pas accder simultanment au tampon

Universit de Valenciennes - ISTV 7

H.Bourzoufi

Cours de Systmes dExploitation

Licence dInformatique

Code des processus producteur et consommateur #define N 100 int compteur = 0 ; /* nbre demplacement ds tampon */ /* nbre dobjets ds tampon */

void producteur () { while (VRAI) { produire_objet() ; if (compteur == N) sleep () ; mettre_objet() ; compteur = compteur + 1 ; if (compteur == 1) wakeup(consommateur) ; } } void consommateur () { while (TRUE) { if (compteur == 0) sleep() ; retirer_objet() compteur = compteur 1 ; if (compteur == N-1) wakeup (producteur) ; consommer_objet() ; } }

Analyse de cette solution : 1. Laccs la variable compteur nest pas protg, 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.
Universit de Valenciennes - ISTV 8 H.Bourzoufi

Vous aimerez peut-être aussi