Partager via

Règles de virgule flottante (Direct3D 11)

Direct3D 11 prend en charge plusieurs représentations à virgule flottante. Tous les calculs en virgule flottante sont effectués selon un sous-ensemble défini des règles de la norme IEEE 754 pour les nombres à virgule flottante de précision simple 32 bits.

Règles de la virgule flottante 32 bits

Il existe deux ensembles de règles : celles qui sont conformes à IEEE-754 et celles qui s’écartent de la norme.

Règles IEEE-754 respectées

Certaines de ces règles sont une option unique où IEEE-754 offre des choix.

  • Diviser par 0 produit +/- INF, à l’exception de 0/0, ce qui entraîne naN.
  • Le journal de (+/-) 0 produit -INF. Le journal d'une valeur négative (autre que -0) produit NaN.
  • La racine carrée réciproque (rsq) ou la racine carrée (sqrt) d’un nombre négatif produit naN. L’exception est -0 ; sqrt(-0) produit -0 et rsq(-0) produit -INF.
  • INF - INF = NaN
  • (+/-)INF / (+/-)INF = NaN
  • (+/-)INF * 0 = NaN
  • NaN (tout OP) toute valeur = NaN
  • Les comparaisons EQ, GT, GE, LT et LE, lorsque l'un des opérandes ou les deux sont NaN, renvoient FALSE.
  • Les comparaisons ignorent le signe 0 (donc +0 est égal à -0).
  • La comparaison NE, lorsque l'un ou les deux opérandes sont NaN, renvoie TRUE.
  • Les comparaisons de n’importe quelle valeur non NaN par rapport à +/- INF retournent le résultat correct.

Écarts ou exigences supplémentaires des règles IEEE-754

  • IEEE-754 exige que les opérations en virgule flottante produisent un résultat qui soit la valeur représentable la plus proche d'un résultat infiniment précis, connu sous le nom d'arrondi au plus proche pair. Direct3D 11 définit la même exigence : les opérations en virgule flottante 32 bits produisent un résultat qui est à 0,5 unité de la dernière position (ULP) du résultat infiniment précis. Cela signifie que, par exemple, le matériel est autorisé à tronquer les résultats en 32 bits plutôt que d’effectuer des opérations round-to-near-even, car cela entraînerait une erreur d’au plus 0,5 ULP. Cette règle s’applique uniquement à l’ajout, à la soustraction et à la multiplication.

  • Il n'y a pas de prise en charge des exceptions, des bits d'état ou des interruptions en virgule flottante.

  • Les nombres dénormalisés sont convertis en zéros avec conservation du signe à l'entrée et à la sortie de toute opération mathématique à virgule flottante. Les exceptions sont effectuées pour toute opération d’E/S ou de déplacement de données qui ne manipule pas les données.

  • Les états contenant des valeurs à virgule flottante, tels que Viewport MinDepth/MaxDepth, les valeurs BorderColor, peuvent être fournis sous forme de valeurs dénormées et peuvent ou non être vidés avant que le matériel ne les utilise.

  • Les opérations Min ou Max vident les dénormes à des fins de comparaison, mais le résultat peut ou non être vidé de dénormes.

  • L'entrée NaN dans une opération produit toujours NaN en sortie. Mais le modèle de bits exact du NaN n’est pas nécessaire pour rester le même (sauf si l’opération est une instruction de déplacement brut , qui ne modifie pas les données.)

  • Les opérations minimales ou maximales pour lesquelles un seul opérande est NaN renvoient l’autre opérande en conséquence (contrairement aux règles de comparaison que nous avons examinées précédemment). Il s’agit d’une règle IEEE 754R.

    Les règles arithmétiques dans Direct3D 10 et versions ultérieures ne font aucune distinction entre les valeurs NaN « silencieux » et « signaling » (QNaN vs SNaN). Toutes les valeurs « NaN » sont gérées de la même façon.

  • Si les deux entrées à min() ou max() sont NaN, n’importe quelle naN est retournée.

  • Une règle IEEE 754R est que min(-0,+0) == min(+0,-0) == -0, et max(-0,+0) == max(+0,-0) == +0 ; qui respectent le signe. Cela contraste avec les règles de comparaison pour le zéro signé (indiquées ci-dessus). Direct3D 11 recommande le comportement IEEE 754R ici, mais ne l’applique pas ; il est possible que le résultat de la comparaison des zéros dépende de l’ordre des paramètres, à l’aide d’une comparaison qui ignore les signes.

  • x*1.0f donne toujours x (sauf si denorm flushed).

  • x/1.0f donne toujours x (sauf si denorm flushed).

  • x +/- 0.0f donne toujours x (sauf si denorm flushed). Mais -0 + 0 = +0.

  • Les opérations fusionnées (telles que mad, dp3) produisent des résultats qui ne sont pas moins précis que le pire ordre de série possible d’évaluation de l’expansion non fusionnée de l’opération. La définition du pire ordre possible, à des fins de tolérance, n’est pas une définition fixe pour une opération fusionnée donnée ; elle dépend des valeurs particulières des entrées. Les étapes individuelles de l'expansion non fusionnée ont chacune une tolérance de 1 ULP (ou pour toute instruction que Direct3D appelle avec une tolérance plus laxiste que 1 ULP, la tolérance plus laxiste est autorisée).

  • Les opérations fusionnées respectent les mêmes règles NaN que les opérations non fusionnées.

  • sqrt et rcp ont une tolérance de 1 ULP. Les instructions réciproques et réciproques de racine carrée de shader, rcp et rsq, ont leur propre exigence de précision assouplie.

  • Chaque opération de multiplication et de division s'effectue avec une précision en virgule flottante de 32 bits (précision de 0,5 ULP pour la multiplication, de 1,0 ULP pour la réciproque). Si x/y est implémenté directement, les résultats doivent être d’une précision supérieure ou égale à une méthode en deux étapes.

