limite taille paquet [TCP] ?

[arthuro]

Bonjour,

J'expérimente des problèmes lorsque j'envoie par TCP des paquets trop gros.
Je ne reçoit pas de paquets lorsque ceux-ci dépasse une certaine limite proche de 1,34 Mo
Je précise que je teste cela à partir de 2 instances de mon programme qui communiquent par TCP à travers le localhost.

Peut-être que je sature une certaines files d'attente en interne ?

En règle générale, il y a t-il une limite dans la tailles des paquets qu'on peut envoyer avec TCP  ?

Je peut bien sur découper mon paquet pour que à la réception je puisse vider petit à petit la file d'attente.
Mais c'est dommage, puisque TCP fait déjà du découpage/assemblage en interne.

Merci,

[Laurent]

Tu utilises quelle version de SFML ?

Sockets bloquantes ou non-bloquantes ?

[arthuro]

SFML 2.0

sockets non bloquantes.

[Laurent]

Alors il se pourrait que SFML 2.1 résolve ton problème

[arthuro]

Je vais effectuer la migration, je te tient au courant.

[arthuro]

Je suis passé sous SFML 2.1
Je l'ai fait depuis les sources à l'aide de cmake.
J'était pas trop certain d'utiliser les bonne version.
Pour vérifier j'ai fait:

ldd -v ./monapplication | grep "sfml"
         libsfml-network.so.2 => /usr/local/lib/libsfml-network.so.2 (0x00007f4824be4000)
         libsfml-graphics.so.2 => /usr/local/lib/libsfml-graphics.so.2 (0x00007f48249a5000)
         libsfml-window.so.2 => /usr/local/lib/libsfml-window.so.2 (0x00007f482478f000)
         libsfml-system.so.2 => /usr/local/lib/libsfml-system.so.2 (0x00007f4824585000)

puis dans /usr/local/lib

ls -la | grep "sfml"
lrwxrwxrwx  1 root root       18 août   6 17:06 libsfml-audio.so -> libsfml-audio.so.2
lrwxrwxrwx  1 root root       20 août   6 17:06 libsfml-audio.so.2 -> libsfml-audio.so.2.1
-rw-r--r--  1 root root    85771 août   6 17:06 libsfml-audio.so.2.1
lrwxrwxrwx  1 root root       21 août   6 17:06 libsfml-graphics.so -> libsfml-graphics.so.2
lrwxrwxrwx  1 root root       23 août   6 17:06 libsfml-graphics.so.2 -> libsfml-graphics.so.2.1
-rw-r--r--  1 root root   302714 août   6 17:06 libsfml-graphics.so.2.1
lrwxrwxrwx  1 root root       20 août   6 17:06 libsfml-network.so -> libsfml-network.so.2
lrwxrwxrwx  1 root root       22 août   6 17:06 libsfml-network.so.2 -> libsfml-network.so.2.1
-rw-r--r--  1 root root   130445 août   6 17:05 libsfml-network.so.2.1
lrwxrwxrwx  1 root root       19 août   6 17:06 libsfml-system.so -> libsfml-system.so.2
lrwxrwxrwx  1 root root       21 août   6 17:06 libsfml-system.so.2 -> libsfml-system.so.2.1
-rw-r--r--  1 root root    55420 août   6 17:04 libsfml-system.so.2.1
lrwxrwxrwx  1 root root       19 août   6 17:06 libsfml-window.so -> libsfml-window.so.2
lrwxrwxrwx  1 root root       21 août   6 17:06 libsfml-window.so.2 -> libsfml-window.so.2.1
-rw-r--r--  1 root root   115016 août   6 17:05 libsfml-window.so.2.1
 

Avec cela, je pense être certain d'avoir les bonne versions au niveau des libs.

Malgrè le changement de version, le problème reste identique (pas de mieux, pas de pire)

Juste une précision que j'avais omis, les programmes tournent sur linux.
Je vais faire un programme minimal qui reproduit mon problème.

[Lolilolight]

