Difference in floating point arithmetics between x86 and x64

by

The issue hinges on this expression:

bool bLarger2 = (a*c)<b;

I looked at the code generated under VS2008, not having VS2010 to hand. For 64 bit the code is:

000000013FD51100  movss       xmm1,dword ptr [a] 
000000013FD51106  mulss       xmm1,dword ptr [c] 
000000013FD5110C  movss       xmm0,dword ptr [b] 
000000013FD51112  comiss      xmm0,xmm1

For 32 bit the code is:

00FC14DC  fld         dword ptr [a] 
00FC14DF  fmul        dword ptr [c] 
00FC14E2  fld         dword ptr [b] 
00FC14E5  fcompp

So under 32 bit the calculation is performed in the x87 unit, and under 64 bit it is performed by the x64 unit.

And the difference here is that the x87 operations are all performed to higher than single precision. By default the calculations are performed to double precision. On the other hand the SSE unit operations are pure single precision calculations.

You can persuade the 32 bit unit to perform all calculations to single precision accuracy like this:

_controlfp(_PC_24, _MCW_PC);

When you add that to your 32 bit program you will find that the booleans are both set to false.

There is a fundamental difference in the way that the x87 and SSE floating point units work. The x87 unit uses the same instructions for both single and double precision types. Data is loaded into registers in the x87 FPU stack, and those registers are always 10 byte Intel extended. You can control the precision using the floating point control word. But the instructions that the compiler writes are ignorant of that state.

On the other hand, the SSE unit uses different instructions for operations on single and double precision. Which means that the compiler can emit code that is in full control of the precision of the calculation.

So, the x87 unit is the bad guy here. You can maybe try to persuade your compiler to emit SSE instructions even for 32 bit targets. And certainly when I compiled your code under VS2013 I found that both 32 and 64 bit targets emitted SSE instructions.

More Related Contents:

  1. Why does changing 0.1f to 0 slow down performance by 10x?
  2. What is the size of float and double in C and C++? [duplicate]
  3. What is the most effective way for float and double comparison?
  4. Random float number generation
  5. What is the difference between float and double?
  6. How to compile a 64-bit application using Visual C++ 2010 Express?
  7. How can I write a power function myself?
  8. long double vs double
  9. Why is template argument deduction disabled with std::forward?
  10. 64 bit ntohl() in C++?
  11. Getting the high part of 64 bit integer multiplication
  12. Why did Microsoft abandon long double data type? [closed]
  13. How to detect double precision floating point overflow and underflow?
  14. Set back default floating point print precision in C++
  15. How to create a DLL with SWIG from Visual Studio 2010
  16. How computer does floating point arithmetic?
  17. How to correctly and standardly compare floats?
  18. Convert a float to a string
  19. Math precision requirements of C and C++ standard
  20. C floating point precision [duplicate]
  21. Why do sin(45) and cos(45) give different results? [duplicate]
  22. error C2065: ‘cout’ : undeclared identifier
  23. C++ floating point to integer type conversions
  24. Printing double without losing precision
  25. Visual Studio debugger error: Unable to start program Specified file cannot be found
  26. Should std::unique_ptr be permitted
  27. Why is the Console Closing after I’ve included cin.get()?
  28. Does the C++ standard specify anything on the representation of floating point numbers?
  29. Why does an lvalue cast work?
  30. sizeof(long) in 64-bit Windows

Leave a Comment