# Compaq KAP Fortran/OpenMP
for Tru64 UNIX
User Guide

Previous | Contents | Index

# Appendix D
PCF Directives

Use Parallel Computing Forum (PCF) directives only with loops that are safe to parallelize. When Compaq KAP sees loops prefaced with PCF directives, it does not perform data dependence analysis and does not prevent you from using a parallel directive incorrectly.

Observe the following rules:

- Begin each PCF directive with `!*kap*` . To continue a directive onto subsequent lines, begin each line with `!*kap*&` .
- Except for PARALLEL DO, you must pair the directives.
- Do not nest the same type of directive. For example, do not insert a CRITICAL SECTION directive inside another CRITICAL SECTION and END CRITICAL SECTION directive.
- Use the CRITICAL SECTION, ONE PROCESSOR SECTION, and PARALLEL DO directives only within a PARALLEL REGION directive.
- Do not use an array element in any variable list as a `local_name` , a `shared_name` , or a `last_local` .
- Do not use common block names in variable lists. Either leave the `last_local` variable undeclared or explicitly declare the `last_local` variable as SHARED. KAP treats an undeclared `last_local` variable as a SHARED variable and issues a warning. Do not declare it to be LOCAL.

# D.1 PARALLEL REGION Directive

The PARALLEL REGION and END PARALLEL REGION directives delineate where parallelism exists in the program. The following example shows the PARALLEL REGION directive syntax:

    !*kap*          PARALLEL REGION
    !*kap*&            [ IF(logical expression) ]
    !*kap*&            [ SHARED(shared_name,...) ]
    !*kap*&            [ LOCAL(local_name,...) ]
    !*kap*          END PARALLEL REGION

In the syntax example, `local_name` and `shared_name` are references to a variable or an array. If the IF clause logical expression evaluates to .FALSE., all of the code between PARALLEL REGION and END PARALLEL REGION executes on a single processor. If the logical expression evaluates to .TRUE., the code between the PARALLEL REGION and the corresponding END PARALLEL REGION may execute on multiple processors.

The SHARED and LOCAL lists on the PARALLEL REGION directive state the explicit forms of data sharing among the processors that execute the code inside the parallel region. When distinct processors reference the same variable or array from the SHARED list, the processors reference the same storage location. When distinct processors reference the same variable or array from the LOCAL list, the processors reference distinct storage locations.

# D.2 PARALLEL DO Directive

The PARALLEL DO directive tells KAP the next statement begins an iterative DO loop that can be executed using multiple processors. Each processor applied to the DO loop can execute one or more iterations.

The following syntax example shows the PARALLEL DO directive inside a PARALLEL REGION:

    !*kap*  PARALLEL REGION
    !*kap*&    [ IF(logical expression) ]
    !*kap*&    [ SHARED(shared_name,...) ]
    !*kap*&    [ LOCAL(local_name,...) ]
    !*kap*          PARALLEL DO
    !*kap*&          [ STATIC ]
    !*kap*&          [ LAST LOCAL(local_name,...) ] ]
    !*kap*&          [ BLOCKED [ (integer constant expression) ] ]
    !*kap* END PARALLEL REGION

In the syntax example, `LAST LOCAL(local_name)` creates a "local name" type variable that is used during execution of the PARALLEL DO loop. During the last PARALLEL DO loop iteration, the final value of `local_name` is copied into an identically named variable created by `SHARED(shared_name)` in the enclosing PARALLEL REGION. For example, the final value of variable `LAST LOCAL(x)` would be copied into variable `SHARED(x)` , as follows:

    !*kap*  PARALLEL REGION
    !*kap*&    SHARED(x)
    !*kap*          PARALLEL DO
    !*kap*&          LAST LOCAL(x)
                     DO 10
                     .
                     .
                     .
       10            CONTINUE
    !*kap*  END PARALLEL REGION

Because the `LAST LOCAL()` variable inside the PARALLEL DO implies the `SHARED()` variable inside the PARALLEL REGION, it is legal to use both PCF directives.

If `[ BLOCKED [ (integer constant expression) ] ]` is specified in a PARALLEL DO, loop iterations are assigned to run-time "workers." A "worker" is a logical processor, that is, a processor, a process, or a thread in blocks of that size.

If `BLOCKED` is omitted in a PARALLEL DO directive, the default is even scheduling where loop iterations are evenly divided among run-time "workers." If `BLOCKED` is specified without a number, the default block size is 1.

