Vous êtes sur la page 1sur 7

La communication interprocessus

Il existe dans Unix diffrents moyens de faire communiquer des processus,


par :
Tube :
Introduits dans premires versions dUnix
Utiliss pour transmettre un flux de caractres en mode continu.
Tubes

Tubes anonymes :
Destins aux
processus dun
mme groupe

Tubes nomms :
Destins des
processus
nappartenant
pas un mme
groupe

File de messages :
Permettent de transmettre des donnes structures entre processus
appartenant ou non un mme groupe
Sockets:
Communication entre processus sexcutant sur des machines diffrentes
dans un rseau, selon un schma client / serveur.

I.

LACOMUNICATION PAR TUBES DANS LE SYSTEME UNIX

Caractristique dun tube

Lecture

criture
ABC 23Y

1. Communication unidirectionnel en mode stream :


Transfert dun flot continu de caractres
2. Gestion FIFO
Les caractres sont lus dans lordre ils ont t cris dans le tube.
3. Il lui correspond deux entres dans la table des fichiers ouverts
Une pour la lecture et lautre pour lcriture.
4. La lecture est destructrice
Une fois lu, un caractre est supprim du tube
Les donnes crites dans le tube ne sont lues quune seule fois.

En cas de plusieurs processus lecteurs (depuis le mme tube), ils ne


liront pas les mmes caractres.
5. Capacit finie
6. Exploite les mmes primitives daccs un fichier :
Open, read, write, close

A. LES TUBES ANONYMES


Un tube anonyme est rfrenc uniquement pas ses deux descripteurs et na
pas de nom.
Les descripteurs sont obtenus la cration de tube qui est faite par un appel
la primitive pipe.

Les descripteurs peuvent tre aussi acquis par hritage : un processus fils hrite
de son pre des descripteurs de tube, entre autres.
La cration dun tube se fait laide de la primitive pipe :
# include <unistd.h>
int pipe (int p[2]) ;
Qui retourne dans le tableau p pass en paramtre les descripteurs utiliser
pour accder au tub.
p[0] : pour la lecture
p[1] : pour lcriture
Elle retourne -1 en cas derreur.
La lecture dans un tube se fait gce la primitive read dont la syntaxe est
int read(int p[0], void *buf, int nb_car) ;
nb_car: le nombre de caractres que lon souhaite lire partir du tube.
buf : un pointeur sur une zone mmoire dans laquelle ils seront rangs aprs
lecture.
Cette primitive retourne le nombre de caractre effectivement lus.
Remarque (lecture bloquante).
Un processus qui tente de lire dans un tube vide et pour lequel il existe des
processus rdacteurs (processus qui dtiennent le descripteur dcriture dans ce
tube), est bloqu jusqu ce que le tube ne soit plus vide.

Il est possible de rendre une lecture non bloquante en positionnant


lindicateur O_NONBLOCK laide de la primitive :
Fcntl (p[0], F_SETFL, O_NONBLOCK)
Lcriture dans un tube se fait laide de la primitive :

write (int p[1], void * buf, int nb_car) ;


nb_car: le nombre de caractres que lon souhaite crire dans le tube.
buf : un pointeur sur la zone contenant les caractres crire.
Comme la lecture lcriture peut aussi tre rendu non bloquante

Exemple :
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#define BUFFER_SIZE 256
int main(void)
{pid_t pid_fils;
int tube[2];
unsigned char bufferR[256], bufferW[256];
puts(creation dun tube);
if (pipe(tube) !=0) {
fprintf(stderr, erreur dans pipe\n);
exit(1) ;
}
Pid_fils =fork();
If (pid_fils == -1)
{ fprintf(stderr, erreur dans pipe\n);

exit(1) ;}
if (pid_fils == 0)

/*processus fils*/

{
printf(fermeture entre dans le fils (pid = %d)\n, getpid()) ;
close(tube[1]) ;
read(tube[0], bufferR, BUFFER_SIZE) ;
printf (le fils (%d) a lu : %s\n, getpid(), bufferR);
}
else
{
printf (fermeture sortie dans le pre (pid=%d)\n,getpid());
close(tube[0]) ;
sprintf(bufferW, Message du pre (%d) au fils, getpid()) ;
write(tube[1], bufferW, BUFFER_SIZE);
wait(NULL);
}
return 0 ;
}
N.B
Les fonctions read et write permettent de transmettre uniquement des
tableaux doctets. Toute donne (nombre ou texte) doit tre convertie en
tableau de caractres pour tre transmise, et la taille de ces donnes doit
tre connue dans les deux processus communicants.
Exercice ( remettre la semaine prochaine)

Ecrire un programme qui cre deux processus. Le processus pre ouvre un


fichier texte en lecture. On suppose que le fichier est compos de mots
forms de caractres alphabtiques spars par des espaces. Le processus fils
saisit un mot au clavier. Le processus pre recherche le mot dans le fichier,
transmet au fils la valeur 1 si le mot est dans le fichier, et 0 sinon.

B. LES TUBES NOMMS


Dfinis afin de permettre des processus sans lien de parent de
communiquer en mode flot.
Un tube nomm possde une rfrence dans le systme de fichiers et
est accessible comme un fichier.
La commande

ls l affiche le type p correspondant un tube nomm.


a) Cration dun tube nomm dans le shell

$ mknod nom_tube p

Pour prciser quil


sagit dun tube
nomm
Permet de crer un fichier ordinaire, un
fichier spcial ou un tube nomm.

b) Cration dun tube nomm dans un programme.


La fonction mkfifo
#include <sys/types.h>
#include <sys/stat.h>
Int mkfifo (cons char *ref, mode_t mode)

Droits daccs
Chemin daccs.

c) ouverture dun tube nomm.


La primitive Open qui permet dacqurir un descripteur sur un
tube est bloquante,

Le premier processus qui demande louverture est bloqu


jusqu ce que le second en demande aussi louverture

Si on utilise plusieurs tubes, il faut les ouvrir dans le mme ordre


dans chacun des processus ; sinon on aboutit un interblocage.

Processus1
Int d_lect, d_ecrit ;

d_ecrit1 = open(fifo1, O_WRONLY);


d_lect1 = open(fifo2, O_RONLY);

n=write(d_ecrit1, &buf, sizeof(buf));

Processus2
Int d_lect, d_ecrit ;

d_lect = open(fifo1, O_RONLY);


d_ecrit = open(fifo2, 0_WRONLY);

n=read(d_ecrit, &buf, sizeof(buf));