Float - Çift Performans

Bazı zamanlama testler yaptı ve aynı zamanda gibi bazı makaleleri okumak bu bir (son yorum) ve Yayın yapılı, şamandıra ve çift değerler işleme zaman aynı miktarda almak gibi görünüyor.

Bu nasıl mümkün olabilir? Float çift değerlere kıyasla daha az hassas ve daha küçük olduğunda, CLR aynı işlem süresine nasıl iki katına çıkabilir?

En azından x86 işlemcilerinde floatve doubleher biri işlem için FPU tarafından 10 bayta gerçek dönüştürülecektir. FPU, desteklediği farklı kayan nokta türleri için ayrı işleme birimlerine sahip değildir.

100 yıl önce çoğu CPU'nun yerleşik FPU'ları olmadığı (ve birkaç kişinin ayrı FPU yongaları olduğu) uygulanandan floatdaha hızlı olan eski tavsiye double, bu nedenle çoğu kayan nokta manipülasyonu yazılımda yapıldı. (Lav çukurları tarafından oluşturulan buhar aracılığıyla sağlanıyordu) bu makinalarda bu oldu kullanmak daha hızlı floats. Şimdi e'lerin tek gerçek yararı, floatdaha az yer kaplamalarıdır (bu, yalnızca milyonlarcasına sahipseniz önemlidir).

CUDA'yı kullandığım küçük bir projem vardı ve şamandıranın orada da iki katından daha hızlı olduğunu hatırlıyorum. Bir kez için Ana Bilgisayar ve Aygıt arasındaki trafik daha düşüktür (Ana Bilgisayar CPU'dur ve "normal" RAM ve Aygıt, GPU ve oradaki karşılık gelen RAM'dir). Ancak veriler her zaman Cihazda bulunsa bile daha yavaştır. Sanırım bir yerlerde bunun son zamanlarda değiştiğini veya gelecek nesil ile değişmesi gerektiğini okudum, ama emin değilim.

Öyle görünüyor ki, GPU bu durumlarda yerel olarak çift hassasiyeti işleyemiyor, bu da neden GLDouble yerine GLFloat'ın kullanıldığını açıklıyor.

(Dediğim gibi, sadece hatırlayabildiğim kadarıyla, bir CPU'da float vs double ararken buna rastladım.)

Bu bağlıdır 32-bit veya 64 bit sistemde. 64-bit'e derlerseniz, double daha hızlı olacaktır. 64 bit (makine ve işletim sistemi) üzerinde 32 bit olarak derlendiğinde, yaklaşık% 30 daha hızlı kayar:

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

Bununla birlikte, kayan noktaların tercih edildiği bazı durumlar da vardır - örneğin OpenGL kodlamasında, çoğu GPU'da GLDouble'dan daha verimli olduğu için GLFloat veri türünü (genellikle doğrudan 16 bit kayan nokta ile eşlenir) kullanmak çok daha yaygındır.