DIGITAL Fortran 90
User Manual for
DIGITAL UNIX Systems

The concepts of the parallel processing thread model are the same as those for OpenMP Fortran API (see Section 6.1.4).

6.2.5 Controlling the Data Environment

The following sections describe how you control the data environment within parallel and worksharing constructs. Using directives and data environment options on directives, you can:

• Privitize named common blocks (see Section 6.2.5.1)
• Control data scope attributes (see Section 6.2.5.2)

You can make named common blocks private to a thread, but global within the thread by using the TASKCOMMON or the INSTANCE PARALLEL directive:

• For TASKCOMMON, specify a comma-separated list of common block names
• For INSTANCE PARALLEL, specify a comma-separated list of common block names, each enclosed by slashes (/name/)

Only named common blocks can be made thread private.

Each thread gets its own copy of the common block, with the result that data written to the common block by one thread is not directly visible to other threads. During serial portions of the program, accesses are to the master thread copy of the common block.

You should assume that the data in thread private common blocks is undefined upon entry into the first parallel region unless you specified the COPYIN option in the PARALLEL directive (see COPYIN Option).

When you make thread private a common block that is initialized using DATA statements, the copy of the common block for each thread has that initial value. If no initial value is provided, the variables in the common block are assigned the value of zero.

You can also specify INSTANCE SINGLE, which is the default in the absence of any instance attribute. In this case, all threads share the same copy of the common block in the master thread. Assignments made by one thread affect the copy in all other threads.

6.2.5.2 Controlling Data Scope Attributes

You can use several options to control the data scope attributes of variables for the duration of the construct in which you specify them. If you do not specify a data scope attribute option on a directive, the default is SHARED for those variables affected by the directive.

Each of the data scope attribute options accepts a list, which is a comma-separated list of named variables or named common blocks that are accessible in the scoping unit. When you specify named common blocks, they must appear between slashes (/name/).

Not all of the options are allowed on all directives, but the directives to which each option applies are listed in the clause descriptions.

The data scope attribute options are:

• COPYIN
• DEFAULT
• FIRSTPRIVATE
• LASTLOCAL or LAST LOCAL
• PRIVATE or LOCAL
• REDUCTION
• SHARED or SHARE

COPYIN Option

Use the COPYIN option on the PARALLEL, PARALLEL DO, and PARALLEL SECTIONS directives to copy named common block values from the master thread copy to threads at the beginning of a parallel region, use the COPYIN option on the PARALLEL directive. The COPYIN option applies only to named common blocks that have been previously declared thread private using the TASKCOMMON or the INSTANCE PARALLEL directive (see Section 6.2.5.1).

Use a comma-separated list to name the common blocks and variables in common blocks you want to copy.

DEFAULT Option

This option is the same as the OpenMP Fortran API DEFAULT clause (see Section 6.1.5.2).

FIRSTPRIVATE Option

The FIRSTPRIVATE option is the same as the OpenMP Fortran API FIRSTPRIVATE clause (see Section 6.1.5.2).

LASTLOCAL or LAST LOCAL Option

Except for differences in directive name spelling, the LASTLOCAL or LAST LOCAL option is the same as the OpenMP Fortran API LASTPRIVATE clause (see Section 6.1.5.2).

PRIVATE or LOCAL Option

Except for the alternate directive spelling of LOCAL, the PRIVATE (or LOCAL) option is the same as the OpenMP Fortran API PRIVATE clause (see Section 6.1.5.2).

REDUCTION Option

Use the REDUCTION option on the PDO directive to declare variables that are to be the object of a reduction operation. Use a comma-separated list to name the variables you want to declare as objects of a reduction.

The REDUCTION option in the DIGITAL Fortran parallel compiler directive set is different from the REDUCTION clause in the OpenMP Fortran API directive set. In the OpenMP Fortran API directive set, both a variable and an operator type are given. In the DIGITAL Fortran parallel compiler directive set, the operator is not given in the directive. The compiler must be able to determine the reduction operation from the source code. The REDUCTION option can be applied to a variable in a DO loop only if the variable meets the following criteria:

• must be scalar
• must be assigned to exactly once in the DO loop
• must be read from exactly once in the DO loop and only in the right side of the assignment
• the assignment must be one of the following forms:

x = x operator expr x = expr operator x (except for subtraction) x = operator(x, expr) x = operator(expr, x)

where operator is one of the following supported reduction operations: +, -, *, .AND., .OR., .EQV., .NEQV., MAX, MIN, IAND, or IOR.

The compiler rewrites the reduction operation by computing partial results into local variables and then combining the results into the reduction variable. The reduction variable must be SHARED in the enclosing context.

SHARED or SHARE Option

Except for the alternate directive spelling of SHARE, the SHARED (or SHARE) option is the same as the OpenMP Fortran API SHARED clause (see Section 6.1.5.2).

6.2.6 Parallel Region Construct

The concepts of using a parallel region construct are the same as those for OpenMP Fortran API (see Section 6.1.6). However, the environment variable you use to set the default number of threads is MP_THREAD_COUNT and the run-time library routine is OtsSetNumThreads.

