SystŁmes d’Exploitation I - Examen Mai 2018
SystŁmes d’Exploitation I - Examen Mai 2018
Programming, Operating Systems, Scheduling · exam
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Voici les concepts et appels système correspondants à chaque définition :
fork()getppid()Le code affiche : value = 5.
Explication :
Lors de l'appel à fork(), le système d'exploitation crée un processus fils qui est une copie exacte du processus père, mais avec un espace mémoire distinct (mécanisme de Copy-On-Write). L'incrémentation value += 15 n'a lieu que dans la copie mémoire du processus fils. Le processus père, qui attend la fin de son fils grâce à wait(NULL), conserve sa propre variable value intacte à 5.
Note sur le code source : Le code fourni dans le sujet nécessite les bibliothèques <unistd.h>, <sys/wait.h> et <stdio.h> pour compiler correctement, mais la logique d'exécution reste celle décrite ci-dessus.
Pour générer une arborescence linéaire stricte de type P1 → P2 → P3 → P4 → P5, chaque processus père doit créer exactement un processus fils, puis s'arrêter d'en créer d'autres.
Voici deux méthodes valides et corrigées pour obtenir ce résultat :
Méthode 1 : Utilisation de conditions imbriquées
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
// Chaque if (fork() == 0) s'exécute uniquement dans le processus fils
if (fork() == 0) {
if (fork() == 0) {
if (fork() == 0) {
if (fork() == 0) {
// Le processus P5 arrive ici
}
}
}
}
// Tous les processus attendent leur enfant potentiel puis affichent leur identité
wait(NULL);
printf("%d --> %d\n", getppid(), getpid());
return 0;
}
Méthode 2 : Utilisation d'une boucle
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
int i;
for (i = 0; i < 4; i++) {
// fork() renvoie le PID du fils (>0) au père, et 0 au fils.
// Si c'est le père, la condition est vraie (différente de 0) et il quitte la boucle.
// Le fils obtient 0 et continue à l'itération suivante pour forker à son tour.
if (fork()) {
break;
}
}
wait(NULL);
printf("%d --> %d\n", getppid(), getpid());
return 0;
}
Les processus ont les caractéristiques suivantes :
L'algorithme SJF (Shortest Job First) utilisé ici est sans réquisition. Une fois qu'un processus commence, il s'exécute jusqu'à la fin. À chaque fin d'exécution, on choisit le processus présent dans la file d'attente ayant le temps d'exécution le plus court.
Diagramme de GANTT :
| P1 | P2 | P5 | P3 | P4 |
|---|---|---|---|---|
| 0 → 3 | 3 → 9 | 9 → 11 | 11 → 15 | 15 → 20 |
L'algorithme Round Robin alloue un quantum de temps maximum à chaque processus (ici 2 unités). Si le processus n'est pas terminé, il est replacé à la fin de la file d'attente.
Diagramme de GANTT :
| P1 | P2 | P1 | P3 | P2 | P4 | P3 | P5 | P2 | P4 |
|---|---|---|---|---|---|---|---|---|---|
| 0→2 | 2→4 | 4→5 | 5→7 | 7→9 | 9→11 | 11→13 | 13→15 | 15→17 | 17→20 |
(Note : À t=4, P1 se termine en n'utilisant qu'une unité sur son quantum. La fin de ce chronogramme montre que P4 termine son exécution avec un bloc de 3 unités, indiquant que son dernier passage couvre la période restante).
Réponse : L'ordonnancement SJF peut entraîner l'apparition de la famine. Justification : Puisque le SJF classique (sans réquisition) sélectionne toujours le processus le plus court, un processus très long pourrait attendre indéfiniment si des processus plus courts continuent d'arriver dans le système de manière ininterrompue.
Données initiales :
Pour pouvoir adresser l'ensemble des 2⁴⁰ octets avec un maximum de 2²⁸ blocs, il faut déterminer la taille de chaque bloc :
Réponse : La taille minimale d'un bloc physique est de 4 Koctets.
Dans un système de fichiers organisé en blocs, la plus petite unité d'espace pouvant être allouée à un fichier est un bloc entier, quelle que soit la taille réelle de ses données.
Réponse : La taille minimale allouée à un fichier est de 1 bloc physique, soit 4 Koctets.
Il faut calculer la taille totale de la table FAT en bits, puis déterminer combien de blocs physiques sont requis pour la stocker.
Réponse : Il faut 28 × 2¹³ blocs pour stocker la table FAT sur le disque.
Dans une table de bits, 1 bloc de données est représenté par 1 bit.
Réponse : La taille de la table de bits est de 2¹³ blocs.
Si on formate ce disque en FAT-16 avec des blocs de 32 Koctets (soit 2¹⁵ octets) :
Réponse : Il est fortement déconseillé de le faire car la capacité maximale adressable serait de 2 Go. Cette capacité (2 Go) est infiniment plus petite que la taille réelle du disque (1 To). L'immense majorité de l'espace de stockage du disque dur deviendrait inutilisable.
Face à ce type d'épreuve associant gestion des processus et de la mémoire, voici l'approche à privilégier :
fork() requièrent une trace manuelle. Dessinez l'arbre des processus sur un brouillon. Rappelez-vous toujours que le code qui suit un fork() sera exécuté par le père ET par le fils. Séparez bien le comportement du père (le retour est > 0) et celui du fils (le retour est 0).