Quel est le coût d'avoir une méthode virtuelle dans une classe C++?

Je couru quelques timings sur un 3ghz dans l'ordre de processeur PowerPC. Sur cette architecture, un appel de fonction virtuelle coûte 7 nanosecondes plus que directe (non virtuelle) d'appel de fonction.

Donc, pas vraiment la peine de s'inquiéter du coût, sauf si la fonction est quelque chose comme un trivial Get()/Set() accesseur, dans lequel rien d'autre que dans la ligne est le genre de gaspillage. Un 7ns frais généraux sur une fonction qui inlines à 0,5 ns est grave; un 7ns-dessus sur une fonction qui prend de 500 ms à exécuter est dénuée de sens.

Le coût énorme de fonctions virtuelles n'est pas vraiment à la recherche d'un pointeur de fonction dans la vtable (qui est habituellement juste un seul cycle), mais que le sous-saut ne peuvent généralement pas être de la branche prédit. Cela peut entraîner un grand pipeline de la bulle que le processeur ne peut pas récupérer toutes les instructions jusqu'à ce que le saut indirect (l'appel à l'aide du pointeur de fonction) a pris sa retraite et un nouveau pointeur d'instruction calculée. Ainsi, le coût d'un appel de fonction virtuelle est beaucoup plus grand qu'il ne paraît à partir de la recherche à l'assemblée... mais toujours seulement 7 nanosecondes.

Edit: Andrew, Pas Sûr, et d'autres soulèvent également le très bon point qu'un appel de fonction virtuelle peut provoquer une cache d'instructions manquer: si vous sautez à une adresse de code qui n'est pas dans le cache, alors tout le programme arrive à un cul de tourner pendant que les instructions sont lues depuis la mémoire principale. C'est toujours un important décrochage: le Xénon, à environ 650 cycles (par mes tests).

Cependant ce n'est pas un problème spécifique à des fonctions virtuelles, parce que même directement appel de fonction sera la cause d'une miss si vous sauter aux instructions qui ne sont pas dans le cache. Ce qui importe est de savoir si la fonction a été exécutée avant que récemment (en les rendant plus susceptibles d'être dans le cache), et si votre architecture peut prédire statique (et non virtuel) des branches et de l'extraction de ces instructions dans le cache à l'avance. Mon PPC n'est pas, mais peut-être que Intel est plus un matériel récent, ne.

Mes timings de contrôler l'influence de l'icache manque à l'exécution (délibérément, car j'étais en train d'examiner le PROCESSEUR pipeline dans l'isolement), la réduction des coûts.

Il dépend. 🙂 (Aviez-vous prévu quelque chose d'autre?)

Une fois une classe devient une fonction virtuelle, il ne peut plus être une GOUSSE de type de données, (il ne peut pas avoir été l'un avant, soit, dans ce cas, il ne fera pas une différence) et qui fait de toute une série d'optimisations impossible.

std::copy() sur la plaine de la GOUSSE types peuvent recourir à une simple memcpy de routine, mais non de la GOUSSE de types doivent être traités avec plus de soin.

Construction devient beaucoup plus lent, car la vtable doit être initialisé. Dans le pire des cas, la différence de performance entre la nacelle et de la non-POD types de données peuvent être importantes.

Dans le pire des cas, vous risquez de voir 5x plus lent d'exécution (ce numéro est tiré à partir d'un projet de l'université que j'ai fait récemment ré-écrire quelques classes de la bibliothèque standard. Notre conteneur a pris environ 5x plus long à construire dès que le type de données stockées eu une vtable)

Bien sûr, dans la plupart des cas, vous êtes peu probable de voir les performances mesurables différence, c'est simplement pour souligner que dans le certains frontière des cas, il peut être très coûteux.

Cependant, les performances ne devraient pas être votre principale considération ici.
Rendre tout ce qui est virtuel n'est pas une solution parfaite pour d'autres raisons.

De permettre à tout être redéfinie dans les classes dérivées rend beaucoup plus difficile le maintien de la classe d'invariants. Comment une classe de garantir qu'il reste dans un état cohérent lorsque l'une quelconque de ses méthodes pourrait être redéfini à tout moment?

Rendre tout ce qui est virtuel peut éliminer quelques bugs potentiels, mais il introduit aussi de nouveaux.

Virtuel de l'expédition est d'un ordre de grandeur inférieure à celle des alternatives - non pas par indirection tellement que la prévention de l'in-lining. Ci-dessous, je montre que, par contraste virtuel expédition avec une mise en œuvre à l'incorporation d'un "type(-numéro d'identification)", dans les objets et à l'aide d'une instruction switch pour sélectionner le type de code spécifiques. Cela évite d'appel de fonction, les frais généraux complètement - il suffit de faire un local de saut. Il y a un coût potentiel de la maintenabilité, de la recompilation des dépendances etc par le biais de la contrainte de localisation (l'interrupteur) du type de fonctionnalité spécifique.

