C++ virtual function call versus boost::function call speedwise

Question

I wanted to know how fast is a single-inheritance virtual function call when compared to one same boost::function call. Are they almost the same in performance or is boost::function slower?

I'm aware that performance may vary from case to case, but, as a general rule, which is faster, and to a how large degree is that so?

Thanks, Guilherme

-- edit

KennyTM's test was sufficiently convincing for me. boost::function doesn't seem to be that much slower than a vcall for my own purposes. Thanks.

Mord

also, it's a micro-optimisation... – Jessiejessika

Answer 1

As a very special case, consider calling an empty function 10⁹ times.

---

Code A:

struct X {
            virtual ~X() {}
        virtual void do_x() {};
};
struct Y : public X {}; // for the paranoid.

int main () {
        Y* x = new Y;
        for (int i = 100000000; i >= 0; -- i)
                x->do_x();
        delete x;
        return 0;
}

Code B: (with boost 1.41):

#include <boost/function.hpp>

struct X {
    void do_x() {};
};

int main () {
    X* x = new X;
    boost::function<void (X*)> f;
    f = &X::do_x;
    for (int i = 100000000; i >= 0; -- i)
        f(x);
    delete x;
    return 0;
}

Compile with g++ -O3, then time with time,

• Code A takes 0.30 seconds.
• Code B takes 0.54 seconds.

---

Inspecting the assembly code, it seems that the slowness may be due to exceptions and handling the possibility and that f can be NULL. But given the price of one boost::function call is only 2.4 nanoseconds (on my 2 GHz machine), the actual code in your do_x() could shadow this pretty much. I would say, it's not a reason to avoid boost::function.

Atbara

And where is the single-inheritance in case A? ;) – Rivalry

@gf: You know how vtable works? Inheritance doesn't matter because the whole vtable is copied. – Atbara

While such a quick test is indeed very helpful, it only tells you how the code behave performance-wise under you specific conditions (test case, compiler, compiler settings, platform etc.). This is not to deny your result, I'm just reminding to be careful when generalizing from a single test case. – Stribling

Roughly yes, but not what every implementation actually does. – Rivalry