Correction Examen2
Questions de cours : (3 pts)
1. Qu’est-ce qu’un PCB ? (0.25 pt)
Réponse : Le Process Control Block (PCB) est une structure de données utilisée par
le système d'exploitation pour stocker les informations relatives à un processus (PID,
état, registres, ressources, etc.).
2. Quels sont les différents états d’un processus et leurs transitions ? (0.5 pt)
Réponse :
o Nouveau (New) → Prêt (Ready) : Le processus est créé.
o Prêt (Ready) → Exécution (Running) : L'ordonnanceur sélectionne le
processus.
o Exécution (Running) → Bloqué (Blocked/Waiting) : Le processus attend
une ressource (E/S, mutex, etc.).
o Exécution (Running) → Prêt (Ready) : Le processus est préempté par un
autre processus plus prioritaire.
o Exécution (Running) → Terminé (Terminated) : Le processus se termine et
libère ses ressources.
3. Critères pour juger l’efficacité d’un algorithme d’ordonnancement ? (0.5 pt)
Réponse :
o Temps de réponse (temps écoulé entre la soumission et la première
exécution).
o Temps de retour (temps total depuis la soumission jusqu'à la fin).
o Temps d’attente (temps total passé en file d’attente).
o Débit (Throughput) (nombre de processus terminés par unité de temps).
4. Qu'appelle-t-on un processus qui s'est terminé mais dont le père n'a pas encore
lu son code de retour ? (0.25 pt)
Réponse : Un processus zombie.
5. Que signifie préempter un processus ? (0.5 pt)
Réponse : A. Suspendre son exécution au profit d’un autre processus.
6. Qu’est-ce qu’un processus au sens d’un OS ? (0.5 pt)
Réponse : C. L’instance d’un programme en cours d’exécution.
7. Quel est le rôle d’un ordonnanceur au sein d’un OS ? (0.5 pt)
Réponse : D. Ordonnancer les processus à exécuter selon un ou des critères.
Exercice 1 : (8 pts)
1. Programme en C utilisant dup2 pour rediriger la sortie standard vers un
fichier [Link] (3.5 pts)
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main() {
int file_desc = open("[Link]", O_WRONLY | O_CREAT | O_TRUNC,
0644);
if (file_desc < 0) {
perror("Erreur lors de l'ouverture du fichier");
return 1;
}
dup2(file_desc, STDOUT_FILENO); // Rediriger stdout vers [Link]
close(file_desc); // On peut fermer file_desc après duplication
printf("Ce message sera écrit dans [Link]\n");
return 0;
}
2. Programme avec un tube anonyme et deux écrivains (4.5 pts)
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main() {
int fd[2];
pipe(fd);
pid_t pid1, pid2;
if ((pid1 = fork()) == 0) {
close(fd[0]);
for (int i = 1; i <= 5; i++) write(fd[1], &i, sizeof(int));
close(fd[1]);
return 0;
}
if ((pid2 = fork()) == 0) {
close(fd[0]);
for (int i = 6; i <= 10; i++) write(fd[1], &i, sizeof(int));
close(fd[1]);
return 0;
}
close(fd[1]);
int sum = 0, num;
while (read(fd[0], &num, sizeof(int)) > 0) sum += num;
close(fd[0]);
printf("Somme totale : %d\n", sum);
wait(NULL);
wait(NULL);
return 0;
}
Résultat attendu : Somme totale : 55
Exercice 2 : (4 pts)
1. Résultat d'exécution du Code 1 (2 pts)
int main() {
pid_t pid;
int value = 9;
if (fork() == 0) { // Processus fils
value += 10;
return 0;
} else {
wait(NULL); // Attente de la fin du fils
printf("value = %d\n", value);
}
return 0;
}
Analyse :
o Le processus fils incrémente value mais dans son propre espace mémoire.
o Le père ne voit pas cette modification et affiche value = 9.
Sortie : value = 9
2. Objectif du Code 2 (2 pts)
int main() {
pid_t pid;
int status;
pid = fork();
if (pid == 0) {
printf("Je suis le processus fils (PID: %d)\n", getpid());
execlp("python3", "python3", "[Link]", NULL);
perror("exec");
return 1;
} else {
printf("Je suis le processus parent (PID: %d)\n", getpid());
waitpid(pid, &status, 0);
return 0;
}
}
o Processus fils : Exécute [Link] en remplaçant son image mémoire.
o Processus père : Attend la fin du fils.
o Si exec échoue, le message perror("exec") s'affiche.
Exercice 3 : (5 pts)
1. Ordonnancement basé sur la priorité préemptive (2.5 pts)
Processus Arrivée Temps CPU Priorité
P1 07:00 10 min 2
P2 07:00 15 min 3
P3 07:03 8 min 4
P4 07:10 18 min 5
Priorité croissante (5 = plus prioritaire).
P4 interrompt les autres dès son arrivée.
Diagramme de Gantt :
| P1 | P2 | P3 | P4 | P2 | P1 |
0 7 10 18 36 44 52
2. Priorité dynamique recalculée toutes les 5 min (2.5 pts)
Nouvelle priorité : Dépend du temps d'attente.
Si égalité, priorité au processus en attente depuis plus longtemps.
Diagramme de Gantt avec recalcul des priorités :
| P1 | P3 | P4 | P2 | P1 |
0 7 15 33 43 52
