web-dev-qa-db-fra.com

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 la version Release, les valeurs flottantes et doubles prennent le même temps de traitement.

Comment est-ce possible? Lorsque le flotteur est moins précis et plus petit par rapport aux valeurs doubles, comment le CLR peut-il obtenir des doubles dans le même temps de traitement?

c#.netclrperformance
88
Joan Venge

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

Le conseil séculaire selon lequel float est plus rapide que double appliqué il y a 100 ans lorsque la plupart des processeurs n'avaient pas de FPU intégrés (et peu de gens avaient des puces FPU séparées), donc la plupart flottant- la manipulation des points a été effectuée dans le logiciel. Sur ces machines (qui étaient alimentées par Steam généré par les fosses de lave), il était plus rapide d'utiliser floats. Désormais, le seul avantage réel de floats est qu'il prend moins de place (ce qui n'a d'importance que si vous en avez des millions).

146
P Daddy

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 le "normal" RAM et le périphérique est le GPU et le RAM là-bas) correspondant) Mais même si les données résident sur l'appareil tout le temps, c'est plus lent. 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 peut tout simplement pas gérer la double précision en natif 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 m'en souvienne, je suis juste tombé dessus lors de la recherche de float vs double sur un CPU.)

14
Mene

Cela dépend du système 2 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 flotteur 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);
    }
12
Bitterblue

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

11
Cruachan