Float vs Double Performance

J'ai fait des tests de synchronisation et j'ai également lu des articles comme celui-ci (dernier commentaire), et il semble que dans Release build, les valeurs flottantes et doubles 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 obtenir des doubles dans le même temps de traitement?

Sur les processeurs x86, au moins, floatet doubleseront chacun convertis en un réel de 10 octets par le FPU pour traitement. Le FPU n'a pas d'unités de traitement distinctes pour les différents types à virgule flottante qu'il prend en charge.

Le conseil séculaire qui floatest plus rapide qu'il y a double100 ans, lorsque la plupart des processeurs n'avaient pas de FPU intégrés (et peu de gens avaient des puces FPU distinctes), de sorte que la plupart des manipulations en virgule flottante étaient effectuées dans un logiciel. Sur ces machines (qui étaient alimentées par la vapeur générée par les fosses de lave), il était plus rapide d'utiliser floats. Maintenant, le seul avantage réel des floats est qu'ils prennent moins de place (ce qui n'a d'importance que si vous en avez des millions).

J'avais un petit projet où j'utilisais CUDA et je me souviens que le flotteur é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 sur l'appareil tout le temps, elles sont plus lentes. 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 GPU 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, ce n'est que pour autant que je me souvienne, je suis tombé sur cela en recherchant un flotteur ou un double sur un processeur.)

Cependant, il existe 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 en flottant 16 bits) car il est plus efficace sur la plupart des GPU que GLDouble.

Cela dépend du système 32 bits ou 64 bits . Si vous compilez en 64 bits, le double sera plus rapide. Compilé en 32 bits sur 64 bits (machine et système d'exploitation), le flottement a été 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);
    }