Discussion :

[dodo285]

Bonjour a tous,

Je souhaite écrire un serveur tcp asynchrone, ce serveur doit parfois recevoir des données.
Je ne connaît pas a l'avance la taille des données a recevoir, ce qui n'est pas forcément un problème car il reçoit en premier lieu un entier d'un type déterminé (et dont la taille ne varie pas) qui contient la taille des données qui vont suivre.

Je voudrait que tout cela soit asynchrone, donc un petit coup de fcntl et hop le descripteur est non bloquant.
L'idée serait de regrouper tout les read qui vont suivre en un seul, on peut faire ça avec readv:

Code :

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

ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

Si j’écris ce code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
size_t size = 0;
char* data = NULL;
 
data = malloc(size * sizeof(char));
 
struct iovec v[2];
 
v[0].iov_base = &size;
v[0].iov_len = sizeof(size_t);
v[1].iov_base = data;
v[1].iov_len = *(v[0].iov_base) * sizeof(char);
 
readv(socket, v, 2);

Je sait que ça ne peut pas fonctionner entre deux machines little et big endian, 32 et 64 bits, pour la simplicité je n'est pas mis les macros d'usage pour ces transformations (de toute façon il n'y a pas les headers..).

L'appel système va il utiliser la valeur size qu'il a récupéré dans la première lecture pour faire la seconde?
A moins qu'il recopie le tableau au départ auquel cas la seconde lecture sera de 0 octets.


PS: La plateforme c'est Linux et du récent..

[Matt_Houston]

Non, tu ne peux pas insérer de traitement au sein de l'opération effectuée par readv. Si le buffer de destination est trop court (à moins d'imposer une contrainte sur la longueur des messages), tu devras donc de toute manière répéter la lecture.

Pourquoi ne pas tout simplement désérialiser le flux dans un seul et unique buffer de lecture de manière classique via read / recv ?

[dodo285]

je ne connais pas du tout la solution que tu propose, développe...

[Matt_Houston]

Je propose simplement de ne pas utiliser readv. Cet appel (scatter) est justifié soit par des contraintes bas niveau sur l'architecture du programme (allocations non contigües), soit par le besoin de dispatcher les informations d'une même source à différents systèmes de manière atomique. Tu ne sembles pas ici être concerné ni par un cas, ni par l'autre si j'en crois ton exemple.

D'où ma suggestion : fais comme dans 99% des cas, à savoir récupère toutes les données disponibles d'un bloc et traite-les séquentiellement.

[Bousk]

+1 pour Matt, readv ne sert strictement à rien.
Si ton protocole envoit la taille suivi des données, mon dernier article traite précisément de ça.
En fait je n'ai jamais vu readv utilisé.

Et ce que tu as écrit est totalement éronné : v[1].iov_len = *(v[0].iov_base) * sizeof(char); vaut un beau 0, de même que data = malloc(size * sizeof(char)); alloue exactement rien du tout.