Discussion :

[Aleph69]

Bonjour,

j'aimerais savoir s'il y a une différence de performance entre ces prototypages pour une seule et même tache :

Code :

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

1
2
3
void fun(size_t);
void fun(size_t const);
void fun(size_t const&)

Je crois me souvenir avoir lu dans le livre d'Alexandrescu que la deuxième solution est plus efficace que la troisième mais je ne vois pas vraiment pourquoi.

J'ai une deuxième question connexe concernant les fonctions templates :

Code :

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

template<typename T> void fun(T const&);

Dans le cas où T peut aussi bien être un type simple qu'un objet, quelle solution préconisez-vous pour forcer les types simples à ne pas être passés par référence mais par valeur?

Merci d'avance pour votre aide et vos conseils!

[Nhaps]

Dans le cas où T peut aussi bien être un type simple qu'un objet, quelle solution préconisez-vous pour forcer les types simples à ne pas être passés par référence mais par valeur?

Bonjour,

Pourquoi ne pas passer les types simples par référence ?

EDIT : sinon j'aurai dit pour ta première question que la 3eme solution est la meilleur car on m'a toujours dit par exemple pour un setteur que le prototype soit comme ta 3eme solution évitant ainsi une duplication en mémoire de ce que tu passe en paramètre.

[Aleph69]

A cause de ce qui est dit plus haut : dans le cas particulier des types simples, j'ai cru comprendre qu'il valait mieux passer par valeur que par référence. Mais je me trompe peut-être.

[dragonjoker59]

Pour avoir un passage de paramètre optimal, tu peux utiliser ceci :

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
18
19
//! Struct used to select best way to put type in parameter : 'value' or 'const reference'
template <typename T>
struct CallTraits
{
	template <typename U, bool Big> struct CallTraitsImpl;
	//! Struct used to select 'const reference' parameter type
	template <typename U>
	struct CallTraitsImpl<U, true>
	{
		typedef const U & Type;
	};
	//! Struct used to select 'value' parameter type
	template <typename U>
	struct CallTraitsImpl<U, false>
	{
		typedef U Type;
	};
	typedef typename CallTraitsImpl<T, (sizeof( T) > 8)>::Type ParamType;
};

Du coup, dans ta fonction, ça donnerait ceci :

Code :

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

void fun(CallTraits<size_t>::ParamType p_param)

[Aleph69]

Merci pour cette solution élégante. Je pense même qu'il est possible de cacher le booléen aux utilisateurs en passant par une autre classe de trait déterminant si un type donné est simple ou pas.

J'ai quelques questions par rapport à cette solution :

1. le test sizeof( T) > 8 est-il pérenne?
2. je vois que les types simples sont passés par valeur non constante : pourquoi?

[dragonjoker59]

Cette solution tient uniquement compte de la taille.
Je pense que c'est la question la plus importante lors du passage d'un paramètre, la copie est à mes yeux négligeable pour une taille <= 8. Au-dessus aussi, dans une certaine limite, mais 8 est une limite qui permet à tous les types basiques de passer.

EDIT : A la question de la pérennité du sizeof( T) > 8, je dirais oui, jusqu'à ce qu'on passe à des processeurs 128 bits.

[Aleph69]

Super, merci!

[r0d]

Veuillez me pardonner de m'immiscer ainsi dans la discussion, mais concrètement, dans quel cas peut-il être préférable de passer un argument par valeur que par référence constante?

[dragonjoker59]

Préférable ? Je dirais aucun.
Commode ? Je dirais pour tous les types basiques.
Personnellement je passe les types basiques par valeur, par habitude, et parce que je pense ne rien gagner à les passer par référence.
D'ailleurs, je pense que passer par référence une variable dont la taille est inférieure à la taille d'une adresse (bool, char, short sur du 32 bits, int, long, float sur du 64 bits) n'est vraiment pas utile car sur la pile une adresse prendra plus de place. C'est ridiculement négligeable, j'en conviens, mais c'est tout de même là.

[Flob90]

La question pertinante se pose sur la taille des données passées, une référence ca a beau être un alias sur quelque chose qui existe déjà, ca n'en a pas moins une taille. Donc c'est préférable dès que sizeof(T) < sizeof(T&) (le const ne change rien à la taille).

Dans le cas d'égalité c'est au choix, mais entre référence constante et copie, la copie offre bien plus de libertés (on peut en faire ce qu'on veut) donc personnelement j'aurais tendance à prendre la copie en cas d'égalité.

NB: Le plus simple et de comparer à sizeof(T&) et pas à une valeur fixé, les tailles (sauf exception, char par exemple) dépendent de l'architecture / de l'implémentation.

Et avec le C++2011, ca donne :

Code :

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

1
2
3
4
5
6
7
8
 
template<class T>
struct param
{
  typedef typename
    std::conditional<sizeof(T) <= sizeof(T*), T, const T&>::type
    type;
};

Par contre ce n'est pas à utiliser partout, ca bloque une partie du processus de déduction automatique des paramètres template.

[Aleph69]

Salut Flob90,

est-ce que tu pourrais développer ce dernier point?

Par contre ce n'est pas à utiliser partout, ca bloque une partie du processus de déduction automatique des paramètres template.

Est-ce que tu connaitrais un exemple concret ou les cas où ça se produit?

[Flob90]

Code :

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

1
2
3
4
5
6
7
 
template<class T>
void foo(typename param<T>::type)
{ }
 
foo(0); //ne compile pas
foo<int>(0); //compile

Alors que si j'avais mis const T& (ou T) à la "main", ca aurait compilé. Le système de déduction automatique des paramètres template est coupé à cause du typename. Le compilateur peut chercher à "matcher" les paramètres template pour qu'il correspondent au type passé en paramètre (même si le motif est MaClassTemplate<T,U,...>), mais il ne peut pas le faire pour un type définie dans une classe template.

[JolyLoic]

Passer par référence peut bloquer le processus d'analyse d'aliasing du compilateur, et donc baisser les performances. On m'a rapporter un vrai programme manipulant plein de strings dont les perfs se sont améliorées en passant les string par copie...

[r0d]

Très intéressant tout ceci.
Ce problème que vous pointez sur le processus d'aliasing, c'est valable uniquement dans le cas de variables templates ou dans le cas général également?

[JolyLoic]

Je ne pense pas que les templates puissent avoir un impact sur ce sujet, c'est une optimisation qui à lieu à un autre moment. L'idée de base est la suivante (mais en pratique, c'est bien plus compliqué) :
Dans le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
string maChaineGlobale;
void g()
{
    maChaineGlobale = "Tutu";
}
 
void f(string s)
{
  if (s=="Toto") {cout << "toto";}
  g();
  if (s=="Toto") {cout << "toto";}
}

Il peut optimiser le code de f, car il sait que s ne peut pas être modifiée par l'appel de g.

Si maintenant f prend en paramètre une référence, même constante, il ne peut plus faire cette optimisation, sauf s'il peut prouver que maChaineGlobale n'est jamais passée en paramètre à f.

[Goten]

Salut Flob90,

est-ce que tu pourrais développer ce dernier point?



Est-ce que tu connaitrais un exemple concret ou les cas où ça se produit?

boost::call_traits pour eviter de reinventer la roue.