Module : Systèmes d'Exploitation Avancés Institut Supérieur d'Informatique

Niveau : 1ère année Ingénieur Année Universitaire : 2010-2011

Documents : Non Autorisés Date : 10 Novembre 2010
Enseignants : W. Youssef, I. Lassoued, L. Sfaxi

SYSTÈMES D'EXPLOITATION AVANCÉS

CORRECTION DU DS

1 point sur la propreté de la feuille

. Questions de Cours ( 6 = 2+1+2+1 )

1. Donner l'algorithme de l'alternance stricte (Jeton). Démontrer qu'il vérifie la

propriété d'exclusion mutuelle.

Algorithme du Jeton
entrer_SC(nbProc){
while (turn != nbProc);
}
libérer_SC(nbProc){
turn = 1 – nbProc;
}
Preuve
On va prouver par l'absurde que cet algorithme vérifie la propriété
d'exclusion mutuelle.
Exclusion Mutuelle : Deux processus ne peuvent pas se trouver dans la SC
en même temps. Supposons alors que les processus P0 et P1 sont dans la SC.
P0 dans SC => turn = 0
impossible
P1 dans SC => turn = 1
Ainsi, la propriété d'exclusion mutuelle est vérifiée.

Systèmes d'Exploitation Avancés Page 1/8

Devoir Surveillé 2010-2011

2. Expliquer le principe de l'algorithme de Peterson.

L'algorithme de Peterson utilise deux variables partagée : une variable turn

qui prend successivement le numéro du processus qui veut s'exécuter, et un
tableau interested qui contient une case propre à chaque processus, indiquant s'il
est intéressé par la section critique ou pas. Un processus Pi laisse la main à un
autre processus Pj, si la variable turn a la valeur i et que Pj est intéressé.

3. Expliquer le principe de la solution "sommeil et activation". Quel est son

avantage par rapport à la solution précédente (Peterson)?

Le sommeil et activation (Sleep et wakeup) utilisent deux primitives : la

primitive Sleep qui va bloquer le processus en cours qu'il ne peut pas entrer dans
la SC, et une primitive Wakeup qui va réveiller l'un des processus qui attendent
la SC. Son avantage par rapport à la solution de Peterson c'est qu'elle utilise une
attente non active, contrairement à Peterson qui utilise une attente active.

4. Quel est l'inconvénient principal de la solution de "sommeil et activation"?

Donner un scénario le décrivant.
L'inconvénient du sommeil et activation : c'est le réveil perdu.

Soit l'exemple du Producteur/Consommateur avec sleep et wakeup.

Supposons que le buffer soit vide et que le consommateur s'exécute. Il va tester
si le buffer est vide ou pas. Il va trouver que oui et va enregistrer ce résultat.
Avant d'exécuter son sleep, l'ordonnanceur va faire une préemption. La main est
donnée au producteur qui va produire un élément, l'insérer dans le buffer, et
effectuer son wakeup. Comme le consommateur n'a pas encore exécuté son
sleep, ce wakeup ne va rien faire, et le producteur va sortir. Quand le conso. va
reprendre la main, il va faire un sleep, et personne ne va le réveiller.

Systèmes d'Exploitation Avancés Page 2/8

Devoir Surveillé 2010-2011

Exercice 1 (4 = 2+2)

Initialisations
int CANDIDAT[2]; // Peut prendre les valeurs 0 et 1
int PRIOR = 1; // Variable partagée
for (int i = 0; i<2; i++) CANDIDAT[i] = 0;

Processus 0 Processus 1
while (1){ while (1){
1 CANDIDAT[0] = 1; CANDIDAT[1] = 1;
2 while(CANDIDAT[1]&&PRIOR==1); while(CANDIDAT[0]&&PRIOR==0);
Section_Critique(); Section_Critique();
3 PRIOR = 1; PRIOR = 0;
4 CANDIDAT[0] = 0; CANDIDAT[1] = 0;
Section_Non_Critique(); Section_Non_Critique();
} }

Pouvez-vous dire (en démontrant) si cet algorithme satisfait :

1. L'exclusion mutuelle

Cet algorithme ne satisfait pas l'exclusion mutuelle.

P0 P1
1 CANDIDAT[0] = 1

2 CANDIDAT[1]&&PRIOR==1 ? FAUX

Section Critique

1 CANDIDAT[1] = 1

2 CANDIDAT[0]&&PRIOR==0 ? FAUX

Section Critique

Ainsi, les deux processus entrent en SC en même temps. L'exclusion

mutuelle n'est donc pas vérifiée.

Systèmes d'Exploitation Avancés Page 3/8

Devoir Surveillé 2010-2011

2. L'absence d'interblocage

L'absence d'interblocage est vérifiée.

Preuve :

Interblocage : Les deux processus sont bloqués (dans le while).

Supposons que P0 et P1 soient bloqués. D'où :

- CANDIDAT[1] == 1 && PRIOR == 1 et

