Optimization option -O3 performs aggressive optimization and its use is recommended to run the MIPSpro APO. The optimization at this level maximizes code quality even if it requires extensive compile time or relaxing language rules. The -O3 option uses transformations that are usually beneficial but can hurt performance in pathological cases. This level may cause noticeable changes in floating-point results due to the relaxation of operation-ordering rules. Floating-point optimization is discussed further in “Miscellaneous Optimization Options”.

Interprocedural analysis (IPA), invoked by the -IPA command-line option, performs program optimizations that can be done only with knowledge of the whole program. Typical IPA optimizations are

More information about these optimizations can be found in the books listed under “References on Optimization Techniques”.

As of the MIPSpro 7.2.1 release, the Auto-Parallelizing Option with IPA is able to optimize only those loops whose function calls were inlined by the MIPSpro APO. This is further described in “Function Calls in Loops”.

---

Note: If IPA expands subroutines inline in a calling routine, the subroutines are compiled with the options of the calling routine. If the calling routine is not compiled with -apo, none of its inlined subroutines are parallelized. This is true even if the subroutines are compiled separately with -apo, because with IPA automatic parallelization is deferred until link time.

---

The loop nest optimizer (LNO) performs loop optimizations that better exploit caches and instruction-level parallelism. Some of the optimizations of the LNO are

The LNO runs when you use the -O3 option. It is an integrated part of the compiler back end, not a preprocessor. As is true with the Auto-Parallelizing Option, the same optimizations and control options can be used with Fortran, C, or C++ programs. The MIPSpro Compiling and Performance Tuning Guide describes three LNO options of particular interest to users of the MIPSpro APO:

If you are using Fortran 77 or C, you can view the transformed code in the original source language after the LNO performs its transformations. Two translators, integrated into the back end, convert the compiler's internal representation into the original source language. You can invoke the desired translator by using the f77 option -FLIST:=on or the cc option -CLIST:=on. For example,

f77 -O3 -FLIST:=on test.f

creates an a.out object file and the Fortran file test.w2f.f. Because it is generated at a later stage of the compilation, this .w2f.f file differs somewhat from the .w2f.f file generated by the -mplist option (see “About the .w2f.f and .w2c.c Files”). You can read the .w2f.f file, which is a compilable Fortran representation of the original program after the LNO phase. Because the LNO is not a preprocessor, recompiling the .w2f.f file may result in an executable that differs from the original compilation of the .f file.

Miscellaneous optimizations, controlled by the -OPT command-line option, are those not associated with a distinct compiler phase. Two of these optimizations are particularly relevant to the MIPSpro APO:

The -OPT:alias=name option has several variations. One of interest to users of the MIPSpro APO is -OPT:alias=restrict. Under this option, the compiler assumes a very restrictive model of aliasing: Memory operations dereferencing different named pointers are assumed neither to alias with each other, nor to alias with any named scalar variable. Even explicit assignments, such as the one below, are forbidden:

int *i, *j;
i = j;

Consider this code:

void dbl (int *i, int *j){
   *i = *i + *i;
   *j = *j + *j;
}

The compiler assumes that i and j point to different memory locations, and produces an overlapped schedule for the two calculations. See also “Aliased Parameter Information” in Chapter 2 about using __restrict as an alternative approach to aliasing.

A related option is -OPT:alias=disjoint. Under this option, the compiler assumes memory operations dereferencing different named pointers do not alias with each other, and different dereferencing depths of the same pointer do not alias with each other. For example, if p and q are pointers, *p does not alias with *q, **p, or **q.

The -OPT:roundoff=n option controls floating-point accuracy and the behavior of overflow and underflow exceptions relative to the source language rules. The default for -O3 optimization is -OPT:roundoff=2. This setting allows transformations with extensive effects on floating-point results. It allows associative rearrangement across loop iterations, and the distribution of multiplication over addition and subtraction. It disallows only transformations known to cause overflow, underflow, or cumulative round-off errors for a wide range of floating-point operands.

At the -OPT:roundoff=2 or 3 level of optimization, the MIPSpro APO may change the sequence of a loop's floating-point operations in order to parallelize it. Because floating-point operations have finite precision, this change may cause slightly different results. If you want to avoid these differences by not having such loops parallelized, you must compile with the -OPT:roundoff=0 or 1 command-line option. Consider this example:

REAL A, B(100)
DO I = 1, 100
  A = A + B(I)
END DO

At the default setting of -OPT:roundoff=2 for the -O3 level of optimization, the MIPSpro APO parallelizes this loop. At the start of the loop, each processor gets a private copy of A in which to hold a partial sum. At the end of the loop, the partial sum in each processor's copy is added to the total in the original, global copy. This value of A may be different from the value generated by a version of the loop that is not parallelized.

The -apo list and -apo keep options generate files, whose names end with .l, that list the original loops in the program along with messages telling whether or not the loops were parallelized. For loops that were not parallelized, an explanation is given.

Example 1-1 shows a simple Fortran 77 program. The subroutine is contained in a file named testl.f.

SUBROUTINE sub(arr, n)
  REAL*8 arr(n)
  DO i = 1, n
    arr(i) = arr(i) + arr(i-1)
  END DO
  DO i = 1, n
    arr(i) = arr(i) + 7.0
    CALL foo(a)
  END DO
  DO i = 1, n
    arr(i) = arr(i) + 7.0
  END DO
END

When testl.f is compiled with

f77 -O3 -n32 -mips4 -apo list testl.f -c.

the Auto-Parallelizing Option produces the file testl.l, shown in Example 1-2.

Parallelization Log for Subprogram sub_
3: Not Parallel
         Array dependence from arr on line 4 to arr on line 4.
