Float vs Double Performance

Eu fiz alguns testes de tempo e também li alguns artigos como este (último comentário), e parece que no Release build, os valores float e double levam a mesma quantidade de tempo de processamento.

Como isso é possível? Quando a flutuação é menos precisa e menor em comparação com os valores duplos, como o CLR pode obter dobras no mesmo tempo de processamento?

Em processadores x86, pelo menos, floate doublecada um será convertido em um real de 10 bytes pela FPU para processamento. A FPU não possui unidades de processamento separadas para os diferentes tipos de ponto flutuante que suporta.

O conselho antigo que floaté mais rápido do que o doubleaplicado há 100 anos, quando a maioria das CPUs não tinha FPUs embutidos (e poucas pessoas tinham chips FPU separados), então a maior parte da manipulação de ponto flutuante era feita em software. Nessas máquinas (que eram movidas a vapor gerado pelos poços de lava), era mais rápido usar floats. Agora, o único benefício real para floats é que eles ocupam menos espaço (o que só importa se você tiver milhões deles).

Tive um pequeno projeto em que usei CUDA e lembro que o float era mais rápido que o dobro também. Por uma vez, o tráfego entre o Host e o Dispositivo é menor (o Host é a CPU e a RAM "normal" e o Dispositivo é a GPU e a RAM correspondente ali). Mas mesmo que os dados residam no dispositivo o tempo todo, é mais lento. Acho que li em algum lugar que isso mudou recentemente ou deve mudar com a próxima geração, mas não tenho certeza.

Portanto, parece que a GPU simplesmente não consegue lidar com precisão dupla nativamente nesses casos, o que também explicaria porque o GLFloat é geralmente usado em vez do GLDouble.

(Como eu disse, só consigo me lembrar, apenas descobri isso enquanto procurava por float vs. double em uma CPU.)

Ainda existem alguns casos onde floats são preferidos - com a codificação OpenGL, por exemplo, é muito mais comum usar o tipo de dados GLFloat (geralmente mapeado diretamente para float de 16 bits), pois é mais eficiente na maioria das GPUs do que GLDouble.

Depende do sistema de 32 ou 64 bits . Se você compilar para 64 bits, o dobro será mais rápido. Compilado para 32 bits em 64 bits (máquina e sistema operacional) fez flutuar cerca de 30% mais rápido:

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