Fonctions de base d'Unix concernant les pipes/tuyaux

Tous les documents de cette page sont sous licence Creative Commons BY-NC-SA . Merci de la respecter.

©A. Dragut
Aix-Marseille Université I.U.T.d'Aix en Provence - Département Informatique
Dernière mise à jour :1/11/2012

Rappel structure des répertoires

allez dans sous-répertoire TP

allez dans le sous-répertoire tpsystem

créez tpipc

allez dans tpipc

créez le répertoire exo_01

allez dans exo_01

copiez-y (avec l'option -r), le répertoire include du dernier exercice sur les processus

créez le répertoire diripc

copiez dans diripc le fichier Makefile du dernier exercice sur les processus (donc depuis son dir...)

pour chaque exercice, vous créérez un nouveau répertoire exo_0x avec x le numéro de l'exercice, et, sauf indication contraire, vous y copierez le répertoire include de l'exercice précédent.

Pour faire de la place dans vos répertoires
Faites un petit coup de make clean dans le dir* de chaque exo_*. Compressez le contenu de chaque répertoire d'exercice avec tar et gzip, avec la commande suivante (exemple pour exo_01) :
tar cvf - exo_01 | gzip -9 - > exo_01.tar.gz
Attention aux espaces autour des tirets seuls, ces tirets demandent l'utilisation de l'entrée, respectivement sortie standard (au lieu d'utiliser des noms de fichiers). Ainsi on peut enchaîner ces commandes et tout déposer directement dans exo_01.tar.gz Par contre, le -9 est bien ensemble, cette option demande la meilleure compression.

Sommaire du document

Liste des fonctions et concepts système étudiés

Liste des exercices

Pour chaque exercice (exo_01, exo_02, exo_03)

Présentation courte du but

Travail à faire

Explications, rappels du cours, petites astuces, etc.

Liste des fonctions et concepts système étudiés
Dans cette série de neuf exercices on étudie pipe(), mkfifo(), ensuite semctl(), semop().
Liste des exercices

exo_01 Partage d'un pipe anonyme

exo_02 Partage d'un pipe nommé

OPTIONNEL exo_03 Partage des pipes entre plusieurs processus

Bon courage !

exo_01 Pipe anonyme entre deux processus -- père et fils.

Dans cet exercice

vous écrivez un programme utilisant un pipe/tuyau pour relier deux processus -- père et fils.

Quoi de neuf

Le schéma de fonctionnement de la communication unidirectionnelle en utilisant des pipes/tuyaux est le suivant ; on suppose que le père écrit et le fils lit du pipe/tuyau :

Le processus initial crée le pipe/tuyau pipe(fd)
Le processus fait un appel à fork() pour créer un fils
Parce que les descripteurs des "fichiers" ouverts sont hérités, le père et fils possèdent alors chacun un descripteur en lecture et un en écriture pour le pipe/tuyau
Le processus père ferme son descripteur en lecture fd[0], tandis que le processus fils ferme son descripteur en écriture fd[1]
Le processus père producteur écrit sur le pipe/tuyau à l'aide de write() et le fils consommateur lit les valeurs écrites à l'aide de read()

Un protocole de communication pour écrire un message de taille variable:

avec une écriture sur une taille fixe (un entier est code toujours sur sizeof(int) ) on annonce au consommateur la taille du message à suivre
on écrit le message de taille variable

Un protocole de fin de communication fait la difference entre une fin attendue et une par erreur.

quand le pipe/tuyau est fermé en écriture par le producteur (celui qui fait write() ) le read() du consommateur renvoie 0, c.à.-d. EOF
si le producteur est fermé à cause d'un incident: segmentation fault, arrivée de signal,.., etc., le read() du consommateur renvoie 0 aussi

Pour établir une communication bidirectionnelle, on utilise deux pipes/tuyaux distincts.

Travail à faire

Récupérez modelmain.cxx, nsSysteme.h et nsSysteme.cxx et étudiez bien le wrapper de la fonction système pipe()

Dans le fichier exo_01.cxx dans le try ... catch du main()

Ouvrez un pipe anonyme.

Créez ensuite un processus fils.

Fermez les descripteurs inutiles pour transformer le père en producteur et le fils en consommateur.

Le père recoit comme arguments de la commande plusieurs chaînes de charactères : "les messages"

Dans une boucle le père producteur écrit deux appels de Write().

il écrit sur le pipe/tuyau chaque chaîne précédée de sa taille en octets, (utilisez la fonction strlen())

Pour marquer la fin de la communication le père écrit sur le pipe/tuyau le charactère '#' précédée de sa taille en octets, 1

Dans le fils consommateur tant que la communication avec le père est possible (le père ne lui a pas dit combien de chaînes sont envoyés) on lit similairement, avec deux appels de Read():

il lit un entier contenant la taille du message et puis un message de la longueur égale à l'entier qu'on vient de lire.

La communication producteur-consommateur peut finir comme prevu après que le producteur envoie le charactère '#' de taille 1 ou lorsque le producteur est prématurément arreté (erreur de segmentation,etc.) et son pipe/tube du producteur ferme et un appel de Read() sur lui va envoyer EOF

Compilez et testez

d'abord avec un seul argument:

./exo_02.run aaaaaa

et ensuite avec plusieurs arguments :

./exo_02.run aaaaaa bbbbbb ccccc

QUESTION: Sauvegarder une copie de l'exo_01.cxx dans sansprotocole.cxx . Commentez les lignes qui font lire la taille et remplacez la taille utilisée pour réserver la mémoire pour la lecture des messages avec la constante PIPE_BUF de climits.h. Que se passe-t-il et pourquoi?