Discussion :

[lea.soineca]

Bonjour,

J'ai une très longue chaîne de caractère qui a plus de 200 000 caractères, appelée char * msgInChar;.

Lorsque j'écris cette chaîne dans un pipe (nommé pfdchildparent), mon code bloque au niveau de l'écriture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

write(pfdchildparent[1], msgInChar, sizeof(char) * (unsigned) strlen(msgInChar));

Mais, lorsque je limite la taille de l'écriture de ma chaîne dans le pipe, cela fonctionne. J'écris cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

write(pfdchildparent[1], msgInChar, sizeof(char) * 65000);

Mais, malheureusement, je n'ai que les 65 000 premiers caractères, et j'aimerai pouvoir envoyer ma chaîne en entière. Je pense que le pipe peut recevoir un certain nombre de caractère au maximum.

Comment est ce que je peux faire pour que la chaine soit écrite en entière?

[schonai]

Bonjour,
Les pipes ont en effet une taille limitée à 64KB. Tu peux donc écrire 65536 caractères au maximum.
Mais tu peux heureusement augmenter cette limite grace à la foncrtion fcntl. Cette fonction sert à configurer tout et n'importe quoi en rapport avec les descripteurs de fichier et notamment les pipes. Tu devrait trouver ton bonheur avec l'option F_SETPIPE_SZ.

Tu peux aussi faire une boucle avec un buffer de taille fixe et écrire ta chaîne en plusieurs fois.

Bon courage!

[neuneutrinos]

ce que tu peux faire c'est envoyer les données par bloc en utilisant le retour de write

write retourne le nombre de caractère effectivement écrit dans le fichier et -1 en cas d'erreur.

pour connaitre l'erreur d'un appel Système par exemple
http://manpagesfr.free.fr/man/man3/errno.3.html
<errno.h> te permettra d'obtenir les réponses

exemple codé à l'arraché pour faire avec une taille "quelconque"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#define TAILLE_BLOC 255
 
//....
 
//strlen est une fonction qui CALCULE donc autant stocker le résultat pour éviter de le recalculer à chaque fois
unsigned int cpt=(unsigned) strlen(msgInChar);//ici (mettre +1 pour envoyer également le caractère '\0'
unsigned int n;//nombre de caractère écrits
do
{
 n=write(pfdchildparent[1], msgInChar, TAILLE_BLOC);
 if(n==-1)break;//erreur
 cpt-=n;//si il n'y a pas d'erreur cpt devrait valoir 0 à la fin de a boucle
 msgInChar+=n;//on décale la lecture de n dans le tableau
}
while(n==TAILLE_BLOC);//tant qu'on lit 1 bloc en entier
//ou bien aussi while(cpt);c'est mieux mais c'est moins clair à expliquer (enfin je crois)

[lea.soineca]

Merci pour vos réponses.

Alors j'ai testé la solution avec fcntl, mais à la compilation il y a une erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

error: 'F_SETPIPE_SZ' undeclared (first use in this function)

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
#include <unistd.h>
#include <fcntl.h>
int flags = fcntl(pfdchildparent[1], F_SETPIPE_SZ, sizeMsg+1);
write(pfdchildparent[1], msgInChar, sizeof(char) * (sizeMsg+1));

Mon Linux est : Kernel Linux 3.2.0-55-generic

[schonai]

Bonjour,
En fête cette constante est spécifique à linux. Tu dois le spécifier avant d'inclure le header de fcntl en ajoutant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#define _GNU_SOURCE

Par contre tu perds la portabilité...
Je pense que la solution de neuneutrinos est plus élégante et sécurisée que ce que tu essayes de faire même si c'est toujours intéressant de savoir le faire.

[lea.soineca]

Ok je vais essayer la technique pour écrire bloc par bloc.

Par contre, j'ai une autre question. Pour la lecture, il y a t-il aussi une limitation sur le pipe?

Car lorsque je lis comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
char msgTurn[300000];
char buffer[300000];
while (read(pfdchildparent[0], buffer, sizeof(char) * 300000) > 0)
{
	strcat(msgTurn, buffer);
}

Seule les 65536 premiers caractères sont lu.

[schonai]

Dans ton sens oui.
Il n'y a pas vraiment de notion de limitation de taille en lecture ou en écriture. Comme tout sur linux, le pipe est un fichier au même titre que toto.txt, il a juste des propriétés supplémentaires. La limitation de taille, c'est la limitation de la taille du fichier qui représente ton pipe. Donc read lit en réalité le pipe tout entier.

[lea.soineca]

Merci, pour ta réponse ! J'ai compris.

Cependant, j'ai testé le code ci-dessous :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
		unsigned sizeMax = 65000;
		unsigned int cpt=(unsigned) strlen(msgInChar)+1;//ici (mettre +1 pour envoyer également le caractère '\0'
		unsigned int n;//nombre de caractère écrits
		do
		{
			printf("1");
			int flags = fcntl(pfdchildparent[1], F_GETFL, 0);//permet au write de ne pas bloquer
			fcntl(pfdchildparent[1], F_SETFL, flags | O_NONBLOCK);
			n=write(pfdchildparent[1], msgInChar, sizeMax);
			if(n==-1)break;//erreur
			printf("2");
			cpt-=n;//si il n'y a pas d'erreur cpt devrait valoir 0 à la fin de a boucle
			msgInChar+=n;//on décale la lecture de n dans le tableau
 
		}
		while(n==sizeMax);

Le résultat obtenu est : 121

Autrement dit, le prog écrit les 65000 premiers caractères mais n'écrit pas les suivants car write renvoie une erreur...
D'où cela peut venir? Peut être parce que le pipe n'est pas vidé ?

D'après errno : Resource temporarily unavailable

[schonai]

Bonjour,
Le problème doit en effet venir de là =/
Je serais tenté d'utiliser select ou poll pour surveiller si le pipe est disponible en écriture.
Le principe de ses fonctions est de surveiller un/des descripteur(s) de fichier afin de détecter leurs changements d'état, données à lire, disponible pour l'écriture... Je ne l'ai jamais utilisé dans ton cas mais ça devrait convenir. =)

Ou alors tu boucles tant que errno te renvoie cette erreur, mais je trouves ça un peu moyen.

[dinobogan]

Le write bloque tant que le pipe est plein.
Dès que le lecteur commence à lire le pipe, le write se débloque.
Il n'y a pas d'utilité à rendre le write non bloquant.

[lea.soineca]

Oui, effectivement j'avais deux processus.
Un qui écrivait sur l'autre et qui attendait sa réponse
L'autre qui attendait une chaine en entrée et qui renvoyé cette chaine modifié

Finalement, je les fais en trois processus:
Un qui écrivait sur l'autre
L'autre qui attendait une chaine en entrée et qui renvoyé cette chaine modifié au troisième processus
Le troisième qui lit

Cela ne bloque plus.