Flotador vs doble rendimiento

Question

Hice algunas pruebas de tiempo y también leí algunos artículos como este (último comentario), y parece que en Release build, float y double valores toman la misma cantidad de tiempo de procesamiento.

¿Cómo es esto posible? Cuando el flotante es menos preciso y más pequeño en comparación con los valores dobles, ¿cómo puede el CLR duplicarse en el mismo tiempo de procesamiento?

Answer 1

En los procesadores x86, al menos, float y double se convertirán en un real de 10 bytes por la FPU para su procesamiento. La FPU no tiene unidades de procesamiento separadas para los diferentes tipos de punto flotante que admite.

El antiguo consejo de que float es más rápido que double aplicado hace 100 años cuando la mayoría de las CPU no tenían FPU incorporadas (y pocas personas tenían FPU separadas chips), por lo que la mayor parte de la manipulación de punto flotante se realizó en software. En estas máquinas (que funcionaban con vapor generado por los pozos de lava), era más rápido usar float s. Ahora, el único beneficio real de float s es que ocupan menos espacio (lo que solo importa si tienes millones de ellos).

Answer 2

Tuve un pequeño proyecto donde usé CUDA y puedo recordar que el flotador también fue más rápido que el doble allí. Por una vez, el tráfico entre el Host y el Dispositivo es menor (el Host es la CPU y la RAM normal y el Dispositivo es la GPU y la RAM correspondiente allí). Pero incluso si los datos residen en el dispositivo todo el tiempo, es más lento. Creo que leí en alguna parte que esto ha cambiado recientemente o se supone que cambiará con la próxima generación, pero no estoy seguro.

Entonces, parece que la GPU simplemente no puede manejar la precisión doble de forma nativa en esos casos, lo que también explicaría por qué GLFloat se usa generalmente en lugar de GLDouble.

(Como dije, es solo hasta donde puedo recordar, me topé con esto mientras buscaba flotante versus doble en una CPU).

Answer 3

Depende del sistema 32 bits o 64 bits . Si compila a 64 bits, el doble será más rápido. Compilado a 32 bits en 64 bits (máquina y sistema operativo) hizo flotar alrededor de un 30% más rápido:

    public static void doubleTest(int loop)
    {
        Console.Write("double: ");
        for (int i = 0; i < loop; i++)
        {
            double a = 1000, b = 45, c = 12000, d = 2, e = 7, f = 1024;
            a = Math.Sin(a);
            b = Math.Asin(b);
            c = Math.Sqrt(c);
            d = d + d - d + d;
            e = e * e + e * e;
            f = f / f / f / f / f;
        }
    }

    public static void floatTest(int loop)
    {
        Console.Write("float: ");
        for (int i = 0; i < loop; i++)
        {
            float a = 1000, b = 45, c = 12000, d = 2, e = 7, f = 1024;
            a = (float) Math.Sin(a);
            b = (float) Math.Asin(b);
            c = (float) Math.Sqrt(c);
            d = d + d - d + d;
            e = e * e + e * e;
            f = f / f / f / f / f;
        }
    }

    static void Main(string[] args)
    {
        DateTime time = DateTime.Now;
        doubleTest(5 * 1000000);
        Console.WriteLine("milliseconds: " + (DateTime.Now - time).TotalMilliseconds);

        time = DateTime.Now;
        floatTest(5 * 1000000);
        Console.WriteLine("milliseconds: " + (DateTime.Now - time).TotalMilliseconds);

        Thread.Sleep(5000);
    }

Answer 4

Sin embargo, todavía hay algunos casos en los que se prefieren flotantes: con la codificación OpenGL, por ejemplo, es mucho más común usar el tipo de datos GLFloat (generalmente asignado directamente a flotante de 16 bits), ya que es más eficiente en la mayoría de las GPU que GLDouble.