This appendix summarizes the Power Fortran directives in alphabetical order. When viewing this Guide online, you can use the cross-references in the following table as hypertext links to the descriptive paragraphs.
Table B-1. Power Fortran Directives
Directive | Class | Summary | Discussion |
|---|---|---|---|
C$& | SGI |
| |
C*$* CONCURRENTIZE | SGI | ||
C*$* LIMIT | SGI | ||
C*$* MINCONCURRENT | SGI | ||
C*$* NO ASSERTIONS | SGI | ||
C*$* NOCONCURRENTIZE | SGI | ||
C*$* OPTIMIZE | SGI | ||
C*$* ROUNDOFF | SGI | ||
CDIR$ IVDEP | Cray | ||
CDIR$ NEXT SCALAR | Cray | ||
C$ DOACROSS | SGI | ||
CVD$ CNCALL | VAST | ||
CVD$ CONCUR | VAST |
C*$*CONCURRENTIZE tells Power Fortran to convert eligible loops to run in parallel. This directive, when specified globally, has the same effect as the –concurrentize command line option. See also “C*$* NOCONCURRENTIZE”.
C*$*LIMIT(n) reduces Power Fortran processing time by limiting the amount of time Power Fortran can spend on trying to determine whether a loop is safe to run in parallel. Power Fortran estimates how much time is required to analyze each loop nest construct. If an outer loop looks like it would take too much time to analyze, Power Fortran ignores the outer loop and recursively visits the inner loops.
Larger limits often allow Power Fortran to generate parallel code for deeply nested loop structures that it might not otherwise be able to run safely in parallel. However, with larger limits Power Fortran can also take more time to analyze a program. The value of n does not correspond to the loop nest level. It is an estimate of the number of loop orderings that Power Fortran can generate from a loop nest.
This directive, when specified globally, has the same effect as the –limit driver option; see “limit”.
C*$*MINCONCURRENT(n) option establishes the minimum amount of work needed inside the loop to make executing a loop in parallel profitable. n is a count of the number of operations (for example, add, multiply, load, store) in the loop, multiplied by the number of times the loop will be executed. If the loop does not contain at least this much work, the loop will not be run in parallel. If the loop bounds are not constants, an IF clause is added to the generated parallelizing directive to test at run time if sufficient work exists.
C*$* NO ASSERTIONS directs Power Fortran to ignore all following assertions to end of file.
C*$*NONCONCURRENTIZE prevents Power Fortran from converting loops to run in parallel. Used globally, it has the same effect as the -noconcurrentize driver option. See also “C*$* CONCURRENTIZE”.
C*$*OPTIMIZE(n) sets the optimization level. The higher the optimization level, the more code is optimized and longer Power Fortran runs. Valid values for n are the integers:
0 | Disables optimization; no loops are converted. |
1 | Converts loops to run in parallel without using advanced data dependence tests. Enables loop interchanging. |
2 | Determines when scalars need last-value assignment using lifetime analysis. Also uses more powerful data dependence tests to find loops that can run safely in parallel. This level allows reductions in loops that execute concurrently but only if the –roundoff option is set to 2 (see “Reductions” for discussion of –roundoff.) |
3 | Recognizes triangular loops and attempts loop interchanging to improve memory referencing. Uses special case data dependence tests. Also, recognizes special index sets called wraparound variables. |
4 | Generates two versions of a loop, if necessary, to break a data dependence arc. This level also implements more-exact data dependence tests and allows special index sets (called wraparound variables) to convert more code to run in parallel. |
5 | Fuses two adjacent loops if it is legal to do so (that is, there are no data dependencies) and if the loops have the same control values. In certain limited cases, this level recognizes arrays as local variables. This level is the default. |
C*$*ROUNDOFF(n) controls whether Power Fortran runs a reduction operation in parallel. Valid values for n are
0, 1 | Suppresses any round-off transformations. This is the default. |
2 | Allows reductions to be performed in parallel.This value is one of the most commonly-specified user options. |
3 | Recognizes REAL induction variables. Permits memory management transformations (refer to the MIPSpro Fortran 90 Programmer's Guide for details.) |
C$ DOACROSS tells the MIPSpro Fortran 90 compiler to generate parallel code for the loop that immediately follows the directive. Putting this directive in the original source marks the loop to run in parallel and signals Power Fortran not to modify the loop. The use of C$ DOACROSS is covered in detail in the MIPSpro Fortran 90 Programmer's Guide.
 | Note: MIPSpro Power Fortran automatically generates C$PAR directives from the PCF directive set. Older versions of Power Fortran generated C$ DOACROSS instead. |
Power Fortran interprets the Cray CDIR$ IVDEP directive as if it were a C*$* ASSERT DO (CONCURRENT) assertion (see “C*$* ASSERT DO (CONCURRENT)”). Cray directives are disabled by default; see “[no]directives”.
Power Fortran interprets the CDIR$ NEXT SCALAR directive as if it were a C*$* ASSERT DO(SERIAL) assertion (see “C*$* ASSERT DO (SERIAL)”). Cray directives are disabled by default; see “[no]directives”.
Power Fortran interprets the CVD$ CNCALL directive as if it were the C*$* ASSERT CONCURRENT CALL assertion (see “C*$* ASSERT CONCURRENT CALL”).
Power Fortran interprets the CVD$ CONCUR directive as if it were the C*$*CONCURRENTIZE directive (see “C*$* CONCURRENTIZE”).