strictfp

From Wikipedia, the free encyclopedia
Jump to: navigation, search

strictfp is a keyword in the Java programming language that restricts floating-point calculations to ensure portability. The strictfp command was introduced into Java with the Java virtual machine (JVM) version 1.2 and is available for use on all currently updated Java VMs.

Basis[edit]

The IEEE standard IEEE 754 specifies a standard method for both floating-point calculations and storage of floating-point values in various formats, including single (32-bit, used in Java's float) or double (64-bit, used in Java's double) precision.

Some hardware also provides extended precision formats that provide higher precision and/or a larger exponent range. On such architectures it may be more efficient to compute intermediate results using such extended formats. This may avoid round-off errors, overflows and underflows that would otherwise occur, but can cause programs to produce different output on such architectures. It was particularly expensive to avoid the use of extended precision on x86 machines with the traditional X87 floating point architecture. Although it was easy to control calculation precision, limiting the exponent range for intermediate results required additional costly instructions.

Prior to JVM 1.2, floating-point calculations were required to be strict; that is, all intermediate floating-point results were required to behave as if represented using IEEE single or double precisions. This made it expensive on common x87-based hardware to ensure that overflows would occur where required.

Since JVM 1.2, intermediate computations are, by default, allowed to exceed the standard exponent ranges associated with IEEE 32 bit and 64 bit formats. They may instead be represented as a member of the "extended-exponent" value set. On platforms like x87, overflows and underflows may not occur where expected, producing possibly more meaningful, but less repeatable, results instead.

Since X87 floating point is no longer widely used by Java implementations, there is an active proposal to again make all floating point operations strict, effectively restoring the pre-1.2 semantics.[1]

How it works[edit]

In the absence of overflow or underflow, there is no difference in results with or without strictfp. If repeatability is essential, the strictfp modifier can be used to ensure that overflow and underflow occurs in the same places on all platforms. Without the strictfp modifier, intermediate results may use a larger exponent range.[2]

The strictfp modifier accomplishes this by representing all intermediate values as IEEE single precision and double precision values, as occurred in earlier versions of the JVM.[3]

Usage[edit]

Programmers can use the modifier strictfp to ensure that calculations are performed as in the earlier versions; that is, only with IEEE single and double precision types used. Using strictfp guarantees that results of floating-point calculations are identical on all platforms.

It can be used on classes, interfaces and non-abstract methods.[4] When applied to a method, it causes all calculations inside the method to use strict floating-point math. When applied to a class, all calculations inside the class use strict floating-point math. Compile-time constant expressions must always use strict floating-point behavior.[5]

Examples

public strictfp class MyFPclass { 
    // ... contents of class here ...
}

References[edit]

  1. ^ Darcy, Joseph D. "JEP 306: Restore Always-Strict Floating-Point Semantics". 
  2. ^ Gosling, James; Joy, Bill; Steele, Guy L. Jr.; Bracha, Gilad; Buckley, Alex; Smith, Daniel (2017). "4.2.3 Floating-Point Types, Formats, and Values". The Java Language Specification, Java SE 9 Edition. Addison-Wesley Professional. Retrieved 2017-10-06. 
  3. ^ Flanagan, David (March 2005). Java in a Nutshell (Fifth ed.). O'Reilly Media. ISBN 978-0-596-00773-7. Retrieved 2010-03-03. 
  4. ^ Schildt, Herbert (2007). Java: A Beginner's Guide (4 ed.). McGraw-Hill Companies. ISBN 978-0-07-226384-8. 
  5. ^ Gosling, James; Joy, Bill; Steele, Guy L. Jr.; Bracha, Gilad (2005). "15.4 FP-strict Expressions". The Java Language Specification, Third Edition. Addison-Wesley Professional. p. 411. ISBN 0-321-24678-0. Retrieved 2016-03-22.