Problema de GCC con comparaciones de tipo doble sin formato

Question

Tengo el siguiente código, sin embargo, al compilarlo con GCC 4.4 con varios indicadores de optimización obtengo algunos resultados inesperados cuando se ejecuta.

#include <iostream> 

int main() 
{ 
    const unsigned int cnt = 10; 
    double lst[cnt] = { 0.0 }; 
    const double v[4] = { 131.313, 737.373, 979.797, 731.137 }; 

    for(unsigned int i = 0; i < cnt; ++i) { 
     lst[i] = v[i % 4] * i; 
    } 

    for(unsigned int i = 0; i < cnt; ++i) { 
     double d = v[i % 4] * i; 
     if(lst[i] != d) { 
     std::cout << "error @ : " << i << std::endl; 
     return 1; 
     } 
    } 
    return 0; 
} 

• cuando se compila con: "g ++ -pedantic -Wall -Werror -O1 -o test.cpp test" consigo la salida siguiente: "error @: 3"

• cuando se compila con: "g ++ -pedantic -Wall -Werror -O2 -o test.cpp test" consigo la salida siguiente: "error @: 3"

• cuando se compila con: "test.cpp g ++ -pedantic -Wall -Werror -O3 -o prueba" me sale ningún error

• cuando se compila con: "g ++ -pedantic -Wall - werror -o test.cpp prueba" me sale ningún error

no creo que esto sea un problema relacionado con el redondeo, o diferencia épsilon en la comparación. Intenté esto con Intel v10 y MSVC 9.0 y todos parecen funcionar como se esperaba. Creo que esto no debería ser más que una comparación de bits.

Si se sustituye la sentencia if con lo siguiente: if (static_cast<long long int>(lst[i]) != static_cast<long long int>(d)), y añadir "-Wno-largo tiempo" me sale ningún error en cualquiera de los modos de optimización cuando se ejecuta.

Si añado std::cout << d << std::endl; antes de que el "retorno 1", me sale ningún error en cualquiera de los modos de optimización cuando se ejecuta.

¿Esto es un error en mi código, o hay algo mal con GCC y la forma en que maneja el tipo doble?

Nota: Acabo de probar esto con las versiones 4.3 y 3.3 de gcc, el error no se exhibe.

Resolución: Mike Dinsdale en cuenta lo siguiente informe de error: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 Parece que el equipo GCC no son completamente seguros sobre la naturaleza del problema.

Como se sugiere en el informe de error, una posible solución es usar la opción ffloat-store. He intentado esto y funciona, sin embargo, los resultados desde el punto de vista del rendimiento no son tan buenos, aunque mmm.

Answer 1

El problema es probablemente el resultado de perder un poco de precisión para el almacenamiento del resultado de una expresión versus el compilador no hacerlo en un local como una optimización:

double d = v[i % 4] * i; // the result, `d`, might be kept in a register 
          // instead of storing it in a memory location, 
          // keeping full precision 

if(lst[i] != d) {   // the value stored in lst[i] may have lost some 
          // precision since it had to be stored in memory, 
          // which might not be able to hold the full 
          // precision that the expression generated 

El estándar C99 dice en 6.3.1 .8/2 "conversiones aritméticas habituales":

Los valores de operandos flotantes y de los resultados de expresiones flotantes pueden ser representado en mayor precisión y rango que el requerido por el tipo; los tipos no son cambiados por eso.

Answer 2

El ancho de los registros de coma flotante en x86 es diferente del ancho de double en RAM. Por lo tanto, las comparaciones pueden tener éxito o fallar dependiendo completamente de cómo el compilador decida optimizar las cargas de los valores de coma flotante.

Answer 3

El hecho de que el resultado dependa de la configuración de optimización sugiere que podría tratarse de una ampliación de precisión x87 complicando las cosas (como dice Michael Burr).

Aquí hay un código que utilizo (con gcc en procesadores x86) para cambiar la precisión extendida fuera:

static const unsigned int PRECISION_BIT_MASK = 0x300; 
///< bitmask to mask out all non-precision bits in the fpu control word \cite{INTEL}. 
static const unsigned int EXTENDED_PRECISION_BITS = 0x300; 
///< add to the fpu control word (after zeroing precision bits) to turn on extended precision \cite{INTEL}. 
static const unsigned int STANDARD_PRECISION_BITS = 0x200; 
///< add to the fpu control word (after zeroing precision bits) to turn off extended precision \cite{INTEL}. 

void set_fpu_control_word(unsigned int mode) 
{ 
    asm ("fldcw %0" : : "m" (*&mode)); 
} 

unsigned int get_fpu_control_word() 
{ 
    volatile unsigned int mode = 0; 
    asm ("fstcw %0" : "=m" (*&mode)); 
    return mode; 
} 

bool fpu_set_extended_precision_is_on(bool state) 
{ 
    unsigned int old_cw = get_fpu_control_word(); 
    unsigned int masked = old_cw & ~PRECISION_BIT_MASK; 
    unsigned int new_cw; 
    if(state) 
    new_cw = masked + EXTENDED_PRECISION_BITS; 
    else 
    new_cw = masked + STANDARD_PRECISION_BITS; 
    set_fpu_control_word(new_cw); 
    return true; 
} 

bool fpu_get_extended_precision_is_on() 
{ 
    unsigned int old_cw = get_fpu_control_word(); 
    return ((old_cw & PRECISION_BIT_MASK) == 0x300); 
} 

o simplemente puede ejecutar el código con valgrind, que no simula los registros de 80 bits ¡y probablemente sea más fácil para un programa corto como este!