c++ - ¿Por qué Clang optimiza x*1.0 pero NO x+0.0?

optimization floating-point

Question

¿Por qué Clang optimiza el bucle en este código?

#include <time.h>
#include <stdio.h>

static size_t const N = 1 << 27;
static double arr[N] = { /* initialize to zero */ };

int main()
{
    clock_t const start = clock();
    for (int i = 0; i < N; ++i) { arr[i] *= 1.0; }
    printf("%u ms/n", (unsigned)(clock() - start) * 1000 / CLOCKS_PER_SEC);
}

pero no el bucle en este código?

#include <time.h>
#include <stdio.h>

static size_t const N = 1 << 27;
static double arr[N] = { /* initialize to zero */ };

int main()
{
    clock_t const start = clock();
    for (int i = 0; i < N; ++i) { arr[i] += 0.0; }
    printf("%u ms/n", (unsigned)(clock() - start) * 1000 / CLOCKS_PER_SEC);
}

(Etiquetado como C y C ++ porque me gustaría saber si la respuesta es diferente para cada uno).

Answer 1

El estándar IEEE 754-2008 para aritmética de punto flotante y el estándar de aritmética independiente del lenguaje (LIA) ISO / IEC 10967, Parte 1, responden por qué esto es así.

IEEE 754 § 6.3 El bit de signo

Cuando una entrada o un resultado es NaN, este estándar no interpreta el signo de un NaN. Sin embargo, tenga en cuenta que las operaciones en cadenas de bits (copy, negate, abs, copySign) especifican el bit de signo de un resultado NaN, a veces basado en el bit de signo de un operando NaN. El predicado lógico totalOrder también se ve afectado por el bit de signo de un operando NaN. Para todas las demás operaciones, este estándar no especifica el bit de signo de un resultado de NaN, incluso cuando solo hay una entrada de NaN o cuando el NaN se produce a partir de una operación no válida.

Cuando ni las entradas ni el resultado son NaN, el signo de un producto o cociente es el OR exclusivo de los signos de los operandos; el signo de una suma, o de una diferencia x - y considerada como una suma x + (−y), difiere de, como máximo, uno de los signos de los sumandos; y el signo del resultado de las conversiones, la operación de cuantización, las operaciones roundTo-Integral y roundToIntegralExact (ver 5.3.1) es el signo del primer o único operando. Estas reglas se aplicarán incluso cuando los operandos o resultados sean cero o infinito.

Cuando la suma de dos operandos con signos opuestos (o la diferencia de dos operandos con signos similares) es exactamente cero, el signo de esa suma (o diferencia) será +0 en todos los atributos de dirección de redondeo excepto roundTowardNegative; bajo ese atributo, el signo de una suma cero exacta (o diferencia) será −0. Sin embargo, x + x = x - (−x) conserva el mismo signo que x incluso cuando x es cero.

El caso de la suma

En el modo de redondeo predeterminado (Round-to-Nearest, Ties-to-Even) , vemos que x+0.0 produce x , EXCEPTO cuando x es -0.0 : en ese caso tenemos una suma de dos operandos con signos opuestos cuya suma es cero, y §6.3 párrafo 3 gobierna esta adición produce +0.0 .

Dado que +0.0 no es idéntico a nivel de bits al original -0.0 , y que -0.0 es un valor legítimo que puede ocurrir como entrada, el compilador está obligado a poner el código que transformará los ceros negativos potenciales a +0.0 .

El resumen: en el modo de redondeo predeterminado, en x+0.0 , si x

• no es -0.0 , entonces x sí mismo es un valor de salida aceptable.
• es -0.0 , entonces el valor de salida debe ser +0.0 , que no es idéntico en bits a -0.0 .

El caso de la multiplicación

En el modo de redondeo predeterminado , no ocurre tal problema con x*1.0 . Si x :

• es un (sub) número normal, x*1.0 == x siempre.
• es +/- infinity , entonces el resultado es +/- infinity del mismo signo.

• es NaN , entonces según

  IEEE 754 § 6.2.3 Propagación de NaN

  Una operación que propaga un operando NaN a su resultado y tiene un solo NaN como entrada debería producir un NaN con la carga útil de la entrada NaN si es representable en el formato de destino.

  lo que significa que se recomienda que el exponente y la mantisa (aunque no el signo) de NaN*1.0 no cambien desde la entrada NaN . El signo no está especificado de acuerdo con §6.3p1 anterior, pero una implementación puede especificar que sea idéntico al NaN origen.

