Info32B – Systèmes d’Exploitations – année 2015-2016

Partiel – 25 octobre 2016

N. Sabouret, F. Faissole, H. Jmila
Correction

Exercice 1 – Question de cours (4 points)

1. Quelles les principales étapes du cycle de vie d’un processus pour l’OS ? (1 point)
Correction : Création, prêt, en exécution, en attente, terminé
2. L’adresse logique peut-elle contenir plus de bits que l’adresse physique ? Justifiez votre
réponse. (1 point)
Correction : Oui, c’est le principe de la mémoire virtuelle où chaque processus se voit
alloué plus de mémoire qu’il ne peut effectivement utiliser.
3. Quelle est la différence entre un MUTEX et un sémaphore (1 point)
Correction : Le sémaphore s’applique à un nombre quelconque de processus et à un
nombre fixé de ressources, alors que le mutex ne s’applique qu’à N processus fixé (N=2
dans l’algorithme de base) pour 1 seule ressource. Les sémaphores mals combinés peuvent
provoquer des interblocages, pas les mutex. L’implémentation des sémaphores contient
des sections critiques, donc il faut utiliser des mutex.
4. Quel est le meilleur algorithme d’ordonnancement ? Justifiez. (1 point)
Correction : Il n’y a pas de meilleur algorithme dans l’absolu : cela dépend des critères
choisis et surtout de l’instance. En pratique, round-robin et plus court d’abord sont les
plus utilisés, généralement combinés entre eux et avec des niveaux de priorité variables.

Exercice 2 – Ordonnancement (7 points)

On considère les cinq processus suivants pour lesquels nous indiquons la date d’arrivée dans
l’ordonnanceur et la durée estimée :
Proc. Arrivée Durée
P1 0 7
P2 1 4
P3 1 2
P4 2 2
P5 3 1
1. Indiquez dans le diagramme de Gantt ci-dessous le résultat d’un ordonnancement de type
FIFO, en supposant que le temps de commutation est négligeable. Indiquez en dessous
le temps d’attente moyen et les éléments d’explication que vous jugez nécessaires. (1
point)
Correction :
date: 0 7 11 13 15 16
P1 P2 P3 P4 P5
temps d’attente moyen = (0 + 6 + 10 + 11 + 12) / 5 = 39/5 = 7,8

1
2. Indiquez dans le diagramme de Gantt ci-dessous le résultat d’un ordonnancement de
type plus court d’abord, en supposant toujours que le temps de commutation est
négligeable. Indiquez en dessous le temps d’attente moyen et les éléments d’explication
que vous jugez nécessaires. (1,5 points)
Correction :
date: 0 1 3 4 6 10 16
P1 P3 P5 P4 P2 P1
temps d’attente moyen = (9 + 5 + 0 + 2 + 0) / 5 = 16/5 = 3,2
Au temps t=1, P3 prend la main car c’est le plus court parmi P1 (reste 6), P2 (reste 4)
et P3 (reste 2). Au temps t=2, P4 est arrivé mais n’est pas plus court. Au temps 3, tous
les processus sont là sauf P3 qui est terminé : on les sert dans l’ordre : P5 (reste 1), P4
(reste 2), P2 (reste 4) puis P1 (reste 6).
3. Indiquez dans le diagramme de Gantt ci-dessous le résultat d’un ordonnancement de
type round-robin avec un quantum de 3, en supposant encore que le temps de com-
mutation est négligeable. Indiquez en dessous le temps d’attente moyen et les éléments
d’explication que vous jugez nécessaires. (1,5 points)
Correction :
date: 0 3 6 8 10 11 14 15 16
P1 P2 P3 P4 P5 P1 P2 P1

temps d’attente moyen = ((0+8+1) + (2+8) + 5 + 6 + 7) / 5 = 37/5 = 7,4

