Thread: Optimization question

Which of the following is faster?:
A :

Code:

float f1; float f2;
//... f1 and f2 are modified
f1 *= x / y;
f2 *= x / y;

OR
B:

Code:

float f1; float f2;
//... f1 and f2 are modified
float temp = x / y;
f1 *= temp;
f2 *= temp;

So is it quicker to make an extra float and only do the multiplication once? This is something I need to do probably 500 times per second.



I am also wondering whether there are any unmentioned costs to creating an object. I have a Vector3d class which has 3 float members and a heap of methods. If I create one of those is that going to take as long as creating a struct with 3 floats? Also, does it take up the same amount of memory as a struct with 3 floats?

What has your testing yielded?

Leave it to the compiler/optimizer. Modern optimizers are really smart, and will do this kind of simple optimizations for you if it thinks it will help.

Unless you are extremely familiar with computer architecture, chances are you won't beat the optimizer at dirty optimization.

Just write your code for clarity, and leave optimizations to the compiler.

Most of the time programmers only need to worry about optimizations on the algorithmic level.

As for the second question, I MAY BE WRONG, but I think the cost is the same as making a struct, assuming an empty constructor. Member functions are essentially functions that take a hidden "this" pointer, and they don't actually go with each instance of the object in memory.

Out of curiosity, I know division is much slower than multiplication, but by how many times approximately? 5x? 10x? 20x? (for both integers and floating points).

Ah I see, thanks.

the second one is faster, although as stated, the compiler may optize the first one anyway, and produce teh same output as the second one. But I wouldnt bet a plug nickel that teh compiler will properly optimize anything. half the time I can do way better, and the rest of the time I do just as well.

Originally Posted by abachler

half the time I can do way better, and the rest of the time I do just as well.

Ah, yes. That's consistent. 90% of all programmers think that are in the top 10% too.

Originally Posted by Salem

Whilst computing the inverse just once and multiplying is correct from a mathematical point of view, you could end up with a different computational result.

That's quite true. I had an experience, several years ago, with an early optimizing compiler (Fortran 77, not C++) which did exactly that. It caused an intermittent instability of an otherwise stable numerical algorithm - and it was a .......... to track down because the behaviour was different when the code was compiled without optimisation for debugging.

One of the most fruitful sources of bugs in numerical code is the programmer who assumes that a series of mathematically equivalent operations on real numbers are also computationally equivalent with floating point. Whereas, the reality is that floating point variables are only an approximate representation of real variables

Thanks for the informative responses everyone!

Is cyberfish the only one venturing an answer to my second question?

cyberfish's answer to your second question mostly covered it.

Technically, a class and a struct are the same thing in C++. The only difference is that class attributes and members are private by default, and struct attributes and members are public. Those affect whether the compiler allows operations but, if an operation is allowed, the runtime performance is usually the same: the access checks are not usually repeated at run time.

Any difference in performance or memory usage with using one approach or the other depends on the compiler. For example, an alterative to a getter/setter pair is simply making the corresponding data member public. Taken literally, that can suggest a difference in performance but compilers are also free to optimise (eg inlining the getter/setter functions, and therefore eliminate the associated function-call overhead).

That's why it's generally considered better to make code readable and understandable. And only worry about performance if it is really necessary - which means bringing out profilers to find the real hot-spots. Totally at odds with what most learning programmers do (premature optimisation) but that's life.

Originally Posted by Noise

I am also wondering whether there are any unmentioned costs to creating an object. I have a Vector3d class which has 3 float members and a heap of methods. If I create one of those is that going to take as long as creating a struct with 3 floats? Also, does it take up the same amount of memory as a struct with 3 floats?