3

I have a class with two virtual member functions: foo and wrapper. foo is short and fast, and wrapper contains a loop that calls foo many times. My hope is that there is some way to inline the calls to foo inside the wrapper function, even when called from a pointer to an object:

MyClass *obj = getObject();
obj->foo(); // As I understand it, this cannot be inlined. That's okay.
obj->wrapper(); // Nor will this. However, I hope that the machine code
                // for the wrapper function will contain inlined calls to
                // foo().

Essentially, I want the compiler to generate multiple versions of the wrapper function -- one for each possible class -- and inline calls to the appropriate foo, which should be possible since the object type is determined before picking which wrapper function to execute. Is this possible? Do any compilers support this optimization?

Edit: I appreciate all of the feedback and answers so far, and I may end up picking one of them. However, most responses ignore the last part of my question where I explain why I think this optimization should be feasible. That is really the crux of my question and I am still hoping someone can address that.

Edit 2: I picked Vlad's answer since he both suggested the popular workaround and partially addressed my proposed optimization (in the comments of David's answer). Thanks to everyone who wrote an answer -- I read them all and there wasn't a clear "winner".

Also, I found an academic paper that proposes an optimization very similar to what I was suggesting: http://www.ebb.org/bkuhn/articles/cpp-opt.pdf.

Improve this question
9
  • 1
    The compiler will probably know enough to optimize the virtual function lookup into a one time hit. Commented Oct 18, 2012 at 21:03
  • 1
    True, but that still leaves the (larger?) overhead of a non-inline function call, right? Commented Oct 18, 2012 at 21:05
  • Yes, but short of machine code instrumentation it's probably not possible to make this happen. Commented Oct 18, 2012 at 21:07
  • Why? I tried to explain why I think it should be possible in the last part of my question -- does that make any sense to you? Commented Oct 18, 2012 at 21:10
  • It might be possible to do this, but it's hard to say. I rather doubt compilers will generate code that behaves like this because it isn't guaranteed to work in the absences of other subclasses of the classes you're writing. Commented Oct 18, 2012 at 21:12

5 Answers 5

Reset to default
3

In certain cases, compiler can determine the virtual dispatch behavior in compile-time and perform non-virtual function invocation or even inline the function. It can only do that if it can figure out that your class is the "top" in inheritance chain or those two functions are not otherwise overloaded. Oftentimes, this is simply impossible, especially if you don't have late time optimization enabled for the whole program.

Unless you want to check the results of your compiler's optimizations, your best bet would be not to use a virtual function in the inner loop at all. For example, something like this:

class Foo {
  public:
    virtual void foo()
    {
        foo_impl();
    }

    virtual void bar()
    {
        for (int i = 0; i < ∞; ++i) {
            foo_impl();
        }
    }

  private:
    void foo_impl() { /* do some nasty stuff here */ }
};

But in that case you clearly give up the idea that somebody may come in, inherit from your class and throw in their own implementation of "foo" to be called by your "bar". They will essentially will need to re-implement both.

On the other hand, it smells a bit like a premature optimization. Modern CPUs will most likely "lock" your loop, predict the exit from it and execute the same µOPs over and over, even if your method is virtually virtual. So I'd recommend you carefully determine this to be a bottleneck before spending your time optimizing it.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2

No, the function call will not be inlined if performed through a pointer or reference (this includes the this pointer). A new type can be created that extends from your current type and overrides foo without overriding wrapper.

If you want to enable the compiler to inline your function, you must disable virtual dispatch for that call:

void Type::wrapper() {
    Type::foo();            // no dynamic dispatch
}
Improve this answer

7 Comments

