Optimization Levels: the /optimize Option

Visual Fortran performs many optimizations by default. You do not have to recode your program to use them. However, understanding how optimizations work helps you remove any inhibitors to their successful function.

If an operation can be performed, eliminated, or simplified at compile time, Visual Fortran does so, rather than have it done at run time. The time required to compile the program usually increases as more optimizations occur.

The program will likely execute faster when compiled at /optimize:4, but will require more compilation time than if you compile the program at a lower level of optimization.

The size of object files varies with the optimizations requested. Factors that can increase object file size include an increase of loop unrolling or procedure inlining.

The following table lists the levels of Visual Fortran optimization with different /optimize:num options (for example, /optimize:0 specifies no selectable optimizations); some optimizations always occur. All levels of optimizations available on the architecture can be specified using /optimize:5. On ia32 systems, /optimize:5 includes loop transformations; on ia64 systems, /optimize:5 includes loop transformations and software pipelining.

Levels of Optimization with Different /optimize:num Options

Optimization Type	/optimize:1	/optimize:2	/optimize:3	/optimize:4	/optimize:5
Software pipelining					x (ia64 only)
Loop transformation					x
Automatic inlining				x	x
Additional global optimizations			x	x	x
Global optimizations		x	x	x	x
Local (minimal) optimizations	x	x	x	x	x

The default for the command line and in the visual development environment for a release configuration is /optimize:4. In the visual development environment for a debug configuration, the default is /optimize:0. However, when /debug is specified, the default is /optimize:0 (no optimizations).

In the table, the following terms are used to describe the levels of optimization (described in detail in the following sections:

Local (minimal) optimizations (/optimize:1) or higher occur within the source program unit and include recognition of common subexpressions and the expansion of multiplication and division.
Global optimizations (/optimize:2) or higher include such optimizations as data-flow analysis, code motion, strength reduction, split-lifetime analysis, and instruction scheduling.
Additional global optimizations (/optimize:3) or higher improve speed at the cost of extra code size. These optimizations include loop unrolling, code replication to eliminate branches, and padding certain power-of-two array sizes for more efficient cache use.
Automatic inlining (/optimize:4) or higher applies interprocedure analysis and inline expansion of small procedures, usually by using heuristics that limit extra code size.
Loop transformation and software pipelining (/optimize:5), include a group of loop transformation optimizations and, on ia64 systems, also include the software pipelining optimization. The loop transformation optimizations apply to array references within loops and can apply to multiple nested loops. Loop transformation optimizations can improve the performance of the memory system.
On ia64 systems, software pipelining applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and execute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution. Software pipelining also enables the prefetching of data to reduce the impact of cache misses.

The following sections discuss I/O performance considerations in more detail: