CODEWITHSUNDEEP
javamathoptimizationfloating-pointdivision
Tyler
Tyler

Reputation: 19858

Efficiency of floating point division and checking values beforehand if eq

I have a situation where I might need to apply a multiplier to a value in order to get the correct results. This involves computing the value using floating point division.

I'm thinking it would be a good idea to check the values before I perform floating point logic on them to save processor time, however I'm not sure how efficient it will be at run-time either way.

I'm assuming that the if check is 1 or 2 instructions (been a while since assembly class), and that the floating point operation is going to be many more than that.

//Check 
if (a != 10) {              //1 or 2 instructions?
    b *= (float) a / 10;    //Many instructions?
}

Value a is going to be '10' most of the time, however there are a few instances where it wont be. Is the floating point division going to take very many cycles even if a is equal to the divisor?

Will the previous code with the if statement execute more efficiently than simply the next one without?

//Don't check
b *= (float) a / 10;    //Many instructions?

Granted there wont be any noticable difference either way, however I'm curious as to the behavior of the floating point multiplication when the divisor is equal to the dividend in case things get processor heavy.

Upvotes: 2

Views: 266

Answers (3)

lessthanoptimal
lessthanoptimal

Reputation: 2812

If you do end up needing to optimize this code I would recommend using Caliper to do micro benchmarks of your inner loops. It's very hard to predict accurately what sort of effect these small modifications will have. Especially in Java where how the VM behaves is bit of an unknown since in theory it can optimize the code on the fly. Best to try several strategies and see what works.

http://code.google.com/p/caliper/

Upvotes: 1

D Stanley
D Stanley

Reputation: 152596

IIRC, floating-point multiplication is much less expensive than division, so this might be faster than both:

b *= (a * 0.1);

Upvotes: 3

Sean Owen
Sean Owen

Reputation: 66886

Assuming this is in some incredibly tight loop, executed billions of times, so the difference of 1-2 instructions matters, since otherwise you should probably not bother --

Yes you are right to weigh the cost of the additional check each time, versus the savings when the check is true. But my guess is that it has to be true a lot to overcome not only the extra overhead, but the fact that you're introducing a branch, which will ultimately do more to slow you down via a pipeline stall in the CPU in the JIT-compiled code than you'll gain otherwise.

If a == 10 a whole lot, I'd imagine there's a better and faster way to take advantage of that somehow, earlier in the code.

Upvotes: 5

Related Questions