---

Mise en ŒUVRE

#include <iostream>
#include <vector>
//virtual dispatch model...
struct Base
{
virtual int f() const { return 1; }
};
struct Derived : Base
{
virtual int f() const { return 2; }
};
//alternative: member variable encodes runtime type...
struct Type
{
Type(int type) : type_(type) { }
int type_;
};
struct A : Type
{
A() : Type(1) { }
int f() const { return 1; }
};
struct B : Type
{
B() : Type(2) { }
int f() const { return 2; }
};
struct Timer
{
Timer() { clock_gettime(CLOCK_MONOTONIC, &from); }
struct timespec from;
double elapsed() const
{
struct timespec to;
clock_gettime(CLOCK_MONOTONIC, &to);
return to.tv_sec - from.tv_sec + 1E-9 * (to.tv_nsec - from.tv_nsec);
}
};
int main(int argc)
{
for (int j = 0; j < 3; ++j)
{
typedef std::vector<Base*> V;
V v;
for (int i = 0; i < 1000; ++i)
v.push_back(i % 2 ? new Base : (Base*)new Derived);
int total = 0;
Timer tv;
for (int i = 0; i < 100000; ++i)
for (V::const_iterator i = v.begin(); i != v.end(); ++i)
total += (*i)->f();
double tve = tv.elapsed();
std::cout << "virtual dispatch: " << total << ' ' << tve << '\n';
//----------------------------
typedef std::vector<Type*> W;
W w;
for (int i = 0; i < 1000; ++i)
w.push_back(i % 2 ? (Type*)new A : (Type*)new B);
total = 0;
Timer tw;
for (int i = 0; i < 100000; ++i)
for (W::const_iterator i = w.begin(); i != w.end(); ++i)
{
if ((*i)->type_ == 1)
total += ((A*)(*i))->f();
else
total += ((B*)(*i))->f();
}
double twe = tw.elapsed();
std::cout << "switched: " << total << ' ' << twe << '\n';
//----------------------------
total = 0;
Timer tw2;
for (int i = 0; i < 100000; ++i)
for (W::const_iterator i = w.begin(); i != w.end(); ++i)
total += (*i)->type_;
double tw2e = tw2.elapsed();
std::cout << "overheads: " << total << ' ' << tw2e << '\n';
}
}

---

RÉSULTATS DE PERFORMANCE

Sur mon système Linux:

~/dev  g++ -O2 -o vdt vdt.cc -lrt
~/dev  ./vdt                     
virtual dispatch: 150000000 1.28025
switched: 150000000 0.344314
overhead: 150000000 0.229018
virtual dispatch: 150000000 1.285
switched: 150000000 0.345367
overhead: 150000000 0.231051
virtual dispatch: 150000000 1.28969
switched: 150000000 0.345876
overhead: 150000000 0.230726

Ceci suggère une ligne de type-nombre de commutation approche est fondée sur des (1.28 - 0.23) /(0.344 - 0.23) = 9.2 fois plus rapide. Bien sûr, qui est spécifique à l'exacte du système testé /drapeaux du compilateur & version etc., mais généralement à titre indicatif.

---

OBSERVATIONS VIRTUELLES ENVOI

Il faut quand-même dire que l'appel de fonction virtuelle frais généraux sont quelque chose qui est rarement significative, et alors seulement pour souvent appelé trivial fonctions (comme les getters et setters). Même alors, vous pourriez être en mesure de fournir une seule fonction pour obtenir et de définir un ensemble de choses à la fois, tout en minimisant les coûts. Les gens s'inquiètent au sujet de virtual chemin d'expédition trop - afin de faire le profilage avant de trouver maladroit alternatives. Le principal problème avec ces derniers est qu'ils sont hors de la ligne d'appel de la fonction, s'ils ont également délocaliser le code exécuté qui change de l'utilisation du cache des modèles (pour le meilleur ou (plus souvent) pour le pire).

Alors que tout le monde est correct sur les performances des méthodes virtuelles et de ce fait, je pense que le vrai problème est de savoir si l'équipe connaît la définition du mot-clé virtuel en C++.