Règles à virgule flottante 64 bits (double précision)

Les pilotes matériels et d'affichage prennent en charge en option la virgule flottante à double précision. Pour indiquer le support, lorsque vous appelez ID3D11Device::CheckFeatureSupport avec D3D11_FEATURE_DOUBLES, le pilote définit DoublePrecisionFloatShaderOps de D3D11_FEATURE_DATA_DOUBLES à TRUE. Le pilote et le matériel doivent alors prendre en charge toutes les instructions à virgule flottante à double précision.

Les instructions de double précision suivent les exigences de comportement IEEE 754R.

La génération de valeurs dénormalisées est nécessaire pour les données en double précision (pas de comportement de mise à zéro). De même, les instructions ne lisent pas les données dénormalisées comme un zéro signé, elles respectent la valeur dénormalisée.

Règles de virgule flottante en 16 bits

Direct3D 11 prend également en charge les représentations 16 bits de nombres à virgule flottante.

Format :

  • 1 bit de signe (s) dans la position du bit MSB
  • 5 bits d'exposant biaisé (e)
  • 10 bits de fraction (f), avec un bit masqué supplémentaire

Une valeur float16 (v) suit les règles suivantes :

  • si e == 31 et f != 0, alors v est NaN indépendamment de s
  • si e == 31 et f == 0, puis v = (-1)s*infinity (infini signé)
  • si e est compris entre 0 et 31, alors v = (-1)s*2(e-15)*(1.f)
  • si e == 0 et f != 0, puis v = (-1)s*2(e-14)*(0.f) (nombres dénormalisés)
  • si e == 0 et f == 0, puis v = (-1)s*0 (zéro signé)

Les règles à virgule flottante 32 bits s'appliquent également aux nombres à virgule flottante 16 bits, en tenant compte de la disposition des bits décrite précédemment. Les exceptions à cela incluent :

  • Précision : les opérations non fusionnées sur des nombres à virgule flottante de 16 bits produisent un résultat qui est la valeur représentable la plus proche d'un résultat de précision infinie (arrondi au pair le plus proche, selon IEEE-754, appliqué à des valeurs de 16 bits). Les règles à virgule flottante 32 bits respectent la tolérance 1 ULP, les règles à virgule flottante 16 bits respectent 0,5 ULP pour les opérations non fusionnées et 0,6 ULP pour les opérations fusionnées.
  • Les nombres à virgule flottante de 16 bits conservent les dénormalisations.

Règles de virgule flottante 11 bits et 10 bits

Direct3D 11 prend également en charge les formats de virgule flottante 11 bits et 10 bits.

Format :

  • Aucun bit de signe
  • 5 bits d'exposant biaisé (e)
  • 6 bits de fraction (f) pour un format 11 bits, 5 bits de fraction (f) pour un format 10 bits, avec un bit masqué supplémentaire dans les deux cas.

Une valeur float11/float10 (v) suit les règles suivantes :

  • si e == 31 et f != 0, alors v est NaN
  • si e == 31 et f == 0, puis v = +infini
  • si e est compris entre 0 et 31, alors v = 2(e-15)*(1.f)
  • si e == 0 et f != 0, puis v = *2(e-14)*(0.f) (nombres dénormalisés)
  • si e == 0 et f == 0, puis v = 0 (zéro)

Les règles de virgule flottante 32 bits s'appliquent également aux nombres à virgule flottante 11 bits et 10 bits, ajustés en fonction de la disposition des bits décrite précédemment. Les exceptions sont les suivantes :

  • Précision : les règles de la virgule flottante 32 bits respectent la limite inférieure de précision de 0,5.
  • Les nombres en virgule flottante 10/11 bits conservent les dénormalisations.
  • Toute opération qui entraînerait un nombre inférieur à zéro est limitée à zéro.

Ressources

Textures