Ok, je n'ai pas se soucis sous windows donc ce problème est spécifique à linux.
Mais avant la nouvelle version sur windows ça ne marchait pas non plus quand les paquets dépassaient une certaines taille en TCP.

[arthuro]

edit:

Ok, je n'ai pas se soucis sous windows donc ce problème est spécifique à linux.
Mais avant la nouvelle version sur windows ça ne marchait pas non plus quand les paquets dépassaient une certaines taille en TCP.

D'accord. Bon, je vais devoir me limiter à des paquets plus petits.


Voila, j'ai terminé le code minimal

http://www.mediafire.com/download/d032a18ff4dfa4x/sfmlTcpLimit.zip

On lance 2 fois le programme en parallèle.

J'initie la connexion puis j'envoie des paquets auquel je double la taille à chaque fois

A partir d'un moment, ( vers 1048576 ~ 1mo). Le client reçoit en permanence ce même paquet sans le vider j'ai l'impression.

Ce n'est pas exactement le même problème, dans mon application, le client ne reçoit plus rien (ni même les paquets suivant) tandis que dans ce code, il reçoit le même paquet en permanence.


Merci pour le temps que tu m'accorde, bonne journée.

[Laurent]

Pourquoi un zip ? Tu ne peux pas le coller dans un message directement ?

[arthuro]

C'était simplement pour y mettre un Makefile avec pour t'éviter de l'écrire si tu voulais le tester.

voila:

#include <SFML/Network.hpp>
#include <iostream>

void sendBigPaquet(int size, sf::TcpSocket& socket)
{
        std::cout<<"envoie du paquet de taille:"<<size<<std::endl;
        sf::Packet paquet;
        paquet<<sf::Uint32(size);
        for(int i=0;i<size;++i)
        {
                paquet<<sf::Uint32(0);
        }
        socket.send(paquet);
}

void receiveBigPaquet(sf::TcpSocket& socket)
{
        sf::Packet paquet;
        if (socket.receive(paquet)==sf::Socket::Done)
        {
                sf::Uint32 size;
                paquet>>size;  
                std::cout<<"reception d'un paquet de taille :" << int(size)<<std::endl;
                //for(int i=0;i<int(size);++i)
                //{
                        //sf::Uint32 b;
                        //paquet>>b;
                //}
        }
}


int main(int argc, const char *argv[])
{
        std::cout<<"serveur(0) ou client(1)"<<std::endl;
        int reponse;
        std::cin>>reponse;
        std::cout<<"port:"<<std::endl;
        int port;
        std::cin>>port;

        if (reponse==0)
        {
                // Serveur
                sf::TcpListener serverListener;
                sf::TcpSocket socket;
               
                socket.setBlocking(false);
                serverListener.setBlocking(false);
       
                serverListener.listen(port);
                while (serverListener.accept(socket)!=sf::Socket::Done)
                                sf::sleep(sf::seconds(0.3));
               
               
                int size=1;
                for(;;)
                {
                        sendBigPaquet(size,socket);    
                        sf::sleep(sf::seconds(1.0));
                        size*=2;
                }

        }
        else
        {
                // client
                sf::TcpSocket socket;
               
                socket.setBlocking(false);
               
                while(socket.connect("127.0.0.1",port)!=sf::Socket::Done)
                        sf::sleep(sf::seconds(0.3));
               
                for(;;)
                {
                        receiveBigPaquet(socket);
                        sf::sleep(sf::seconds(0.3));
                }

        }
        return 0;
}

et chez moi, cela donne ceci:
server:

./main
serveur(0) ou client(1)
0
port:
1234
envoie du paquet de taille:1
envoie du paquet de taille:2
envoie du paquet de taille:4
envoie du paquet de taille:8
envoie du paquet de taille:16
envoie du paquet de taille:32
envoie du paquet de taille:64
envoie du paquet de taille:128
envoie du paquet de taille:256
envoie du paquet de taille:512
envoie du paquet de taille:1024
envoie du paquet de taille:2048
envoie du paquet de taille:4096
envoie du paquet de taille:8192
envoie du paquet de taille:16384
envoie du paquet de taille:32768
envoie du paquet de taille:65536
envoie du paquet de taille:131072
envoie du paquet de taille:262144
envoie du paquet de taille:524288
envoie du paquet de taille:1048576
envoie du paquet de taille:2097152
envoie du paquet de taille:4194304
envoie du paquet de taille:8388608
envoie du paquet de taille:16777216
 

