Rendimiento flotante vs doble

Hice algunas pruebas de tiempo y también leí algunos artículos como este (último comentario), y parece que en la compilación de la versión, los valores flotantes y dobles toman la misma cantidad de tiempo de procesamiento.

¿Cómo es esto posible? Cuando el flotador 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?

En procesadores x86, al menos, floaty doublela FPU convertirá cada uno a un valor real de 10 bytes para su procesamiento. La FPU no tiene unidades de procesamiento separadas para los diferentes tipos de punto flotante que admite.

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

Tuve un pequeño proyecto en el que usé CUDA y puedo recordar que el flotador también era más rápido que el doble. 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 doble precisión de forma nativa en esos casos, lo que también explicaría por qué se usa generalmente GLFloat en lugar de GLDouble.

(Como dije, es solo por lo que puedo recordar, me encontré con esto mientras buscaba flotante frente a doble en una CPU).

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

Depende del sistema de 32 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);
    }