Delen via

Regels voor zwevendekomma (Direct3D 11)

  • Artikel

Direct3D 11 ondersteunt verschillende drijvende-komma representaties. Alle drijvendekommaberekeningen worden uitgevoerd onder een gedefinieerde subset van de IEEE 754 32-bits drijvendekommaregels met enkelvoudige precisie.

32-bit drijvende-komma regels

Er zijn twee sets regels: regels die voldoen aan IEEE-754 en regels die afwijken van de standaard.

Gehonoreerde IEEE-754-regels

Sommige van deze regels zijn één optie waarbij IEEE-754 opties biedt.

  • Delen door 0 produceert +/- INF, behalve 0/0, wat resulteert in NaN.
  • Logaritme van (+/-) 0 levert -INF op. logaritme van een negatieve waarde (anders dan -0) levert NaN op.
  • Reciproque vierkantswortel (rsq) of vierkantswortel (sqrt) van een negatief getal resulteert in NaN. De uitzondering is -0; sqrt(-0) produceert -0 en rsq(-0) produceert -INF.
  • INF - INF = NaN
  • (+/-)INF / (+/-)INF = NaN
  • (+/-)INF * 0 = NaN
  • NaN (any OP) any-value = NaN
  • De vergelijkingen EQ, GT, GE, LT en LE, wanneer een of beide operanden NaN is, retourneren FALSE.
  • Vergelijkingen negeren het teken van 0 (dus +0 is gelijk aan -0).
  • De vergelijking NE, wanneer een van beide operanden of beide NaN zijn, retourneert TRUE.
  • Vergelijkingen van een niet-NaN-waarde ten opzichte van +/- INF retourneren het juiste resultaat.

Afwijkingen of aanvullende vereisten van IEEE-754-regels

  • IEEE-754 vereist drijvende-kommabewerkingen om een resultaat te produceren dat de dichtstbijzijnde vertegenwoordigbare waarde is voor een oneindig nauwkeurig resultaat, ook wel round-to-nearest-even genoemd. Direct3D 11 definieert dezelfde vereiste: 32-bits drijvendekommabewerkingen produceren een resultaat dat binnen 0,5 ULP (unit-last-place) van het oneindig nauwkeurige resultaat ligt. Dit betekent dat hardware bijvoorbeeld de resultaten mag afkappen tot 32-bits in plaats van round-to-nearest-even uit te voeren, omdat dit tot een fout van maximaal 0,5 ULP zou leiden. Deze regel geldt alleen voor optellen, aftrekken en vermenigvuldigen.

  • Er is geen ondersteuning voor drijvendekomma-uitzonderingen, status-bits of traps.

  • Denormalisaties worden bij invoer en uitvoer van een zwevendekommabewerking teruggebracht naar nul met behoud van het teken. Er worden uitzonderingen gemaakt voor een I/O- of gegevensverplaatsingsbewerking die de gegevens niet bewerkt.

  • Toestanden die zwevend-komma waarden bevatten, zoals Viewport MinDepth/MaxDepth en BorderColor waarden, kunnen worden opgegeven als denormwaarden en kunnen al dan niet worden gewist voordat de hardware ze gebruikt.

  • Min- of max-bewerkingen negeren denormen voor vergelijking, maar het resultaat kan mogelijk wel of niet denorm zijn.

  • NaN-invoer voor een bewerking produceert altijd NaN op uitvoer. Maar het exacte bitpatroon van de NaN is niet vereist om hetzelfde te blijven (tenzij de bewerking een onbewerkte verplaatsingsinstructie is - die geen gegevens wijzigt.)

  • Minimale of maximale bewerkingen waarvoor slechts één operand NaN is, retourneert de andere operand als resultaat (in tegenstelling tot vergelijkingsregels die we eerder hebben bekeken). Dit is een IEEE 754R-regel.

    De rekenkundige regels in Direct3D 10 en hoger maken geen onderscheid tussen 'stille' en 'signalering' NaN-waarden (QNaN versus SNaN). Alle 'NaN'-waarden worden op dezelfde manier verwerkt.

  • Als beide invoerwaarden voor min() of max() NaN zijn, wordt een NaN geretourneerd.

  • Een IEEE 754R-regel is dat min(-0,+0) == min(+0,-0) == -0 en max(-0,+0) == max(+0,-0) == +0; die het teken eren. Dat is in tegenstelling tot de vergelijkingsregels voor ondertekende nul (hierboven vermeld). Direct3D 11 raadt hier het IEEE 754R-gedrag aan, maar dwingt dit niet af; het is toegestaan dat het resultaat van het vergelijken van nullen afhankelijk is van de volgorde van parameters, met behulp van een vergelijking die de tekens negeert.

  • x*1,0f resulteert altijd in x (behalve denorm leeggemaakt).

  • x/1,0f resulteert altijd in x (behalve denorm leeggemaakt).

  • x +/- 0,0f resulteert altijd in x (behalve denorm leeggemaakt). Maar -0 + 0 = +0.

  • Gefuseerde operaties (zoals mad, dp3) leveren resultaten op die niet minder nauwkeurig zijn dan de slechtst mogelijke seriële volgorde van de evaluatie van de ongefuseerde uitbreiding van de bewerking. De definitie van de slechtst mogelijke volgorde, met het oog op tolerantie, is geen vaste definitie voor een bepaalde gefuseerde bewerking; dit hangt af van de specifieke waarden van de invoer. De afzonderlijke stappen in de niet-samengevoegde uitbreiding zijn elk toegestaan 1 ULP-tolerantie (of voor instructies die Direct3D aanroept met een meer laxtolerantie dan 1 ULP, hoe meer laxtolerantie is toegestaan).

  • Samengevoegde bewerkingen voldoen aan dezelfde NaN-regels als niet-samengevoegde bewerkingen.

  • sqrt en rcp hebben 1 ULP-tolerantie. De shader-instructies voor reciprociteit en omgekeerde vierkantswortel, rcp en rsq, hebben hun eigen afzonderlijke gerelaxeerde precisievereiste.

  • Vermenigvuldig en deel elke bewerking op het 32-bits precisieniveau van drijvende komma (nauwkeurigheid tot 0,5 ULP voor vermenigvuldigen, 1,0 ULP voor wederkerig). Als x/y rechtstreeks wordt geïmplementeerd, moeten de resultaten groter of gelijk zijn aan de nauwkeurigheid dan een methode in twee stappen.

