Re: Virtual classes and run-time performance
allnor@tele.ntnu.no (Rune Allnor) wrote (abridged):
This way, the test about what method to call is done by
run-time type matching. Of course, this will be optimized
in the end, so one might be optimistic about performance.
Is there reason to expect the latter implementation to
perform particularly worse than the first approach, what
run-time is concerned? Have anybody tested the relative
run-time performance of these sorts of things?
Although you don't show it, I think you must be talking about a quadruple
dispatch. You'd call a virtual function on each of the 4 points, which
would effectively determine the type of that point, and you'd chain them
together so that the final function implementation knew the types of all 4
of them. It's quite a lot of infrastructure. (If you have a lot of
different functions, it would be worth considering a Visitor instead of
multiple dispatch - it would simplify the implementation at the cost of
another virtual call.)
In addition you'd effectively add the overhead of a vtable pointer to each
point, although you might be able to avoid that by using the Flyweight
Pattern.
In general I'd expect a virtual function call to be slower than a normal
function call, but faster than a normal call plus a (large) switch
statement. In this case we don't need a switch; there are only two classes
of point so a simple if statement will do. I think you would need to
measure this on your target machine.
My intuition says that the if-statement would win. It sounds like you have
something like:
inline bool is_special( int index ) { return index > N; }
inline bool any_are_special( int i0, int i1, int i2, int i3 ) {
return is_special( i0 ) || is_special( i1 ) ||
is_special( i2 ) || is_special( i3 );
}
void f( Point points[], int i0, int i1, int i2, int i3 ) {
if (any_are_special( i0, i1, i2, i3 ))
slow_f( points, i0, i1, i2, i3 );
else
fast_f( points, i0, i1, i2, i3 );
}
I would expect this to be faster than anything based on virtual functions,
because if statements are fast, we have no vtable indirection (which can
be slow because it brings in more memory, and can be hard for the CPU to
branch-predict), and we avoid some function calls.
It doesn't strike me as hard to maintain, either. If you have lots of
functions, I'd consider encapsulating it and using a visitor or callback.
Here's another version:
void dispatch( Func *f, Point points[],
int i0, int i1, int i2, int i3 ) {
if (is_special(i0))
if (is_special(i1))
if (is_special(i2)
if (is_special(i3))
f->do_ssss( points, i0, i1, i2, i3 );
else
f->do_sssn( points, i0, i1, i2, i3 );
else
if (is_special(i3))
f->do_ssns( points, i0, i1, i2, i3 );
else
f->do_ssnn( points, i0, i1, i2, i3 );
// ... etc...
}
where Func is a class with 16 virtual functions. With or without Func we
can encapsulate the dispatching into a single function, separate to the
functions that do the work.
It doesn't seem like it would be hard to write several versions and time
them to see which is quicker.
-- Dave Harris, Nottingham, UK.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]