Flotteur vs double performance

Question

J'ai fait des tests de chronométrage et lu des articles tels que celui-ci (dernier commentaire). Il semble que, dans la version Release, les valeurs float et double prennent le même temps de traitement.

Comment est-ce possible? Lorsque le flottant est moins précis et plus petit que les valeurs doubles, comment le CLR peut-il doubler le même temps de traitement?

Answer 1

Sur les processeurs x86, au moins, float et double seront chacun convertis en un réel de 10 octets par la FPU pour traitement. La FPU ne dispose pas d'unités de traitement distinctes pour les différents types de virgule flottante qu'elle prend en charge.

Le conseil séculaire selon lequel float est plus rapide que le double appliqué il y a 100 ans lorsque la plupart des processeurs ne possédaient pas de FPU intégrées (et peu de personnes disposaient de FPU distinctes). puces), la plupart des manipulations en virgule flottante ont donc été effectuées par logiciel. Sur ces machines (alimentées par la vapeur générée par les fosses de lave), il était plus rapide d'utiliser des float . Maintenant, le seul avantage réel pour les float est qu’ils occupent moins d’espace (ce qui ne compte que si vous en avez des millions).

Answer 2

J'avais un petit projet où j'avais utilisé CUDA et je me souviens que le flottant était plus rapide que le double là aussi. Pour une fois, le trafic entre l'hôte et le périphérique est plus faible (l'hôte est le CPU et la RAM "normale" et le périphérique est le GPU et la RAM correspondante). Mais même si les données résident tout le temps sur le périphérique, cela ralentit. Je pense avoir lu quelque part que cela a changé récemment ou est censé changer avec la prochaine génération, mais je ne suis pas sûr.

Il semble donc que le processeur graphique ne puisse tout simplement pas gérer la double précision de manière native dans ces cas, ce qui expliquerait également pourquoi GLFloat est généralement utilisé plutôt que GLDouble.

(Comme je l’ai dit, c’est seulement si je me souviens bien, je suis tombé par hasard sur cette question tout en recherchant float vs double sur un CPU.)

Answer 3

Cela dépend du système 32 bits ou 64 bits . Si vous compilez en 64 bits, double sera plus rapide. Compilé en 32 bits sur 64 bits (machine et système d’exploitation), le flottement est environ 30% plus rapide:

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

Answer 4

Il y a encore des cas où les flottants sont préférés - avec le codage OpenGL par exemple, il est beaucoup plus courant d'utiliser le type de données GLFloat (généralement mappé directement sur 16 bits) car il est plus efficace que GLDouble sur la plupart des GPU.