- CANDIDAT[0] == 1 && PRIOR == 0

Or PRIOR = 1 et PRIO = 0 impossible, d'où il ne peut pas y avoir un

interblocage.

Exercice 2 (3 = 1(réponse)+2 (démonstration))

Initialisations
init (s_inc,0) //Initialisation du sémaphore s_inc
init (s_dec,0) //Initialisation du sémaphore s_dec
init (mutex,1) //Initialisation du sémaphore mutex
int data = 0 //Variable partagée

Processus P1 Processus P2
tant_que (vrai) tant_que (vrai)
up(s_dec) up(s_inc)
down(s_inc) down(s_dec)
down(mutex) down(mutex)
data <- data +1 data <- data -1
write ("P1 : "+data); write ("P2 : "+data);
up(mutex) up(mutex)
fin tant_que fin tant_que

Si on lance les processus P1 et P2 dans des conditions de concurrence,

Systèmes d'Exploitation Avancés Page 4/8

Devoir Surveillé 2010-2011

quelles sont les valeurs possibles que peut prendre la variable data? Justifier
votre réponse.

Les valeurs possibles sont : 0, 1 et -1

Grâce aux deux sémaphores, s_dec et s_inc, cet algorithme fait en sorte
qu'un processus ne puisse pas changer data deux fois de suite. Ainsi, si c'est P1
qui commence en premier, alors data va toujours passer de 0 à 1 à 0..., et si c'est
P2 qui s'exécute en premier, alors data prendra les valeurs 0, -1, 0...

. Exercice 3 (6 = 3+1+2)

Le tri du courrier à la poste se fait en deux étapes : la première dans le

bureau de poste régional, et la deuxième dans le bureau de poste principal. On
dénombre quatre bureaux régionaux et un bureau principal.

Dans chaque bureau de poste régional, trois agents procèdent au tri (fonction
trier_courrier_régional). Si l'un des agents termine avant les autres, il doit les
attendre (fonction attendre). Une fois que tous les agents ont terminé, un unique
agent doit être désigné pour se rendre au bureau de poste principal (fonction
designer_transporteur).

Au bureau de poste principal, les quatre agents régionaux désignés pour

transporter le courrier doivent procéder au tri final (fonction
trier_courrier_principal). Le courrier n'est enfin expédié (fonction
expédier_courrier) que si tous ces agents ont fini leur tri. L'expédition sera faite
par un unique agent (choisi par la même fonction designer_transporteur).

Systèmes d'Exploitation Avancés Page 5/8

Devoir Surveillé 2010-2011

Un processus représente un agent de la poste. On se propose de synchroniser

ces processus avec les sémaphores. On définit les constantes suivantes :

Constante Valeur Rôle

nb_reg 3 Nombre de fonctionnaires dans un bureau régional
nb_princ 4 Nombre de fonctionnaires dans un bureau principal

Chaque réponse doit être précédée par une partie initialisations qui doit
définir les variables partagées et les sémaphores utilisés.

1. Donner le code de la méthode attendre (num, nbAgentTotal) qui va permettre

à un agent de numéro num d'attendre les autres s'il n'est pas le dernier (le
nombre d' agents total à attendre est nbAgentTotal).

Initialisations :
nbAgent = 0;
semaphore mutex = 1;
semaphore rdv = 0;
attendre (num, nbAgentTotal){
down(mutex);
nbAgent++;
if ( nbAgent < nbAgentTotal){
up(mutex);
down(rdv);
}else{
up(mutex);
for ( int i = 0; i < nbAgentTotal ; i++){
up(rdv);
}
}

Systèmes d'Exploitation Avancés Page 6/8

Devoir Surveillé 2010-2011

2. Donner le code de la méthode désigner_transporteur(num, nbAgentTotal) qui

va choisir un unique agent comme transporteur. L'agent choisi sera le dernier
agent parmi les nbAgentTotal agents ayant appelé la fonction
désigner_transporteur. Les agents qui ne sont pas choisis quitteront la poste
(fonction exit() ).

Initialisations :
nbAgent = 0;
semaphore mutex = 1;
désigner_transporteur (num, nbAgentTotal){
down(mutex);
nbAgent++;
if ( nbAgent < nbAgentTotal){
up(mutex);
exit( );
}else{
up(mutex);
}

Systèmes d'Exploitation Avancés Page 7/8

Devoir Surveillé 2010-2011

3. Donner le code de la fonction principale agent(num) qui définit le

comportement de chaque agent.

Initialisations :
nbAgent = 0;
semaphore mutex = 1;
semaphore rdv = 0;
agent (num){
trier_courrier_régional();
attendre(num, nb_reg);
désigner_transporteur(num, nb_reg);
trier_courrier_principal();
attendre(num, nb_princ);
désigner_transporteur(num, nb_princ);
expédier_courrier();
}
Bon Travail

Systèmes d'Exploitation Avancés Page 8/8