Quand dois-je utiliser le mot-clé "strictfp" en java?

Wikipedia a en fait un bon article sur ce sujet ici , avec un lien vers la spécification Java.

lecture entre les lignes , l'implication est que si vous ne spécifiez pas strictfp , alors le JVM et JIT compilateur ont la licence pour calculer vos calculs à virgule flottante comme ils le veulent. Dans l'intérêt de la vitesse, ils vont très probablement déléguer le calcul à votre processeur. Avec strictfp , les calculs ont pour se conformer aux normes arithmétiques IEEE 754, qui, dans la pratique, signifie probablement que la JVM fera le calcul.

alors pourquoi utiliser strictfp ? Un scénario que je peux voir est dans une application distribuée (ou un jeu multijoueur) où tous les calculs à virgule flottante doivent être déterministes, peu importe le matériel sous-jacent ou CPU. Quel est le trade-off? Les plus susceptibles de temps d'exécution.

voici plusieurs références:

• à l'Aide de strictfp (JDC Conseil technique)

• jGuru: à quoi sert le modificateur strictfp? Quand devrais-je envisager de l'utiliser?

  fondamentalement, ce à quoi tout se résume est de savoir si oui ou non vous vous souciez que les résultats des expressions à virgule flottante dans votre code sont rapides ou prévisibles. Par exemple, si vous avez besoin d' les réponses que votre code trouve qui utilise des valeurs à virgule flottante pour être cohérent sur plusieurs plates-formes puis utiliser strictfp .

• strictfp - Java Glossary

  matériel de point Flottant calcule avec plus de précision, et avec une plus grande gamme de valeurs que la spécification de Java exige. Il serait déroutant que certaines plates-formes donnent plus de précision que d'autres. Lorsque vous utilisez le modificateur strictfp sur une méthode ou une classe, le compilateur génère du code qui adhère strictement aux spécifications Java pour des résultats identiques sur toutes les plateformes. Sans strictfp , il est un peu plus laxiste, mais pas au point d'utiliser les bits de garde du Pentium pour donner 80 bits de précision.

• et enfin la spécification Java Language actuelle, §15.4 FP-strict Expressions :

  dans une expression FP-strict, toutes les valeurs intermédiaires doivent être des éléments du jeu de valeurs float ou du jeu de valeurs double, ce qui implique que les résultats de toutes les expressions FP-strict doivent être ceux prédits par IEEE 754 arithmétique sur opérandes représentées en utilisant les formats simple et double. Dans une expression qui n'est pas FP-strict, une certaine marge de manœuvre est accordée pour une implémentation d'utiliser une plage étendue d'exposant pour représenter des résultats intermédiaires; l'effet net, en gros, est qu'un calcul pourrait produire "la réponse correcte" dans les situations où l'utilisation exclusive de la valeur flottante ou double valeur ensemble pourrait entraîner un débordement ou un sous-débit.

Je n'en ai jamais eu personnellement l'usage, cependant.

tout a commencé par une histoire,

quand java a été développé par James Gosling, Herbert et le reste de son équipe. Ils avaient cette chose folle à l'esprit appelé indépendance de plate-forme . Ils voulaient faire oak(Java) tellement mieux qu'il fonctionnerait exactement le même sur n'importe quelle machine ayant un ensemble d'instruction différent, même en exécutant des systèmes d'exploitation différents. Mais, il y avait un problème avec décimale les nombres de points aussi connus comme point flottant et double dans les langages de programmation. Certaines machines ont été construites en ciblant l'efficacité tandis que les autres ciblaient la précision. Ainsi, les machines plus récentes(plus précises) avaient une taille de virgule flottante de 80 bits tandis que les machines plus anciennes(plus efficaces/plus rapides) avaient des doubles 64 bits. Mais c'était contre l'idée de base de construire un langage indépendant de plate-forme. En outre, cela pourrait conduire à une perte de précision / données quand un code est construit sur une machine(ayant le double de 64 bits taille) et fonctionner sur un autre type de machine(ayant double de taille de 80 bits).

Up-Dimensionnement peut être toléré, mais la réduction des effectifs peut pas l'être. Ainsi, ils sont tombés sur un concept de strictfp i.e. point flottant strict . Si vous utilisez ce mot-clé avec une classe/fonction alors son point flottant et doubles ont une taille cohérente sur n'importe quelle machine. c'est à dire 32/64 bits respectivement.

