fp-model, fp
Controls the semantics of floating-point
calculations.
-fp-model
keyword
-fp-model
keyword
/fp:
keyword
- keyword
- Specifies the semantics to be used. Possible values are:
- precise
- Disables optimizations that are not value-safe on floating-point data.
- fast[=1|2]
- Enables more aggressive optimizations on floating-point data.
- consistent
- The compiler uses default heuristics to determine results for different optimization levels or between different processors of the same architecture.
- strict
- Enables precise and except, disables contractions, andenables pragmastdc fenv_access.
- source
- Rounds intermediate results to source-defined precision.
- double
- Rounds intermediate results to 53-bit (double) precision.
- extended
- Rounds intermediate results to 64-bit (extended) precision.
- [no-]except(Linux*and) ormacOS*except[-](Windows* )
- Determines whether strict floating-point exception semantics are honored.
- -fp-model fast=1or/fp: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,strict
- Group B:source,double,extended
- Group C:except(or negative forms-no-exceptor/except-)
- Group D:consistent
You can specify more than one
keyword
. However,
the following rules apply:
- You cannot specifyfastandexcepttogether in the same compilation. You can specify any other combination of group A, group B, and group C.Sincefastis the default, you must not specifyexceptwithout a group A or group Bkeyword.
- You should specify only onekeywordfrom group A and only onekeywordfrom group B. If you try to specify more than onekeywordfrom either group A or group B, the last (rightmost) one takes effect.
- If you specifyexceptmore than once, the last (rightmost) one takes effect.
- If you specifyconsistentand any other keyword from another group, the last (rightmost) one may not fully override the heuristics set byconsistent.
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:
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 | The compiler uses default heuristics to
generate code that will determine 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 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.
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:
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:
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) ormacOS*/Qimf-accuracy-bits(Windows*)
- -fimf-max-error(Linuxand) ormacOS*/Qimf-max-error(Windows)
- -fimf-precision(Linuxand) ormacOS*/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
).
In Microsoft* Visual Studio, when you create a
Microsoft* Visual C++ project, option
/fp:precise
is set by default. It sets the floating-point
model to improve consistency for floating-point operations by disabling certain
optimizations that may reduce performance. To set the option back to the
general default
/fp:fast
, change the IDE project property for Floating Point
Model to Fast.
Optimization Notice
|
|---|
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
|
None