Поплавок проти подвійної продуктивності

Я провів кілька тестів синхронізації, а також прочитав деякі статті, подібні до цієї (останній коментар), і схоже, що у версії build, float і double значення займають однакову кількість часу обробки.

Як це можливо? Коли float менш точний і менший порівняно з подвійними значеннями, як CLR може отримати подвоєння за той самий час обробки?

На процесорах x86, принаймні, floatі doubleкожен з них буде перетворений у 10-байтовий реальний FPU для обробки. FPU не має окремих блоків обробки для різних типів плаваючих крапок, які він підтримує.

Вікова порада, яка floatшвидша, ніж doubleзастосовувалася 100 років тому, коли більшість процесорів не мали вбудованих FPU (а у деяких людей були окремі мікросхеми FPU), тому більшість маніпуляцій з плаваючою точкою виконувались у програмному забезпеченні. На цих машинах (які живилися від пари, що утворюється в ямах лави) було швидше використовувати floats. Тепер єдиною реальною перевагою floats є те, що вони займають менше місця (що важливо лише у тому випадку, якщо їх у вас мільйони).

У мене був невеликий проект, де я використовував CUDA, і я пам’ятаю, що плаваючий показник там теж був швидшим, ніж подвійний. Одного разу трафік між хостом і пристроєм стає нижчим (хост - це центральний процесор і "звичайна" оперативна пам'ять, а пристрій - це графічний процесор і відповідна оперативна пам'ять). Але навіть якщо дані постійно зберігаються на Пристрої, це повільніше. Здається, я десь читав, що це нещодавно змінилося або має змінитися з наступним поколінням, але я не впевнений.

Отже, здається, що в цих випадках графічний процесор просто не може обробляти подвійну точність, що також пояснює, чому зазвичай використовується GLFloat, а не GLDouble.

(Як я вже говорив, це лише наскільки я пам’ятаю, просто натрапив на це під час пошуку float проти double на центральному процесорі.)

Проте все ще існують випадки, коли переважно плаваючі коди - наприклад, з кодуванням OpenGL набагато частіше застосовується тип даних GLFloat (як правило, що відображається безпосередньо на 16-бітний плаваючий), оскільки він є більш ефективним на більшості графічних процесорів, ніж GLDouble.

Це залежить від 32-розрядної або 64-розрядної системи. Якщо ви компілюєте до 64-розрядної, подвійне буде швидшим. Компільований до 32-розрядних на 64-розрядних (машина та ОС) змусив плавати близько 30% швидше:

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