Considérer ce code, quelle est la sortie?

#include <stdio.h>
class A
{
public:
void Foo()
{
printf("A::Foo()\n");
}
};
class B : public A
{
public:
void Foo()
{
printf("B::Foo()\n");
}
};
int main(int argc, char** argv)
{    
A* a = new A();
a->Foo();
B* b = new B();
b->Foo();
A* a2 = new B();
a2->Foo();
return 0;
}

Rien de surprenant ici:

A::Foo()
B::Foo()
A::Foo()

Que rien n'est virtuel. Si le mot-clé virtuel est ajouté à l'avant de Foo dans les deux classes A et B, nous obtenons ceci pour la sortie:

A::Foo()
B::Foo()
B::Foo()

À peu près ce que tout le monde attend.

Maintenant, vous avez mentionné qu'il y a des bugs parce que quelqu'un a oublié d'ajouter un mot clé virtual. Considérez donc ce code (où le mot-clé virtuel est ajouté à Un, mais pas de classe B). Qu'est-ce que la sortie alors?

#include <stdio.h>
class A
{
public:
virtual void Foo()
{
printf("A::Foo()\n");
}
};
class B : public A
{
public:
void Foo()
{
printf("B::Foo()\n");
}
};
int main(int argc, char** argv)
{    
A* a = new A();
a->Foo();
B* b = new B();
b->Foo();
A* a2 = new B();
a2->Foo();
return 0;
}

Réponse: Le même que si le mot-clé virtuel est ajouté à un point B? La raison en est que la signature de B::Foo correspond exactement que A::Foo() et parce que l'Un des Foo est virtuel, donc, est B.

Considérons maintenant le cas où B Foo est virtuelle et ne l'est pas. Qu'est-ce que la sortie alors? Dans ce cas, la sortie est

A::Foo()
B::Foo()
A::Foo()

Le mot clé virtual fonctionne vers le bas dans la hiérarchie, non pas vers le haut. Il ne fait jamais les méthodes de classe de base virtuelle. La première fois, une méthode virtuelle est rencontré dans la hiérarchie, c'est quand le polymorphisme commence. Il n'y a pas un moyen pour plus tard classes pour les classes précédentes ont des méthodes virtuelles.

N'oubliez pas que les méthodes virtuelles dire que cette classe est de donner aux futures classes la possibilité de modifier/modifier certains de ses comportements.

Donc, si vous avez une règle à supprimer le mot-clé virtuel, il peut ne pas avoir l'effet escompté.

Le mot clé virtual dans C++ est un concept puissant. Assurez-vous que chaque membre de l'équipe sait vraiment ce concept, de sorte qu'il peut être utilisé comme prévu.

Il faudra juste un couple d'extra asm instruction de l'appel de méthode virtuelle.

Mais je ne pense pas que vous vous inquiétez à ce que le plaisir(int a, int b) est un couple d'extra "pousser" des instructions par rapport à l'amusement(). Alors ne vous inquiétez pas virtuals trop, jusqu'à ce que vous êtes dans une situation particulière et voir qu'elle est vraiment conduit à des problèmes.

P. S. Si vous avez une méthode virtuelle, assurez-vous d'avoir un destructeur virtuel. De cette façon, vous éviterez d'éventuels problèmes

---

En réponse à la "xtofl" et " Tom " des commentaires. J'ai fait des petits tests avec 3 fonctions:

1. Virtuel
2. Normal
3. Normal avec 3 paramètres int

Mon test était une simple itération:

for(int it = 0; it < 100000000; it ++) {
test.Method();
}

Et voici les résultats:

1. 3,913 sec
2. De 3 873 sec
3. 3,970 sec

Il a été compilé par VC++ en mode de débogage. Je n'ai fait que 5 tests par la méthode et calculé la valeur moyenne (donc les résultats peuvent être assez imprécise)... de Toute manière, les valeurs sont presque égaux en supposant que 100 millions d'appels. Et la méthode avec un supplément de 3 push/pop a été plus lent.

Le point principal est que si vous n'aimez pas l'analogie avec le push/pop, pensez supplémentaire si/d'autre dans votre code? Pensez-vous à propos du PROCESSEUR pipeline lorsque vous ajoutez un supplément si/d'autre 😉 Aussi, on ne sait jamais sur quel PROCESSEUR le code sera exécuté... d'Habitude compilateur génère un code plus optimal pour un CPU et moins optimale pour un autre (Le Compilateur Intel C++ )