# D.3 DO Loop Example with PCF Directives

The following example shows the use of the PARALLEL REGION and the PARALLEL DO directives in a simple loop:

    !*kap* PARALLEL REGION
    !*kap*& SHARED(A,B,C) LOCAL(I)
    !*kap* PARALLEL DO
          do 10 i=1,n
              a(i) = b(i) * c(i)
       10 continue
    !*kap* END PARALLEL REGION

# D.4 Program Example with PCF Directives

The following program example shows the use of the PARALLEL REGION and the PARALLEL DO directives:

            PROGRAM ATIMESB

            PARAMETER M=512, N=512, P=512

            REAL time1,time2
            REAL*8 A,B,C
            DIMENSION A(1:M,1:N), B(1:N,1:P), C(1:M,1:P)

    C Initialize the matrices

    !*kap* PARALLEL REGION SHARED (A,B) LOCAL (J,I)
    !*kap* PARALLEL DO

            DO 10 J=1,N
              DO 10 I=1,M
              A(I,J) = 1.5
       10   CONTINUE

    !*kap* PARALLEL DO

            DO 20 J=1,P
              DO 20 I=1,N
              B(I,J) = 3.0
       20   CONTINUE

    !*kap* END PARALLEL REGION

    C Compute C = A * B

            CALL CSETTIME()
            time1 = CTIMEC()
            CALL MATMUL(A, M, B, N, C, P)
            time2 = CTIMEC()
            write(*,*)'elapsed time in seconds is:',(time1-time2)
            END

            SUBROUTINE MATMUL(A, LDA, B, LDB, C, LL)
            REAL A(LDA,LDB), B(LDB,LL), C(LDA,LL)
            INTEGER LDA,LDB,LL

    !*kap* PARALLEL REGION SHARED (A,LDA,B,LDB,C,LL) LOCAL (J,K,I)

    !*kap* PARALLEL DO
            DO 20 J=1,LL
              DO 20 I=1,LDA
              C(I,J) =0.0
                DO 20 K=1,LDB
                C(I,J) = C(I,J) + ( A(I,K) * B(K,J) )
       20   CONTINUE

    !*kap* END PARALLEL REGION
            RETURN

            END

# D.5 CRITICAL SECTION Directive

The CRITICAL SECTION and END CRITICAL SECTION directives define the scope of a critical section. Exactly one logical processor at a time is allowed inside a CRITICAL SECTION. This construct must be coded lexically inside a PARALLEL REGION and END PARALLEL REGION.

# D.6 ONE PROCESSOR SECTION Directive

The ONE PROCESSOR SECTION and END ONE PROCESSOR SECTION directives define the scope of a section of code where exactly one processor is allowed to execute the code. This directive must be coded lexically inside a PARALLEL REGION and END PARALLEL REGION.

# D.7 Comparison of KAP PCF and Cray Autotasking Directives

If you formerly used Cray autotasking to perform parallel decomposition, you can substitute KAP PCF directives, as shown in Table D-1.

Table D-1 KAP PCF and Cray Autotasking Directives
KAP Parallel Computing Forum | Cray Autotasking
--- | ---
Specifying Regions of Parallel Execution
!*kap* PARALLEL REGION | CMIC$ PARALLEL
!*kap* END PARALLEL REGION | CMIC$ END PARALLEL
Specifying Parallel Loops |
!*kap* PARALLEL DO | CMIC$ DO PARALLEL
End defined by loop scope | CMIC$ END DO
Specifying Synchronized Code Sections |
!*kap* CRITICAL SECTION | CMIC$ GUARD
End defined by loop scope | CMIC$ END GUARD
!*kap* ONE PROCESSOR SECTION |
!*kap* END ONE PROCESSOR SECTION |
Specifying Code Sections for Parallel Execution |
Equivalent coded with PARALLEL DO | CMIC$ END CASE
Controlling Subroutines Called Within Parallel Regions |
!*$* ASSERT CONCURRENT CALL | CMIC$ CONTINUE
Unstructured Exits from Parallel Region |
Not available currently | CMIC$ SOFT EXIT
Equivalent coded with PARALLEL REGION with one loop optimization performed by KAP | CMIC$ DO ALL (end defined by loop)

Previous | Next | Contents | Index