TP 1 - Gestion de Processus
TP 1 - 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 TP 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 synchronisation avec wait(), ainsi que l’analyse des arborescences de processus. Le TP inclut également un exercice pratique de génération de la suite de Fibonacci dans un processus fils. Pour réaliser ce TP, il est nécessaire de disposer d’un environnement de développement C avec un compilateur gcc et un système Unix/Linux.
Ce programme simple crée un processus fils avec fork() et affiche les valeurs de pid à quatre endroits (lignes A, B, C et D). L’objectif est de comprendre ce que retourne fork() dans chaque processus.
Procédure :
Explication :
Les deux processus continuent l’exécution après fork(), mais la valeur retournée par fork() permet de distinguer le parent (retour non nul) du fils (retour 0).
L’objectif est d’écrire un programme C qui crée un processus fils avec fork(), puis exécute un programme générant la suite de Fibonacci dans ce fils. Le nombre d’éléments de la suite est passé en argument en ligne de commande.
Ce programme affiche n nombres de la suite de Fibonacci, où n est passé en argument.
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char * argv[] )
{
int a=0;
int b=1;
int c;
int n=atoi(argv[1]);
while(n>0)
{
printf("%d \n",a);
c=a+b;
a=b;
b=c;
n=n-1;
}
}
Ce programme crée un processus fils avec fork(). Le fils exécute le programme fibonacci avec execl(). Le parent attend la fin du fils avec wait().
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char * argv[]) {
pid_t pid;
int n=atoi(argv[1]);
if(argc != 2)
{
printf("Error \n");
return;
}
if(n<0)
{
printf("Error:Negative Entry \n");
return;
}
switch(pid=fork()) {
case -1:
perror("fork error \n");
break;
case 0:
execl("/home/Nessrine/fibonacci","fibonacci",argv[1],NULL);
break;
default:
wait(NULL);
break;
}
}
gcc tp1ex2.c -o tp1ex2
gcc fibonacci.c -o fibonacci
./tp1ex2 10
Le résultat attendu est l’affichage des 10 premiers nombres de la suite de Fibonacci :
0
1
1
2
3
5
8
13
21
34
Le programme suivant :
#include <unistd.h>
int main ( void )
{
fork () && ( fork () || fork () );
sleep (2);
return 0;
}
Demande de déterminer combien de processus sont créés et leur arborescence.
Analyse :
Conclusion : Le processus principal crée 3 autres processus au total, nommés F1, F2 et F3, avec l’arborescence :
Programme :
#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;
}
Les processus créés sont :
Oui, il existe un risque :
On peut vérifier cela en lançant la commande ps -la dans un autre terminal pendant l’exécution.
Il faut ajouter un appel à wait() dans la boucle while pour que chaque processus père attende la terminaison de ses fils :
#include <unistd.h>
#include <stdio.h>
int main ( ) {
int i=0 ;
while (fork() >=0 && i<2){
i=i+1;
wait();
}
printf(" Processus %d termine avec i=%d \n", getpid(), i);
return 0;
}
Cette modification garantit que les processus fils sont correctement attendus, évitant ainsi la création de zombies ou orphelins. L’arborescence obtenue est celle souhaitée, avec un contrôle strict des processus.
Ce dernier exercice étudie les différentes sorties possibles d’un programme C qui crée plusieurs processus et effectue des appels printf(). On suppose que tous les appels printf() sont immédiatement flushés vers stdout.
Pour les combinaisons suivantes, indiquer si elles peuvent apparaître :
Les sorties possibles du programme sont :