Vous êtes sur la page 1sur 5

2009 - 2010

Systèmes d’exploitation 2
TD n 2 : Synchronisation des processus

Mme Lilia SFAXI


Systèmes d’exploitation 2

Systèmes d’exploitation 2
TD n 2 : Synchronisation des processus

Exercice 1 : Algorithmes d’Exclusion mutuelle


1. Rappeler brièvement les exigences d'un bon mécanisme de contrôle d'accès à
une section critique.

Les exigences d'un bon mécanisme de contrôle d'accès à la section critique sont:
a- Deux processus ne peuvent se trouver simultanément dans le section critique (exclusion
mutuelle).
b- Il ne faut pas faire de suppositions quant à la vitesse ou au nombre de processus mis en œuvre.
c- Aucun processus s'exécutant à l'extérieur de sa section critique ne doit bloquer d'autres
processus.
d- Aucun processus ne doit attendre indéfiniment pour pouvoir entrer dans la section critique.
(attente bornée)

2. Rappeler l’algorithme de l’alternance stricte. Citer certains inconvénients de


cet algorithme.
3. On propose dans ce qui suit un algorithme pour une nouvelle version de
l’alternance stricte.

void entrer_SC(int MonNumero) { //MonNumero=0 pour P0, 1 pour P1


flag0 = true;
while(flag1 == true) ; /* attente active */
}
void liberer_SC(int MonNumero) {
flag0 = false;
}

Cet algorithme respecte-il les 4 conditions précédemment citées ? Sinon,


donner un exemple explicatif pour l’une des conditions violées.

1
TD2 : Introduction à la synchronisation des processus

L’idée ici est d’indiquer à l’aide d’un drapeau l’intention d’entrer en section critique, et
de n’y entrer que si aucun processus n’a signalé son intention d’y entrer (à l’aide d’un
autre drapeau).
Cet algorithme illustre le cas d’un excès de courtoisie : si les deux processus P0 et P1
mettent leurs flags à true, alors chacun des deux va attendre que l’autre libère le flag :
interblocage !
4. Soit l’algorithme suivant :

//Pour le thread Pi :
while(true){
veut[i]=true ; // je veux entrer en SC
tour = j; // je donne une chance à l'autre
while (veut[i] && tour==j);
SC //Section critique
veut[i] = false;

SR //Section restante
}

Cet algorithme respecte-il les 4 conditions précédemment citées ? Sinon,


donner un exemple explicatif pour l’une des conditions violées.

Cet algorithme ne respecte pas la condition de « progression » : si aucun autre processus


n’exécute entrer_SC, alors tour restera toujours à j et le processus bouclera à jamais.

Exercice 2 : Algorithme de Peterson


1. Rappeler le principe de l’algorithme de Peterson.

L'algorithme de Peterson est un algorithme d'exclusion mutuelle. Cet algorithme est basé
sur une approche par attente active. Il est constitué de deux parties : le protocole
d'entrée dans la section critique et le protocole de sortie. L'algorithme présenté est une
version pouvant fonctionner avec deux threads. Il est dû à Gary Peterson.
L'algorithme de Peterson nécessite les éléments et les informations suivantes :
- Chaque thread dispose d'un numéro l'identifiant, à savoir dans le cas avec deux
threads les numéros 1 et 2.

2
Systèmes d’exploitation 2

- Il faut disposer d'un tableau (dont chaque case correspond à un thread grâce à
l'utilisation des numéros précités) et d'une variable. Le tableau pourra contenir
deux valeurs, à savoir une valeur indiquant qu'un thread souhaite entrer en section
critique ou y est et qu'un thread ne souhaite pas entrer en section critique. Par
défaut aucun thread ne souhaite entrer dans la section critique.
Un processus ne peut entrer en SC que si l’autre thread ne désire pas y accéder.

2. Prouver que cet algorithme respecte toutes les exigences d’un bon mécanisme
de contrôle d’accès.

Le mécanisme précédent est l'algorithme de Peterson. Ce mécanisme est un bon


mécanisme de contrôle d'accès à la section critique. En effet, il respecte les 3 exigences
d'un bon système de contrôle d'accès à la section critique (à part l'exigence qu'il n'y a
aucune hypothèse ni sur la vitesse des processus ni sur le nombre de processus) qui sont:
a- Exclusion mutuelle
On va démontrer l'exclusion mutuelle par l'absurde.
Supposons que l'exclusion mutuelle n'est pas réalisée,
alors Pi et Pj peuvent être dans la section critique au même temps.
En d'autres termes, les 3 propositions suivantes sont vérifiées au même temps:
(i) Pi en SC <=> veutEntrer[j]=faux ou tour=j
(ii) Pj en SC <=> veutEntrer[i]=faux ou tour=i
(iii) Pi en SC et Pj en SC <=>veutEntrer[i]=vrai et veutEntrer[j]=vrai
Ceci étant absurde car veutEntrer[j]=faux et veutEntrer[j]=vrai au même temps.
(idem pour veutEntrer[i] et pour tour).
D'où l'exclusion mutuelle est garantie par ce mécanisme.
b- Progression
On va démontrer le déroulement par l'absurde.
Supposons que Pi est dans la section restante (i.e, en dehors de la section critique)
Alors veutEntrer[i]=faux
Supposons aussi que Pj ne peut pas entrer dans la section critique
Alors on aura veutEntrer[i]=vrai et tour=i (Pi est dans sa section critique)
Ce qui est absurde car veutEntrer[i]=faux et veutEntrer[i]=vrai au même temps.
En d'autres termes, si Pi n'est pas dans sa section critique, alors il ne va pas
interdire l'accès à Pj dans sa section critique (Ceci n'est autre qu'une garantie que

3
TD2 : Introduction à la synchronisation des processus

le choix du prochain processus à entrer dans sa section critique est réalisé parmi
les processus qui sont intéressés par y enter). D'où le respect du déroulement.
c- Attente bornée
L'attente bornée va être démontrée par l'absence de famine et l'absence
d'interblocage.
c1- Absence d'interblocage
On va démontrer par l'absurde l'absence de l'interblocage.
Supposons que Pi et Pj sont bloqués au même temps,
Alors les propositions suivantes sont vérifiées au même temps:
(i) Pi bloqué <=> veutEntrer[j]=vrai et tour=j
(ii) Pj bloqué <=> veutEntrer[i]=vrai et tour=i
Ceci est absurde car tour ne peut être égale à i et j au même temps.
D'où l'absence de l'interblocage.
c2- Absence de famine
Deux cas vont être traités.
CAS 1.
Si Pi a demandé l'entrée dans sa section critique et Pj est déjà dans sa section
critique
alors Pi ne va pas attendre indéfiniment car le déroulement est assuré.
CAS 2.
Si Pi et Pj demandent ensemble l'accès à la section critique
alors nous aurons veutEntrer[i]=vrai et veutEntrer[j]=vrai
or tour=j /*c'est la dernière valeur enregistrée dans tour.*/
donc Pi entre dans sa section critique et Pj attend
mais si Pi veut encore entrer dans sa section critique
alors veutEntrer[i]=vrai
mais tour=j (Pj est le dernier à avoir écrit dans tour)
donc interdiction de l'entrée de Pi et entrée de Pj

En conclusion, chaque processus demandant l'accès à sa section critique attend au


plus un passage de l'autre processus par sa section critique.
Conclusion finale: l'algorithme de Peterson fournit un bon mécanisme de contrôle
d'accès à la section critique.

4

Vous aimerez peut-être aussi