NoteOn IA-32 and Intel® EM64T systems, explicitly setting -fpe0 can degrade performance since the generated code stream must be synchronized after each floating-point instruction to allow for abrupt underflow fix-up.
The Fortran compiler supports several kinds of floating-point exceptions; a summary of their masked (or default) responses is given below:
overflow: Overflow is signaled whenever the destination format’s largest finite number is exceeded in magnitude by what would have been the rounded floating-point result. The result computed is rounding mode specific:
Round-to-nearest (default): +/- Infinity in specified precision
Round-to-zero: +/- Maximum Number in specified precision
Round-to-+Infinity: +Infinity or –(Maximum Positive Number) in specified precision
Round-to--Infinity: (Maximum Positive Number) or -Infinity in specified precision
For example, in round-to-nearest mode 1E30 * 1E30 overflows the single-precision floating-point range and results in a +Infinity; -1E30 * 1E30 results in a -Infinity.
divide-by-zero:
Divide-by-zero is signaled when the divisor is zero and the dividend is
a finite nonzero number. The computed result is a correctly signed Infinity.
For example, 2.0E0/+0.0 produces a divide-by-zero exception and results
in a +Infinity; -2.0E0/+0.0 produces a divide-by-zero exception and results
in a –Infinity.
underflow: Underflow occurs when a computed result (of an add, subtract, multiply, divide, or math function call) falls beyond the minimum range in magnitude of normalized numbers of the floating-point data type. Each floating-point type (32-, 64-, and 128-bit) has a denormalized range where very small numbers can be represented with some loss of precision. This is called gradual underflow. For example, the lower bound for normalized single-precision float-point is approximately 1E-38, while the lower bound for denormalized single-precision float-point is approximately 1E-45. Results falling below the lower bound of the denormalized range simply become zero. 1E-30 / 1E10 underflows the normalized range but not the denormalized range so the result is the denormal value 1E-40. 1E-30 / 1E30 underflows the entire range and the result is zero.
invalid: Invalid occurs when operands to the basic floating-point operations or math function inputs produce an undefined (QNaN) result. Some examples include:
SNaN operand in any floating-point operation or math function call.
Division of zeroes: (+/-0.0)/(+/-0.0)
Sum of Infinities having different signs: Infinity + (-Infinity)
Difference of Infinities having the same sign: (+/-Infinity) – (+/-Infinity)
Product of signed Infinities with zero: (+/-Inf) * 0
Math Function Domain Errors: log(negative), sqrt(negative), asin(|x}>1)
The -fpen option allows some control over the results of floating-point exceptions.
-fpe0 restricts floating-point exceptions as follows:
Enables the overflow, the divide-by-zero, and the invalid floating-point exceptions. The program will print an error message and abort if any of these exceptions occurs. If a floating-point underflow occurs, the result is set to zero and execution continues. This is called flush-to-zero. This option sets -IPF_fp_speculationstrict if no specific -IPF_fp_speculation option is specified. The -fpe0 option sets -ftz. To get more detailed location information about where the exception occurred, use -traceback.
Note
On IA-32 and Intel®
EM64T systems, explicitly setting -fpe0 can degrade
performance since the generated code stream must be synchronized after
each floating-point instruction to allow for abrupt underflow fix-up.
-fpe1 restricts only floating-point underflow:
Floating-point overflow, floating-point divide-by-zero, and floating-point invalid produce exceptional values (NaN and signed Infinities) and execution continues. If a floating-point underflow occurs, the result is set to zero and execution continues. The -fpe1 option sets -ftz.
-fpe3, the default, allows full floating-point exception behavior:
Floating overflow, floating divide-by-zero, and floating invalid produce exceptional values (NaN and signed Infinities) and execution continues. Floating underflow is gradual: denormalized values are produced until the result becomes 0.
The -fpe option affects the Fortran main program only. The floating-point exception behavior set by the Fortran main program remains in effect throughout the execution of the entire program unless changed by the programmer. If the main program is not Fortran, the user can use the Fortran intrinsic FOR_SET_FPE to set the floating-point exception behavior.
When compiling different routines in a program separately, you should use the same value of n in -fpen.
An example follows:
IMPLICIT NONE
real*4 res_uflow, res_oflow
real*4 res_dbyz, res_inv
real*4 small, big, zero, scale
small = 1.0e-30
big = 1.0e30
zero = 0.0
scale = 1.0e-10
! IEEE underflow condition (Underflow Raised)
res_uflow = small * scale
write(6,100)"Underflow: ",small, " *", scale, " = ", res_uflow
! IEEE overflow condition (Overflow Raised)
res_oflow = big * big
write(6,100)"Overflow: ", big, " *", big, " = ", res_oflow
! IEEE divide-by-zero condition (Divide by Zero Raised)
res_dbyz = -big / zero
write(6,100)"Div-by-zero: ", -big, " /", zero, " = ", res_dbyz
! IEEE invalid condition (Invalid Raised)
res_inv = zero / zero
write(6,100)"Invalid: ", zero, " /", zero, " = ", res_inv
100 format(A14,E8.1,A2,E8.1,A2,E10.1)
end
Consider the following command line:
ifort fpe.f -fpe0 -g
The following output is produced:
./a.out
Underflow: 0.1E-29 * 0.1E-09 = 0.0E+00
forrtl: error (72): floating overflow
Image PC Routine Line Source
a.out 0804A063 Unknown Unknown Unknown
a.out 08049E78 Unknown Unknown Unknown
Unknown B746B748 Unknown Unknown Unknown
a.out 08049D31 Unknown Unknown Unknown
Aborted
The following command line uses -fpe1:
ifort fpe.f -fpe1 -g
The following output is produced:
./a.out
Underflow: 0.1E-29 * 0.1E-09 = 0.0E+00
Overflow: 0.1E+31 * 0.1E+31 = Infinity
Div-by-zero: -0.1E+31 / 0.0E+00 = -Infinity
Invalid: 0.0E+00 / 0.0E+00 = NaN
The following command line uses -fpe3:
ifort fpe.f -fpe3 -g
The following output is produced:
./a.out
Underflow: 0.1E-29 * 0.1E-09 = 0.1E-39
Overflow: 0.1E+31 * 0.1E+31 = Infinity
Div-by-zero: -0.1E+31 / 0.0E+00 = -Infinity
Invalid: 0.0E+00 / 0.0E+00 = NaN
The -ftz option affects the results of floating underflow in the following ways:
-ftz results in abrupt underflow to 0: the result of a floating underflow is set to zero and execution continues. -ftz also makes a denomal value used in a computation be treated as a zero so no floating invalid exception will occur.
-ftz- results in gradual underflow to 0: the result of a floating underflow is a denormalized number or a zero.
If the optimization level is -O2 or -O3, abrupt underflow to zero is set by default. At lower optimization levels, gradual underflow to 0 is the default.
The -fpe0 and -fpe1 options set -ftz.
The -ftz option sets or resets the FTZ and the DAZ hardware flags in the MXCSR register. Setting FTZ on means that denormal results from floating-point calculations will be set to the value zero. If FTZ is off, denormal results remain as is. Setting DAZ on means that denormal values used as input to floating-point instructions will be treated as zero. If DAZ is off, denormal instruction inputs remain as is.
Itanium®-based systems have the FTZ, but not the DAZ hardware flag. Intel® EM64T-based systems have both FTZ and DAZ hardware flags. FTZ and DAZ are not supported on all IA-32 architectures.
When -ftz is used in combination with an SSE-enabling option (for example, -xN) on IA-32 systems, the compiler will insert code in the main routine to set FTZ and DAZ. When -ftz is used without such an option, the compiler will insert code to conditionally set FTZ/DAZ based on a runtime processor check (this processor check fails for non-Intel machines). Specifying -no-ftz will prevent the compiler from inserting any code that might set FTZ or DAZ.
On IA-32 and Intel® EM64T systems with SSE and SSE2 code, there is no performance degradation and possibly even a performance gain due to the fact that the hardware handles the denormals. The default setting of abrupt underflow affects the SSE hardware, not the instruction stream.
On Itanium®-based processors, gradual underflow to 0 can degrade performance. You can improve performance by using higher optimization levels to get the default abrupt underflow or explicitly setting -ftz.
See Also: