Duplos mais rápidas do que flutua em C #?

https://stackoverflow.com/questions/158889

03-07-2019
|

Pergunta

Eu estou escrevendo um aplicativo que lê grandes conjuntos de carros alegóricos e realiza algumas operações simples com eles. Estou usando carros alegóricos, porque eu pensei que seria mais rápido do que dobra, mas depois de fazer alguma pesquisa descobri que há alguma confusão sobre este tema. Alguém pode explicar isso?

Solução

A resposta curta é, "é necessário usar qualquer precisão para resultados aceitáveis."

Seu uma garantia é que as operações realizadas em dados de ponto flutuante são feitas em, pelo menos, o mais alto membro precisão da expressão. Assim, multiplicando dois flutuador 's é feito com, pelo menos, a precisão de flutuador , e multiplicando a flutuador e duplo seria feito com pelo menos o dobro de precisão. Os estados padrão que "[ponto flutuante] operações podem ser executadas com maior precisão do que o tipo de resultado da operação."

Dado que o JIT para o .NET tentativas de deixar suas operações de ponto flutuante na precisão solicitado, podemos dar uma olhada em documentação da Intel para acelerar nossas operações. Na plataforma Intel suas operações de ponto flutuante pode ser feito em uma precisão intermediária de 80 bits, e converteu-se com a precisão requerida.

De guia da Intel para C ++ operações de ponto flutuante ¹ (desculpe só tem árvore morta), eles mencionam:

Use um único tipo de precisão (por exemplo, float) a menos que o maior precisão obtida através de casal ou long double é necessária. Maiores tipos de precisão aumentar os requisitos de tamanho de memória e largura de banda. ...

Evite expressões aritméticas tipo de dados misto

Esse último ponto é importante porque pode retardar -se para baixo com elencos desnecessários de / para float e double , que resultam em código JIT'd que solicita o x87 com elenco longe de seu formato intermediário de 80 bits entre operações!

1. Sim, ele diz que C ++, mas o C # padrão, além de conhecimento do CLR permite-nos saber as informações para C ++ deve ser aplicável neste caso.

Outras dicas

Acabei de ler o "Desenvolvimento .NET Framework-Microsoft Application Foundation 2" para o exame MCTS 70-536 e há uma nota na página 4 (capítulo 1):

Otimizando o desempenho NOTA com built-in tipos
O tempo de execução de optimizar o desempenho de tipos inteiro de 32-bit (Int32 e UInt32), então utilizar esses tipos de contadores e outras variáveis ??integrais frequentemente acedidos. Para as operações de ponto flutuante, duplo é o tipo mais eficiente porque essas operações são otimizados por hardware.

É escrito por Tony Northrup. Eu não sei se ele é uma autoridade ou não, mas eu esperaria que o livro oficial para o exame .NET deve ter algum peso. É claro que não um gaurantee. Eu apenas pensei que eu iria adicioná-lo a esta discussão.

Eu perfilado uma pergunta semelhante há algumas semanas. A linha inferior é que para x86 hardware, não há diferença significativa no desempenho dos carros alegóricos contra duplas, a menos que você se tornar memória ligada, ou você começar a correr em questão cache. Nesse caso flutua geralmente têm a vantagem porque eles são menores.

atual Intel CPUs realizar todas as operações de ponto flutuante em 80 bit registros de largura de modo a velocidade real da computação não deve variar entre carros alegóricos e duplos.

Se as operações de carga e da loja são o gargalo, então flutua será mais rápido, porque eles são menores. Se você estiver fazendo um número significativo de cálculos entre cargas e lojas, deve ser aproximadamente igual.

Alguém mencionou evitando conversões entre flutuante e dupla, e cálculos que utilizam operandos de ambos os tipos. É um bom conselho, e se você usar quaisquer funções de biblioteca de matemática que duplos de retorno (por exemplo), em seguida, manter tudo como duplos será mais rápido.

Eu estou escrevendo um traçador de raios, e substituindo os carros alegóricos com camas de casal para minha classe Color me dá um aumento de velocidade de 5%. Substituindo os vetores flutua com duplas é outro 5% mais rápido! Muito legal:)

Isso é com um Core i7 920

Com 387 FPU aritmética, flutuador só é mais rápido do que o dobro para certas operações iterativos longos como prisioneiro de guerra, log, etc (e somente se o compilador define a palavra de controle FPU apropriadamente).

Com embalado SSE aritmética, faz uma grande diferença embora.

Matthijs,

Você está errado. 32-bit é muito mais eficiente do que o de 16 bits -. Em processadores modernos ... Talvez não-memória sábio, mas na eficácia de 32 bits é o caminho a percorrer

Você realmente deve atualizar seu professor para algo mais "up-to-date". ;)

De qualquer forma, para responder à pergunta; float e double tem exatamente o mesmo desempenho, pelo menos na minha Intel i7 870 (como na teoria).

Aqui estão minhas medidas:

(eu fiz uma "algoritmo" que eu repetido para 10.000.000 vezes, e depois repetiu isso por 300 vezes, e fora do que eu fiz uma média.)

double
-----------------------------
1 core  = 990 ms
4 cores = 340 ms
6 cores = 282 ms
8 cores = 250 ms

float
-----------------------------
1 core  = 992 ms
4 cores = 340 ms
6 cores = 282 ms
8 cores = 250 ms

Isso indica que flutua são ligeiramente mais rápido do que dobra: http://www.herongyang.com /cs_b/performance.html

Em geral, qualquer vez que você faz uma comparação sobre o desempenho, você deve levar em conta quaisquer casos especiais, como faz usando um tipo requerem conversões ou dados adicionais massageando? Aqueles somar e pode desmentir benchmarks genéricos como esta.

flutua deve ser mais rápido em um sistema de 32 bits, mas o perfil do código para se certificar de que você está otimizando a coisa certa.

Eu sempre pensei que os processadores foram otimizados ou o mesmo, independentemente de float ou double. Busca de otimizações em meus cálculos intensivos (muitos recebe a partir de uma matriz, comparações de dois valores) eu descobri que flutua executar cerca de 13% mais rápido.

Isso me surpreendeu, mas eu acho que é devido à natureza do meu problema. Eu não faço conversões entre float e double no núcleo das operações, e os meus cálculos são principalmente adição, multiplicação e subtração.

Esta é a minha i7 920, executando um sistema operacional de 64 bits.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow