All versions of IRIX 6.x support development for o32, n32 and n64 programs. All IRIX 6.x systems also support execution of o32 and n32 programs. However, in order to execute 64-bit programs you must be running on IRIX 6.4 or a 64-bit version of IRIX 6.2 or IRIX 6.5. IRIX 6.3 and the 32-bit version of IRIX 6.2 or IRIX 6.5 do not support execution of 64-bit programs. You can tell if you are running on a system capable of executing 64-bit programs by running the uname command. If it returns IRIX64, you are on a 64-bit version of IRIX. If it returns IRIX, you are on a 32-bit version.

On 64-bit versions of IRIX you can execute programs conforming to any of the following Application Binary Interfaces (ABIs):

Figure 1-1 illustrates the ABIs supported by IRIX 6.x.

Figure 1-1. ABIs supported by IRIX 6.x

More specifically, the execution and development environments under IRIX 6.x provide the following functionality:

The MIPSpro Fortran 77 compiler and the MIPSpro 7 Fortran 90 compiler support 32-bit, 64-bit and N32 compiler modes. The following section describe the components of these compiling systems. For more details about using the compilers, see the manuals provided with each compiling system.

%f77 -64 foo.f
%f77 -64 -O foo.f
       fe --> be --> linker

%f77 -64 -mp foo.f
%f77 -64 -pfa foo.f
       fe --> be --> dsm_prelink --> linker

%f77 -32 foo.f
    cpp --> fcom --> ugen --> as1 --> linker

%f77 -32 -O foo.f
    cpp --> fcom --> uopt --> ugen --> as1 --> linker

%f77 -32 -sopt foo.f
    cpp --> fopt --> fcom --> ugen --> as1 --> linker

%f77 -32 -mp foo.f
    cpp --> fcom --> ugen --> as1 --> linker

For C, the respective compiler systems are similar to their Fortran counterparts. The front ends, of course, are different in each system.

%cc -64 foo.c
%cc -64 -O foo.c
        fec --> be --> linker

%cc -64 -mp foo.c
%cc -64 -pca foo.c
        fec --> be --> dsm_prelink --> linker

C 32-Bit System

The 32-bit (ucode) C compiler systems contain the following components:

cc		C driver: Executes the appropriate components below.
acpp		ANSI C preprocessor: Handles #include statements and other cpp constructs such as #define, #ifdef, and so on, in the source file.
cfe		C front end: Preprocesses the C file, and then parses the source file into intermediate code (ucode).
mpc		Interprets parallel directives.
copt		C scalar optimizer: Performs scalar optimization.
uopt		Optimizer: Performs optimizations on the intermediate file.
ugen		Code Generator: Generates binary assembly code from the intermediate file.
as1		Binary assembler: Assembles the binasm code into an object file.
linker		Linker: Links the object file(s) with any libraries.

When you run simple examples through the ucode C compiler, the following components are executed by the compiler driver:

%cc -32 foo.c cfe --> ugen --> as1 --> linker

---

Note: cfe has a built-in C preprocessor.

---

The command

%cc -32 -O foo.c cfe --> uopt --> ugen --> as1 --> linker

also invokes the ucode optimizer, uopt.

The command

%cc -32 -sopt foo.c acpp --> copt --> cfe --> ugen --> as1 --> linker

invokes the scalar optimizer but does not invoke the ucode optimizer.

The C preprocessor has to be run before copt can do its source-to-source translation:

%cc -32 -mp foo.c acpp --> mpc --> cfe --> ugen --> as1 --> linker

-mp signals mpc to recognize inserted parallelization directives.

To compile with automatic parallelization you must obtain the MIPSpro Auto-Parallelizing Option and install its license. The syntax for compiling programs with automatic parallelization is as follows:

For Fortran 77, C, and Fortran 90 compilations use -apo on your compilation command line. For example:

%f77 -apo foo.f

If you link separately, you must also add -mp to the link line. See the apo(5) man page for details.

The auto-parallelizer provides a listing mechanism when you use the -apo list option. This causes the compiler to generate a .l file. The .l file lists the original loops in the program along with messages telling if the loops were parallelized. For loops that were not parallelized, an explanation is given. For example:

%cat test.f
       program test
       real*8 a, x(100000),y(100000)
       do i = 1,2000
         y(i) =  y(i-1) + x(i)
       enddo
       do i = 1,2000
         call daxpy(3.7,x,y,100000)
        enddo
        stop
        end

        subroutine daxpy( a, x, y, nn)
        real*8 a, x(*), y(*)
        do i = 1, nn,1
          y(i) =  y(i) + a*x(i)
        end do
        return
        end
%f77 -64 -mp list test.f
%cat test.l
Parallelization Log for Subprogram MAIN__
    3: Not Parallel
        Array dependence from y on line 4 to y on line 4.
    6: Not Parallel
        Call daxpy on line 7.
