Programmation Système et Réseau

Par : Anis ZOUAOUI

Anis.ZOUAOUI@esprit.ens.tn
Anis.zwawi@gmail.com

1
 Programmation Système et Réseau

Chapitre 3

Communication Inter
Processus

Par : Anis ZOUAOUI

2
 PLAN

• Introduction

•Les tubes de communication anonymes

•Les signaux

3
 Introduction

9 Les systèmes d’exploitation actuels offrent la possibilité

de créer plusieurs processus(threads) concurrents qui
coopèrent pour réaliser des traitements complexes d’un
même application.

9 Ces processus s’exécutent sur même ordinateur

(monoprocesseur) ou multiprocesseur ou sur des
différents ordinateurs, et peuvent s’échanger des
informations(communication inter processus).

4
 Introduction

9 Il existe plusieurs mécanismes de communication

interprocessus :

¾ Les données communes (variables,

fichiers, segments de données)

¾ Les signaux

¾ Les messages.

5
 Introduction
Les threads (POSIX) d’un processus partagent :

¾ La zone de données globales

¾ Le code
¾ La table des descripteurs de fichiers du processus.

Lors de la création d’un processus (fork) :

¾ la table des descripteurs de fichiers est dupliquée

¾ Les processus créateur et créé partageront le même pointeur de
fichier pour chaque fichier déjà ouvert lors de la création.

6
Comment ça marche?

7
 Les tubes de communications unix

Définition:

Les tubes (pipes) de communications permettent entre deux

ou plusieurs processus s’exécutant sur une même machine
d’échanger des informations.

Deux types :

™ Les tubes anonymes

™ Les tubes nommés, qui ont une existence dans
le systèmes de fichiers : Donc un chemin
d’accès

8
 Les tubes Anonymes : Création
Un tube de communication est créé par l’appel système :
int pipe(int p[2])

Cette appel système crée deux descripteurs de fichiers, il

retourne, dans p, les descripteurs de fichiers créés.

• p[0] : contient le descripteur réservés aux

lectures à partir du tube.
• p[1] : contient le descripteur réservés aux
écritures dans le tube.

9
 Les tubes Anonymes : Création

Les descripteurs crées sont ajoutés aux tables de

descripteurs de fichiers du processus appelant.

Seul le processus créateur du tube et ses descendants

peuvent accéder au tube. (Duplication de la table de
descripteurs de fichiers).

Si le tube n’est pas créé: manque d’espace, l’appel système

renvoie ‐1, sinon il retourne la valeur 0.

L’accès au tubes se fait via les descripteurs de fichiers.

10
 Les tubes Anonymes : Création
Communications unidirectionnels:

11
 Les tubes Anonymes
Communications unidirectionnels:

12
 Les tubes Anonymes
Communications unidirectionnels:

Les tubes anonymes sont, en général, utilisés entre un

processus père et son fils.

Scénario:
Père : Crée un tube.
Père : Crée un ou plusieurs fils
Père ÆLecteur
Fils ÆEcrivain
Ecrivain : ferme le fichier non utilisé : de lecture.
Lecteur : Ferme le fichier non utilisé : d’écriture

Les processus (lecteur et écrivain) communiquent en

utilisant les primitives read et write.
13
Les tubes Anonymes

14
 Les tubes Anonymes
Communications unidirectionnels:
Exemple 1:
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define R 0
#define W 1

