The assertion C*$* ASSERT DO (SERIAL) tells Power Fortran to run the loop immediately following it serially. Power Fortran also does not try to run any enclosing loop in parallel. However, it can still convert any loops nested inside the serial loop to run in parallel. For example, consider the code shown in Example 3-3.

subroutine nest(x,y,z,n)
real x(n,n,n), y(n,n), z(n,n)
   do i=1,n
      do j = 1,n
         do k = 1,n
            x(i,j,k) = x(i,j,k) * y(i,j)
         end do
         do k = 1,n
            X(i,j,k) = X(i,j,k) + Z(i,k)
         end do
      end do
   end do
end

As written, Power Fortran will interchange loop variables to invert the order of the three loops, and parallelizes the outermost loop. Adding an assertion as shown in Example 3-4 makes a dramatic change.

subroutine nest(x,y,z,n)
real x(n,n,n), y(n,n), z(n,n)
   do i=1,n
      do j = 1,n
!*$* ASSERT DO(SERIAL)
         do k = 1,n
            x(i,j,k) = x(i,j,k) * y(i,j)
         end do
         do k = 1,n
            X(i,j,k) = X(i,j,k) + Z(i,k)
         end do
      end do
   end do
end

The assertion forces the loop on I, the loop on J, and the first loop on K to be serial. Power Fortran still executes the second loop on K in parallel.

Silicon Graphics Power Fortran supports the Cray directive, CDIR$ NEXT SCALAR as a synonym for the C*$* ASSERT DO (SERIAL) assertion.

The C*$* ASSERT DO PREFER (SERIAL) assertion tells the compiler to prefer any ordering in which the loop following the assertion remains serial. Unlike C*$* ASSERT DO (SERIAL), this assertion does not inhibit optimization of outer loops. This assertion directs Power Fortran to leave the loop alone, regardless of the setting of the optimization level. You can use this assertion to control which loop in a nest of loops Power Fortran chooses to run in parallel. The code fragment in Example 3-5 is an example of how to use the assertion.

DO I = 1,  N
C*$*ASSERT DO PREFER (SERIAL)
   DO J = 1,  M
      A(I,J) = B(I,J)
   END DO
END DO

The assertion requests that the loop on J be serial. In this construction, Power Fortran tries to run the loop on I in parallel. This capability is useful when you know the value of M to be very small or less than N.

If the assertion in Example 3-4 is changed from DO (SERIAL) to DO PREFER (SERIAL), Power Fortran makes remarkable alterations in the transformed program, producing two copies of the outer loop, each containing just one of the inner loops on K.

The C*$*[NO]CONCURRENTIZE directive enables or disables Power Fortran from transforming eligible loops to run in parallel to the end of the current program unit.

Used locally, these directives override the –[no]concurrentize driver option. Used globally, these directives have the same effect as the –[no]concurrentize driver option. (See “Enabling Parallelization of Loops”)

Power Fortran supports the VAST directive CVD$CONCUR. Power Fortran interprets this directive as if it were the C*$*CONCURRENTIZE directive.

The C*$* ASSERT DO PREFER (CONCURRENT) assertion directs Power Fortran to run a particular nested loop in parallel if possible. Power Fortran runs another of the nested loops in parallel only if a condition prevents running the selected loop in parallel. This assertion applies only to the loop immediately after it.

Consider the code in Example 3-6.

!*$* ASSERT DO PREFER (CONCURRENT)
   DO I = 1, N
      DO 100 J = 1, M
         A (I, J) = B (I, J)
      END DO
   END DO

The assertion directs Power Fortran to prefer to run the loop on I in parallel. However, if a data dependence conflict prevents running that loop in parallel, Power Fortran might run the loop on J in parallel.

The –noconcurrentize command line option and the C*$* NO CONCURRENTIZE directive prevent Power Fortran from generating concurrent code, even if you specify the C*$* ASSERT DO PREFER (CONCURRENT) assertion.

