0.1f frente a 0: por qué el código C++ se ralentiza 10 veces y cómo solucionarlo

Introducción: el error que costó 10x de rendimiento

Imagina la situación: estás escribiendo código de alto rendimiento en C++. Todo vuela, las pruebas pasan, te sientes un genio de la optimización. Y entonces cambias una única constante — 0.1f por 0. Y el rendimiento cae 10 veces. Sin bromas. Sin exageración. Precisamente esta pregunta obtuvo miles de visitas en Stack Overflow y se convirtió en un clásico para quienes quieren entender cómo funcionan los números de punto flotante a nivel de procesador.

En este artículo analizaremos por qué un reemplazo aparentemente tan inofensivo lleva a una catástrofe, qué mecanismos internos del procesador son responsables de ello y, lo más importante, cómo evitarlo. El artículo será útil tanto para desarrolladores principiantes de C++ como para ingenieros experimentados que deseen comprender más a fondo la optimización del código C++.

El núcleo del problema: números desnormalizados y su impacto en el rendimiento de C++

Para empezar, reproduzcamos el problema. Consideremos un bucle simple que realiza cálculos con punto flotante:

#include <iostream>\n#include <chrono>\n\nvoid slow_function(float factor) {\n    float sum = 0.0f;\n    for (int i = 0; i < 100000000; ++i) {\n        sum += factor * 0.1f;  // Rápido, si factor = 0.1f\n        // sum += factor * 0;  // Lento, si factor = 0\n    }\n    std::cout << sum << std::endl;\n}\n\nint main() {\n    auto start = std::chrono::high_resolution_clock::now();\n    slow_function(0.1f);  // Prueba a cambiarlo por 0\n    auto end = std::chrono::high_resolution_clock::now();\n    std::cout << "Time: " \n              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() \n              << " ms" << std::endl;\n    return 0;\n}

Si ejecutas este código con factor = 0.1f, el tiempo de ejecución será, digamos, 100 ms. Cámbialo a factor = 0 — y obtendrás 1000 ms o más. Una diferencia de 10 veces. ¿Por qué?

La respuesta está en los números desnormalizados (subnormales). Esta es una de las trampas más engañosas en la optimización de C++, de la que pocos saben hasta que se enfrentan a ella personalmente.

¿Qué son los números desnormalizados y por qué ralentizan el código?

El estándar IEEE 754 para números de punto flotante define no solo números normales (donde la mantisa comienza con 1), sino también números desnormalizados (subnormales). Se utilizan para representar valores muy pequeños, cercanos a cero. Cuando el resultado de un cálculo se vuelve menor que el número normal mínimo, el procesador entra en modo de procesamiento de desnormalizados.

El problema es que el soporte hardware de los desnormalizados en los procesadores x86 es extremadamente lento. Si las operaciones normales con float se ejecutan en 1-3 ciclos, las operaciones con desnormalizados pueden tomar 100-200 ciclos o más. Esta es la causa de la caída del rendimiento.

Volvamos a nuestro ejemplo. Cuando factor = 0.1f, todos los resultados intermedios permanecen en el rango normal. Pero cuando factor = 0, la multiplicación por cero da cero. Luego sumamos 0.1f a cero — obtenemos 0.1f. Pero en la siguiente iteración volvemos a multiplicar por cero y obtenemos cero nuevamente. Y así millones de veces. Como resultado, el procesador genera constantemente valores desnormalizados, lo que provoca una desaceleración catastrófica.

Experimento: cómo ver la diferencia con tus propios ojos

Escribamos un ejemplo más ilustrativo que muestre cómo los desnormalizados afectan el rendimiento del código C++:

#include <iostream>\n#include <chrono>\n#include <cmath>\n\nvoid test_performance(float initial_value) {\n    float x = initial_value;\n    auto start = std::chrono::high_resolution_clock::now();\n    \n    for (int i = 0; i < 100000000; ++i) {\n        x = x * 0.5f + 0.1f;  // Fórmula recurrente típica\n    }\n    \n