Question

I have this question in mind regarding optimazation of compiler when it comes to shorthanded if/else.

I have this function:

double eu_distance (const coor& x, const coor& y) {

return ((y.x - x.x)*(y.x - x.x) + (y.y - x.y)*(y.y - x.y));
}

I am wondering what is more efficient?

min = min > eucl_distance(point_a, point_b) ? eucl_distance(point_a, point_b) : min;

or

double dis = eucl_distance(point_a, point_b);
if (min > dis)
    min = dis;

in the former case, does compiler (in my case, GCC 4.6.2) know how to optimize that if/else to keep the return value of eucl_distance() to reuse instead of computing it twice?

A piggy back question would be:

What is more efficient?

(y.x - x.x)*(y.x - x.x)

or

pow((y.x - x.x),2)

PS: Sorry that I cannot pick more than one correct answers!! 🙁 Thank you all for your answers! I really appreciate them!!

Answer 1

There’s no universal answer: you’ll have to profile the code generated
by your implementation to know for sure. In most cases, however, if
eu_distance is in a separate translation unit, and is not specially
annotated, the compiler will be unable to know that calling it twice
with the same arguments will give the same results; in this case, the
second form will almost surely be faster. On the other hand, If
eu_distance can be inlined, any decent optimizer will end up
generating almost exactly the same code for both.

In practice, I would almost certainly use a third form:

min = std::min( eu_distance( point_a, point_b ), min );

(I am supposing that eucl_distance is a typo for eu_distance.)

Also, I’d avoid a name like min. Somebody’s too likely to add a
using namespace std; later, or even to include <windows.h>, without
hvaing defined NOMINMAX. (<windows.h> defines min and max as
macros if NOMINMAX has not been defined. Which leads to some
interesting error messages if you define your own min or max. Or
even include <algorithm>.)

Concerning pow( x, 2 ): again, you’ll really have to measure, but
typically, x * x will be faster, even if x is a complicated
expression. (Of course, if the expression is non trivial, then
recognizing that both x are identical may not be that easy, which
makes the code harder to read. In such cases, you might want to
consider a small function, say squared, which does nothing but return
x * x. Inline it if it makes a difference in performance.)