Module : Système d’exploitation et

programmation système. 2022/2023

TP N°3 : Processus et parallélisme

Objectifs :
Création et communication entre processus

Exercice 1 : Création de processus

Que réalisent les programmes suivants. Combien de processus sont créés ? Indiquez le résultat à
l’écran.
1.1

1. #include<stdio.h>
2. #include<sys/types.h>
3. #include<unistd.h>
4.
5. int main(int argc, char **argv) {
6. int p1, p2, p3;
7. p1 = fork();
8. p2 = getpid();
9. p3 = getppid();
10. printf("p1=%d - p2=%d - p3=%d\n",p1,p2,p3);
11. return 0;
12. }

1.2

1. #include<stdio.h>
2. #include<sys/types.h>
3. #include<unistd.h>
4.
5. int main(int argc, char **argv) {
6. int p1, p2, p3;
7. p2 = getpid();
8. p3 = getppid();
9. p1 = fork();
10. printf("p1=%d - p2=%d - p3=%d\n", p1, p2, p3);
11. return 0;
12. }

1.3

1. #include<stdio.h>
2. #include<sys/types.h>

1 TP N°3
 3. #include<unistd.h>
4.
5. int main(int argc, char **argv) {
6. int pid;
7. int x = 2;
8. printf("x=%d\n",x);
9. pid = fork();
10. x = x+1;
11. printf("x=%d\n",x);
12. if (pid != 0) {
13. waitpid(pid, 0, 0);
14. }
15. return 0;
16. }

Exercice 2 : La fonction execl()

2.1 Donnez le code source C d'un programme print.c qui affiche à l'écran la chaîne de caractères qui
lui est passée en paramètre en ligne de commande, par exemple print coucou. Compiler et tester ce
programme.
Réponse :
#include <stdio.h>
int main(int argc, char const *argv[]) {
if (argc < 2)
{
printf("usage: %s message\n",argv[0]);
return 0;
}

printf("%s\n", argv[1]);

return 0;
}

2.2 Ecrire un programme prog1 qui crée un processus fils qui exécute print avec l’argument salut. On
utilisera la fonction execl.

2 TP N°3
Réponse :
#include <unistd.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/wait.h>
int main(int argc, char const *argv[]) {
pid_t pid;
if ((pid=fork()) < 0)
{
perror("Erreur de fork");
}
else if(pid == 0)
{
if(execl("chemin","TP3_EX3_a","Salut",(char *) NULL))
{
perror("execl error");
}
}
wait(NULL);
return 0;
}

Exercice 3 : La fonction kill()

Ecrire un programme qui crée un processus fils qui affiche à chaque seconde le nombre de secondes
écoulées. Le processus père arrête le processus fils au bout de 10 secondes.
Réponse
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include<stdlib.h>
int main(int argc, char const *argv[]) {
int i = 0;
int pidfils = fork();
if(pidfils < 0)
{ perror("Erreur de fork");
exit(-1);
}
if (pidfils > 0)
{sleep(10);
kill(pidfils,SIGKILL);
}
else {
while (1){
sleep(1);
i++;
printf("%d\n", i); }}
return 0;}

3 TP N°3
 Exercice 4 : La fonction wait()
Ecrire un programme qui crée 2 processus, l’un faisant la commande ls -l, l’autre ps -l. Le père devra
attendre la fin de ses deux fils et afficher quel a été le premier processus à terminer.

Réponse :

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include <sys/wait.h>
int main(int argc, char const *argv[]) {

pid_t pid1,pid2;
int status;
if ((pid1=fork()) < 0)
{ perror("la création d'un processus fils a échoué");
exit(1);
}
else if(pid1 > 0)
printf("Processus créé avec Pid : %d\n",pid1);
if (pid1 == 0)
{
execlp("ls", "ls", "-l",(char *) NULL);
perror("Erreur d'exécution de execlp");
exit(-1);
}
if ((pid2=fork()) < 0)
{ perror("la création d'un processus fils a échoué");
exit(-1);
}
else if (pid2 > 0)
{
printf("Processus créé avec Pid : %d\n",pid2 );
}
if (pid2 == 0)
{
execlp("ps", "ps", "-l",NULL);
perror("Erreur d'exécution de execlp");
exit(-1);
}
else
{
wait(&status);
printf("Premier processus à terminer: %d \n", premier_arrive);
}
return 0;}

4 TP N°3