Using the -fp-model or /fp Option

The -fp-model (Linux* and Mac OS*) or /fp (Windows*) option allows you to control the optimizations on floating-point data. You can use this option to tune the performance, level of accuracy, or result consistency across platforms for floating-point applications.

For applications that do not require support for denormalized numbers, the -fp-model or /fp option can be combined with the -ftz (Linux and Mac OS) or /Qftz (Windows) option to flush denormalized results to zero in order to obtain improved runtime performance on processors based on:

• IA-32 and Intel® 64 architectures, for calculations that make use of Streaming SIMD Extensions (SSE) only

• IA-64 architecture

You can use keywords to specify the semantics to be used. Possible values of the keywords are as follows:

The default value of the option is -fp-model fast=1 or /fp:fast=1, which means that the compiler uses more aggressive optimizations on floating-point calculations.

Several examples are provided to illustrate the usage of the keywords. These examples show:

• A small example of source code
  Note that the same source code is considered in all the included examples.
• The semantics that are used to interpret floating-point calculations in the source code
• One or more possible ways the compiler may interpret the source code
  Note that there are several ways the compiler may interpret the code; we show just some of these possibilities.

-fp-model fast or /fp:fast

Example source code:

float t0, t1, t2;

...

t0 = 4.0f + 0.1f + t1 + t2;

When this option is specified, the compiler applies the following semantics:

• Additions may be performed in any order

• Intermediate expressions may use single, double, or extended double precision

• The constant addition may be pre-computed, assuming the default rounding mode

Using these semantics, the following shows some possible ways the compiler may interpret the original code:

float t0, t1, t2;

...

t0 = (float)((double)t1 + (double)t2) + 4.1f;

float t0, t1, t2;

...

t0 = (t1 + t2) + 4.1f;

float t0, t1, t2;

...

t0 = (t1 + 4.1f) + t2;

-fp-model extended or /fp:extended

This setting is equivalent to -fp-model precise on Linux systems based on the IA-32 architecture and -fp-model precise or /fp:precise on systems based on the IA-64 architecture.

Example source code:

float t0, t1, t2;

...

t0 = 4.0f + 0.1f + t1 + t2;

When this option is specified, the compiler applies the following semantics:

• Additions are performed in program order

• Intermediate expressions use extended double precision

• The constant addition may be pre-computed, assuming the default rounding mode

Using these semantics, the following shows a possible way the compiler may interpret the original code:

float t0, t1, t2;

...

t0 = (float)(((long double)4.1f + (long double)t1) + (long double)t2);

-fp-model source or /fp:source

This setting is equivalent to -fp-model precise or /fp:precise on systems based on the Intel® 64 architecture.

Example source code:

float t0, t1, t2;

...

t0 = 4.0f + 0.1f + t1 + t2;

When this option is specified, the compiler applies the following semantics:

• Additions are performed in program order, taking into account any parentheses

• Intermediate expressions use the precision specified in the source code

• The constant addition may be pre-computed, assuming the default rounding mode

Using these semantics, the following shows a possible way the compiler may interpret the original code:

float t0, t1, t2;

...

t0 = ((4.1f + t1) + t2);

-fp-model double or /fp:double

This setting is equivalent to -fp-model precise or /fp:precise on Windows systems based on the IA-32 architecture.

Example source code:

float t0, t1, t2;

...

t0 = 4.0f + 0.1f + t1 + t2;

When this option is specified, the compiler applies the following semantics:

• Additions are performed in program order

• Intermediate expressions use double precision

• The constant addition may be pre-computed, assuming the default rounding mode

Using these semantics, the following shows s a possible way the compiler may interpret the original code:

float t0, t1, t2;

...

t0 = (float)(((double)4.1f + (double)t1) + (double)t

-fp-model strict or /fp:strict

Example source code:

float t0, t1, t2;

...

t0 = 4.0f + 0.1f + t1 + t2;

When this option is specified, the compiler applies the following semantics:

• Additions are performed in program order, taking into account any parentheses

• Expression evaluation matches expression evaluation under keyword precise.

• The constant addition will not be pre-computed, because there is no way to tell what rounding mode will be active when the program runs.

Using these semantics, the following shows a possible way the compiler may interpret the original code:

float t0, t1, t2;

...

t0 = (float)((((long double)4.0f + (long double)0.1f) +

               (long double)t1) + (long double)t2);

See Also

• -fp-model compiler option