The C*$* ASSERT DO (CONCURRENT) assertion tells Power Fortran to ignore assumed data dependencies.

Normally, Power Fortran is conservative about converting loops to run in parallel. When Power Fortran analyzes a loop, it categorizes the loop into one of three groups:

Normally, Power Fortran does not run in parallel a loop with an assumed data dependency. C*$* ASSERT DO (CONCURRENT) tells Power Fortran to go ahead and run “not sure” loops in parallel.

Power Fortran interprets the Cray directive CDIR$ IVDEP as if it were a C*$* ASSERT DO (CONCURRENT) assertion. Some dependencies that are safe to run on Cray hardware are not safe to run on Silicon Graphics hardware. Therefore, to avoid incorrect parallelization of loops recognition of this assertion is turned off by default.

The C*$* ASSERT RELATION(name.xx.name) assertion specifies that a particular logical relation always holds between two variables, or between a variable and a constant. name is the variable or constant, and xx is any of the logical relations GT, GE, EQ, NE, LT, or LE. Used locally, this assertion applies only to the following DO statement.

C*$* ASSERT RELATION can be specified globally when the variable names appear in COMMON blocks or are dummy arguments to a subprogram. You cannot use global assertions to make relational assertions about variables that are local to a subprogram.

The code in Example 3-7 illustrates the use of C*$* ASSERT RELATION.

subroutine sumdown(a,b,m,n)
   integer m,n,j
   real a,b
   dimension a(:),b(:)
   do j=1,n
      a(j) = a(j+m) + b(j)
   end do
end

When Power Fortran analyzes this code, it detects that a data dependence would exist if M were less than or equal to N, because in that case different instances of a concurrent loop could store into the same elements of A. Power Fortran parallelizes the loop by generating this IF statement:

if (M .ge. 1 .and. N .ge. M .or. M .le. (-1)) then

The THEN branch of the IF contains a serial version of the loop as originally written. The ELSE branch, executed when no data dependency can exist, contains a parallel version of the loop.

When you know that M is always greater than N, there is no need for this duplication of code. You can use C*$* ASSERT RELATION to inform Power Fortran, as shown in Example 3-8. When you do this, Power Fortran generates only the parallel form of the loop.

subroutine sumdown(a,b,m,n)
   integer m,n,j
   real a,b
   dimension a(:),b(:)
!*$* assert relation (m.gt.n)
   do j=1,n
      a(j) = a(j+m) + b(j)
   end do
end

The C*$* ASSERT NO RECURRENCE(variable) assertion tells the compiler to ignore all data dependence conflicts caused by variable in the loop that follows it. For example, the following code tells the compiler to ignore all dependence arcs caused by the variable X in the loop:

!*$* assert no recurrence (x)
   do i= 1,m,5
      x(k) = x(k) + x(i)
   end do

Not only does the compiler ignore the assumed dependence, it also ignores the real dependence caused by X(k) appearing on both sides of the assignment.

The C*$* ASSERT NO RECURRENCE assertion applies only to the following loop. It cannot be specified as a global assertion.

The C*$* ASSERT PERMUTATION(array) assertion tells Power Fortran that array contains no repeated values. This assertion permits Power Fortran to run in parallel certain kinds of loops that use indirect addressing. For a detailed example of the use of this assertion, see “Indirect Indexing”.

C*$* ASSERT CONCURRENT CALL tells Power Fortran to ignore assumed dependencies that are caused by a subroutine call or a function reference. You must ensure that the subroutines and referenced functions have no side effects and are safe for parallel execution. This assertion applies to all subroutine and function references in the following loop. For detailed examples of the use of this assertions, see “Function Call” and “Procedure Parameters”.

Power Fortran interprets the VAST directive CDIR$ CNCALL as if it were a C*$* ASSERT CONCURRENT CALL assertion. Some dependencies that are safe to run on Cray hardware are not safe to run on Silicon Graphics hardware. Therefore, recognition of this assertion is turned off by default.