Suite à un post que j'avais ouvert récemment, j'ai isolé une curiosité
que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et une
methode b() normale.
Je crée une classe dérivée B dans laquelle je mets dans a() la même
implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je remarque
que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Suite à un post que j'avais ouvert récemment, j'ai isolé une curiosité
que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et une
methode b() normale.
Je crée une classe dérivée B dans laquelle je mets dans a() la même
implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je remarque
que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Suite à un post que j'avais ouvert récemment, j'ai isolé une curiosité
que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et une
methode b() normale.
Je crée une classe dérivée B dans laquelle je mets dans a() la même
implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je remarque
que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais dans mon
projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés (30.000), je
ne sais pas si ça peut jouer ....
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais dans mon
projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés (30.000), je
ne sais pas si ça peut jouer ....
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais dans mon
projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés (30.000), je
ne sais pas si ça peut jouer ....
Je ne vois pas ce que ça aurait à faire dans l'histoire, mais bon...
Peut-être un problème de cache, mais ce sont pas des problèmes
forcément faciles à identifier.
Je ne vois pas ce que ça aurait à faire dans l'histoire, mais bon...
Peut-être un problème de cache, mais ce sont pas des problèmes
forcément faciles à identifier.
Je ne vois pas ce que ça aurait à faire dans l'histoire, mais bon...
Peut-être un problème de cache, mais ce sont pas des problèmes
forcément faciles à identifier.
<<
Mais ce n'est pas sûr qu'il
le fasse systématiquement, il faut peut-être augmenter le niveau
d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?
<<
Mais ce n'est pas sûr qu'il
le fasse systématiquement, il faut peut-être augmenter le niveau
d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?
<<
Mais ce n'est pas sûr qu'il
le fasse systématiquement, il faut peut-être augmenter le niveau
d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?
Suite à un post que j'avais ouvert récemment, j'ai isolé une
curiosité que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et
une methode b() normale. Je crée une classe dérivée B dans
laquelle je mets dans a() la même implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je
remarque que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Suite à un post que j'avais ouvert récemment, j'ai isolé une
curiosité que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et
une methode b() normale. Je crée une classe dérivée B dans
laquelle je mets dans a() la même implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je
remarque que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Suite à un post que j'avais ouvert récemment, j'ai isolé une
curiosité que j'aimerais éclaircir grâce à vos remarques :
J'ai une classe mère A avec une methode a() virtuelle pure, et
une methode b() normale. Je crée une classe dérivée B dans
laquelle je mets dans a() la même implémentation que b().
Concrètement B.a(), et B.b() font la même chose.
Je caste B en A de façon à utiliser plutot A.a() et A.b()
Si j'exécute ces 2 méthodes un très grand nombre de fois, je
remarque que a() est beaucoup plus lente que b().
Est-ce un résultat attendu ?
Gégé writes:
> Si j'exécute ces 2 méthodes un très grand nombre de fois, je
> remarque que a() est beaucoup plus lente que b().
> Est-ce un résultat attendu ?
Plus ou moins. Un appel de méthode virtuelle est toujours plus
coûteux, parce que la liaison est dynamique. L'appel est donc
indirect : il y a au minimum une indirection supplémentaire.
En gros,
o->a(...)
devient
o->t[123](...) // 123 est supposé être un id de a()
parce que chaque classe a potentiellement sa version de a(),
et l'appel (o->a()) ne peut pas être résolu à la compil. C'est
un temps éventuellement non négligeable.
Cela dit, si tu fais quelque chose comme :
A unA = monB;
unA.a();
alors il ne devrait pas y avoir de surcoût, parce que le
compilo sait exactement quelle version de a() utiliser.
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Gégé <val...@gmail.com> writes:
> Si j'exécute ces 2 méthodes un très grand nombre de fois, je
> remarque que a() est beaucoup plus lente que b().
> Est-ce un résultat attendu ?
Plus ou moins. Un appel de méthode virtuelle est toujours plus
coûteux, parce que la liaison est dynamique. L'appel est donc
indirect : il y a au minimum une indirection supplémentaire.
En gros,
o->a(...)
devient
o->t[123](...) // 123 est supposé être un id de a()
parce que chaque classe a potentiellement sa version de a(),
et l'appel (o->a()) ne peut pas être résolu à la compil. C'est
un temps éventuellement non négligeable.
Cela dit, si tu fais quelque chose comme :
A unA = monB;
unA.a();
alors il ne devrait pas y avoir de surcoût, parce que le
compilo sait exactement quelle version de a() utiliser.
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Gégé writes:
> Si j'exécute ces 2 méthodes un très grand nombre de fois, je
> remarque que a() est beaucoup plus lente que b().
> Est-ce un résultat attendu ?
Plus ou moins. Un appel de méthode virtuelle est toujours plus
coûteux, parce que la liaison est dynamique. L'appel est donc
indirect : il y a au minimum une indirection supplémentaire.
En gros,
o->a(...)
devient
o->t[123](...) // 123 est supposé être un id de a()
parce que chaque classe a potentiellement sa version de a(),
et l'appel (o->a()) ne peut pas être résolu à la compil. C'est
un temps éventuellement non négligeable.
Cela dit, si tu fais quelque chose comme :
A unA = monB;
unA.a();
alors il ne devrait pas y avoir de surcoût, parce que le
compilo sait exactement quelle version de a() utiliser.
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
////////////////////////////////////////////////////////////////////////
void main(int argc, char * argv[])
{
A * _A = new B();
clock_t t1, t2, t0;
t0 = clock();
const int N = 1000000000;
for ( int i = 0; i < N; i++ )
{
_A->a();
}
t1 = clock();
for ( int i = 0; i < N; i++ )
{
_A->b();
}
t2 = clock();
cout << "a() : " << ( double )( t1 - t0 ) / CLOCKS_PER_SEC << "
sec" << endl;
cout << "b() : " << ( double )( t2 - t1 ) / CLOCKS_PER_SEC << "
sec" << endl;
delete _A;
system("pause");
return;
}
////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais
dans mon projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés
(30.000), je ne sais pas si ça peut jouer ....
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
////////////////////////////////////////////////////////////////////////
void main(int argc, char * argv[])
{
A * _A = new B();
clock_t t1, t2, t0;
t0 = clock();
const int N = 1000000000;
for ( int i = 0; i < N; i++ )
{
_A->a();
}
t1 = clock();
for ( int i = 0; i < N; i++ )
{
_A->b();
}
t2 = clock();
cout << "a() : " << ( double )( t1 - t0 ) / CLOCKS_PER_SEC << "
sec" << endl;
cout << "b() : " << ( double )( t2 - t1 ) / CLOCKS_PER_SEC << "
sec" << endl;
delete _A;
system("pause");
return;
}
////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais
dans mon projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés
(30.000), je ne sais pas si ça peut jouer ....
Merci Alain pour ta réponse.
Je pensais à un exemple comme celui-ci :
////////////////////////////////////////////////////////////////////////
void main(int argc, char * argv[])
{
A * _A = new B();
clock_t t1, t2, t0;
t0 = clock();
const int N = 1000000000;
for ( int i = 0; i < N; i++ )
{
_A->a();
}
t1 = clock();
for ( int i = 0; i < N; i++ )
{
_A->b();
}
t2 = clock();
cout << "a() : " << ( double )( t1 - t0 ) / CLOCKS_PER_SEC << "
sec" << endl;
cout << "b() : " << ( double )( t2 - t1 ) / CLOCKS_PER_SEC << "
sec" << endl;
delete _A;
system("pause");
return;
}
////////////////////////////////////////////////////////////////////////
Ceci dit, les résultats sont qd meme assez proches ... mais
dans mon projet j'ai de bien plus grosses différences ...
J'utilise en revanche beaucoup plus d'objets instanciés
(30.000), je ne sais pas si ça peut jouer ....
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?
Mais ce n'est pas sûr qu'il le fasse systématiquement, il faut
peut-être augmenter le niveau d'optimisation.
Qu'appelles-tu "niveau d'optimisation" ?