6.2.7 Worksharing Constructs

At the heart of parallel processing is the concept of the worksharing construct. A worksharing construct divides the execution of the enclosed code region among the members of the team created upon entering the enclosing parallel region construct.

A worksharing construct must be enclosed lexically within a parallel region if the worksharing directive is to execute in parallel. No new threads are launched and there is no implied barrier upon entry to a worksharing construct.

The worksharing constructs are:

• PDO and END PDO directives (see Section 6.2.7.1)
• PSECTIONS, SECTION, and END PSECTIONS directives (see Section 6.2.7.2)
• SINGLE PROCESS and END SINGLE PROCESS directives (see Section 6.2.7.3)

The PDO directive specifies that the iterations of the immediately following DO loop must be dispatched across the team of threads so that each iteration is executed in parallel by a single thread. The loop that follows a PDO directive cannot be a DO WHILE or a DO loop that does not have loop control. The iterations of the DO loop are divided among and dispatched to the existing threads in the team.

You cannot use a GOTO statement, or any other statement, to transfer control into or out of the PDO construct.

If you specify the optional END PDO directive, it must appear immediately after the end of the DO loop. If you do not specify the END PDO directive, an END PDO directive is assumed at the end of the DO loop.

If you do not specify the optional NOWAIT clause on the END PDO directive, threads synchronize at the END PDO directive. If you specify NOWAIT, threads do not synchronize at the END PDO directive. Threads that finish early proceed directly to the instructions following the END PDO directive.

The PDO directive optionally lets you:

• Control data scope attributes (see Section 6.1.5.2)
• Specify chunk size
• Specify schedule type
• Terminate loop execution early
• Override implicit synchronization

Specifying Chunk Size

A chunk is a contiguous group of iterations dispatched to a thread. You can explicitly define a chunk size for the current PDO directive by using the CHUNK or BLOCKED option. Chunk size must be a scalar integer expression. The specified chunk size overrides any chunk size specified by an earlier CHUNK directive, and applies only to the current PDO directive.

Refer to Section 6.2.10 for information about how chunk size and schedule type interact.

You can determine the chunk size for the current PDO or PARALLEL DO directive by using the following prioritized list. The available chunk size closest to the top of the list is used:

• The chunk size specified in the CHUNK or BLOCKED option of the current PDO or PARALLEL DO directive
• The value specified in the most recent CHUNK directive
• If the schedule type for the current PDO or PARALLEL DO directive is either INTERLEAVED, DYNAMIC, GUIDED, or RUNTIME; the chunk size default value specified in the MP_CHUNK_SIZE environment variable
• The compiler default chunk size value of one

Specifying Schedule Type

The schedule type specifies a scheduling algorithm that determines how chunks of loop iterations are dispatched to the threads of a team. You can explicitly define a schedule type for the current PDO or PARALLEL DO directive by using the MP_SCHEDTYPE option. The specified schedule type overrides any default schedule type specified by an earlier MP_SCHEDTYPE directive, and applies to the current PDO or PARALLEL DO directive only.

You can determine the schedule type used for the current PDO or PARALLEL DO directive by using the following prioritized list. The available schedule type closest to the top of the list is used:

• The schedule type specified in the MP_SCHEDTYPE option of the current PDO or PARALLEL DO directive
• The schedule type specified in the most recent MP_SCHEDTYPE directive
• If the schedule type for the current PDO or PARALLEL DO directive is RUNTIME, the default value specified in the MP_SCHEDTYPE environment variable
• The compiler default schedule type of STATIC

For information about schedule types, see Section 6.2.11.

Another option you can use to affect the way threads are dispatched is the ORDERED option. When you specify this option, iterations are dispatched to threads in the same order they would be for sequential execution.

Terminating Loop Execution Early

If you want to terminate loop execution early because a specified condition has been satisfied, use the PDONE directive. This is an executable directive and any undispatched iterations are not executed. However, all previously dispatched iterations are completed. When the schedule type is STATIC or INTERLEAVED, this directive has no effect because all iterations are dispatched prior to loop execution.

Overriding Implicit Synchronization

Whether or not you include the END PDO directive at the end of the DO loop, by default an implicit synchronization point exists immediately after the last statement in the loop. Threads reaching this point wait until all threads complete their work and reach this synchronization point.

If there are no data dependences between the variables inside the loop and those outside the loop, there may be no reason to make threads wait. In this case, use the NOWAIT clause on the END PDO directive to override synchronization and allow threads to continue.

6.2.7.2 PSECTIONS, SECTION, and END PSECTIONS Directives

Except for the different PSECTIONS directive name, this directive is the same as the OpenMP Fortran API SECTIONS directive (see Section 6.1.7.2).

6.2.7.3 SINGLE PROCESS and END SINGLE PROCESS Directives

Except for the different SINGLE PROCESS directive name, this directive is the same as the OpenMP Fortran API SINGLE directive (see Section 6.1.7.3).

