Does any floating point-intensive code produce bit-exact results in any x86-based architecture?

by

Table of contents:

  • C/C++
  • asm
  • Creating real-life software that achieves this.

In C or C++:

No, a fully ISO C11 and IEEE-conforming C implementation does not guarantee bit-identical results to other C implementations, even other implementations on the same hardware.

(And first of all, I’m going to assume we’re talking about normal C implementations where double is the IEEE-754 binary64 format, etc., even though it would be legal for a C implementation on x86 to use some other format for double and implement FP math with software emulation, and define the limits in float.h. That might have been plausible when not all x86 CPUs included with an FPU, but in 2016 that’s Deathstation 9000 territory.)

related: Bruce Dawson’s Floating-Point Determinism blog post is an answer to this question. His opening paragraph is amusing (and is followed by a lot of interesting stuff):

Is IEEE floating-point math deterministic? Will you always get the same results from the same inputs? The answer is an unequivocal “yes”. Unfortunately the answer is also an unequivocal “no”. I’m afraid you will need to clarify your question.

If you’re pondering this question, then you will definitely want to have a look at the index to Bruce’s series of articles about floating point math, as implemented by C compilers on x86, and also asm, and IEEE FP in general.

First problem: Only “basic operations”: + – * / and sqrt are required to return “correctly rounded” results, i.e. <= 0.5ulp of error, correctly-rounded out to the last bit of the mantissa, so the results is the closest representable value to the exact result.

Other math library functions like pow(), log(), and sin() allow implementers to make a tradeoff between speed and accuracy. For example, glibc generally favours accuracy, and is slower than Apple’s OS X math libraries for some functions, IIRC. See also glibc’s documentation of the error bounds for every libm function across different architectures.

But wait, it gets worse. Even code that only uses the correctly-rounded basic operations doesn’t guarantee the same results.

