fp-model, fp

Intel® C++ Compiler Classic Developer Guide and Reference

Download PDF

ID 767249

Date 12/16/2022

Version

Public

A newer version of this document is available. Customers should click here to go to the newest version.

Visible to Intel only — GUID: GUID-63514789-6BE7-4FA8-9389-F3B618A2EE1A

View Details

fp-model, fp

Controls the semantics of floating-point calculations.

Syntax

Linux:

-fp-model=keyword

macOS:

-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.
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, and enables pragma stdc 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 macOS) 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.

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	macOS
IA-32 architecture	Double	Extended	Not applicable
Intel® 64 architecture	Source	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.

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.

-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* and macOS) or /Qimf-accuracy-bits (Windows*)
-fimf-max-error (Linux and macOS) or /Qimf-max-error (Windows)
-fimf-precision (Linux and macOS) 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).

NOTE:

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

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

Xcode: Floating Point > Floating Point Model

Floating Point > Reliable Floating Point Exceptions Model

Alternate Options

None

Parent topic: Floating-Point Options

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Intel® C++ Compiler Classic Developer Guide and Reference

fp-model, fp

See Also