6: Not Parallel
         Call foo on line 8.
10: PARALLEL (Auto) __mpdo_sub_1

The last line (10) is important to understand. Whenever a loop is run in parallel, the parallel version of the loop is put in its own subroutine. The MIPSpro profiling tools attribute all the time spent in the loop to this subroutine. The last line indicates that the name of the subroutine is __mpdo_sub_1. For more information about interpreting this file, you can refer to Chapter 2, “Understanding Incomplete Optimization,” or “Additional Reading”.

The 7.2.1 release of the MIPSpro compilers is the first to incorporate OpenMP, a cross-vendor API for shared-memory parallel programming in Fortran and, eventually, C and C++. OpenMP— a collection of directives, library routines, and environment variables—is used to specify shared-memory parallelism in source code. Additionally, OpenMP is intended to enhance your ability to implement the coarse-grained parallelism of large code sections. On Silicon Graphics platforms, OpenMP replaces the older Parallel Computing Forum (PCF) and SGI DOACROSS directives for Fortran. More information about the specification can be found at the OpenMP Web site: http://www.openmp.org/.

The MIPSpro APO interoperates with OpenMP as well as with the older directives. This means that an Auto-Parallelizing Fortran 77 or Auto-Parallelizing Fortran 90 file may use a mixture of directives from each source. As of the 7.2.1 release, the only OpenMP-related changes that most MIPSpro APO users see are in the Auto-Parallelizing Fortran 77 w2f.f and .m files, generated using the -mplist and -apo keep flags, respectively. The parallelized source programs contained in these files now contain OpenMP directives. None of the other MIPSpro auto-parallelizing compilers generate source programs based on OpenMP.

The .w2f.f and .w2c.c files contain Fortran 77 and C code, respectively, that mimics the behavior of programs after they undergo automatic parallelization. The representations in these files are designed to be readable so that you can see what portions of the original code were not parallelized. You can use the information in these files to change the original programs to aid their parallelization.

The MIPSpro auto-parallelizing compilers create the .w2f.f and .w2c.c files by invoking the appropriate translator to turn the compilers' internal representations into Fortran 77 or C. In most cases, the files contain valid code that can be recompiled, although compiling a .w2f.f or .w2c.c file with a standard MIPSpro compiler does not produce object code that is exactly the same as that generated by an auto-parallelizing compiler processing the original source. This is because the MIPSpro APO is an internal phase of the MIPSpro auto-parallelizing compilers, not a source-to-source preprocessor, and does not use a .w2f.f or .w2c.c source file to generate the object file.

The -mplist option tells Auto-Parallelizing Fortran 77 to compile a program and generate a .w2f.f file. Because it is generated at an earlier stage of the compilation, this .w2f.f file is much more easily understood than the .w2f.f file generated using the -FLIST:=on option (see “Loop Nest Optimizer Options”). The parallelized program in the .w2f.f file uses OpenMP directives (see “OpenMP and the Auto-Parallelizing Fortran 77 Output Files”). A .w2f.f program that uses PCF instead of OpenMP can be generated by adding the option -FLIST:emit_pcf to the f77 command line. There is no .w2f.f file for Auto-Parallelizing Fortran 90.

The -mplist and -apo keep options instruct Auto-Parallelizing C to generate a .w2c.c file. The .w2c.c file contains a parallelized program based on directives similar to the Fortran ones of PCF. There is no .w2c.c file for the auto-parallelizing version of C++.

Consider the subroutine in Example 1-3, contained in a file named testw2.f.

SUBROUTINE trivial(a)
  REAL a(10000)
  DO i = 1,10000
    a(i) = 0.0
  END DO
END

After compiling testw2.f using

f77 -O3 -n32 -mips4 -c -apo -mplist testw2.f

you get an object file, testw2.o, and a file, testw2.w2f.f, that contains the code shown in Example 1-4.

C ***********************************************************
C Fortran file translated from WHIRL Sun Dec  7 16:53:44 1997
C ***********************************************************


        SUBROUTINE trivial(a)
        IMPLICIT NONE
        REAL*4 a(10000_8)
C
C       **** Variables and functions ****
C
        INTEGER*4 i
C
C       **** statements ****
C
C       PARALLEL DO will be converted to SUBROUTINE __mpdo_trivial_1
C$OMP PARALLEL DO private(i), shared(a)
        DO i = 1, 10000, 1
          a(i) = 0.0
        END DO
        RETURN
        END ! trivial

---

Note: WHIRL is the name for the compiler's intermediate representation.

---

As explained in “About the .l File”, parallel versions of loops are put in their own subroutines. In this example, that subroutine is __mpdo_trivial_1. C$OMP PARALLEL DO is an OpenMP directive that specifies a parallel region containing a single DO directive. See “OpenMP and the Auto-Parallelizing Fortran 77 Output Files” for more information on OpenMP.

For Auto-Parallelizing Fortran 77, the -apo keep option generates two files in addition to a .l file:

Silicon Graphics provides a separate product, WorkShop Pro MPF, that provides a graphical interface to aid in both automatic and manual parallelization for Fortran 77. In particular, the WorkShop Pro MPF Parallel Analyzer View helps you understand the structure and parallelization of multiprocessing applications by providing an interactive, visual comparison of their original source with transformed, parallelized code. Refer to the Developer Magic: WorkShop Pro MPF User's Guide and the Developer Magic: Performance Analyzer User's Guide for details.

SpeedShop, another Silicon Graphics product, allows you to run experiments and generate reports to track down the sources of performance problems. SpeedShop consists of an API, a set of commands that can be run in a shell, and a number of libraries to support the commands. For more information, see the SpeedShop User's Guide.