Float vs Double Performance

Ich habe einige Timing-Tests durchgeführt und auch einige Artikel wie diesen gelesen (letzter Kommentar). In Release-Builds benötigen Float- und Double-Werte dieselbe Verarbeitungszeit.

Wie ist das möglich? Wenn float im Vergleich zu doppelten Werten weniger genau und kleiner ist, wie kann die CLR in derselben Verarbeitungszeit verdoppelt werden?

Zumindest auf x86-Prozessoren floatund doublewird von der FPU zur Verarbeitung jeweils in ein 10-Byte-Real konvertiert. Die FPU verfügt nicht über separate Verarbeitungseinheiten für die verschiedenen unterstützten Gleitkommatypen.

Der uralte Ratschlag, der floatschneller ist als vor double100 Jahren, als die meisten CPUs keine eingebauten FPUs hatten (und nur wenige Leute separate FPU-Chips hatten), so dass die meisten Gleitkomma-Manipulationen in Software durchgeführt wurden. Auf diesen Maschinen (die durch Dampf erzeugt durch die Lavagruben angetrieben wurden), es war schneller zu bedienen floats. Der einzige wirkliche Vorteil von floats ist, dass sie weniger Platz beanspruchen (was nur wichtig ist, wenn Sie Millionen von ihnen haben).

Ich hatte ein kleines Projekt, in dem ich CUDA verwendet habe, und ich kann mich daran erinnern, dass Float auch dort schneller als doppelt so hoch war. Ausnahmsweise ist der Verkehr zwischen Host und Gerät geringer (Host ist die CPU und der "normale" RAM und Gerät ist die GPU und der entsprechende RAM dort). Aber selbst wenn sich die Daten ständig auf dem Gerät befinden, sind sie langsamer. Ich glaube, ich habe irgendwo gelesen, dass sich dies in letzter Zeit geändert hat oder mit der nächsten Generation ändern soll, aber ich bin mir nicht sicher.

Es scheint also, dass die GPU in diesen Fällen einfach nicht mit doppelter Genauigkeit nativ umgehen kann, was auch erklären würde, warum GLFloat normalerweise anstelle von GLDouble verwendet wird.

(Wie gesagt, es ist nur so weit ich mich erinnern kann, bin nur darauf gestoßen, als ich auf einer CPU nach float vs. double gesucht habe.)

Es gibt jedoch immer noch Fälle, in denen Floats bevorzugt werden. Bei der OpenGL-Codierung wird beispielsweise der GLFloat-Datentyp (im Allgemeinen direkt dem 16-Bit-Float zugeordnet) weitaus häufiger verwendet, da er auf den meisten GPUs effizienter ist als GLDouble.

Dies hängt vom 32-Bit- oder 64-Bit- System ab. Wenn Sie auf 64-Bit kompilieren, ist double schneller. Kompiliert auf 32-Bit auf 64-Bit (Maschine und Betriebssystem), schwebte um 30% schneller:

    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);
    }