Parallelization Log for Subprogram daxpy_
    14: PARALLEL (Auto) __mpdo_daxpy_1

The -mplist option will, in addition to compiling your program, generate a .w2f.f file (for Fortran, .w2c.c file for C) that represents the program after the automatic parallelization phase. These programs should be readable and in most cases should be valid code suitable for recompilation. The -mplist option can be used to see what portions of your code were parallelized. Continuing our example from above:

%f77 -64 -apo -mplist test.f
%cat test.w2f.f
C ***********************************************************
C Fortran file translated from WHIRL Sat Jul 26 12:05:52 1997
C ***********************************************************


        PROGRAM MAIN
        IMPLICIT NONE
C
C          **** Variables and functions ****
C
        REAL*8 x(100000_8)
        REAL*8 y(100000_8)
        INTEGER*4 i
        
C
C       **** statements ****
C
        DO i = 1, 2000, 1
          y(i) = (x(i) + y(i + -1))
        END DO
        DO i = 1, 2000, 1
          CALL daxpy(3.7000000477, x, y, 100000)
        END DO
        STOP
        END ! MAIN


        SUBROUTINE daxpy(a, x, y, nn)
        IMPLICIT NONE
        REAL*8 a
        REAL*8 x(*)
        REAL*8 y(*)
        INTEGER*4 nn
C
C       **** Variables and functions ****
C
        INTEGER*4 i
        INTEGER*4 __mp_sug_numthreads_func$
        EXTERNAL  __mp_sug_numthreads_func$
C
C       **** statements ****
C
C       PARALLEL DO will be converted to SUBROUTINE __mpdo_daxpy_1
C$OMP PARALLEL DO if(((DBLE(__mp_sug_numthreads_func$()) *((DBLE(
C$&(__mp_sug_numthreads_func$())*1.23D+02)+2.6D+03)).LT. (DBLE((
C$&(__mp_sug_numthreads_func$()+ -1))*(DBLE(nn)*7.0D00)))), private
C$&(i), shared(y, x, a, nn)

        DO i = 1, nn, 1
          y(i) = (y(i) +(x(i) * a))
        END DO
        RETURN
        END ! daxpy

The -pfa keep option generates a .l file, a .anl file that used by the Workshop ProMPF tool, and a .m file. The .m file is similar to the .w2f.f or .w2c.c file except that the file is annotated with some information used by Workshop ProMPF.

For Fortran 90 and C++, automatic parallelization happens after the source program has been converted into an internal representation. It is not possible to regenerate Fortran 90 or C++ after parallelization.

This section describes 64-bit and 32-bit Fortran MP compiler compatibility:

The MIPSpro 64-bit Fortran MP I/O library has been enhanced to allow I/O from parallel regions. In other words, multiple threads can read and write to different files as well as read and write to the same file. The latter case, of course, encounters normal overhead due to file locking.

The MIPSpro 64-bit compilers also have been enhanced to allow parallel C and parallel Fortran programs to share a common runtime. This allows you to link parallel C routines with parallel Fortran routines and have a single master. Figure 1-2 illustrates this.

Figure 1-2. Running Parallel C and Parallel Fortran Programs Together

The MIPSpro 64-bit compilers are also enhanced to provide a variety of primitive synchronization operations. The operations are guaranteed to be atomic (typically achieved by implementing the operation using a sequence of load-linked/store- conditional instructions in a loop).

Associated with each operation are certain memory barrier properties that restrict the movement of memory references to visible data across the intrinsic operation (by either the compiler or the processor). For more information, see the MIPSpro Fortran77 Programmer's Guide and the sync(3i) and the sync(3c) man pages.

The Origin2000 provides cache-coherent, shared memory in the hardware. Memory is physically distributed across processors. Consequently, references to locations in the remote memory of another processor take substantially longer (by a factor of two or more) to complete than references to locations in local memory. This can severely affect the performance of programs that suffer from a large number of cache misses.

The new programming support consists of extensions to the existing multiprocessing Fortran and C directives (pragmas) as well as support for C++. Also provided are intrinsic functions that can be used to manage and query the distribution of shared memory. For more information, see the MIPSpro Fortran77 Programmer's Guide, and MIPSPro C and C++ Pragmas.

Starting with the MIPSpro 7.2.1 release, the Fortran77 and Fortran90 64-bit and N32 compilers support the OpenMP application programming interface (API) when used in conjunction with the -mp flag.The -mp flag enables the processing of the original SGI/PCF directives as well as the OpenMP directives. To selectively disable one or the other set of directives, add the following -MP option group flag to the -mp flag:

In general, to test 64-bit MP applications, follow these guidelines:

You can, of course, skip as many steps as you like. In case of failure, however, this method of incremental iterations can help you narrow down and identify the problem.