4. Quel est le meilleur algorithme suivant le critère du temps d’attente moyen ? Et suivant
le critère du temps d’attente min-max ? (1 point)
Correction : Pour le temps d’attente moyen, c’est forcément "plus court d’abord". Pour
le temps d’attente min-max, c’est encore plus court d’abord avec un temps max de 9
(contre 10 pour RR et 12 pour FIFO).
5. Si le temps de commutation est de 0,5 unités de temps, quel est le temps total d’exé-
cution d’un algorithme "plus court d’abord" et d’un algorithme "round-robin" avec un
quantum de 3 ? (1 point)
Correction : Avec l’algorithme "plus court d’abord", il y a 5 commutations de contexte,
soit 2,5 unités de temps en plus (total = 18,5). Il faudrait aussi tenir compte des nou-
velles dates pour chaque processus mais sur cette instance, cela n’impacte pas l’ordre des
processus. Pour round-robin, nous avons 7 commutations, soit un temps total de 19,5.
6. On se place dans le contexte d’une exécution plus longue de ces mêmes cinq processus,
comme indiqué ci-dessous :
— Le processus P1, après son exécution de 7 pas de temps, fait une E/S qui prendra 3
pas de temps puis redemande la main pour 8 pas de temps.
— Le processus P3, après son exécution de 2 pas de temps, fait une E/S qui prendra 5
pas de temps puis redemande la main pour 3 pas de temps, puis refait une E/S pour
4 pas de temps et enfin reprend la main pour 5 pas de temps.
— Le processus P5, après son exécution de 1 pas de temps, fait une E/S qui prendra 4
pas de temps puis redemande la main pour 4 pas de temps.
Quel algorithme, parmi tous ceux que vous avez vu en cours, vous semblerait le mieux
adapté ? Justifiez votre réponse. (1 point)
Correction : Si on privilégie les petits processus (plus court d’abord), le processus P1
va avoir du mal à s’exécuter. Si on fait un round-robin, on risque d’avoir un système
moins réactif. Un algorithme multi-niveau avec priorité (type Windows XP ou Linux)
serait mieux adapté.

2
Exercice 3 – Processus (4 points)
On considère le code C suivant :
# include < stdio .h >
# include < stdlib .h >
# include < unistd .h >
# include < sys / types .h >
# include < sys / wait .h >

# define N 100

int k = 1;

int main () {

int t [ N ];
int i ;
for ( i =0; i < N ; i ++)
t [ i ] = rand ()% N ;

pid_t fils = fork ();

if ( fils ==0) {
k =0;
for ( i =0; i < N ; i ++)
if ( t [0] < t [ i ])
t [0]= t [ i ];
}
else {
for ( i =1; i < N ; i ++)
t [0]+= t [ i ];
waitpid ( fils , NULL ,0);
}

printf ( " processus ␣ % d ␣ : ␣ % d \ n " ,k , t [0]);

return 0;
}

1. Que fait le "processus 1" dans ce code ? Expliquez.

Remarque : les processus s’annoncent à la fin du programme avant le return 0. (1 point)

Correction : Le processus 1 initialise un tableau aléatoirement et calcule la somme des

éléments du tableau dans t[0] avant de l’afficher.
2. Que fait le "processus 0" dans ce code ? Expliquez. (1 point)
Correction : Le processus 0 initialise un tableau aléatoirement et calcule le maximum
du tableau dans t[0] avant de l’afficher.
3. Y a-t-il un risque pour que les deux processus ne fournissent pas le résultat souhaité ?
Expliquez. (1 point)
Correction : Non, car les deux processus ont des espace de données différents (pas de
variable partagée, y compris le tableau).

3
 4. Les deux résultats sont affichés dans deux processus différents : le processus 1 ne peut pas
utiliser le résultat calculé par le processus 0 et réciproquement. Proposez une solution
pour résoudre ce problème. (1 point)
Correction : Il existe plein de possibilités :
— Passer par des threads et utiliser des variables partagées (variables globales dans le
tas) pour les résultats ;
— Créer deux variables partagées entre les processus à l’aide de shmget
— Utiliser une communication par TCP/IP entre les deux processus (mais on sort un
peu du cadre, là. . .)

