Virtual function performance when called by derived classes?

Question

Is there a performance penalty when a virtual method is called from a class that's known to be the derived class at compile time? Below I explicitly call force_speak with a derived class.

Code:

#include <iostream>
#include <array>
#include <memory>

class Base
{
public:
  virtual void speak()
  {
    std::cout << "base" << std::endl;
  }
};

class Derived1 : public Base
{
public:
  void speak()
  {
    std::cout << "derived 1" << std::endl;
  }
};

template<class B>
void force_speak(std::array<std::unique_ptr<B>, 3>& arr)
{
  for (auto& b: arr)
  {
    b->speak();
  }
}

int main()
{
  std::array<std::unique_ptr<Derived1>, 3> arr = 
    {
      std::unique_ptr<Derived1>(new Derived1),
      std::unique_ptr<Derived1>(new Derived1),
      std::unique_ptr<Derived1>(new Derived1)
    };
  force_speak(arr);
  return 0;
}

What is a performance penalty, something you think it is or something you measured (or better recognized as one) ? — , Dec 17 '14 at 21:23

score 6 · Accepted Answer · answered Dec 17 '14 at 21:23

Is there a performance penalty when a virtual method is called from a class that's known to be the derived class at compile time? See code below.

It depends. Most compilers will "de-virtualize" code like this:

Derived1 d;
d.speak();

The dynamic type of the object is known at the call site, so the compiler can avoid going through the vtable to make the call and can just call Derived1::speak() directly.

In your example the compiler needs to be smarter because in force_speak you only have Derived1* pointers (stored inside the unique_ptr objects) and in that context it's not clear whether the dynamic type of the pointed-to objects is Derived1 or some more-derived type. The compiler either needs to inline the call to force_speak into main (where the dynamic type is known) or use some additional knowledge about the type to allow devirtualization to happen. (As one example of additional knowledge, whole program optimization can determine that there are no other derived types declared anywhere in the program, so a Derived1* must point to a Derived1.)

Using the C++11 final keyword can help compilers to devirtualize some cases, e.g. if Derived1 is marked final then the compiler knows that a Derived1* can only point to a Derived1 and not some other type derived from it that might override speak()

Looking at the assembly, looks like neither GCC nor Clang fully devirtualizes the call in OP's code. (GCC does something clever, it inlines `Derived1::speak()` and does a comparison on the vtable pointer, jumping to a virtual call only if the comparison is unequal.) `final` on either class or the function makes it devirtualized. — T.C., Dec 17 '14 at 21:31
@T.C. Is there any need for the template parameter `B` in `force_speak`, i.e. can I declare `force_speak` as `void force_speak(std::array, 3>& arr)` and still get devirtualization using final? Thanks. — Agrim Pathak, Dec 18 '14 at 18:52
@anon, you can't do that, `array, N>` is not convertible to `array, N>` — Jonathan Wakely, Dec 18 '14 at 19:11

score 2 · Answer 2 · answered Dec 17 '14 at 21:25

It's compiler dependent. Compiler must statically know that Derived1:speak() is the only option. That includes knowing that there is no some Derived2::speak() definition, where class Derived2: public Derived1. But compiler might not implement such an optimization at all.
Function template parameters can be deduced automatically by a compiler. This is part of C++ standard. Compiler knows the type of parameter at a call site so user does not have to provide it. Note, that user can provide the type, and thay can for example provide type compatible but different that the type of an actual parameter.

Thanks for answering the 2nd question (now removed). – Agrim Pathak Dec 17 '14 at 21:31 — Agrim Pathak, Dec 17 '14 at 21:31

score 1 · Answer 3 · answered Dec 17 '14 at 21:24

In this specific case, the answer is maybe.

If the compiler decides to inline force_speak() it could theoretically deduce that all of the pointers in the array are Derived1 instances and so call the method statically. (This optimization is not required by the standard, so whether the method is called statically or virtually depends on your particular compiler and possibly what options you use during compilation.)

If the compiler does not inline the call then it must emit instructions to call the method virtually, because you could further derive the class Derived1 and override the method yet again, store instances of that class in std::unique_ptr<Derived1>, and pass an array of those into the function.

Virtual function performance when called by derived classes?

3 Answers3