Developer Guide and Reference

Contents

fp-model, fp

Controls the semantics of floating-point calculations.
This content is specific to C++; it does not apply to
DPC++
.

Syntax

Linux:
-fp-model
keyword
Windows:
/fp:
keyword
Arguments
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.
There is currently no difference between fast=1 and fast=2.
consistent
The compiler uses default heuristics to determine results for different optimization levels or between different processors of the same architecture.
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*) or
except[-]
(Windows* )
Determines whether strict floating-point exception semantics are honored.
Default
-fp-model fast=1
or
/fp:fast=1
The compiler uses more aggressive optimizations on floating-point calculations.
-fp-model precise
or
/fp:precise
The compiler disables optimizations that are not value-safe on floating-point data.
Description
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-except
    or
    /except-
    )
  • Group D:
    consistent
You can specify 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.
  • If you specify
    consistent
    and any other keyword from another group, the last (rightmost) one may not fully override the heuristics set by
    consistent
    .
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:
Windows
Linux
IA-32 architecture
Double
Extended
Intel® 64 architecture
Source
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.
There is currently no difference between fast=1 and fast=2.
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 https://software.intel.com/content/www/us/en/develop/articles/consistency-of-floating-point-results-using-the-intel-compiler.html
-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 (the following options are only available for ifort):
  • -fimf-accuracy-bits
    (Linux*) or
    /Qimf-accuracy-bits
    (Windows*)
  • -fimf-max-error
    (Linux) or
    /Qimf-max-error
    (Windows)
  • -fimf-precision
    (Linux) or
    /Qimf-precision
    (Windows)
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.
Product and Performance Information
Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.
Notice revision #20201201
IDE Equivalent
Visual Studio:
Code Generation>Floating Point Model
Code Generation>Enable Floating Point Exceptions
Code Generation> Floating Point Expression Evaluation
Eclipse:
Floating Point > Floating Point Model
Alternate Options
None

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.