Université Yahia Fares de Médéa Année Universitaire : 2023‐2024

3ème année Informatique (L.M.D)

Système d’Exploitation 2
Série d’exercices N°2
(La Synchronisation)

Partie I (suite du Parallélisme)

Exercice N°1 :

1. Dans le système UNIX, est‐ce que tout processus a un père ? Que se passe‐t‐il lorsqu’un
processus devient orphelin (mort de son père) ? Quand est‐ce un processus passe à
l’état Zambie ?
2. Pour lancer en parallèle plusieurs traitements d’une même application, vous avez le
choix entre les appels système fork( )et pthread_create( ). Laquelle des deux
possibilités choisir ? pourquoi ?
3. Dans le cas d’UNIX, la création de processus est réalisée par duplication.
a. Citez un avantage et un inconvénient.
b. Citez les avantages des processus légers (threads) par rapport aux processus.

Exercice N°2 :

Considérez un fichier nommé COURS. Pour accélérer la recherche du mot INF3600 dans le fichier
COURS, le processus de départ crée quatre processus. Chaque processus fils créé effectue la
recherche dans une des quatre parties du fichier en appelant la fonction Recherche suivante :
bool Recherche (char * Fichier, char * Mot, int Partie) où :
‐ Fichier est le nom du fichier, c'est‐à‐dire COURS,
‐ Mot est le mot recherché, c'est‐à‐dire INF3600 et
‐ Partie est la partie 1, 2, 3 ou 4 du fichier.
Cette fonction retourne 1 en cas de succès et 0 sinon.
Au retour de la fonction Recherche, le processus fils transmet, en utilisant l’appel système
exit, au processus père le résultat de la recherche (exit(0) en cas de succès, exit(1) en cas
d’échec). Lorsque le processus père est informé du succès de l’un de ses fils, il tue tous les
autres fils.
1. Écrivez un programme C qui réalise le traitement ci‐dessus.
Attention : n’écrivez pas le code de la fonction Recherche.

Partie II (Exclusion Mutuelle)

Exercice N°3 :

1. Pourquoi le partage de données pose des problèmes dans un système multiprogrammé

en temps partagé ? Le système UNIX permet‐il de contrôler les accès aux données
partagées ? Qu’est‐ce qu’une section critique ?

Page 1
Faculté des Sciences Département de Mathématiques et Informatique
 2. Ils existent plusieurs solutions pour l’exclusion mutuelle, nous citons : le masquage des
IT et l’utilisation de l’instruction assembleur Test and Set (TAS). Citez les inconvénients
des deux solutions.

3. Une solution matérielle pour l’exclusion mutuelle consiste à utiliser une instruction
indivisible appelée SWAP qu’a pour but de permuter les valeurs de deux variables
comme suit:

void SWAP (var a, b : boolean)

var temp: boolean;
Debut
temp = a;
a= b;
b = temp;
Fin.

a. Programmer le problème de l’exclusion mutuelle de deux processus à l’aide de

cette instruction.

Exercice N°4 :

1. Alternance : Une première tentative pour l’exclusion mutuelle consiste à utiliser une
variable commune « tour » qui est initialisée à 0 et dont la signification est la suivante :
tour = i : Pi est autorisé à exécuter sa section critique.
Le corps d’un processus Pi avec i=0,1 est :

//données partagées
tour = 0 ;
Pi
Répéter
Tantque (tour ≠ i) ;
<section critique>
tour = 1-i ;
Jusqu’à faux

a. Commentez cette solution.

2. Une autre solution pour l’exclusion mutuelle consiste à améliorer la solution précédente
par l’utilisation d’un tableau de type boolean (flag[0, 1]= {faux, faux}) où tous ses
éléments sont initialisés à faux. Si flag[i] = vrai : alors le processus Pi est en exécution de
sa section critique.
La structure d’un processus Pi est:
//données partagées
flag [0, 1] = {faux, faux} ;
Pi
Répéter
Tantque (flag[1-i]) ;
flag[i]= vrai ;
<section critique>
flag[i]= faux ;
Jusqu’à faux
a. De même, commentez cette solution.