C rules also allow some flexibility in keeping higher precision temporaries. The implementation defines FLT_EVAL_METHOD so code can detect how it works, but you don’t get a choice if you don’t like what the implementation does. You do get a choice (with #pragma STDC FP_CONTRACT off) to forbid the compiler from e.g. turning a*b + c into an FMA with no rounding of the a*b temporary before the add.

On x86, compilers targeting 32-bit non-SSE code (i.e. using obsolete x87 instructions) typically keep FP temporaries in x87 registers between operations. This produces the FLT_EVAL_METHOD = 2 behaviour of 80-bit precision. (The standard specifies that rounding still happens on every assignment, but real compilers like gcc don’t actually do extra store/reloads for rounding unless you use -ffloat-store. See https://gcc.gnu.org/wiki/FloatingPointMath. That part of the standard seems to have been written assuming non-optimizing compilers, or hardware that efficiently provides rounding to the type width like non-x86, or like x87 with precision set to round to 64-bit double instead of 80-bit long double. Storing after every statement is exactly what gcc -O0 and most other compilers do, and the standard allows extra precision within evaluation of one expression.)

So when targeting x87, the compiler is allowed to evaluate the sum of three floats with two x87 FADD instructions, without rounding off the sum of the first two to a 32-bit float. In that case, the temporary has 80-bit precision… Or does it? Not always, because the C implementation’s startup code (or a Direct3D library!!!) may have changed the precision setting in the x87 control word, so values in x87 registers are rounded to 53 or 24 bit mantissa. (This makes FDIV and FSQRT run a bit faster.) All of this from Bruce Dawson’s article about intermediate FP precision).

In assembly:

With rounding mode and precision set the same, I think every x86 CPU should give bit-identical results for the same inputs, even for complex x87 instructions like FSIN.

Intel’s manuals don’t define exactly what those results are for every case, but I think Intel aims for bit-exact backwards compatibility. I doubt they’ll ever add extended-precision range-reduction for FSIN, for example. It uses the 80-bit pi constant you get with fldpi (correctly-rounded 64-bit mantissa, actually 66-bit because the next 2 bits of the exact value are zero). Intel’s documentation of the worst-case-error was off by a factor of 1.3 quintillion until they updated it after Bruce Dawson noticed how bad the worst-case actually was. But this can only be fixed with extended-precision range reduction, so it wouldn’t be cheap in hardware.

I don’t know if AMD implements their FSIN and other micro-coded instructions to always give bit-identical results to Intel, but I wouldn’t be surprised. Some software does rely on it, I think.

Since SSE only provides instructions for add/sub/mul/div/sqrt, there’s nothing too interesting to say. They implement the IEEE operation exactly, so there’s no chance that any x86 implementation will ever give you anything different (unless the rounding mode is set differently, or denormals-are-zero and/or flush-to-zero are different and you have any denormals).

SSE rsqrt (fast approximate reciprocal square root) is not exactly specified, and I think it’s possible you might get a different result even after a Newton iteration, but other than that SSE/SSE2 is always bit exact in asm, assuming the MXCSR isn’t set weird. So the only question is getting the compiler go generate the same code, or just using the same binaries.

In real life:

So, if you statically link a libm that uses SSE/SSE2 and distribute those binaries, they will run the same everywhere. Unless that library uses run-time CPU detection to choose alternate implementations…

As @Yan Zhou points out, you pretty much need to control every bit of the implementation down to the asm to get bit-exact results.

However, some games really do depend on this for multi-player, but often with detection/correction for clients that get out of sync. Instead of sending the entire game state over the network every frame, every client computes what happens next. If the game engine is carefully implemented to be deterministic, they stay in sync.

In the Spring RTS, clients checksum their gamestate to detect desync. I haven’t played it for a while, but I do remember reading something at least 5 years ago about them trying to achieve sync by making sure all their x86 builds used SSE math, even the 32-bit builds.

One possible reason for some games not allowing multi-player between PC and non-x86 console systems is that the engine gives the same results on all PCs, but different results on the different-architecture console with a different compiler.

Further reading: GAFFER ON GAMES: Floating Point Determinism. Some techniques that real game engines use to get deterministic results. e.g. wrap sin/cos/tan in non-optimized function calls to force the compiler to leave them at single-precision.

More Related Contents:

  1. Using LEA on values that aren’t addresses / pointers?
  2. Observing stale instruction fetching on x86 with self-modifying code
  3. Can I use Intel syntax of x86 assembly with GCC?
  4. Stack allocation, padding, and alignment
  5. Is it safe to read past the end of a buffer within the same page on x86 and x64?
  6. clflush to invalidate cache line via C function
  7. Syscall implementation of exit()
  8. How do I determine the number of x86 machine instructions executed in a C program?
  9. What’s missing/sub-optimal in this memcpy implementation?
  10. Unexpected output when printing directly to text video memory
  11. Efficient integer compare function
  12. x86_64 ASM – maximum bytes for an instruction?
  13. Fastest way to calculate a 128-bit integer modulo a 64-bit integer
  14. Ranges of floating point datatype in C?
  15. Fused multiply add and default rounding modes
  16. multi-word addition using the carry flag
  17. signed and unsigned arithmetic implementation on x86
  18. Inline assembly that clobbers the red zone
  19. How does a mutex lock and unlock functions prevents CPU reordering?
  20. Calling C functions from x86 assembly language
  21. How to do an atomic increment and fetch in C?
  22. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  23. calling assembly function from c
  24. CPU cache inhibition
  25. Is there a C compiler that targets the 8086? [closed]
  26. Is it possible to call a non-exported function that resides in an exe?
  27. Writing a Linux int 80h system-call wrapper in GNU C inline assembly [duplicate]
  28. Why is gcc allowed to speculatively load from a struct?
  29. What is the effect of second argument in _builtin_prefetch()?
  30. How to convert 32-bit float to 8-bit signed char? (4:1 packing of int32 to int8 __m256i)

Leave a Comment