6.2.8 Combined Parallel/Worksharing Constructs

The combined parallel/worksharing constructs provide an abbreviated way to specify a parallel region that contains a single worksharing construct. The combined parallel/worksharing constructs are:

• PARALLEL DO (see Section 6.2.8.1)
• PARALLEL SECTIONS (see Section 6.2.8.2)

This directive is the same as the OpenMP Fortran API PARALLEL DO directive with the following exceptions:

• You can use the alternate DOACROSS directive name instead of PARALLEL DO
• The options can be one or more of the options for the PARALLEL and PDO directives

For information about the OpenMP Fortran API PARALLEL DO directive, see Section 6.1.8.1.

6.2.8.2 PARALLEL SECTIONS and END PARALLEL SECTIONS Directives

This directive is the same as the OpenMP Fortran API PARALLEL SECTIONS directive with the following exception:

• The options can be one or more of the options for the PARALLEL and PSECTIONS directives

For more information about the OpenMP Fortran API PARALLEL SECTIONS directive, see Section 6.1.8.2.

6.2.9 Synchronization Constructs

Synchronization refers to the interthread communication that ensures the consistency of shared data and coordinates parallel execution among threads.

Shared data is consistent within a team of threads when all threads obtain the identical value when the data is accessed.

To achieve explicit thread synchronization, you can use:

• BARRIER directive (see Section 6.2.9.1)
• CRITICAL SECTION directive (see Section 6.2.9.2)

The BARRIER directive is the same as the OpenMP Fortran API BARRIER directive (see Section 6.1.9.2).

6.2.9.2 CRITICAL SECTION and END CRITICAL SECTION Directives

The CRITICAL SECTION and END CRITICAL SECTION directives are the same as the OpenMP Fortran API CRITICAL and END CRITICAL directives with the following exceptions:

• The directive names are CRITICAL SECTION and END CRITICAL SECTION.
• You can specify an optional latch variable name.
• If you do not specify a latch variable name, the compiler assigns a unique name.
• The END CRITICAL SECTION directive does not take a latch variable name.
• You must explicitly initialize a latch variable to zero before any critical section using that latch variable is executed.
• You must not reuse that latch variable in anything other than a critical section until all uses as a latch variable are complete.

For additional information about the OpenMP Fortran API CRITICAL directive, see Section 6.1.9.3.

6.2.10 Specifying a Default Chunk Size

To specify a default chunk size, use the CHUNK directive. Chunk size must be a scalar integer expression. The interaction between the chunk size and the schedule type are:

• For the DYNAMIC and INTERLEAVED schedule types, iterations are always dispatched to threads in chunk size groups. If the total number of iterations is not evenly divisible by chunk size, the last group dispatched has fewer iterations.
• For the GUIDED schedule type, chunk size is the minimum number of iterations that can be dispatched to a thread. If less than chunk size iterations remain, the remaining iterations are dispatched to the next available thread.
• For the STATIC schedule type, chunk size is ignored.

You can also specify a chunk size by using the CHUNK option of the PDO or PARALLEL DO directive (see Specifying Chunk Size.)

6.2.11 Specifying a Default Schedule Type

To specify a default schedule type, use the MP_SCHEDTYPE directive. The following list describes the schedule types and how the chunk size affects scheduling:

• For the STATIC or SIMPLE schedule types, one contiguous group of iterations is dispatched to each thread, with each group having approximately the same number of iterations.
• For the INTERLEAVED or INTERLEAVE schedule types, a chunk sized group of iterations is dispatched to each thread in a round-robin manner.
• For the DYNAMIC schedule type, a chunk sized group of the remaining iterations is dispatched to the next available thread. If less than one chunk size of iterations remain, all the remaining iterations are dispatched.
• For the GUIDED or GSS schedule types (similar to the DYNAMIC schedule type), the number of iterations dispatched is relatively large at the beginning of the loop and decreases exponentially. The number of iterations dispatched is not necessarily evenly divisible by chunk size.
  The specified chunk size is the minimum number of iterations that can be dispatched when a thread becomes available. When the number of remaining iterations is less than or equal to chunk size, all of the remaining iterations are dispatched to the next available thread.
  In some cases, setting a chunk size greater than 1 improves execution efficiency as the loop nears termination. This is because contention between threads for the small number of remaining iterations is reduced.
• For the RUNTIME schedule type, the schedule type and the chunk size are those specified in the MP_SCHEDTYPE environment variable.

The DYNAMIC and GUIDED schedule types introduce some amount of overhead required to manage the continuing dispatching of iterations to threads. However, this overhead is sometimes offset by better load balancing when the average execution time of iterations is not uniform throughout the loop.

The STATIC and INTERLEAVED schedule types dispatch all of the iterations to the threads in advance, with each thread receiving approximately equal numbers of iterations. One of these types is usually the most efficient schedule type when the average execution time of iterations is uniform throughout the loop.

You can also specify a schedule type using the MP_SCHEDTYPE option of the PDO or PARALLEL DO directive (see Specifying Schedule Type.)