Devirtualization in LLVM and Clang

http://blog.llvm.org/2017/03/devirtualization-in-llvm-and-clang.html

by jjuhl • 9 years ago

64 24 9 years ago

blog.llvm.org

gok2• 9 years ago

I’m curious how helpful this is in practice. Often, if you’re going through the pain of using C++, you probably care a lot about performance, so you also try to make sure to minimize use of virtual calls.

xorblurb2• 9 years ago

A virtual call on a modern processor is typically not very costly. Too much inlining, OTOH, can be (if it generates bloated code that trashes your cache)

Coding_Cat• 9 years ago

The call itself is not very expensive, but the effect of having to jump through vtables can prevent other optimizations in a way similar to calling a function in a DLL.

Not a huge issue for business logic bits or if your virtual functions are quite large, but using virtual functions for small often used calls such as specific getters or some mathematical function can cause a big performance hit.

exDM693• 9 years ago

Virtual function calls can be expensive, just compare the out-of-the-box performance between std::sort (c++, no virtual calls) and qsort (c, "virtual call" via function pointer). This can make a 10x difference when sorting something trivial (e.g. integer array). std::sort will compile to a single instruction for the comparison, qsort will typically have to do a full virtual function call, not expensive by itself but still significantly worse than single integer comparison instruction.

Ono-Sendai• 9 years ago

I disagree, virtual function calls are somewhat costly. Removing a single virtual function call in any kind of hot code can result in measurable performance improvements.

Edit: it also depends a lot on if the virtual function can be predicted, e.g. which derived classes' method will actually end up being called. Mispredicted virtual functions are pretty slow.

DSrcl• 9 years ago

It blocks other interprocedural optimization such inlining and interprocedural const prop.

anon946• 9 years ago

I'm also curious about the real-world benefits. Generally speaking, if you are using a virtual function, it's because you need polymorphic behavior. Is there a lot of code that uses virtual functions where not needed?

cheez• 9 years ago

Most polymorphism is actually statically determined, and most that isn't is static at compile time is static after program initialization. There is a lot of optimization you can do based on this knowledge.

pcwalton• 9 years ago

You'd be surprised. WebKit, for example, uses a lot of virtual calls for simple things like "is this element a table".

gok2• 9 years ago

Right but are those call sites typically monomorphic (i.e. devirtualizable?)

CyberDildonics• 9 years ago

Should it really be done that way though? I have to think that if virtual calls are used like that there is a huge amount of performance squandered by the general structure.

gigatexal• 9 years ago

Maybe we should take the stackoverflow approach and code up some examples to show the virtual function performance tax?

twoodfin• 9 years ago

The most significant cost of virtual functions is hard to demonstrate in micro-benchmarks: It's the optimization opportunities lost because you can't inline.

ec109685• 9 years ago

Impressive undergraduate work: Undergraduate student at University of Warsaw, currently working on C++ static analysis in IIIT.

nayuki• 9 years ago

On the Java side of things, devirtualization in the JVM's JIT compiler is discussed in articles like: http://insightfullogic.com/2014/May/12/fast-and-megamorphic-... ; https://shipilev.net/blog/2015/black-magic-method-dispatch/

Devirtualization in LLVM and Clang

Related Stories