Compartilhar via

Regras de ponto flutuante (Direct3D 11)

  • Artigo

O Direct3D 11 dá suporte a várias representações de ponto flutuante. Todos os cálculos de ponto flutuante operam sob um subconjunto definido das regras de ponto flutuante de precisão única do IEEE 754 de 32 bits.

Regras de ponto flutuante de 32 bits

Há dois conjuntos de regras: aqueles que estão em conformidade com o IEEE-754 e aqueles que se desviam do padrão.

Respeitadas as regras do IEEE-754

Algumas dessas regras são uma única opção em que o IEEE-754 oferece opções.

  • Dividir por 0 produz +/- INF, exceto 0/0 que resulta em NaN.
  • log de (+/-) 0 produz -INF. o log de um valor negativo (diferente de -0) produz NaN.
  • Raiz quadrada recíproca (rsq) ou raiz quadrada (sqrt) de um número negativo produz NaN. A exceção é -0; sqrt(-0) produz -0 e rsq(-0) produz -INF.
  • INF - INF = NaN
  • (+/-)INF / (+/-)INF = NaN
  • (+/-)INF * 0 = NaN
  • NaN (qualquer OP) qualquer valor = NaN
  • As comparações EQ, GT, GE, LT e LE, quando um ou ambos os operandos são NaN, retornam FALSE.
  • As comparações ignoram o sinal de 0 (portanto, +0 é igual a -0).
  • O NE de comparação, quando um ou ambos os operandos são NaN, retorna TRUE.
  • Comparações de qualquer valor não NaN em relação a +/- INF retornam o resultado correto.

Desvios ou requisitos adicionais das regras do IEEE-754

  • O IEEE-754 requer que operações de ponto flutuante produzam um resultado que seja o valor representável mais próximo de um resultado infinitamente preciso, conhecido como arredondamento para o par mais próximo. Direct3D 11 define o mesmo requisito: as operações de ponto flutuante de 32 bits produzem um resultado que está dentro de 0,5 ulp (unit-last-place) do resultado infinitamente preciso. Isso significa que, por exemplo, o hardware pode truncar os resultados para 32 bits em vez de arredondar para o par mais próximo, pois isso resultaria em um erro de no máximo 0,5 ULP. Essa regra se aplica somente a adição, subtração e multiplicação.

  • Não há suporte para exceções de ponto flutuante, bits de status ou interceptações.

  • Números desnormalizados são liberados para zero com sinal preservado na entrada e saída de qualquer operação matemática de ponto flutuante. Exceções são feitas para qualquer operação de movimentação de dados ou de E/S que não manipule os dados.

  • Estados que contêm valores de ponto flutuante, como Viewport MinDepth/MaxDepth e BorderColor, podem ser fornecidos como valores de número desnormalizado e podem ou não ser liberados antes que o hardware os utilize.

  • Operações mínimas ou máximas liberam números desnormalizados para comparação, mas o resultado pode ou não ser a liberação de números desnormalizados.

  • A entrada de NaN em uma operação sempre resulta em NaN na saída. Mas o padrão de bit exato do NaN não é necessário para permanecer o mesmo (a menos que a operação seja uma instrução de movimentação bruta - que não altere os dados).)

  • Operações mínimas ou máximas para as quais apenas um operando é NaN retornam o outro operando como resultado (ao contrário das regras de comparação que examinamos anteriormente). Esta é uma regra IEEE 754R.

    As regras aritméticas no Direct3D 10 e posteriores não fazem distinções entre valores de NaN "quieto" e "de sinalização" (QNaN vs SNaN). Todos os valores "NaN" são tratados da mesma maneira.

  • Se ambas as entradas para min() ou max() forem NaN, qualquer NaN será retornado.

  • Uma regra do IEEE 754R é que min(-0,+0) == min(+0,-0) == -0 e max(-0,+0) == max(+0,-0) == +0, respeitando o sinal. Isso contrasta com as regras de comparação para zero sinalizado (mencionadas acima). O Direct3D 11 recomenda o comportamento do IEEE 754R aqui, mas não o impõe; é permitido que o resultado da comparação de zeros dependa da ordem dos parâmetros, usando uma comparação que ignora os sinais.

  • x*1.0f sempre resulta em x (exceto número desnormalizado liberado).

  • x/1.0f sempre resulta em x (exceto número desnormalizado liberado).

  • x +/- 0.0f sempre resulta em x (exceto número desnormalizado liberado). Mas -0 + 0 = +0.

  • Operações conectadas (como mad, dp3) produzem resultados que não são menos precisos do que a pior sequência serial possível de avaliação da expansão desconectada da operação. A definição da pior ordenação possível, para fins de tolerância, não é uma definição fixa para uma determinada operação fundida; depende dos valores específicos das entradas. Cada uma das etapas individuais na expansão desconectada tem uma tolerância permitida de 1 ULP (ou para qualquer instrução que Direct3D chamar com tolerância mais frouxa do que 1 ULP, a tolerância mais frouxa é permitida).

  • Operações fundidas seguem as mesmas regras de NaN que operações não fundidas.

  • sqrt e rcp têm tolerância de 1 ULP. As instruções recíprocas e recíprocas de raiz quadrada, rcp e rsq, têm seu próprio requisito de precisão relaxada.

  • As operações de multiplicação e divisão operam no nível de precisão de ponto flutuante de 32 bits (precisão de 0,5 ULP para multiplicação e 1,0 ULP para recíproca). Se x/y for implementado diretamente, os resultados deverão ser de precisão maior ou igual a um método de duas etapas.