• es +/- 0.0 , entonces el resultado es un 0 con su bit de signo XORed con el bit de signo de 1.0 , de acuerdo con §6.3p2. Como el bit de signo de 1.0 es 0 , el valor de salida no cambia desde la entrada. Por lo tanto, x*1.0 == x incluso cuando x es un cero (negativo).

El caso de la resta

En el modo de redondeo predeterminado , la resta x-0.0 también es un no-op, porque es equivalente a x + (-0.0) . Si x es

• es NaN , entonces §6.3p1 y §6.2.3 se aplican de manera muy similar a la suma y multiplicación.
• es +/- infinity , entonces el resultado es +/- infinity del mismo signo.
• es un (sub) número normal, x-0.0 == x siempre.
• es -0.0 , entonces en §6.3p2 tenemos "el [...] signo de una suma, o de una diferencia x - y considerada como una suma x + (−y), difiere de como máximo uno de los sumandos" signos ". Esto nos obliga a asignar -0.0 como resultado de (-0.0) + (-0.0) , porque -0.0 difiere en signo de ninguno de los sumandos, mientras que +0.0 difiere en signo de dos de los sumandos, en violación de esta cláusula .
• es +0.0 , entonces esto se reduce al caso de suma (+0.0) + (-0.0) considerado anteriormente en El caso de la adición , que según §6.3p3 se determina que da +0.0 .

Dado que para todos los casos el valor de entrada es legal como la salida, es permisible considerar x-0.0 como no operativo, y x == x-0.0 como tautología.

Optimizaciones de cambio de valor

El estándar IEEE 754-2008 tiene la siguiente cita interesante:

IEEE 754 § 10.4 Significado literal y optimizaciones de cambio de valor

[...]

Las siguientes transformaciones que cambian el valor, entre otras, preservan el significado literal del código fuente:

• Aplicando la propiedad de identidad 0 + x cuando x no es cero y no es una señalización de NaN y el resultado tiene el mismo exponente que x.
• Aplicando la propiedad de identidad 1 × x cuando x no es una señal de NaN y el resultado tiene el mismo exponente que x.
• Cambiar la carga útil o firmar un poco de un NaN silencioso.
• [...]

Como todos los NaN y todos los infinitos comparten el mismo exponente, y el resultado correctamente redondeado de x+0.0 y x*1.0 para x finito tiene exactamente la misma magnitud que x , su exponente es el mismo.

SNANS

Los NaN de señalización son valores de trampa de punto flotante; Son valores especiales de NaN cuyo uso como operando de punto flotante da como resultado una excepción de operación no válida (SIGFPE). Si se optimizara un bucle que desencadena una excepción, el software ya no se comportaría igual.

Sin embargo, como señala user2357112 en los comentarios , el Estándar C11 deja explícitamente indefinido el comportamiento de la señalización de NaNs ( sNaN ), por lo que el compilador puede asumir que no se producen y, por lo tanto, las excepciones que generan tampoco se producen. El estándar C ++ 11 omite describir un comportamiento para la señalización de NaN y, por lo tanto, también lo deja indefinido.

Modos de redondeo

En modos de redondeo alternativo, las optimizaciones permitidas pueden cambiar. Por ejemplo, en el modo Round-to-Negative-Infinity , la optimización x+0.0 -> x vuelve permisible, pero x-0.0 -> x se prohíbe.

Para evitar que GCC asuma modos y comportamientos de redondeo predeterminados, la bandera experimental -frounding-math se puede pasar a GCC.

Conclusión

Clang y GCC , incluso a -O3 , siguen cumpliendo con IEEE-754. Esto significa que debe cumplir con las reglas anteriores del estándar IEEE-754. x+0.0 no es idéntico a x para todas las x bajo esas reglas, pero se puede elegir x*1.0 para que sea así : a saber, cuando

1. Obedezca la recomendación de pasar sin cambios la carga útil de x cuando es un NaN.
2. Deje el bit de signo de un resultado NaN sin cambios por * 1.0 .
3. Obedezca la orden de XOR el bit de signo durante un cociente / producto, cuando x no es un NaN.

Para habilitar la optimización IEEE-754-insegura (x+0.0) -> x , el indicador -ffast-math debe pasarse a Clang o GCC.

Answer 2

x += 0.0 no es un NOOP si x es -0.0 . Sin embargo, el optimizador podría eliminar todo el ciclo ya que los resultados no se utilizan. En general, es difícil saber por qué un optimizador toma las decisiones que toma.