Discussion :

[Yabo]

Bonjour,

J'ai un problème de conception au niveau d'une application client/serveur. J'ai construit un protocole, où chaque type de packet à un numéro (packet 1 : chat, packet 2 : combat ...) et où quand je le reçois il faut que j'execute une fonction pour le traiter. La première solution bourrin qui viens à l'esprit :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
unsigned int ID = get_id_from_packet( packet );
switch( ID )
{
case 1 : chat_packet( packet );
break;
case 2 : war_packet( packet );
break;
// ....
}

Ca marche avec 2 ID, j'en ai plus de 100 ... Pour des raisons de performances et de "beauté" du code cette solution est à jeter.

La solution actuellement implémentée utilise les pointeurs de fonction.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
typedef void (*ptr_function)( unsigned char * );
 
ptr_function packet_function[100];
 
// Ensuite j'initialise chaque packet_function[i] pour pointer vers la fonction qui correspond au packet dont l' ID == i.
packet_function[1] = chat_packet;
packet_function[2] = war_packet;
// ....
 
// Ce qui me permet de faire à la réception d'un packet :
int ID = get_ID_from_packet( packet );
packet_function[ID]( packet );

Ca marche, c'est performant, mais c'est pas beau et c'est une technique que j'utilise en C surtout. Or ici je souhaiterais faire du C++, du vrai . Donc je voulais savoir s'il existait une solution de conception pour ce genre de situation ?

Merci beaucoup.

[Luc Hermitte]

Les modifications sont possibles à divers endroits :
- on peut utiliser des functeurs améliorés plutôt que des pointeurs de fonctions -> boost::function, Loki::Function, ...
- On peut utiliser des sortes de chaines de responsabilité plutôt que des tables dans lesquelles ont été enregistrées les diverses opérations à traiter. Perso, je préfère les tables pour l'accès en O(1) ou O(ln n).

On peut au moment de la reception du paquet contruire un objet dédié à ce type de paquet à l'aide d'une fabrique (factory). L'un dans l'autre, cela revient à ta seconde solution. Avec une sur-couche qui réalise une mini abstraction : au lieu de stocker des fonctions, on stocke des créateurs de foncteurs (ou plus comme des classes de la hiérarchie "paquet").
J'ai envie de dire que c'est une approche typique de sérialisation.

[Yabo]

Est-ce que ma solution se justifierait par rapport aux autres en au vu des performances ? J'ai 200 clients connectés qui envoient chacun plusieurs packets par seconde, j'ai besoin de chaque nanoseconde que je peux glâner . Et comme celà reviendrait au même au final, point de vue du code, ce n'est peut-être pas si interressant que ca d'abandonner ma méthode. Idem pour la mini-surcouche dont tu me parles. Ca fait pas mal d'appel en plus (et donc un coût infimement plus élevé sur 1 appel, mais sur ~500 à 1000 appels par seconde ca fait une différence notable et non-négligeable.

[Luc Hermitte]

Ta solution est parfaitement justifiable je pense.

Sinon, une solution plus propre qui stocke des classes au lieu de fonctions rajouterait juste une petite indirection de type fonction virtuelle ou de type foncteur amélioré. Suivant les calculs qui suivent c'est négligeable.

De sur-couche tu en auras probablement une : un truc qui détermine, à partir des paquets entrants, les opérations qui vont bien ensuite.

[Yabo]

D'accord, merci pour tes conseils