Fast multiplication/division by 2 for floats and doubles (C/C++)

by

This is one of those highly-application specific things. It may help in some cases and not in others. (In the vast majority of cases, a straight-forward multiplication is still best.)

The “intuitive” way of doing this is just to extract the bits into a 64-bit integer and add the shift value directly into the exponent. (this will work as long as you don’t hit NAN or INF)

So something like this:

union{
    uint64 i;
    double f;
};

f = 123.;
i += 0x0010000000000000ull;

//  Check for zero. And if it matters, denormals as well.

Note that this code is not C-compliant in any way, and is shown just to illustrate the idea. Any attempt to implement this should be done directly in assembly or SSE intrinsics.

However, in most cases the overhead of moving the data from the FP unit to the integer unit (and back) will cost much more than just doing a multiplication outright. This is especially the case for pre-SSE era where the value needs to be stored from the x87 FPU into memory and then read back into the integer registers.

In the SSE era, the Integer SSE and FP SSE use the same ISA registers (though they still have separate register files). According the Agner Fog, there’s a 1 to 2 cycle penalty for moving data between the Integer SSE and FP SSE execution units. So the cost is much better than the x87 era, but it’s still there.

All-in-all, it will depend on what else you have on your pipeline. But in most cases, multiplying will still be faster. I’ve run into this exact same problem before so I’m speaking from first-hand experience.

Now with 256-bit AVX instructions that only support FP instructions, there’s even less of an incentive to play tricks like this.

More Related Contents:

  1. Is multiplication and division using shift operators in C actually faster?
  2. Which is better option to use for dividing an integer number by 2?
  3. my first c++ program runtime is super long like 5 – 10 minutes on a fast CPU it's a very basic c++ program [closed]
  4. What is the most effective way for float and double comparison?
  5. What exactly is the “as-if” rule?
  6. Why does C++ code for testing the Collatz conjecture run faster than hand-written assembly?
  7. Fast bignum square computation
  8. Advantage of switch over if-else statement
  9. How to overload std::swap()
  10. How can I multiply and divide using only bit shifting and adding?
  11. Is the compiler allowed to optimize out heap memory allocations?
  12. Virtual functions and performance – C++
  13. Why can lambdas be better optimized by the compiler than plain functions?
  14. What is more efficient? Using pow to square or just multiply it with itself?
  15. Getting the high part of 64 bit integer multiplication
  16. How can I know which parts in the code are never used?
  17. How to read file content into istringstream?
  18. cin input (input is an int) when I input a letter, instead of printing back incorrect once, it prints correct once then inc for the rest of the loop
  19. What is copy elision and how does it optimize the copy-and-swap idiom?
  20. Is RVO (Return Value Optimization) applicable for all objects?
  21. Is optimisation level -O3 dangerous in g++?
  22. Is std::vector memory freed upon a clear?
  23. Get sum of values stored in __m256d with SSE/AVX
  24. Skip some arguments in a C++ function?
  25. Can I hint the optimizer by giving the range of an integer?
  26. Is it legal for a C++ optimizer to reorder calls to clock()?
  27. Is Visual Studio 2013 optimizing correctly in the presence of /OPT:ICF?
  28. How to reduce the size of executable produced by MinGW g++ compiler?
  29. C++ Best way to get integer division and remainder
  30. std::array with aggregate initialization on g++ generates huge code

Leave a Comment