Dave, it may. These days compilers are a bit smarter than a toaster :)
@Vlad: When the function is compiled it does not have visibility for the whole program, so it cannot know whether there is a most derived type that overrides foo (and not wrapper). Even with whole program optimization, you can load code from a dynamic library and that could have more types. This is one of the reasons for the new final contextual non-keyword in C++11. In that context, because the language guarantees it could, but only if foo is tagged final (and I have not seen that used anywhere yet)
Yes and no. It depends on symbol visibility, really.
@VladLazarenko: How How can the compiler, when generating code for a translation unit know whether in a different translation unit, possibly in a loaded dynamic library, maybe in a manually loaded dynamic library there will not be a type that extends this one? It is not theoretically impossible to implement in some subcases, but I'd like to know of any compiler that does this. (Also I am not sure that symbol visibility is the right term)
Dave, the optimization is performed on a later stage, not when generating code for a translation unit, but when generating code for an executable. There, compiler may know the inheritance scheme, as well as visibility, and perform all of the necessary optimizations. Vtables are one thing, it can also re-arrange parameters, re-allocate registers etc. It's been quite a while since I looked at those techniques, so can't give you specific references unfortunately. But you may poke around clang and gcc internals to figure out.
|
2

Imagine the following hierarchy:

class Base
{
    virtual void foo();
    virtual void wrapper();
};

class Derived1: public Base
{
    virtual void foo() { cout << "Derived1::foo"; }
    virtual void wrapper() { foo(); }
};

class Derived2: public Derived1
{
    virtual void foo() { cout << "Derived2::foo"; }
};

Base * p1 = new Derived1;
p1->wrapper();  // calls Derived1::wrapper which calls Derived1::foo
Base * p2 = new Derived2;
p2->wrapper();  // calls Derived1::wrapper which calls Derived2::foo

Can you see the problem? Derived1::wrapper must call Derived2::foo. It can't know until runtime whether it will be calling Derived1::foo or Derived2::foo, so there's no way to inline it.

If you want to insure that inlining is possible, make sure that the function you want to inline isn't virtual. It seems from your description that this might be possible, if every class in the hierarchy reimplements both foo and wrapper. A function doesn't need to be virtual to be overridden.

Improve this answer

2 Comments

This is true, but there's an option that he wants Derived1::wrapper to call Derived1::foo regardless if it's the most derived class or not. (it's not clear though)
@Mark: Good example. In this case, I want the compiler to autogenerate two functions for me: Derived1::wrapper_calledFromDerived1 and Derived1::wrapper_calledFromDerived2. Then the vtable for objects of type Derived1 would point to the first of these, and objects of type Derived2 point to the second. Does that make sense?
1

This is not accurate. virtual functions can be inlined, but only if the compiler knows the static type of the object with certainty - and thus have the guarantee that polymorphism works.

For example:

struct A
{
    virtual void foo()
    {
    }
};
struct B
{
    virtual void foo()
    {
    }
};

int main()
{
    A a;
    a.foo(); //this can be inlined
    A* pa = new A;
    pa->foo(); //so can this
}

void goo(A* pa)
{
    pa->foo() //this probably can't
}

That said, it appears that in your case this can't happen. What you can do is have another non-virtual function that actually implements the functionality and call it statically, so the call gets resolved at compile-time:

class MyClass
{
    virtual void foo() = 0;
    virtual void wrapper() = 0;
};

class Derived : MyClass
{
    void fooImpl()
    {
       //keep the actual implementation here
    }
    virtual void foo()
    {
       fooImpl();
    }
    virtual void wrapper()
    {
       for ( int i = 0 ; i < manyTimes ; i++ )
          fooImpl(); //this can get inlined
    }
};

or simply Derived::foo() as pointed out by @avakar.

Improve this answer

3 Comments

Note that you can call a virtual function without dynamic dispatch: Derived::foo(). That should remove the need for fooImpl.
I do not know the type until runtime, so Derived::foo() is not an option. The fooImpl() patter seems like a reasonable workaround.
@DrewFrank it's the same thing really. You call Derived::foo from Derived::wrapper, not from the same class, so it works.
0

Your function is virtual and its type is not indicate until runtime, so how you expect compiler to inline code of some class into it?

In some similar situation I had 2 functions: foo that is virtual and foo_impl that is normal function and will be called from foo and wrapper

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.