Professional Documents
Culture Documents
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
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
Licence dInformatique
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
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
H.Bourzoufi
Licence dInformatique
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 ()
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.
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
Licence dInformatique
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 ; }
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.
inconvnient : elle base sur lattente active ; un processus ne pouvant entrer en SC utiliserait lUC inutilement .
H.Bourzoufi
Licence dInformatique
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
Tampon de taille
Producteur
Consommateur
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
H.Bourzoufi
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