Exercice 4 – Synchronisation (5 points)

On considère une route reliant Paris et l’Université Paris-Sud. La particularité de cette route
est d’être à circulation alternée : des voitures peuvent y circuler ensemble dans le sens Orsay
→ Paris ou dans le sens Paris → Orsay, mais elles ne doivent jamais pouvoir se croiser. Nous
avons donc deux classe d’utilisateurs : VP →O (voitures de Paris vers Orsay) et VO→P .
1. Rappeler brièvement la définition d’une section critique ainsi que les trois critères qui y
sont associés (1 point)
Correction : Une section critique est une portion de code qu’on ne peut pas interrompre
car elle contient des variables partagées. Pour l’accès aux section critiques, on souhaite
garantir l’exclusion mutuelle, le déroulement et l’attente bornée (ou vivacité).
2. Expliquez l’analogie entre ce problème et le problème des lecteurs-écrivains vu en TD.
(0,5 point)
Correction : Nous sommes face à un problème proche de celui des lecteurs-écrivains,
sauf qu’il peut y avoir plusieurs écrivains en même temps.
3. En utilisant des sémaphores, écrivez (en pseudo-code ou dans le langage de votre choix)
les fonctions de demande d’accès aux tronçons Paris → Orsay (respectivement Orsay
→ Paris) et les fonctions de sortie des tronçons Paris → Orsay (respectivement Orsay
→ Paris) : nous attendons de vous quatre fonctions, et l’utilisation d’un ou plusieurs
sémaphores. Vous n’avez pas besoin de redonner le code d’un sémaphore. (2 points)
Correction : Ci-après la partie pour Paris → Orsay (les deux fonctions "PO"). La
correction est symétrique pour le sens inverse.
Sempahore route;
Sempahore mutexOP;
Sempahore mutexPO;
int nbOP nbPO;

fonction OPaccess :
mutexOP.verrouiller();
nbOP++;
si (nbOP == 1) route.acquerir();
mutexOP.relacher();

fonction OPexit :
mutexOP.acquerir();
nbOP--;

4
 si (nbOP == 0) route.relacher();
mutexOP.relacher();
4. On ajoute un nouvel acteur : le camion de travaux. On ajoute alors une contrainte sup-
plémentaire : un camion ne peut accéder à un tronçon que s’il n’y a aucun autre camion,
et aucun autre automobiliste. Proposer une solution pour ajouter cette contrainte. (1
point)
Correction : Il suffit de rajouter deux fonctions entreeCamion et sortieCamion qui
prennent le sémaphore "route".
Sempahore route;
Sempahore mutexOP;
Sempahore mutexPO;
int nbOP nbPO;

fonction OPaccessCamion :
route.verrouiller();

fonction OPexitCamion :
route.relacher();
5. Y’a-t-il un quelconque risque de famine ? Justifiez votre réponse. (0,5 point)
Correction : Attention : la réponse dépend de la solution donnée par les étudiants. Telle
qu’elle est fournie dans le corrigé ci-dessus, il peut y avoir une famine puisqu’un groupe
de voiture en continu dans un sens ou dans l’autre peut maintenir la route verrouillée
avec des nbXX++. Mais les étudiants peuvent aussi avoir directement fourni la solution
avec un sémaphore de demande d’accès comme ci-dessous pour le cas du camion.
Sempahore entree mutexOP mutexPO demandeCamion;
int nbOP nbPO;

fonction OPaccess :
demandeCamion.verrouiller();
mutexOP.verrouiller();
nbOP++;
si (nbOP == 1) entree.verrouiller();
mutexOP.relacher();
demandeCamion.relacher();

...

fonction OPaccessCamion :
demandeCamion.verrouiller();
entree.verrouiller();
demandeCamion.relacher();

...