Les méthodes SSE et SSE2 CompareGreaterThan gèrent correctement les entrées NaN

  • Article

Les méthodes System.Runtime.Intrinsics.X86.Sse et System.Runtime.Intrinsics.X86.Sse2 suivantes ont été corrigées pour gérer correctement les entrées NaN et correspondre au comportement matériel des méthodes équivalentes dans la classe System.Runtime.Intrinsics.X86.Avx :

  • CompareGreaterThan
  • CompareGreaterThanOrEqual
  • CompareNotGreaterThan
  • CompareNotGreaterThanOrEqual
  • CompareScalarGreaterThan
  • CompareScalarGreaterThanOrEqual
  • CompareScalarNotGreaterThan
  • CompareScalarNotGreaterThanOrEqual

Description de la modification

Auparavant, les entrées NaN des méthodes répertoriées Sse et Sse2 renvoyaient un résultat incorrect. Le résultat diffère également du résultat généré par la méthode correspondante dans la classe Avx.

À compter de .NET 5, ces méthodes gèrent correctement les entrées NaN et retournent les mêmes résultats que les méthodes correspondantes dans la classe Avx.

Les architectures standard du secteur (ISA) SSE (Streaming SIMD Extensions) et SSE2 (Streaming SIMD Extensions 2) ne fournissent pas de prise en charge matérielle directe pour ces méthodes de comparaison. Elles sont donc implémentées dans les logiciels. Auparavant, les méthodes étaient implémentées de manière incorrecte et elles géraient incorrectement les entrées NaN. Pour le code porté à partir du mode natif, le comportement incorrect peut introduire des bogues. Pour un chemin de code 256 bits, les méthodes peuvent également produire des résultats différents aux méthodes équivalentes dans la classe Avx.

À titre d’exemple de la façon dont les méthodes étaient précédemment incorrectes, vous pouvez implémenter CompareNotGreaterThan(x,y) comme CompareLessThanOrEqual(x,y) pour les entiers standard. Toutefois, pour les entrées NaN, cette logique calcule le mauvais résultat. Au lieu de cela, l’utilisation de CompareNotLessThan(y,x) compare correctement les nombres et prend les entrées NaN en considération.

Version introduite

5,0

  • Si le comportement précédent était un bogue, aucune modification n’est requise.

  • Si le comportement précédent était souhaité, vous pouvez conserver ce comportement en modifiant l’appel approprié comme suit :

    • CompareGreaterThan(x,y) ->CompareNotLessThanOrEqual(x,y)
    • CompareGreaterThanOrEqual(x,y) ->CompareNotLessThan(x,y)
    • CompareNotGreaterThan(x,y) ->CompareLessThanOrEqual(x,y)
    • CompareNotGreaterThanOrEqual(x,y) ->CompareLessThan(x,y)
    • CompareScalarGreaterThan(x,y) ->CompareScalarNotLessThanOrEqual(x,y)
    • CompareScalarGreaterThanOrEqual(x,y) ->CompareScalarNotLessThan(x,y)
    • CompareScalarNotGreaterThan(x,y) ->CompareScalarLessThanOrEqual(x,y)
    • CompareScalarNotGreaterThanOrEqual(x,y) ->CompareScalarLessThan(x,y)

API affectées