Discussion :

[loup_precaire]

Bonjour à tous,

J'ai un petit projet réseau destiné à transférer des données UDP en peer to peer et je me suis aperçu que la vitesse du réseau (suis en Gb) est tellement rapide que je perd bcp de paquets. En fait, en réception, j'ai une boucle qui réceptionne les paquets tant que je n'ai pas atteint la taille des données à recevoir (je connais exactement la taille des données envoyées) et je n'arrive à tout recevoir que si je ralenti la vitesse d'envoi des paquets en mettant un sleep entre chaque envoi de paquet.
Pour être plus précis, j'envoi plusieurs Mo que je découpe en paquets de 65Ko et donc je ne reçois tous mes paquets que si je met un sleep entre chacun des 65Ko que j'envoi. J'en déduit que dans ma boucle de réception, si je reçois un paquet alors que je suis en train de traiter le paquet précédent, je ne suis pas en écoute donc le paquet est perdu.

Y a-t-il une technique de pgm qui me permet de régler ça? ou qu'est-ce que je fais mal? Faut-il faire un gros truc genre 2 process en écoute pour qu'il y en ai un en écoute pdt que l'autre traite (ça me parait lourd).

code d'envoi :

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
 
bool SendToUDP(void *pBuffer_, int BufferLenght_)
{
 char *pCurrentBuff = (char *)pBuffer_;
 int iDataSizeSent =0;
 int iCurrentDataSizeSent=0;
 do
 {
	unsigned int iDataSizeToSent = min(unsigned int(BufferLenght_ - iDataSizeSent), 65000);
	iCurrentDataSizeSent = sendto(m_SendSocket, (char *)pCurrentBuff, iDataSizeToSent, 0, (SOCKADDR *) &m_DestSocketAdress, sizeof(m_DestSocketAdress));
	iDataSizeSent += iCurrentDataSizeSent;
	pCurrentBuff += iCurrentDataSizeSent;
	iCpt++;
 }
 while (iCurrentDataSizeSent>0 && pCurrentBuff - ((char *)pBuffer_) < BufferLenght_);
}

et réception :

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
 
bool RecvFromUDP(void *pBuffer_, int BufferLenght_, S_DONNEES_RECU &Datas_)
{
 int iDataSizeReadTotal=0;
 int iDataSizeRead=0;
 char *pBuf = (char *)pBuffer_;
 
 do
 {
	iDataSizeRead = recvfrom(m_SendSocket, pBuf, BufferLenght_-iDataSizeReadTotal, 0, (SOCKADDR *)&m_DestSocketAdress, &iRecvAdressSize);
	iDataSizeReadTotal += iDataSizeRead;
	pBuf+=iDataSizeRead;
	iCpt++;
 }
while (iDataSizeReadTotal<BufferLenght_ && iDataSizeRead != -1 && iDataSizeRead != 0);
}

[white_tentacle]

Tu peux utiliser des threads plutôt que des processus différents, ça sera moins lourd.

Sinon, UDP ne te garantit pas l'ordre des paquets, ni même qu'ils arriveront à destination. Donc dans tous les cas, il te faut un mécanisme pour redemander des paquets perdus.

[loup_precaire]

En ce qui concerne l'ordre des paquets, dans la mesure où j'ai juste un cable qui relie directement 2 ordis, pas de hub, switch, routeur, rien qu'un cable, je me dis qu'il ne devrais pas y avoir de soucis, je me trompe?

Et oui, en disant processus, je pensais thread en fait, dsl.

[Invité(e)]

Bonjour,

En ce qui concerne l'ordre des paquets, dans la mesure où j'ai juste un cable qui relie directement 2 ordis, pas de hub, switch, routeur, rien qu'un cable, je me dis qu'il ne devrais pas y avoir de soucis, je me trompe?

Même entre deux processus sur une même machine, il y peut y avoir des soucis...

[ram-0000]

Pour être plus précis, j'envoi plusieurs Mo que je découpe en paquets de 65Ko et donc je ne reçois tous mes paquets que si je met un sleep entre chacun des 65Ko que j'envoi.

Avec un truc pareil, je passerai en TCP, il n'y a ques des avantages

• Pas besoin de tronconner les paquets, TCP s'en occupe
• Pas besoin de réassembler, TCP s'en occupe
• Les paquets arrivent toujours dans le bon ordre
• Les paquest ne sont jamais perdus ou alors, quand cela arrive, TCP s'occupe de les redemander
• En plus, dans ce cas, vu que tu as du GByte sur le réseau et que tu transmets quand même de gros volumes de données, l'overhead dû à TCP par rapport à UDP est négligeable

Mon avis à 0,01€