C++

void f(int val) vs void f(int & val)

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : void f(int val) vs void f(int & val)

Glock 17Pro

salut,

en terme de perf le fait de passer des types de base par référence est-il plus lent que de les passer par valeur ou cela revient il exactement au même ?

merci

---------------
.

Publicité

Joel F

Real men use unique_ptr

par référence ou par référence constante. La ton exemple est foireux car la sémantique de la fonction change.

Glock 17Pro

disons les deux cas, par rapport à un passage par référence et par rapport à un passage par référence constante

---------------
.

bjone

Insert booze to continue

Si ce que tu veux comme cas d'utilisation, c'est du void f(int val), le passage par valeur sera plus économique.

Maintenant je dirais (probablement mal):
A partir du moment où tu as une référence, la logique voudrait que le compilo déréférence la référence a chaque utilisation car l'objet référencé peut avoir changé (bon à voir peut être avec volatile).

void f(int val)
{
while (val)
{
poulpe();
--val;
}
}

void f(int &val)
{
while (val)
{
poulpe(); // poulpe peut avoir changé le int
--val;
}
}

Maintenant je sais pas si c'est une remarque à la con. (et que le compilo n'optimisera pas que si y'a un volatile en plus )

edit: je me suis pris les pieds dans le tapis en voulant faire une démo foireuse >> seek coffee.

Mais si tu cherche les perfs, à partir du moment où le type rentre dans un registre du cpu (ou plusieurs de manière efficace) c'est int ou const int (le const permettant entre autre au niveau optimisation de garantir que l'appelé ne modifia pas le registre utilisé pour le passage).

Enfin je dis ça comme ça moa.

Message édité par bjone le 05-11-2009 à 13:11:02

Joel F

Real men use unique_ptr

gcc à l'air de pas tenir compte des const& sur les types atomiques.

Message cité 1 fois

Un Programmeur

Joel F a écrit :

gcc à l'air de pas tenir compte des const& sur les types atomiques.

Il donne pourtant le resultat que j'attends pour

Code :

#include <iostream>
#include <ostream>
int i = 0;
void f(int const& p)
{
std::cout << "p = " << p << '\n';
i = 42;
std::cout << "p = " << p << '\n';
}
int main()
{
f(i);
return 0;
}

Message cité 1 fois

---------------
The truth is rarely pure and never simple (Oscar Wilde)

bjone

Insert booze to continue

il voulait dire const int & nope ?
oupa ?
ha non café

Message édité par bjone le 05-11-2009 à 17:15:10

Joel F

Real men use unique_ptr

Un Programmeur a écrit :

Il donne pourtant le resultat que j'attends pour

je veut dire que le code généré pour f(int) et f(int cosnt& ) est identique ...

Un Programmeur

C'est bien ce que j'avais compris. Je vois mal comment c'est possible si on veut traiter correctement le genre de cas que j'ai donné (hormis si f est statique et qu'on ne passe jamais de pointeurs à f à une fonction dont on ne voit pas le code et tous les appels...).

Message cité 1 fois

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Joel F

Real men use unique_ptr

Un Programmeur a écrit :

Hmmmm, soit y a inference de l'origine de la référence soit ca a changé.
Je comprends pas pourquoi j'ai le résultat p=0,p=42 d'ailleurs au vu du code.

Publicité

Un Programmeur

C'est pourtant le comportement attendu. Une référence est un alias pour l'objet initial (ici i), le fait qu'on ne puisse pas modifier l'objet en utilisant cet alias n'empêche pas de pouvoir le faire en utilisant un autre accès.

Et si tu parles du code généré, ça me semble compréhensible ici -- g++ 4.2 sur x86. En gros c'est compilé comme

Code :

#include <iostream>
#include <ostream>
int i = 0;
void f(int const* p)
{
std::cout << "p = " << *p << '\n';
i = 42;
std::cout << "p = " << *p << '\n';
}
int main()
{
f(&i);
return 0;
}

---------------
The truth is rarely pure and never simple (Oscar Wilde)

bjone

Insert booze to continue

Code asm il voulait dire je pense :??:

Un Programmeur

Et bien?

Appel de f dans main:

Code :

.LCFI17:
sub %esp, 4
.LCFI18:
mov DWORD PTR [%esp], OFFSET FLAT:i
call f(int const& )
add %esp, 4

on passe l'adresse de i. Code de f

Code :

.text
.align 2
.p2align 4,,15
.globl f(int const& )
.type f(int const& ), @function
f(int const& ):
.LFB1428:
push %ebp
.LCFI7:
mov %ebp, %esp
.LCFI8:
sub %esp, 40
.LCFI9:
mov DWORD PTR [%ebp-4], %edi
.LCFI10:
mov %edi, DWORD PTR [%ebp+8]
mov DWORD PTR [%ebp-8], %esi
.LCFI11:
lea %esi, [%ebp-13]
mov DWORD PTR [%ebp-12], %ebx
.LCFI12:
mov %ebx, DWORD PTR [%edi]
mov DWORD PTR [%esp+8], 4
mov DWORD PTR [%esp+4], OFFSET FLAT:.LC0
mov DWORD PTR [%esp], OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, int)
mov DWORD PTR [%esp+4], %ebx
mov DWORD PTR [%esp], OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
mov DWORD PTR [%esp+4], %esi
mov BYTE PTR [%ebp-13], 10
mov DWORD PTR [%esp+8], 1
mov DWORD PTR [%esp], %eax
call std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, int)
mov DWORD PTR i, 42
mov %ebx, DWORD PTR [%edi]
mov DWORD PTR [%esp+8], 4
mov DWORD PTR [%esp+4], OFFSET FLAT:.LC0
mov DWORD PTR [%esp], OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, int)
mov DWORD PTR [%esp+4], %ebx
mov DWORD PTR [%esp], OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
mov DWORD PTR [%esp+4], %esi
mov BYTE PTR [%ebp-13], 10
mov DWORD PTR [%esp+8], 1
mov DWORD PTR [%esp], %eax
call std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, int)
mov %ebx, DWORD PTR [%ebp-12]
mov %esi, DWORD PTR [%ebp-8]
mov %edi, DWORD PTR [%ebp-4]
mov %esp, %ebp
pop %ebp
ret

