Bonjour,
J'ai un programme client/serveur qui fonctionne en multi-thread.
Je veux que le serveur envoi sur sa socket TCP des "paquets"ou buffer toutes les 100 µs.
Pour cela, le thread qui est chargé d'envoyer les paquets utilise la fonction gettimeofday.
Cette fonction renvoit le temps écoulé depuis ...
ex: 129789.202948 (129789 s et 202948 µs)
 
Ca fonctionne à moitié  
J'ai observé que toutes les 2ms, c'est comme si le thread n'avait plus la main pendant entre 50ms et 150ms
Pour résumer :
ça marche pendant 2ms et après ça s'arrête pendant 50 à 150 ms puis ça remarche pendant 2 ms puis .....  
 
Est ce que qq'un pourrait m'apporter une solution pour que ça marche plus de 2ms

10couNAS a écrit a écrit : Bonjour, J'ai un programme client/serveur qui fonctionne en multi-thread. Je veux que le serveur envoi sur sa socket TCP des "paquets"ou buffer toutes les 100 µs. Pour cela, le thread qui est chargé d'envoyer les paquets utilise la fonction gettimeofday. Cette fonction renvoit le temps écoulé depuis ... ex: 129789.202948 (129789 s et 202948 µs)   Ca fonctionne à moitié   J'ai observé que toutes les 2ms, c'est comme si le thread n'avait plus la main pendant entre 50ms et 150ms Pour résumer : ça marche pendant 2ms et après ça s'arrête pendant 50 à 150 ms puis ça remarche pendant 2 ms puis .....     Est ce que qq'un pourrait m'apporter une solution pour que ça marche plus de 2ms

 
Je pense que ça s'appelle le scheduling ça....    
 
T'as beaucoup d'autres thread? T'as changé les priorités?
 

10couNAS a écrit a écrit : Bonjour, J'ai un programme client/serveur qui fonctionne en multi-thread. Je veux que le serveur envoi sur sa socket TCP des "paquets"ou buffer toutes les 100 µs. Pour cela, le thread qui est chargé d'envoyer les paquets utilise la fonction gettimeofday. Cette fonction renvoit le temps écoulé depuis ... ex: 129789.202948 (129789 s et 202948 µs)   Ca fonctionne à moitié   J'ai observé que toutes les 2ms, c'est comme si le thread n'avait plus la main pendant entre 50ms et 150ms Pour résumer : ça marche pendant 2ms et après ça s'arrête pendant 50 à 150 ms puis ça remarche pendant 2 ms puis .....     Est ce que qq'un pourrait m'apporter une solution pour que ça marche plus de 2ms

 
tu ne peux PAS être sûr d'avoir la main toutes les 100ms, parce que le scheduler te donne la main quand il en a envie. Alors à moins de mettre ton thread en priorité 'temps réel', tu ne pourras pas être sûr d'avoir la main toutes les 100µs.
Par contre, tes valeurs de 50 à 100ms m'étonnent. J'aurrais plus compris une valeur entre 20 et 40ms...

J'ai a peu près 10 threads minimum et je ne me suis pas occupé des priorités
 
En fait pour le serveur, j'ai 5 threads et j'ai un thread par client.
Et chaque thread associé a un client doit envoyer des paquets toutes les 100µs à son client

 
Sais tu que ce ne sont pas les seuls process qui tournent sur ta machine...    
Combien de temps prends ton envoi?    
 
Je pense que tu as deja la reponse à ta question.
 
100 microsecondes = 0,1 ms, non?!?

 
Mis a par tourner sur un multi-proc le seul conseil que j'ai a te donner, c'est de ne pas faire une thread par client...
 
Quand le nombre de tes client va augmentre les perfs de ta machine vont s'effondrer, et ce d'autant plus que la creation destruction de thread n'est pas anodin...
 
Une bonne solution est de faire du thread-pooling...

Ben avec 5 threads, ca me parait difficile. Ceci dit, tu dois avoir une appli sérieusement critique pour avoir besoin d'envoyer des données toutes les 100µs. Je veux dire que si tu pouvais réellement faire cela, avec 5 threads en même temps, la machine va passer son temps à essayer d'envoyer des messages.
Donc:
  - soit tu n'as pas besoin d'envoyer toutes les 100µs
  - soit tu as vraiment besoin, auquel cas il faudrait qu tu n'ai qu'un seul thread qui se charge de l'envoi des messages, et que tu augmente sa priorité. ATtention, sous Linux, ton client devra avoir des droits spéciaux (root?) pour pouvoir changer la policy du scheduler et augmenter la priorité du thread en question.
 
Mias quand même, 5 threads qui envoient des messages toutes les 100µs, ca mùe parait louche

"Sais tu que ce ne sont pas les seuls process qui tournent sur ta machine.." -> oui
 
Mon envoi dure 10 secondes par exemple
 
ex:
En même temps
Le serveur envoit pendant 10 secondes 1 paquet(2 octets) toutes les 100µs au client A
Le serveur envoit pendant  5 secondes 1 paquet(1 octets) toutes les 100µs au client B
Le serveur envoit pendant  8 secondes 1 paquet(2 octets) toutes les 200µs au client C

10couNAS a écrit a écrit : "Sais tu que ce ne sont pas les seuls process qui tournent sur ta machine.." -> oui   Mon envoi dure 10 secondes par exemple   ex: En même temps Le serveur envoit pendant 10 secondes 1 paquet(2 octets) toutes les 100µs au client A Le serveur envoit pendant  5 secondes 1 paquet(1 octets) toutes les 100µs au client B Le serveur envoit pendant  8 secondes 1 paquet(2 octets) toutes les 200µs au client C

 
oui, mais en fait rien ne se fait en même temps vraiment.
avec 100 micros seconde, tu passes ton temps a scheduler!

BENB c'est quoi le thread-pooling

de toute façon, rien que ton envoi risque de prendre plus de 100 micros, donc tu risques de bourrer ton buffer d'envoi....

Et avec un envoi ttes les 1ms ça changerait qqch par rapport aux 100µs?

En fait, je crois que mon pb viens surtout du fait que mes clients fonctionnent en utilisant des boucles d'attente actives avec  
while(heure!=fin) gettimeofday(heure);
A part ça les autres threads utilise la fonctions pthread_cond_wait pour attendre qu'une condition soit rempli et ça, je ne sais pas si ça consomme beaucoup en temps...
 
Je ne sais pas ce que je peux faire pour remplacer mes boucles d'attente actives alors si vous avez des idées ...