64-bit regels voor drijvende-komma-getallen (dubbele precisie)

Hardware- en weergavestuurprogramma's bieden optioneel ondersteuning voor drijvende komma met dubbele precisie. Als u ondersteuning wilt aangeven, stelt het stuurprogramma de DoublePrecisionFloatShaderOps van D3D11_FEATURE_DATA_DOUBLES in op TRUE wanneer u ID3D11Device::CheckFeatureSupport met D3D11_FEATURE_DOUBLESaanroept. Het stuurprogramma en de hardware moeten vervolgens alle instructies voor drijvende komma's met dubbele precisie ondersteunen.

Dubbele precisie-instructies volgen de IEEE 754R-gedragsvereisten.

Ondersteuning voor het genereren van gedenormaliseerde waarden is vereist voor dubbele precisiegegevens (geen gedrag voor leegmaken naar nul). Instructies lezen ook geen gedenormaliseerde gegevens als een getekende nul; zij behouden de denormwaarde.

16-bits regels voor drijvende komma

Direct3D 11 ondersteunt ook 16-bits weergaven van floating-pointgetallen.

Opmaak:

  • 1 teken-bit (s)in de MSB-bitpositie
  • 5 bits van vertekende exponent (e)
  • 10 bits van een fractiebits (f), met een extra verborgen bit

Een float16-waarde (v) volgt deze regels:

  • als e == 31 en f != 0, is v NaN, ongeacht s
  • als e == 31 en f == 0, dan v = (-1)s*oneindigheid (ondertekend oneindig)
  • als e tussen 0 en 31 ligt, dan v = (-1)s*2(e-15)*(1.f)
  • als e == 0 en f != 0, dan v = (-1)s*2(e-14)*(0.f) (gedenormaliseerde getallen)
  • als e == 0 en f == 0, dan v = (-1)s*0 (ondertekend nul)

32-bits drijvende-kommaregels gelden ook voor 16-bits drijvende-kommanummers, aangepast aan de eerder beschreven bitindeling. Uitzonderingen hierop zijn:

  • Precisie: Niet-samengevoegde bewerkingen op 16-bits drijvendekommanummers produceren een resultaat dat de dichtstbijzijnde vertegenwoordigbare waarde is voor een oneindig nauwkeurig resultaat (afgerond op dichtstbijzijnde even, per IEEE-754, toegepast op 16-bits waarden). 32-bits drijvendekommaregels hebben een ULP-tolerantie van 1, 16-bits drijvendekommaregels hebben een ULP van 0,5 voor ongedeelde bewerkingen en 0,6 ULP voor gecombineerde bewerkingen.
  • 16-bits halfprecisie getallen behouden denormalen.

11-bit en 10-bit drijvendekommaregels

Direct3D 11 ondersteunt ook 11-bits en 10-bits drijvende-kommaformaten.

Indeling:

  • Geen tekenbit
  • 5 bits van vertekende exponent (e)
  • 6 bits van de breuk (f) voor een 11-bits formaat, 5 bits van de breuk (f) voor een 10-bits formaat, met in beide gevallen een extra verborgen bit.

Een float11/float10-waarde (v) volgt de volgende regels:

  • als e == 31 en f != 0, is v NaN
  • als e == 31 en f == 0, dan v = +oneindig
  • als e tussen 0 en 31 ligt, dan v = 2(e-15)*(1.f)
  • als e == 0 en f != 0, dan v = *2(e-14)*(0,f) (gedenormaliseerde getallen)
  • als e == 0 en f == 0, dan v = 0 (nul)

Voor 32-bits drijvendekommapunten gelden dezelfde regels ook voor 11-bits en 10-bits drijvendekommanummers, aangepast voor de eerder beschreven bitindeling. Uitzonderingen zijn:

  • Precisie: 32-bits regels voor drijvende komma voldoen aan 0,5 ULP.
  • 10/11-bit drijvende-kommagetallen behouden denormen.
  • Elke bewerking die tot een getal kleiner dan nul zou leiden, wordt vastgeklemd tot nul.

Hulpmiddelen

texturen