Devoir Surveillé - Systèmes d'Exploitation I
Devoir Surveillé - Systèmes d'Exploitation I
Programming, Operating Systems · exam
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
L'exercice demande d'associer une description à la commande Linux correspondante.
rmmodkillallpidof (Note : la lettre figurait probablement à la place des parenthèses vides dans l'énoncé original).sizelsmodIl s'agit de corriger les affirmations erronées.
wait (ou waitpid) permet d'éviter l'apparition des processus zombies.getppid retourne le PID du processus père.
Note pédagogique : Le corrigé source de l'examen indique de façon erronée "processus grand-père". L'abréviation "ppid" signifie "Parent Process ID" (identifiant du processus père).L'objectif est d'écrire un code en C demandant à l'utilisateur un entier n, puis générant n processus.
Le code extrait du document original présente une logique corrompue (les boucles for appelant fork() en boucle infinie ou exponentielle sans arrêt explicite). Pour générer exactement n processus (le père initial + n-1 processus fils), la méthode standard consiste à utiliser l'appel système fork() dans une boucle et à s'assurer que les processus fils sortent de la boucle pour ne pas créer leurs propres fils.
Voici le code corrigé, propre et fonctionnel pour générer n processus au total, en créant n-1 fils à partir d'un seul père :
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
int i;
int n;
printf("n ?\n");
if (scanf("%d", &n) != 1) {
return 1; // Sécurité pour la saisie
}
// On crée n-1 fils pour avoir n processus au total (avec le père)
for (i = 1; i < n; i++) {
if (fork() == 0) {
// Nous sommes dans le processus fils.
// On quitte la boucle pour éviter que le fils ne crée d'autres fils.
break;
}
}
return 0;
}
Il faut proposer les instructions C minimales pour obtenir différentes arborescences.
(a) Arborescence : P1 père de P2. Un seul appel suffit :
fork();
(b) Arborescence : P1 père de P2, et P2 père de P3.
Il faut que le premier fils (P2) exécute un second fork(), mais pas le père (P1).
if (fork() == 0) fork();
Autre option (évaluation paresseuse) : fork() || fork();
(c) Arborescence : P1 père de P2 et de P3.
Il faut que le père (P1) exécute les deux fork(), mais que le premier fils (P2) s'arrête.
if (fork() > 0) fork();
Autre option (évaluation paresseuse) : fork() && fork();
(d) Arborescence : P1 père de P2 et P3, et P2 père de P4.
L'instruction fork(); fork(); réalise exactement cela.
fork() crée P2 (depuis P1).fork() est exécuté par P1 (créant P3) et par P2 (créant P4).fork();
fork();
Nous disposons d'un seul processeur et de la file d'attente suivante :
L'algorithme FCFS (Premier Arrivé, Premier Servi) est non préemptif. Chaque processus s'exécute de bout en bout dans son ordre d'arrivée.
(a) Diagramme de GANTT
| P1 (0 à 3) | P2 (3 à 9) | P3 (9 à 13) | P4 (13 à 18) | P5 (18 à 20) |
|---|
(b) Temps de séjour moyen Le temps de séjour (ou temps de rotation) se calcule comme : Date de fin - Date d'arrivée.
Somme des temps de séjour = 3 + 7 + 9 + 12 + 12 = 43 Temps de séjour moyen = 43 ÷ 5 = 8.6
(c) Temps d'attente moyen Le temps d'attente se calcule comme : Temps de séjour - Durée d'exécution (ou Date de début - Date d'arrivée).
Somme des temps d'attente = 0 + 1 + 5 + 7 + 10 = 23 Temps d'attente moyen = 23 ÷ 5 = 4.6
Pourquoi l'ordonnancement FCFS peut-il conduire à la situation de famine ?
Le principe FCFS est un ordonnancement non préemptif (sans réquisition par le système). Si un processus s'accapare le processeur (par exemple, à cause d'une boucle infinie ou d'un bug de conception) et ne le libère jamais volontairement, le système d'exploitation ne reprendra pas la main pour la donner aux autres. Les processus en file d'attente n'obtiendront donc jamais le processeur : c'est la situation de famine.
Face à ce type d'épreuve de systèmes d'exploitation, voici les étapes recommandées pour vous assurer un maximum de points :
fork() divise le flux en deux. Dessinez un arbre binaire. Si la condition est if (fork() == 0), seule la branche fils (retour 0) continuera le code dans le bloc. Rappelez-vous que les opérateurs && et || exploitent l'évaluation paresseuse : le second fork() ne s'exécutera que si le résultat du premier le nécessite (faux pour le ET logique, vrai pour le OU logique).break ou exit() dans le processus fils pour ne pas qu'il participe aux itérations suivantes de la création.wait avec zombie, fork avec création, exec avec recouvrement). Attention aux pièges : getpid identifie le processus courant, tandis que getppid identifie toujours le parent direct, pas les grands-parents.