Discussion :

[bolhrak]

Bonsoir à tous,

Juste une petite question concernant le choix entre l'utilisation du passage de paramètres par référence et celui par copie. Pour les objets de grande taille, aucun problème, la réponse est évidente. Par contre pour ceux de petite taille, c'est plus délicat. D'après ce que j'ai pu lire, le passage par copie est préférable pour les types de base tels int ou double, car le proc peut utiliser un registre pour stocker cette valeur plutôt que de l'allouer sur la stack.

Maintenant qu'en est-il des objets genre complex (deux doubles) ? A priori cet objet sera alloué sur la pile s'il est copié, donc une référence semble plus apropriée. Pourtant l'implémentation du type complex de la librairie standard préfère le passage de complex par copie (pour les opértateurs arithméthiques par exemple). Y'a-t-il une raison à ce choix et une réelle modification des performances ?

[Sergejack]

Il y a un juste équilibre à trouver entre la sécurisation des données et les performances, puisque passer les paramètre par copie offre la sécurité de ne pas rallonger la portée des données outre mesure (sécurité face à l'erreur de programmation donc).

L'équilibre a été estimé en faveur du passage par recopie en ce qui concerne les complexes.

[Luc Hermitte]

La "sécurité" dont tu parles n'a de sens que dans un environnement multithréadé si la donnée passée est une entité pouvant évoluer. Ou que l'on ne trouve rien de mieux que de stocker une référence vers cette dernière. Dans ce dernier cas, il faut juste réfléchir aux dépendances. C'est exactement pareil que de garder des pointeurs.

C'est au nouveau du double double (sic) que je commence à faire un coup d'une façon, un coup de l'autre. Probablement parce que je ne me suis pas amusé à faire des mesures de perfs.

[Jean-Marc.Bourguet]

Il y a aussi des désavantages d'un point de vue performance à utiliser le passage par référence: les accès ont une indirection supplémentaire; donc le choix optimal peut être dépendant de l'implémentation de la fonction.

A mon avis, c'est typiquement le genre de choix qui devrait être laissé au compilateur (comme en Ada où le compilateur peut passer les paramètre in par valeur ou référence comme il veut -- sauf quelques exceptions comme les types limités où le passage par référence est obligatoire) et à ceux qui définissent l'ABI, car ils sont les seuls qui disposent réellement de l'information nécessaire pour choisir.

A noter en ce qui concerne l'utilisation des registres pour le passage des paramètres que rien n'interdit au compilateur d'implémenter:

Code :

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

1
2
3
void f(C obj) {
   ...
}

comme

Code :

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

1
2
3
4
void f(C& _obj) {
C obj(_obj);
   ...
}

Ce qui a au moins l'avantage de pouvoir diminuer la taille du code généré (et donc la pression sur les caches).

[Charlemagne]

Je vois encore d'autres critères qui peuvent influencer sur le choix d'un passage par référence ou par valeur:

-Si le paramètre est un template (99% des cas dans mes programmes), il vaut mieux faire un passage par référence étant donné qu'on ne connait pas (a priori) la taille du paramètre

-Si le temps d'appel de la fonction n'est pas négligeable par rapport à son temps d'exécution, alors c'est probablement une fonction qui pourrait/devrait être inlinée. J'ai déjà visualisé le code généré par mon compilo (Intel Compiler) pour les 2 types de passages sur des fonctions inlines: il ne fait aucune différence car tout est géré dans les registres.


Dans l'ensemble, je dirais qu'il faut passer:
- les types simples par valeur
- tout le reste par référence

Mais si tu veux en avoir le coeur net sur ton programme, rien ne remplacera une mesure des temps d'exécution

[Matthieu Brucher]

A ce sujet, pour les types simple, je crois que Boost propose un type templaté adapté - si le compilo le supporte -, ce qui permet d'activer le passage par référence ou pas selon le paramètre, justement