Float vs Double Performance

Ho fatto alcuni test di temporizzazione e ho letto anche alcuni articoli come questo (ultimo commento), e sembra che nella build di rilascio, i valori float e double richiedano la stessa quantità di tempo di elaborazione.

Com'è possibile? Quando il float è meno preciso e più piccolo rispetto ai valori doppi, come può il CLR raddoppiare nello stesso tempo di elaborazione?

Almeno sui processori x86, floate doubleciascuno verrà convertito in un reale a 10 byte dall'FPU per l'elaborazione. L'FPU non dispone di unità di elaborazione separate per i diversi tipi di virgola mobile che supporta.

Il vecchio consiglio che floatè più veloce di quanto doubleapplicato 100 anni fa, quando la maggior parte delle CPU non disponeva di FPU incorporate (e poche persone avevano chip FPU separati), quindi la maggior parte della manipolazione in virgola mobile veniva eseguita nel software. Su queste macchine (che erano alimentate dal vapore generato dalle fosse di lava), era più veloce usare floats. Ora l'unico vero vantaggio di floats è che occupano meno spazio (il che conta solo se ne hai milioni).

Avevo un piccolo progetto in cui ho usato CUDA e posso ricordare che anche lì il float era più veloce del doppio. Per una volta il traffico tra Host e Device è inferiore (Host è la CPU e la RAM "normale" e Device è la GPU e la RAM corrispondente lì). Ma anche se i dati risiedono sul dispositivo tutto il tempo, è più lento. Penso di aver letto da qualche parte che questo è cambiato di recente o dovrebbe cambiare con la prossima generazione, ma non ne sono sicuro.

Quindi sembra che la GPU semplicemente non possa gestire la doppia precisione in modo nativo in quei casi, il che spiegherebbe anche perché di solito viene utilizzato GLFloat piuttosto che GLDouble.

(Come ho detto è solo per quanto posso ricordare, mi sono imbattuto in questo durante la ricerca di float vs double su una CPU.)

Tuttavia, ci sono ancora alcuni casi in cui i float sono preferiti: con la codifica OpenGL, ad esempio, è molto più comune utilizzare il tipo di dati GLFloat (generalmente mappato direttamente su float a 16 bit) poiché è più efficiente sulla maggior parte delle GPU rispetto a GLDouble.

Dipende dal sistema a 32 o 64 bit . Se compili a 64 bit, double sarà più veloce. Compilato a 32 bit su 64 bit (macchina e sistema operativo) ha reso fluttuante circa il 30% più veloce:

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