int main()
{
int pid;
int fd[2];
char message[100];
int Nboctects;
char* phrase="VOICI MON MESSAGE POUR TOI PERE";
system("clear");

15
 Les tubes Anonymes
Communications unidirectionnels:
Exemple :
printf("_____________________________________________\n");
printf("\t\tProcessus Courant:: %d\n",(int)getpid());
printf("_____________________________________________\n");

if (pipe(fd) == ‐1)
{
perror ("Creation du pipe a échoué ");
exit(1);
}

pid=fork();
if(!pid)
{
close(fd[R]);//fermeture du fichier de lecture par le fils
printf("\t\t\t\t\t\t+++++++++++++++++++++++++++++++++++++++\e[m\n");
printf("\t\t\t\t\t\t\t \e[29m Processus FILS:: %d\n",(int)getpid());
printf("\t\t\t\t\t\t+++++++++++++++++++++++++++++++++++++++\n");
printf("\t\t\t\t\t\t \e[29mProcessus FILS::PERE JE T'ENVOIE UN MESSAGE\n");
16
 Les tubes Anonymes
Communications unidirectionnels:
Exemple :
if (write(fd[W],phrase,strlen(phrase)+1)== ‐1)
{
perror("write : Ecriture dans le pipe à échoué ");
exit(4);
}

close(fd[W]);//fermeture du fichier d'écriture par le fils

//sleep(2);
exit(3);
}

printf("%c[%d;%dm J'attends la terminaison du fils%c[%dm\n",27,1,33,27,0);

wait(NULL);

close(fd[W]);//fermeture du fichier de lecture par le pere

17
 Les tubes Anonymes
Communications unidirectionnels:
Exemple :
if (( Nboctects = read (fd[0],message, 100)) == ‐1)
{
perror ("read : Lecture échoué ");
exit(5);
}
message[Nboctects]='\0';
printf("%c[%d;%dmMESSAGE RECU :: nboctets = %d Message=
%s%c[%dm\n",27,1,33,Nboctects,message,27,0);
close(fd[R]);//fermeture du fichier d'écriture par le pere
return 0;

18
 Les tubes Anonymes
Communications unidirectionnels:
Exemple 2:
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
if(pipe(tube)==‐1)
#include<stdio.h>
{
#include<string.h>
perror("Création pipe : ");
#include<stdlib.h>
exit(EXIT_FAILURE);
#include<assert.h>
}
#define R 0
#define W 1
system("clear");
int main(int argc,char* argv[])
{
printf("_______________________________\n");
int tube[2];
printf("\t\tProcessus Courant:: %d\n",(int)getpid());
int pid;
printf("_______________________________\n");
char buf;
assert(argc==2);

19
 Les tubes Anonymes
Communications unidirectionnels:
Exemple 2:
pid=fork();
//PERE
if(pid==‐1) close(tube[R]);
{ write(tube[W],argv[1],strlen(argv[1])+1);
perror("Fork echec"); close(tube[W]);
exit(EXIT_FAILURE); printf("%c[%d;%dm J'attends la terminaison du
} fils%c[%dm\n",27,1,33,27,0);
wait(NULL);
if(!pid)//FILS printf("%c[%d;%dm BYE %c[%dm\n",27,1,33,27,0);
{
close(tube[W]); return 0;
while(read(tube[R],&buf,1) > 0) }
{
sleep(1);
write(STDOUT_FILENO,&buf,1);
}
write(STDOUT_FILENO,"\n",1);
close(tube[R]);
exit(EXIT_SUCCESS); 20
}
 Les tubes Anonymes
Communications unidirectionnels:
Redirection des entrées standards et des sorties standards
La duplication de descripteur permet à un processus de créer
un nouveau descripteur (dans la table de descripteur )
synonyme d’un descripteur déjà existant.
#include<unistd.h>
int dup(int desc);
int dup2(int desc1, int desc2);

dup crée et retourne un descripteur synonyme à desc, le

numéro associé au descripteur crée est le plus petit
descripteur disponible dans la table des descripteurs des
fichiers du processus

dup2 transforme le desc2 à un descripteur synonyme au

descripteur desc1 21
 Les tubes Anonymes
Communications unidirectionnels:
Redirection des entrées standards et des sorties standards
Les fonctions dup et dup2 permettent la redirection des
entrées sorties vers les tubes de communications.

22
who wc
 Les tubes Anonymes
Communications unidirectionnels:
Exemple 3:

int execl (const char *app, const char *arg, ...);

app : chemin complet de l’application

arg : paramètre sous forme d’une liste d’argument,
termine par pointeur NULL
int main(int argc,char* argv[])
#include<sys/types.h> {
#include<sys/wait.h> int pid;
#include<unistd.h> int fd[2];
#include<stdio.h> assert(argc==3);
#include<assert.h> system("clear");
#include<string.h> pid=fork();
#include<stdlib.h> if(!pid) {
#define R 0 close(fd[W]);
#define W 1 dup2(fd[R],0);
close(fd[R]);
execlp(argv[2],argv[2],NULL);
} 23
 Les tubes Anonymes
Communications unidirectionnels:
Exemple 3:
else
{
close(fd[R]);
dup2(fd[W],1);
close(fd[W]);
if(execlp(argv[1],argv[1],NULL)==‐1)
perror("execlp");

return 0;
}

Execlp: la recherche de commande se fait dans la variable d’environnement

PATH

24
 Les tubes Anonymes
Communications unidirectionnels:
EXERCICE
On veut établir, en utilisant les tubes nommés, une
communication de type anneau unidirectionnel entre trois
processus fils. Pour ce faire, la sortie standard de l’un doit être
redirigée vers l’entrée standard d’un autre.

25
 Les tubes Anonymes
Communications unidirectionnels:
EXERCICE

26
 Les tubes Anonymes
Communications unidirectionnels:
EXERCICE

27
 Les tubes Anonymes
Communications unidirectionnels:
EXERCICE

28