Gestion de Processus
Gestion de Processus
Systèmes d’exploitation, Programmation Concurrente · lab
Fiche de révisionGuide de TP
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce laboratoire porte sur la gestion des processus en programmation système sous Unix/Linux. Il permet de comprendre le fonctionnement de l'appel système fork(), la création de processus fils, la gestion des identifiants de processus (pid), ainsi que la synchronisation entre processus parent et fils via wait(). Les exercices couvrent l'analyse de programmes simples, la génération de suites numériques dans un processus fils, la compréhension des arborescences de processus, et la prévention des processus orphelins ou zombies. Pour réaliser ce TP, il est nécessaire d'avoir un environnement de développement C avec un compilateur compatible POSIX et un système supportant les appels fork() et wait().
Ce premier exercice consiste à analyser un programme C simple qui crée un processus fils avec fork(). L'objectif est d'identifier les valeurs des pid affichées aux lignes marquées A, B, C, et D, en supposant que le pid du parent est 2600 et celui du fils 2603.
Programme :
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
pid_t pid, pid1;
/* fork a child process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
return 1;
}
else if (pid == 0) { /* Child Process */
pid1 = getpid();
printf("child: pid = %d", pid); /* A */
printf("child: pid1 = %d", pid1); /* B */
}
else { /* parent process */
pid1 = getpid();
printf("parent: pid = %d", pid); /* C */
printf("parent: pid1 = %d", pid1); /* D */
wait(NULL);
}
return 0;
}
Ce qu'il faut faire :
Pourquoi cette étape : Elle permet de comprendre comment fork() retourne différentes valeurs dans le processus parent (pid du fils) et dans le processus fils (0), et comment obtenir le pid courant avec getpid().
Résultat attendu :
Dans cet exercice, vous devez écrire un programme C qui utilise fork() pour créer un processus fils qui calcule et affiche la suite de Fibonacci jusqu'à un nombre donné en argument de la ligne de commande.
Instructions :
Pourquoi cette étape : Elle permet de pratiquer la création de processus, la gestion des arguments en ligne de commande, et la synchronisation entre processus.
Exemple d'exécution :
./fibonacci 5
0 1 1 2 3
Ce qu'il faut faire :
Le programme suivant crée plusieurs processus via des appels fork() imbriqués :
#include <unistd.h>
int main(void)
{
fork() && (fork() || fork());
sleep(2);
return 0;
}
Ce qu'il faut faire :
Pourquoi cette étape : Elle permet de comprendre les effets combinés de plusieurs appels fork() et les opérateurs logiques sur la création de processus.
Conseil : Analyser chaque appel fork() et son retour dans chaque processus pour déduire le nombre total de processus.
Le programme suivant crée des processus dans une boucle while avec fork() :
#include <unistd.h>
#include <stdio.h>
int main()
{
int i = 0;
while (fork() != 0 && i < 2)
i = i + 1;
printf("Processus %d termine avec i=%d\n", getpid(), i);
return 0;
}
Questions à traiter :
Pourquoi cette étape : Elle permet de comprendre les conséquences des forks dans une boucle, la gestion des processus zombies et orphelins, et les techniques pour les éviter.
Deux programmes C sont présentés (images non reproduites ici). On suppose que tous les appels printf() sont immédiatement flushés vers stdout et que les fonctions ne retournent pas d'erreur.
Partie I : Pour plusieurs combinaisons d'ordres d'affichage (exemple : 513242, 324251, etc.), il faut indiquer si elles sont possibles en sortie du programme.
Partie II : Il faut énumérer toutes les sorties possibles du second programme.
Ce qu'il faut faire :