Regras de ponto flutuante de 64 bits (precisão dupla)

Os drivers de hardware e vídeo opcionalmente dão suporte para ponto flutuante de precisão dupla. Para indicar suporte, quando você chama ID3D11Device::CheckFeatureSupport com D3D11_FEATURE_DOUBLES, o driver define DoublePrecisionFloatShaderOps de D3D11_FEATURE_DATA_DOUBLES como TRUE. O driver e o hardware devem dar suporte a todas as instruções de ponto flutuante de precisão dupla.

Instruções de precisão dupla seguem os requisitos de comportamento do IEEE 754R.

O suporte para geração de valores desnormalizados é necessário para dados de precisão dupla (sem comportamentos de liberação para zero). Da mesma forma, as instruções não leem dados desnormalizados como se fossem zero com sinal, elas respeitam o valor desnormalizado.

Regras de ponto flutuante de 16 bits

O Direct3D 11 também dá suporte a representações de 16 bits de números de ponto flutuante.

Formato:

  • 1 bit de sinal (s) na posição do bit MSB
  • 5 bits de expoente tendencioso (e)
  • 10 bits de fração (f), com um bit oculto adicional

Um valor float16 (v) segue estas regras:

  • se e == 31 e f != 0, v é NaN independentemente de s
  • se e == 31 e f == 0, então v = (-1)s*infinidade (infinito assinado)
  • se e estiver entre 0 e 31, v = (-1)s*2(e-15)*(1.f)
  • se e == 0 e f != 0, v = (-1)s*2(e-14)*(0.f) (números desnormalizados)
  • se e == 0 e f == 0, então v = (-1) s*0 (zero com sinal)

As regras de ponto flutuante de 32 bits também são aplicadas para números de ponto flutuante de 16 bits, ajustadas para o layout de bits descrito anteriormente. As exceções a isso incluem:

  • Precisão: as operações desconectadas em números de ponto flutuante de 16 bits produzem um resultado que é o valor representável mais próximo de um resultado infinitamente preciso (arredondar para o par mais próximo, de acordo com o IEEE-754, aplicado a valores de 16 bits). As regras de ponto flutuante de 32 bits seguem uma tolerância de 1 ULP, regras de ponto flutuante de 16 bits seguem 0,5 ULP para operações não fundidas e 0,6 ULP para operações fundidas.
  • Números de ponto flutuante de 16 bits preservam números desnormalizados.

Regras de 11 bits e 10 bits para ponto flutuante

O Direct3D 11 também dá suporte a formatos de ponto flutuante de 11 bits e 10 bits.

Formato:

  • Nenhum bit com sinal
  • 5 bits de expoente tendencioso (e)
  • 6 bits de fração (f) para um formato de 11 bits, 5 bits de fração (f) para um formato de 10 bits, com um bit oculto adicional em ambos os casos.

Um valor float11/float10 (v) segue as seguintes regras:

  • se e == 31 e f != 0, v é NaN
  • se e == 31 e f == 0, v = +infinito
  • se e estiver entre 0 e 31, v = 2(e-15)*(1.f)
  • se e == 0 e f != 0, v = *2(e-14)*(0.f) (números desnormalizados)
  • se e == 0 e f == 0, v = 0 (zero)

As regras de ponto flutuante de 32 bits também se aplicam a números de ponto flutuante de 11 bits e 10 bits, ajustadas para a configuração de bits descrita anteriormente. As exceções incluem:

  • Precisão: as regras de ponto flutuante de 32 bits seguem a ULP 0,5.
  • Números de ponto flutuante de 10/11 bits preservam números desnormalizados.
  • Qualquer operação que resulte em um número menor que zero é fixada a zero.

Recursos

Texturas