Background:
Many years ago, I inherited a codebase that was using the Visual Studio (VC++) flag ‘/fp:fast’ to produce faster code in a particular calculation-heavy library. Unfortunately, ‘/fp:fast’ produced results that were slightly different to the same library under a different compiler (Borland C++). As we needed to produce exactly the same results, I switched to ‘/fp:precise’, which worked fine, and everything has been peachy ever since. However, now I’m compiling the same library with g++ on uBuntu Linux 10.04 and I’m seeing similar behavior, and I wonder if it might have a similar root cause. The numerical results from my g++ build are slightly different from the numerical results from my VC++ build. This brings me to my question:
Question:
Does g++ have equivalent or similar parameters to the ‘fp:fast’ and ‘fp:precise’ options in VC++? (and what are they? I want to activate the ‘fp:precise’ equivalent.)
More Verbose Information:
I compile using ‘make’, which calls g++. So far as I can tell (the make files are a little cryptic, and weren’t written by me) the only parameters added to the g++ call are the “normal” ones (include folders and the files to compile) and -fPIC (I’m not sure what this switch does, I don’t see it on the ‘man’ page).
The only relevant parameters in ‘man g++’ seem to be for turning optimization options ON. (e.g. -funsafe-math-optimizations). However, I don’t think I’m turning anything ON, I just want to turn the relevant optimization OFF.
I’ve tried Release and Debug builds, VC++ gives the same results for release and debug, and g++ gives the same results for release and debug, but I can’t get the g++ version to give the same results as the VC++ version.
Excess register precision is an issue only on FPU registers, which compilers (with the right enabling switches) tend to avoid anyway. When floating point computations are carried out in SSE registers, the register precision equals the memory one.
In my experience most of the /fp:fast impact (and potential discrepancy) comes from the compiler taking the liberty to perform algebraic transforms. This can be as simple as changing summands order:
can be – distributing multiplications like a*(b+c) at will, and can get to some rather complex transforms – all intended to reuse previous calculations.
In infinite precision such transforms are benign, of course – but in finite precision they actually change the result. As a toy example, try the summand-order-example with a=b=2^(-23), c = 1. MS’s Eric Fleegal describes it in much more detail.
In this respect, the gcc switch nearest to /fp:precise is -fno-unsafe-math-optimizations. I think it’s on by default – perhaps you can try setting it explicitly and see if it makes a difference. Similarly, you can try explicitly turning off all -ffast-math optimizations: -fno-finite-math-only, -fmath-errno, -ftrapping-math, -frounding-math and -fsignaling-nans (the last 2 options are non default!)