Handle infinity and NaN with `-ffinite-math-only`

[fwyzard]

gcc

According to the documentation of -ffinite-math-only:

Allow optimizations for floating-point arithmetic that assume that arguments and results are not NaNs or +-Infs.

When -ffinite-math-only is used, gcc

• may replace a call to std::isnan(arg) with 0 (x86-64, aarch64).

• compiles correctly the current implementation of xtd::isnan(arg) (x86-64, aarch64).

nvcc

According to the documentation --use_fast_math:

Make use of fast math library. --use_fast_math implies --ftz=true --prec-div=false --prec-sqrt=false --fmad=true.

When --use_fast_math is used, nvcc

• compiles std::isnan(arg), ::isnan(arg) and __builtin_isnan(arg) to correct PTX (sm_90)

• compiles the current implementation of xtd::isnan(arg) to correct PTX (sm_90)

clang

According to the documentation of -ffinite-math-only:

Allow floating-point optimizations that assume arguments and results are not NaNs or +-inf. This defines the __FINITE_MATH_ONLY__ preprocessor macro.

host compilation

When -ffinite-math-only is used, clang

• may replace a call to std::isnan(arg) with 0, with a warning (x86-64, aarch64):

  warning: use of NaN is undefined behavior due to the currently enabled floating-point options [-Wnan-infinity-disabled]

• optimises the current implementation of xtd::isnan(arg) and replaces it with 0 (x86-64, aarch64)

clang -x cu

When -ffinite-math-only is used, clang -x cu

• may replace a call to __builtin_isnan(arg) with 0, with a warning (sm_90):

  warning: use of NaN is undefined behavior due to the currently enabled floating-point options [-Wnan-infinity-disabled]

• optimises the current implementation of xtd::isnan(arg) and replaces it with 0 (sm_90)

clang -x hip, hipcc

When -ffinite-math-only is used, hipcc or clang -x hip

• may replace a call to __builtin_isnan(arg), ::isnan(arg) or std::isnan(arg) with 0, with a warning (gfx906, gfx942)

• optimises the current implementation of xtd::isnan(arg) and replaces it with 0 (gfx906)

[fwyzard]

Gemini suggests using an inline assembly to prevent the compiler from optimising the checks based on any assumptions on the floating point value:

template <std::unsigned_integral T>
constexpr T do_not_optimise(T value) noexcept {
    if (std::is_constant_evaluated()) {
        return value;
    } else {
#if defined(__HIP_DEVICE_COMPILE__) || defined(__AMD__)
        // HIP/ROCm specific barrier
        // use "v" to ensure a Vector Register in the AMD ALU
        asm volatile ("" : "+v"(value));
#elif defined(__CUDA_ARCH__)
        // CUDA specific barrier
        if constexpr (sizeof(T) == 4) {
            // "r" = 32-bit register (.u32)
            asm volatile ("" : "+r"(value));
        } else {
            // "l" = 64-bit register (.u64)
            asm volatile ("" : "+l"(value));
        }
#elif defined(__SYCL_DEVICE_ONLY__)
        // Intel oneAPI specific barrier
        asm volatile ("" : "+r"(value)); 
#elif defined(__clang__) || defined(__GNUC__)
        // CPU specific barries
        asm volatile ("" : "+g"(value));
#endif
        return value;
    }
}