On voit bien qu'on déréférence ce qui est passé (DWORD PTR[%edi]).

(g++ -O2 -masm=intel -S puis le résultat est passé dans c++filt pour démangler les noms)

Message édité par Un Programmeur le 05-11-2009 à 20:15:04

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Joel F

Real men use unique_ptr

je viens de vérifier. Je m'a fait eu comme une tanche donc.

Glock 17Pro

bon in finé c'est quoi le verdict en terme de perf :$

---------------
.

Un Programmeur

J'ai du mal à comprendre pourquoi tu veux comparer par valeur et par référence non constante, le choix entre les deux doit se faire à mon avis sur des considérations sémantiques.

Entre par valeur et par référence constante et si on a le choix -- autrement dit, si les considérations de possibilité d'alias n'impose pas l'un ou l'autre -- par valeur devrait généralement être plus performant (mais comme toujours 1/ est-ce que ce n'est pas prématuré d'envisager ce genre de chose 2/ mesure 3/ est-ce que le gain vaut la peine)

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Joel F

Real men use unique_ptr

et surtout paye ta micro-optimisation qui sert à rien 99% du temps

Glock 17Pro

pour mesurer sous visual, vous utilisez quoi typiquement ? je me heurte à ce problème , QueryCouter & co ? et si oui de quelle manière le faite vous

---------------
.

Glock 17Pro

no idea ?

---------------
.

bjone

Insert booze to continue

Tu veux mesurer quoi ? Une différence entre passage par référence et passage par valeur ?

Glock 17Pro

exact

---------------
.

bjone

Insert booze to continue

Tu va mesurer du bruit

Quand c'est une implémentation d'un algo avec une charge de travail réaliste, les queryperfcounters & autres sont corrects.

Mais pour ce genre de trucs faudrait du rdtsc.

Dans tous les cas c'est de l'enculage de mouche, d'autant plus que la donne peut changer si le compilo peut faire de l'inlining sauvage ou de la compilation lors de l'édition des liens, ou pas (link dll/lib statique).

Comme dit plus haut, le code tu le fais de la manière la plus élégante possible et la plus cohérente avec l'intention initiale, et autrement pour un type qui tiens dans un ou deux registre => valeur, classe/struct => ref.

Message édité par bjone le 09-11-2009 à 16:55:21

Glock 17Pro

ok ok donc au final ça revient au même alors

---------------
.

Un Programmeur

A lire avant de chercher a optimiser http://www.linux-kongress.org/2009 [...] eitner.pdf

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Joel F

Real men use unique_ptr

/me bookmark this

Glock 17Pro

thanks pour le lien

---------------
.

Publicité

FORUM HardWare.fr

Programmation

C++

void f(int val) vs void f(int & val)

Sujets relatifs
interet fonction void	Stopper public void (pour gestion d'événements)
[JAVA] Méthode "void" ou faire un "return"	[DDD] et le type void
Typage d'un pointeur "void *"	argument void *
void	Execution d'un void main(args[]) en java et valeur retour
[C] -pedantic et affectation entre pointeur de fonction et "void *"	de char à void
Plus de sujets relatifs à : void f(int val) vs void f(int & val)

Page générée en 0.108 secondes