Page 2
Faculté des Sciences Département de Mathématiques et Informatique
 3. La deuxième solution a été améliorée. En effet, flag[i] = vrai, signifie que le
processus Pi désire entrer en section critique où qu’il est en section critique.

//données partagées
flag [0, 1] = {faux, faux} ;
Pi
Répéter
flag[i]= vrai ;
Tantque (flag[1-i]) ;
<section critique>
flag[i]= faux ;
Jusqu’à faux

a. Quels sont vos commentaires ?

4. Solution de DEKKER: la solution de DEKKER utilise deux variables partagées : un tableau

de boolean (flag [0, 1] = {faux, faux}) et une variable « tour » pouvant
prendre la valeur 0 ou 1.
//données partagées
flag [0, 1] = {faux, faux} ;
tour=0 ;
Pi
Répéter
flag[i]= vrai ;
Tantque (flag[1-i]) faire
Si tour = 1-i alors
Flag[i]= faux ;
Tantque (tour ≠ i) ;
Flag[i]= vrai ;
FinSi
FinTantque
<section critique>
tour = 1-i; flag[i]= faux ;
Jusqu’à faux

a. De même, cette solution répond à l’exclusion mutuelle ? Quels sont vos

commentaires ?

5. Solution de Peterson: Cette solution représente une généralisation de la solution de

DEKKER.

//données partagées
interesse [0, 1] = {faux, faux} ;
tour=0 ;
Pi
Répéter
interesse [i]= vrai ; //il veut entrer en sc
tour = i ;
Tantque (tour == i et interesse [1-i]) ;
<section critique>
interesse [i]= faux ;
Jusqu’à faux

a. Commentez cette solution?

Page 3
Faculté des Sciences Département de Mathématiques et Informatique
Exercice N°5 :
On suppose que sur Unix on peut définir des variables x et y communes à deux processus
comme suit :
shared long x = 0 ;
shared long y = 0 ;
Deux processus exécutent les codes suivants :

Processus P1 Processus P2
Debut Debut
x = x + 1; x = x * 2;
y = y + 1; y = y * 2;
printf("x=%d,y=%d\n", x, y); printf("x=%d,y=%d\n", x, y);
Fin. Fin.
a. En utilisant un sémaphore, modifier le code pour assurer que les printf affichent
toujours des valeurs identiques pour x et y.

Exercice N°6 :
1. Soient trois processus concurrents P1, P2 et P3 qui partagent les variables n et out. Pour
contrôler les accès aux variables partagées, un programmeur propose les codes suivants :
mutex1, mutex2 : Semaphore init(1) ;

Processus P1 Processus P2 Processus P2

Debut Debut Debut
P(mutex1) ; P(mutex2) ; P(mutex2) ; P(mutex1) ;
out=out+1 ; n=n-1 ; out=out-1 ; n=n+1 ;
V(mutex2) ; V(mutex1) ; V(mutex2) ; V(mutex1) ;
Fin. Fin. Fin.

a. Cette proposition est‐elle correcte ? Sinon, indiquez parmi les 4 conditions requises pour
réaliser une exclusion mutuelle correcte, celles qui ne sont pas satisfaites ? Proposez
une solution correcte.

2. On veut effectuer en parallèle le produit de deux matrices A et B d’ordre n(nxn). Pour se

faire, on crée m(m<n) processus légers (threads). Chaque processus léger se charge de
calculer quelques lignes de la matrice résultat R :
pour j  0 à n  1 Ri, j   k 0,n 1 Ai, k * Bk , j 

a. Donnez sous forme de commentaires (en utilisant les sémaphores et les opérations P et
V), le code des processus légers : CalculLignes( ). Précisez les sémaphores utilisés
et les variables partagées.

Page 4
Faculté des Sciences Département de Mathématiques et Informatique