Intel® Advisor: Selected Topics From the Intel C++ Compiler 17.0 User and Reference Guides
Controls the semantics of floating-point calculations.
Linux and OS X: | -fp-model keyword |
Windows: | /fp:keyword |
keyword |
Specifies the semantics to be used. Possible values are:
|
-fp-model fast=1
|
The compiler uses more aggressive optimizations on floating-point calculations. |
This option controls the semantics of floating-point calculations.
The keywords can be considered in groups:
Group A: precise, fast, consistent, strict
Group B: source, double, extended
Group C: except (or the negative form)
You can use more than one keyword. However, the following rules apply:
You cannot specify
fast and
except together in the same
compilation. You can specify any other combination of group A, group B, and
group C.
Since
fast is the default, you must
not specify
except without a group A or
group B
keyword.
You should specify only one keyword from group A and only one keyword from group B. If you try to specify more than one keyword from either group A or group B, the last (rightmost) one takes effect.
If you specify except more than once, the last (rightmost) one takes effect.
The floating-point (FP) environment is a collection of registers that control the behavior of FP machine instructions and indicate the current FP status. The floating-point environment may include rounding-mode controls, exception masks, flush-to-zero controls, exception status flags, and other floating-point related features.
|
Option |
Description |
||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
-fp-model precise or /fp:precise |
Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations. It disables optimizations that can change the result of floating-point calculations, which is required for strict ANSI conformance. These semantics ensure the reproducibility of floating-point computations for serial code, including code vectorized or auto-parallelized by the compiler, but they may slow performance. They do not ensure value safety or run-to-run reproducibility of other parallel code. Run-to-run reproducibility for floating-point reductions in OpenMP* code may be obtained for a fixed number of threads through the KMP_DETERMINISTIC_REDUCTION environment variable. For more information about this environment variable, see topic "Supported Environment Variables". The compiler assumes the default floating-point environment; you are not allowed to modify it. Intermediate results are computed with the precision shown in the following table, unless it is overridden by a keyword from Group B:
IA-32 architecture: Windows: Double; Linux: Extended; OS X: Extended Intel® 64 architecture: All operating systems: Source Floating-point exception semantics are disabled by default. To enable these semantics, you must also specify -fp-model except or /fp:except. |
||||||||||||
|
-fp-model fast[=1|2] or /fp:fast[=1|2] |
Tells the compiler to use more aggressive optimizations when implementing floating-point calculations. These optimizations increase speed, but may affect the accuracy or reproducibility of floating-point computations. Specifying fast is the same as specifying fast=1. fast=2 may produce faster and less accurate results. Floating-point exception semantics are disabled by default and they cannot be enabled because you cannot specify fast and except together in the same compilation. To enable exception semantics, you must explicitly specify another keyword (see other keyword descriptions for details). To enable exception semantics, you must explicitly specify another keyword (see other keyword descriptions for details). |
||||||||||||
|
-fp-model consistent or /fp:consistent |
Tells the compiler to generate code that will give consistent, reproducible floating-point results for different optimization levels or between different processors of the same architecture . For more information, see the article titled: Consistency of Floating-Point Results using the Intel® Compiler, which is located in http://software.intel.com/en-us/articles/consistency-of-floating-point-results-using-the-intel-compiler/ |
||||||||||||
|
-fp-model strict or /fp:strict |
Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations and enables floating-point exception semantics. This is the strictest floating-point model. The compiler does not assume the default floating-point environment; you are allowed to modify it. Floating-point exception semantics can be disabled by explicitly specifying -fp-model no-except or /fp:except-. |
||||||||||||
|
-fp-model source or /fp:source |
This option causes intermediate results to be rounded to the precision defined in the source code. It also implies keyword precise unless it is overridden by a keyword from Group A. Intermediate expressions use the precision of the operand with higher precision, if any.
long double: 64-bit precision; 80-bit data type; 15-bit exponent double: 53-bit precision; 64-bit data type; 11-bit exponent; on Windows systems using IA-32 architecture, the exponent may be 15-bit if an x87 register is used to hold the value. float: 24-bit precision; 32-bit data type; 8-bit exponent The compiler assumes the default floating-point environment; you are not allowed to modify it. |
||||||||||||
|
-fp-model double or /fp:double |
This option causes intermediate results to be rounded as follows: 53-bit (double) precision 64-bit data type 11-bit exponent; on Windows systems using IA-32 architecture, the exponent may be 15-bit if an x87 register is used to hold the value. This option also implies keyword precise unless it is overridden by a keyword from Group A. The compiler assumes the default floating-point environment; you are not allowed to modify it. |
||||||||||||
|
-fp-model extended or /fp:extended |
This option causes intermediate results to be rounded as follows: 64-bit (extended) precision 80-bit data type 15-bit exponent This option also implies keyword precise unless it is overridden by a keyword from Group A. The compiler assumes the default floating-point environment; you are not allowed to modify it. |
||||||||||||
|
-fp-model except or /fp:except |
Tells the compiler to follow strict floating-point exception semantics. |
The -fp-model and /fp options determine the setting for the maximum allowable relative error for math library function results (max-error) if none of the following options are specified:
-fimf-accuracy-bits (Linux* and OS X*) or /Qimf-accuracy-bits (Windows*)
-fimf-max-error (Linux and OS X) or /Qimf-max-error (Windows)
-fimf-precision (Linux and OS X) or /Qimf-precision (Windows)
[Q]fast-transcendentals
Option -fp-model fast (and /fp:fast) sets option -fimf-precision=medium (/Qimf-precision:medium) and option -fp-model precise (and /fp:precise) implies -fimf-precision=high (and /Qimf-precision:high). Option -fp-model fast=2 (and /fp:fast2) sets option -fimf-precision=medium (and /Qimf-precision:medium) and option -fimf-domain-exclusion=15 (and /Qimf-domain-exclusion=15).
|
Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804 |
Eclipse: Floating Point > Floating Point Model
Xcode: Floating Point > Floating Point Model
Floating Point > Reliable Floating Point Exceptions Model
None