comme les autres réponses l'ont mentionné, cela rend les résultats des points flottants intermédiaires conformes à la spécification de L'IEEE. En particulier, les processeurs x86 peuvent stocker des résultats intermédiaires avec une précision différente de celle des spécifications IEEE. La situation devient plus compliquée lorsque le JIT optimise un calcul particulier; l'ordre des instructions pourrait être différent à chaque fois résultant en un arrondi légèrement différent.

les frais généraux encourus par strictfp susceptibles d'être très dépendant du processeur et du JIT. Cet article de wikipedia sur SSE2 semble avoir un aperçu du problème. Donc, si le JIT peut générer des instructions SSE pour effectuer un calcul, il semble que strictfp n'aura pas de frais généraux.

Dans mon projet actuel, il y a quelques endroits où j'utilise strictfp. Il y a un point où les rayons cosmiques potentiels doivent être retirés des valeurs des pixels. Si un chercheur de l'extérieur a la même valeur de pixel et ils devraient avoir la même valeur résultante que notre logiciel.

• strictfp est un modificateur qui limite les calculs en virgule flottante conformément à la norme IEEE 754.

• peut être utilisé sur toute la classe comme "Public strictfp class StrictFpModifierExample {}"ou sur la méthode" public strictfp void example ()".Si elle est utilisée sur la classe que toutes les méthodes suivront IEEE 754 et si elle est utilisée sur la méthode alors la méthode particulière suivra IEEE 754.

• pourquoi il est-il utilisé??::: Comme différentes plates-formes ont un matériel flottant différent qui calcule avec plus de précision et une plus grande plage de valeurs que la spécification java exige qui peut produire une sortie diffrente sur les plates-formes diffrentes.il confirme donc la même sortie indépendamment des différentes plateformes

• strictfp assure également de tirer profit de la vitesse et de la précision des opérations de pointe flottantes de précision prolongée.

• il n'y a aucun inconvénient avec ce mot-clé que nous pouvons utiliser lorsque nous faisons des calculs à virgule flottante

• mon dernier point est --ce qui est IEEE754 en bref IEEE 754 définit la méthode standard pour les calculs à virgule flottante et le stockage des valeurs à virgule flottante dans la précision soit simple (32 bits, utilisé dans les flotteurs Java) ou double (64 bits, utilisé dans les doubles Java).Il définit également des normes pour les calculs intermédiaires et pour les formats de précision étendue.

strictfp est un mot-clé et peut être utilisé comme modificateur de non-accès pour les classes ou les méthodes (mais jamais les variables). Le marquage d'une classe comme strictfp signifie que tout code de méthode dans la classe sera conforme aux règles IEEE 754 standard pour les points flottants.

sans ce modificateur, les points flottants utilisés dans les méthodes pourraient se comporter d'une manière dépendante de la plate-forme. Avec elle, vous pouvez prédire comment vos points flottants se comporteront indépendamment du sous-jacent plate-forme sur laquelle fonctionne la JVM. L'inconvénient est que si la plate-forme sous-jacente est capable de supporter une plus grande précision, une méthode strictfp ne sera pas en mesure d'en tirer avantage.

si vous ne déclarez pas une classe comme strictfp , vous pouvez toujours obtenir strictfp comportement sur une base méthode par méthode, en déclarant une méthode comme strictfp .

~ SCJP Sun®Certified Programmer for Java™ 6-Kathy Sierra & Bert Bates ~

peut aider à comprendre ce plus clair exemple ci-dessous : En java chaque fois que nous utilisons la recherche d'informations précises pour n'importe quelle opération, par exemple si nous faisons double num1 = 10e+102; double num2 = 8e+10 ; résultat = num1+ num2;

        The output will be so long and not precise, becasue it is precissed by the hardware e.g JVM and JIT has the license 
        as long as we dont have specify it Strictfp

Marking it Strictfp will make the result Uniform on every hardware and platform, because its precised value will be same
One scenario I can see is in a distributed application (or multiplayer game) where all floating-point calculations need to 
be deterministic no matter what the underlying hardware or CPU is.