Discussion :

[p4sc0]

Bonjour tout le monde,

J'essaie de développer un application d'analyse réseau (genre iPerf, mais en graphique) avec Delphi 2006. J'en suis qu'aux balbusciements mais je rencontre déjà 2 gros problèmes qui sont :

• Comment calculer le temps que met un paquet entre le logiciel client et le logiciel serveur (temps de latence)
• Quel moyen utiliser pour calculer le débit entre le client et le serveur
• Et y a-t-il un moyen de choisir la taille de fenêtrage TCP avec un composant delphi ?

Pour l'instant, j'ai essayé d'utiliser SNTP grâce au composant Indy TIdSNTP pour synchroniser les 2 horloges de mes PC afin de calculer la latence. Mais le résultat n'a pas l'air de marcher à 100%.

Il faudrait une solution qui fonctionne en TCP et en UDP, donc pas de ping, ni de comptage aller-retour divisé par 2...

Pour la bande passante, j'envoie un tableau de Char de grandeur variable (l'utilisateur pouvant ainsi définir la taille qu'il veut envoyer) grâce au composant TIdTCPClient. Cependant, quand je compare les résultats avec iPerf, je n'arrive pas du tout à la même chose :

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
 
taille := StrToInt(EdtTailleData.Text); //Nbr d'octets à envoyer
try
  SetLength(data, taille);  //On crée le tableau de taille voulue
  for i := 0 to taille-1 do
    data[i] := 9;               //Pour chaque élément on aloue une valeur test
except
  ShowMessage('Erreur tableau');
end;
 
IdTCPClient.WriteBuffer(taille, SizeOf(Integer), True);   //On transmet la taille afin de créer la tableau de bonne taille sur le serveur
IdTCPClient.SendBufferSize := taille*SizeOf(Char); //On définit la taille du buffer d'envoi
 
debut := GetTickCount;   //On va compter le temps qu'il faut pour envoyer tout ca
for i := 0 to taille -1 do
  IdTCPClient.WriteBuffer(data[i], SizeOf(Char), True);   //On envoie le tableau
fin := GetTickCount;

Ca fait en tout cas une voire deux bonne semaine que je suis la dessus. Je commence à déprimer de ne rien trouver. Je vous remercie déjà pour toutes les petites ou grandes aides que vous pourrez m'apporter !

[Franck SORIANO]

Comment calculer le temps que met un paquet entre le logiciel client et le logiciel serveur (temps de latence)

Je crois que tu n'as pas le choix, tu dois faire un PING même si ça ne te plait pas. Le paquet peut passer par plusieurs routeurs intermédiaire, donc tu ne peux pas considérer que le paquet est arrivé lorsque tu as finis de l'émettre. Par conséquent la seule façon de mesurer le temps de traversé du réseau, c'est d'envoyer une trame très simple au serveur. Lorsque ce dernier la reçoit, il va l'acquiter en renvoyant une réponse au client (en d'autres terme, la définition d'un Ping).

N'espère pas horodater la trame à partir de l'horloge client, puis comparer cette heure avec l'horloge serveur, à moins de disposer d'un mécanisme matériel de synchronisation des horloges tu ne pourras jamais les synchroniser avec une précision suffisante pour faire ce type de mesure.

Quel moyen utiliser pour calculer le débit entre le client et le serveur

Tu envoies un bloc de données avec une taille suffisante de l'un vers l'autre et tu mesures la durée du transfer.
Cependant, avec un réseau Ethernet et du TCP/IP, tu n'as pas un réseau déterministe. Donc il ne faut pas t'étonner si en faisant plusieurs mesures tu trouves des résultats différents.
Sans compter que la vitesse du transfer dépend de l'état du réseau, mais également de la vitesse de la machine cliente (la vitesse à laquelle elle arrive à fournir les nouvelles données à envoyer) et la vitesse de la machine serveur (la vitesse à laquelle elle arrive à acquitter les trames), donc de la charge de chacune des machines.

Et y a-t-il un moyen de choisir la taille de fenêtrage TCP avec un composant delphi ?

Aucune idée. Mais j'ai peur que ce soit un paramétrage "en dur" dans la base de registre qui configure la pile IP de Microsoft (avec peut-être un reboot à faire entre chaque modification...).

Code :

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

1
2
3
4
5
 
debut := GetTickCount;   //On va compter le temps qu'il faut pour envoyer tout ca
for i := 0 to taille -1 do
  IdTCPClient.WriteBuffer(data[i], SizeOf(Char), True);   //On envoie le tableau
fin := GetTickCount;

Plusieurs remarques :
- A moins que le tableau ne soit très grand, GetTickCount n'a probablement pas une précision suffisante pour faire la mesure. Chaque GetTickCount possède une incertitude absolue de 15 ms. Tu mesures donc une durée avec une incertitude de 30 ms. Tu ferais mieux d'utiliser les compteurs de performances.
- Le dernier paramètre de WriteBuffer à true, est-ce qu'il n'est pas censé provoquer l'envoie immédiat du buffer, qu'il soit plein ou pas ? Ici tu n'envoies pas un tableau de n Char, mais n trames contenant 1 Char. Avec une entête de l'ordre de 40 octets, ça doit changer beaucoup de choses...
- Enfin, de cette façon, tu pourras mesurer la consommation de la bande passante pour l'envoie des données. Mais ça ne te donnera pas la bande passante de ton interface réseau, puisque tu envoies les données à la vitesse où le serveur arrive à les ingurgiter.