ISI

IN S T I TUT ‫ﺍاﻟﺠـﻤـــﻬﮭـﻮﺭرﻳﯾﺔ ﺍاﻟﺘــــﻮﻧـﺴـﻴﯿـﺔ‬

SUPERIEUR ‫ﻭوﺯزﺍاﺭرﺓة ﺍاﻟـﺘﻌﻠﻴﯿﻢ ﺍاﻟﻌﺎﻟﻲ‬
INFORMATIQUE ‫ﺟﺎﻣــــﻌــﺔ ﺗــﻮﻧــﺲ ﺍاﻟﻤــﻨـﺎﺭر‬
‫ﺔـﻴﯿــﻣﻼـﻋﻺﻟ ﻲـﻟﺎـﻌﻟﺍا ﺪـﻬﮭﻌﻤـﻟﺍا‬ ‫ﺍاﻟﻤﻌـﻬﮭـﺪ ﺍاﻟـﻌﺎﻟـﻲ ﻟﻺﻋـﻼﻣـﻴﯿـﺔ‬

Année Universitaire : 2011/2012

Devoir Surveillé [session principale] Semestre : 1er Semestre
Niveau d’Etude : L2ARS-SIL Date : 14/11/2011
Matière : Systèmes d’Exploitation 2 Durée : 1h30
Enseignants Responsables: W. Youssef, A. Gazdar, A. Ben Documents : Non autorisés
Chikha, L. Sfaxi, W. Mrabet, S. Ouali, H. Limam
Nombre de pages : 4
Le barème est donné à titre indicatif. La clarté de la copie rendue sera comptée sur 1 point.

EXERCICE 1 : Questions de compréhension (6 points : 1-2-3)

1- Quand est ce qu’on dit qu’une solution de synchronisation des processus assure la
progression ?
Une solution de synchronisation assure la progression quand tout processus, en dehors de sa
section critique, ne peut pas empêcher un autre processus d’accéder à sa section critique. (1 pt)
2- Est-ce qu’il peut y avoir plusieurs sections critiques dans le code d’un processus ? Si oui
ça dépend de quoi ?
Oui, il est possible d’avoir plusieurs SC dans le code, cela dépend du nombre et de l’utilisation
des ressources partagées. (2 pts)
3- On suppose qu’un processus P0 s’exécute dans sa section critique (cette section critique
n’est pas encore terminée) et qu’un autre processus P1 concurrent à P0 vient d’être élu
par un ordonnanceur tourniquet pour l’exécution et veut accéder à sa section critique.
Donner l’état (Elu, Bloqué ou Prêt) dans lequel P1 va se trouver dés qu’il se rend compte
que P0 est dans sa section critique pour les techniques de synchronisation suivantes :
a. Attente active
Quand P1 se rend compte que P0 est en SC, s’il utilise l’attente active, il se trouve à l’état Elu
pendant l’attente. (1,5 pts, 1 pt si l’étudiant répond Prêt)
b. Sleep/Wakeup
Quand P1 se rend compte que P0 est en SC, s’il utilise l’attente non active, il se trouve à l’état
Bloqué pendant l’attente. (1,5 pts)

1
EXERCICE 1 (5 points : 2-3)
Pour se synchroniser avec un processus P1 (qui fait la même chose), un processus P0 exécute le
code suivant :

bool intention[2] = {false,false};

int tour = 0; /* variable partagée indiquant le tour du
processus qui peut passer en section critique*/
void *T0(void *arg)
{
while (true) {
intention[0] = true;
while (tour != 0) {
while (intention[1]);
tour = 0;
}
/* section critique */
intention[0] = false;
/* section non-critique */
}
}

1- Déduire le code du processus P1.

void *T1(void *arg)

{
while (true) {
intention[1] = true;
while (tour != 1) {
while (intention[0]);
tour = 1;
}
/* section critique */
intention[1] = false;
/* section non-critique */
}
} (2 pts)

2- Cette solution n’assure pas l’exclusion mutuelle. Donner un scénario qui le prouve
(indication : le processus P1 s’exécute le premier avec tour=0).

2
Intention[0] Intention[1] Tour P0 P1
False False 0
False True 0 Intention[1]=true
While(tour !=1) //oui
False True 0 While(intention[0]) //non
True True 0 Intention[0]=true
True True 0 While(tour !=0) //non
SC
True True 1 Tour = 1
True True 0 While (tour !=1) //non
SC

Les deux processus entrent en SC en même temps. Cette solution n’assure donc pas l’exclusion
mutuelle. (3 pts)

EXERCICE 2 ( 8 points : 2-3-3)

Soit un chemin de fer reliant deux villes A et B. Les trains utilisent ce chemin dans les deux sens
mais un seul peut l’utiliser à la fois. On se propose d’implémenter la fonction void train(char
depart, char destination) que chaque train doit exécuter pour faire le voyage de la ville de départ à
la ville de destination . Cette fonction, s’assure qu’il n’y a pas de train sur les rails pour
démarrer. Si c’est le cas (il n’y a aucun train sur les rails) elle fait appel à la fonction
circuler(depart,destination) qui permet au train de démarrer effectivement vers la ville de
destination.
1- Supposons que nous disposons des deux fonctions suivantes :
a. testerRail() : Cette fonction permet de tester s’il y’a un train sur les rails. Si c’est
le cas, le processus appelant reste bloqué, Sinon, il peut circuler.
b. signalerRailLibre() : Cette fonction permet à l’un des trains bloqués dans sa
fonction testerRail() de démarrer et de réserver le rail.

On vous demande, d’écrire la fonction void train(char depart, char destination) en faisant
appel aux fonctions circuler,testerRail() et signalerRailLibre() pour garantir qu’un train unique
circule sur ce chemin de fer.

void train(char depart, char destination){

testerRail() ;
circuler(depart, destination) ;
signalerRailLibre() ;
} (2 pts)
2- Proposer une implémentation des fonctions testerRail() et signalerRailLibre()
garantissant l’exclusion mutuelle. Expliquer brièvement la technique de synchronisation
que vous avez utilisée.

3
Comme cela n’est pas précisé dans l’énoncé, l’étudiant peut utiliser n’importe quelle méthode
de synchronisation vue en cours et assurant l’EM.

Attente active Attente non active (sémaphores)

Initialisations : Initialisations :
bool interested[2] = {false,false} ; init (mutex,1) ;
int tour = 0 ;
void testerRail(int monNum){ void testerRail(){
interested[monNum] = true ; down (mutex) ;
tour = monNum ; }
while(interested[1-monNum] &&
tour == monNum) ;
}
void signalerRailLibre(int monNum){ void signalerRailLibre(){
interested[monNum] = false; up(mutex);
} }
(chacune des méthodes sur 2 pt, et l’explication du principe sur 2 pt)

BON TRAVAIL.