Privatizing region variables

Regional privatization is manually specified using the parallel_private directive or pragma. parallel_private is provided to declare a list of variables and/or arrays private to the immediately following parallel region. It serves the same purpose for parallel regions as task_private does for tasks, and loop_private does for loops.

`parallel_private`

The parallel_private directive must immediately precede, or appear on the same line as, its corresponding parallel directive. Using parallel_private asserts that there are no dependences in the parallel region.

Do not use parallel_private if there are dependences.

Each parallel thread of execution receives a private copy of the parallel_private data object for the duration of the region. No starting or ending values are assumed for the data. If a parallel_private data object is referenced within a region, it must have been previously assigned a value in the region.

The form of this directive and pragma is shown in Table 6-5 “Form of parallel_private directive and pragma”.

Table 6-5 Form of parallel_private directive and pragma

Language	Form
Fortran	`C$DIR PARALLEL_PRIVATE(`namelist`)`
C	`#pragma _CNX parallel_private(`namelist`)`

where

namelist: is a comma-separated list of variables and/or arrays that are to be private to the immediately following parallel region. namelist cannot contain dynamic, allocatable, or automatic arrays.

Example 6-10 parallel_private

The following Fortran code shows how

parallel_private privatizes regions:

      REAL A(1000,8), B(1000,8), C(1000,8), AWORK(1000), SUM(8)
      INTEGER MYTID
      . 
      . 
      . 
C$DIR PARALLEL(MAX_THREADS = 8) 
C$DIR PARALLEL_PRIVATE(I,J,K,L,M,AWORK,MYTID)
      IF(NUM_THREADS() .LT. 8) STOP "NOT ENOUGH THREADS; EXITING"
      MYTID = MY_THREAD() + 1 !ADD 1 FOR PROPER SUBSCRIPTING
      DO I = 1, 1000
        AWORK(I) = A(I, MYTID)
      ENDDO
      DO J = 1, 1000
        A(J, MYTID) = AWORK(J) + B(J, MYTID)
      ENDDO
      DO K = 1, 1000
        B(K, MYTID) = B(K, MYTID) * AWORK(K)
        C(K, MYTID) = A(K, MYTID) * B(K, MYTID)
      ENDDO
      DO L = 1, 1000
        SUM(MYTID) = SUM(MYTID) + A(L,MYTID) + B(L,MYTID) + C(L,MYTID)
      ENDDO
      DO M = 1, 1000
        A(M, MYTID) = AWORK(M)
      ENDDO
C$DIR END_PARALLEL

This example checks for a certain number of threads and divides up the work among those threads. The example additionally introduces the parallel_private variable AWORK.

Each thread initializes its private copy of AWORK to the values contained in a dimension of the array A at the beginning of the parallel region. This allows the threads to reference AWORK without regard to thread ID. This is because no thread can access any other thread’s copy of AWORK. Because AWORK cannot carry values into or out of the region, it must be initialized within the region.

Induction variables in region privatization

All induction variables contained in a parallel region must be privatized. Code contained in the region runs on all available threads. Failing to privatize an induction variable would allow each thread to update the same shared variable, creating indeterminate loop counts on every thread.

In the previous example, in the J loop, after AWORK is initialized, AWORK is effectively used in a reduction on A; at this point its contents are identical to the MYTID dimension of A. After A is modified and used in the K and L loops, each thread restores a dimension of A’s original values from its private copy of AWORK. This carries the appropriate dimension through the region unaltered.

Privatizing region variables

Technical documentation

» Table of Contents

» Glossary

`parallel_private`

Induction variables in region privatization