client:

./main
serveur(0) ou client(1)
1
port:
1234
reception d un paquet de taille :1
reception d un paquet de taille :2
reception d un paquet de taille :4
reception d un paquet de taille :8
reception d un paquet de taille :16
reception d un paquet de taille :32
reception d un paquet de taille :64
reception d un paquet de taille :128
reception d un paquet de taille :256
reception d un paquet de taille :512
reception d un paquet de taille :1024
reception d un paquet de taille :2048
reception d un paquet de taille :4096
reception d un paquet de taille :8192
reception d un paquet de taille :16384
reception d un paquet de taille :32768
reception d un paquet de taille :65536
reception d un paquet de taille :131072
reception d un paquet de taille :262144
reception d un paquet de taille :524288
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
reception d un paquet de taille :1048576
 

[Laurent]

C'était simplement pour y mettre un Makefile avec pour t'éviter de l'écrire si tu voulais le tester

J'ai un projet tout prêt dans Visual Studio, j'ai qu'à coller ton code et faire F5 pour tester. Donc les archives qu'il faut télécharger et décompresser pour découvrir que finalement il y a juste un petit morceau de code avec un makefile qui ne correspond pas à mon environnement de développement, ça ne m'arrange pas tant que ça

Ce qui serait bien dans ce code, ce serait de tester et d'afficher les cas d'erreur. Parce que là on sait que ça arrête de fonctionner, mais on n'en sait pas plus. Tu peux en savoir beaucoup plus, simplement en testant et affichant le retour des fonctions send et receive.

Ensuite est-ce que tu as testé avec des sockets bloquantes ?

[arthuro]

J'ai fait ces tests.

Effectivement quand je passe avec des sockets bloquantes, cela tourne impeccablement.

Avec des sockets non bloquantes:
le status de Send passe de Done à NotReady à partir de gros paquets.
En faisant des Sleep, il arrive à repasser en Done  mais seulement pour une certaine taille, ensuite c'est inutile (même en doublant le temps de sleep à chaque fois que c'est en NotReady)
Cela est vraisemblablement normal, on ne peut pas faire send d'un gros paquets dans le laps de temps aussi court.
Je me demandais , en mode non bloquant, c'est un timeout très courts ou bien un arrêt lorsque qu'il n'y a rien à faire d'autre que d'attendre ? Si c'est la première réponse, c'est normal. Sinon je ne sais pas.

Par contre au niveau de receive, c'est plus bizarre:
A partir d'un moment que send ne fonctionne plus, le status de Receive reste sur Done et je reçoit en permanence le même paquet.

[Laurent]

Ca me paraît vraiment être lié au bug qui a été corrigé dans SFML 2.1. Tu es absolument certain que c'est bien un 2.1 que tu fais tourner ? Il n'y a pas un 2.0 qui traîne ?

[arthuro]

J'était certain.
Mais pour l'être vraiment j'ai supprimé toute occurence des lib de la sfml dans mon system. ( car il y avait aussi les versions 1.6 et 2.0 dans mon system )

j'ai compiler mon programme sans rien réinstaller et il y a des erreur de linkage pour la sfml (comme cela on est certains qu'il n'existe pas d'endroit ou trouver une mauvaise version des libs de la sfml.

J'ai réinstaller la version 2.1 et compilé. Le problème demeure.

[Laurent]

Hmm ok, dommage.

Si l'anglais ne te dérange pas, tu devrais poster sur le forum anglais. Y a un expert en réseau (et en pas mal d'autres choses) là-bas qui pourra t'aider.