This appendix lists and describes the following PFA assertions alphabetically:
C*$* ASSERT ARGUMENT ALIASING
C*$* ASSERT DO (SERIAL)
C*$* ASSERT DO (CONCURRENT)
C*$* ASSERT DO PREFER (SERIAL)
C*$* ASSERT DO PREFER (CONCURRENT)
C*$* ASSERT EQUIVALENCE HAZARD
C*$* ASSERT NO ARGUMENT ALIASING
C*$* ASSERT NO EQUIVALENCE HAZARD
C*$* ASSERT RELATION (name .xx. name)
C*$* ASSERT CONCURRENT CALL
C*$* ASSERT NO RECURRENCE
C*$* ASSERT PERMUTATION (name)
Chapter 1, “Overview of PFA,” describes the purpose of assertions. For details about using assertions, refer to Chapter 5, “Fine-Tuning PFA.”
The C*$* ASSERT ARGUMENT ALIASING assertion allows PFA to make assumptions about subprogram arguments in a program. According to the Fortran 77 standard, you can alias a variable only if you do not modify (that is, write to) the aliased variable. This assertion tells PFA that the subprogram on the following line violates the Fortran 77 standard in this regard.
The C*$* ASSERT DO (SERIAL) assertion tells PFA to run the specified loop serially. PFA does not try to convert the specified loop to run in parallel. Nor does it try to run any enclosing loop in parallel. However, PFA can still convert any loops nested inside the serial loop to run in parallel.
The C*$* ASSERT DO (CONCURRENT) assertion tells PFA to ignore assumed data dependencies. Normally, PFA is conservative about what loops it converts run in parallel. When PFA analyzes a loop to see if it is safe to run in parallel, it categorizes the loop into one of three groups:
yes (loop is safe to run in parallel)
no
not sure
Normally, PFA does not run “not sure” loops in parallel. C*$* ASSERT DO (CONCURRENT) tells PFA to go ahead and run “not sure” loops in parallel.
 | Note: If PFA identifies a loop as containing definite (as opposed to assumed) data dependencies, it does not run the loop in parallel even if a C*$* ASSERT DO (CONCURRENT) assertion precedes the loop. |
The C*$* ASSERT DO PREFER (SERIAL) assertion indicates that you want to execute a DO loop in serial mode. This assertion directs PFA to leave the DO loop alone, regardless of the setting of the optimization level. You can use this assertion to control which loop (in a nest of loops) PFA chooses to run in parallel.
The C*$* ASSERT DO PREFER (CONCURRENT) assertion runs a particular nested loop in parallel whenever possible. PFA runs other nested loops in parallel only if a condition prevents running the selected loop in parallel.
The C*$* ASSERT DO PREFER (CONCURRENT) assertion applies only to the DO loop that it precedes. PFA does not generate parallel code if you use the -NOCONCURRENTIZE command line option or the C*$* NOCONCURRENTIZE directive.
The C*$* ASSERT EQUIVALENCE HAZARD assertion allows equivalence variables to refer to the same memory location inside one loop. This assertion, when specified globally, has the same effect as the -ASSUME=E command line option. The C*$* ASSERT EQUIVALENCE HAZARD assertion is active until you reset it or until the end of the program unit. See also C*$* ASSERT NO EQUIVALENCE HAZARD.
C*$* ASSERT CONCURRENT CALL tells PFA to ignore assumed dependencies that are due to a subroutine call or a function reference. However, you must ensure that the subroutines and referenced functions are safe for parallel execution. This assertion applies to all subroutine and function references in the immediately following loop.
The C*$* ASSERT NO ARGUMENT ALIASING assertion allows PFA to make assumptions about subprogram arguments in a program. According to the Fortran 77 standard, you can alias a variable only if you do not modify (that is, write to) the aliased variable.
The C*$* ASSERT NO EQUIVALENCE HAZARD assertion tells PFA that your code does not use equivalenced variables to refer to the same memory location inside one loop nest. Normally, EQUIVALENCE statements allow your code to use different variable names to refer to the same memory location.
The C*$* ASSERT NO RECURRENCE (variable) assertion tells PFA to ignore all data dependencies associated with variable. PFA ignores not just assumed dependencies (as with the C*$* ASSERT DO (CONCURRENT) assertion) but also real dependencies. Use this assertion to force PFA to parallelize a loop when other, gentler means have failed. Use this assertion with great caution, as indiscriminate use can result in illegal parallel code.
The C*$* ASSERT PERMUTATION(array) assertion tells PFA that array contains no repeated values. This assertion permits PFA to run in parallel certain kinds of loops that use indirect addressing.
The C*$* ASSERT RELATION (name1 .xx. name2) assertion explicitly states the relationship between name1 and name2. name1 and name2 are two variables or a variable and a constant, and xx is any of the following: GT, GE, EQ, NE, LT, or LE. This assertion applies only to the DO statement it precedes.
If you specify this assertion globally, the program uses the assertion only when name1 and name2 appear in COMMON blocks or are dummy argument names to the subprogram.