Flotante vs Doble Rendimiento

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 values ​​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 obtener los dobles en el mismo tiempo de procesamiento?

En los procesadores x86, al menos, el float y el double serán convertidos a 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.

Los antiguos consejos que float son más rápidos que el double aplicado 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ía de las manipulaciones de punto flotante se realizaban en software. En estas máquinas (que funcionaban con vapor generado por las fosas de lava), era más rápido usar float . Ahora, el único beneficio real para float es que ocupan menos espacio (lo que solo importa si tienes millones de ellos).

Tuve un pequeño proyecto donde utilicé CUDA y puedo recordar que el flotador fue más rápido que el doble allí también. 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.

Por lo tanto, 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 lo que puedo recordar, me encontré con esto mientras buscaba flotación vs. doble en una CPU).

Depende del sistema de 32 bits o de 64 bits . Si comstack a 64 bits, el doble será más rápido. Comstackdo a 32 bits en 64 bits (máquina y SO) hecho flotar alrededor de 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); } 

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