This chapter describes how to use PGHPF to control the compilation process for a program written in High Performance Fortran (HPF). The pghpf command is called the compilation driver. The compilation driver controls several phases of compilation: pre-processing, HPF compilation, Fortran compilation using an underlying node compiler if necessary, assembling and linking (linking includes the correct PGHPF runtime routines for the target communications protocol). Since PGHPF runs on a variety of host systems and generates output for several target systems, the commands used to execute an HPF program will vary from system to system as outlined in Chapter 3, PGHPF Runtime Options.
In general, using PGHPF, the compilation process involves three steps:
The PGHPF compiler allows many variations on these general program development steps. These variations include the following:
The PGHPF compiler targets an SPMD (Single Program Multiple Data) programming model. Each processor executes the same program, but operates on a distinct subset of the program's data. The SPMD model is implemented by loading the same program image into each processor. Each processor then allocates and operates on its own local portion of distributed arrays, according to the distributions, array sizes and number of processors as determined by HPF directives and the use of command-line arguments.
Special attention is required to address the unique communication characteristics of many parallel systems. The PGHPF runtime libraries take into account the communications to be performed and are optimized at two levels. At the transport independent level, efficient communications are generated based on the type and pattern of data access performed in the computation. At the transport dependent level, communication is performed using a standard protocol (e.g. MPI) or a custom data transfer mechanism (e.g. direct manipulation of E Registers on the CRAY T3E).
To translate and link an HPF program, the pghpf driver does the following:
The pghpf driver sets the PGHPF compiler and Fortran node compiler switches and assembles and links the program. It lets you pass command-line options to any of the various driver stages. Chapter 2, PGHPF Compiler Options, covers the compiler's command-line options. The executable output from PGHPF is an SPMD program that can execute on a target parallel system. Chapter 3, PGHPF Runtime Options, describes some of the command-line options and environment variables available for the PGHPF runtime, the PGHPF executable and the PGHPF environment. For more information on the Fortran node compiler, the assembler and linker, refer to the appropriate manuals supplied with your system.
The following examples show a few driver options that are available on all systems. The command lines and output may differ on your system. You can compile the HPF program hello.hpf using the default PGHPF driver options.
% pghpf hello.hpf
By default, the executable output is placed in the file a.out. You can use the -o option to specify the output file.
% pghpf -o hello hello.hpf
To see the command lines the pghpf driver will run, without actually executing them, use the driver's -dryrun option. For example:
% pghpf -dryrun -o hello hello.hpf
The pghpf command-line syntax is:
pghpf [options] filename [...]
Where:
The compiler command-line options control various aspects of the compilation process. For a listing and a description of the PGHPF-specific compiler command-line options, refer to Chapter 2, PGHPF Compiler Options. There are many additional options that apply specifically to the FORTRAN 77 or Fortran 90 node compiler for your system, if applicable. Refer to the online manual page or user manual for the node compiler for your system, or use the PGHPF driver option -help to list the available options on a particular platform. Most Fortran node compiler options will be recognized by pghpf. Options not recognized by pghpf can be passed through to the underlying node compiler using the -W0 option, described further in Chapter 2.
Several options provide for optimization of the HPF program. Two of these options, -O1 and -O2, provide varying levels of optimization to the HPF code, and also set optimization flags for the Fortran node compiler. For details on the optimization transformations applied, refer to the Release Notes supplied with the PGHPF Software or to sections in this manual describing optimizations.
The pghpf driver uses the filenames that you specify on the command line to find and to create input and output files. This section describes the input and output filename conventions for the phases of the compilation process.
You can specify HPF source files, preprocessed HPF source files, assembly-language files, object files and libraries as inputs on the pghpf command line. The driver determines the type of each input file by examining the filename extension. The driver uses the following conventions:
The driver passes files with .o and .a extensions to the linker and .s files to the assembler. Input files with unrecognized extensions, or no extensions, are also passed to the linker.
Any input files not needed for a particular phase of processing are not processed. For example, if on the command line you use an assembly-language file (filename.s) and the -S option to stop before the assembly phase, the compiler takes no action on the assembly-language file. Processing stops after compilation and the assembler does not run (in this case compilation must have been completed in a previous pass which created the .s file). Refer to the following section, Output Files, for a description of the -S option.In addition to specifying files with extensions indicating an HPF source file on the command line, you can include text from include files using the INCLUDE statement or the preprocessor #include directive from within HPF source files. Preprocessing, and hence includes using #include, are only available if you use a .F or .F90 extension or the -Mpreprocess command line option.When linking a program object file with a library, the linker extracts only those objects from the library required for creation of the executable program. The pghpf driver links against several libraries by default. For more information about libraries, refer to Chapter 4, PGHPF Libraries.
By default, the PGHPF executable output is placed in the file a.out. Alternatively, on the command line you can use the -o option to specify the name of the output file.
If you use one of the options: -Mftn, -F, -S or -c, the compiler produces a file containing the output of the last phase that completes for each input file, as specified by the option supplied[*]. The output file will be a Fortran file with PGHPF runtime library calls or an intermediate language file (for systems on which PGHPF is native, such as IA-32 systems), a preprocessed source file, an assembly-language file or an unlinked object file respectively. Similarly, the -E option does not produce a file, but displays the preprocessed HPF source file on the standard output. Using any of these options, the -o option is valid only if you specify a single input file. If no errors occur during processing, you can use the files created by these options as input to a future invocation of pghpf. Table 1-1 lists the stop after options and the output files that pghpf creates when you use these options.
If you specify multiple input files or do not specify an object filename, the compiler uses the input filenames to derive corresponding default output filenames of the following form, where filename is the input filename without its extension:
Option
|
Stop after
|
Output from PGHPF
|
|---|---|---|
-F |
preprocessing |
preprocessed file - .f extension |
-Mftn |
HPF compilation |
Fortran/Intermediate file - .f or .ilm extension |
-S |
compilation |
assembly-language file - .s extension |
-c |
assembly |
unlinked object file - .o extension |
none |
linking |
executable file - a.out |
On systems where an underlying node compiler is coupled to PGHPF, you can specify that compilation should continue and the intermediate file be saved by using the -Mkeepftn option to the pghpf command. This option continues compilation after the HPF compilation phase is complete, but does not remove the intermediate file. Use of the -Mnohpfc option will skip the HPF compilation phase and compile using the Fortran node compiler if a file with a .f or a .F extension is supplied. This option is useful if you have a need to compile a file produced using -Mftn or -Mkeepftn, bypassing HPF compilation (which has already been performed) and proceeding directly to compilation by the Fortran node compiler.
The -Mipa interprocedural analysis processing, module processing, and the static initialization and prelinking phases of the compiler generate additional intermediate files. For further information, refer to Section 5 of this manual or the PGHPF release notes.