Fortran OpenMP with subroutines and functions

by

OK, this is about the difference between the lexical and dynamic extent of OpenMP directives and the interaction with variable scoping. The lexical extent of a directive is the text between the beginning and the end of the structured block following a directive. The dynamic extent is the lexical extent plus statements executed as part of any subprogram executed as a result of statements in the lexical extent. So in something like

Program stuff
   Implicit None
   Real, Dimension( 1:100 ) :: a
   Call Random_number( a )
   !$omp parallel default( none ) shared( a )
   Call sub( a )
   !$omp end parallel
Contains
   Subroutine sub( a )
      Real, Dimension( : ), Intent( InOut ) :: a
      Integer :: i
      !$omp do
      Do i = 1, Size( a )
         a( i ) = 2.0 * a( i )
      End Do
   End Subroutine Sub
End Program stuff

(totally untested, written direct in here) the lexical extent of the parallel region initiated by !$omp parallel is just

   Call sub( a )

while the dynamic extent is the call and the contents of the subroutine. And for completeness of terminology the !$omp do is an example of an orphaned directive, a directive that is not in the lexical extent of another directive, but in the dynamic extent. See

https://computing.llnl.gov/tutorials/openMP/#Scoping

for another example.

Why does this matter? Well you can only explicitly scope variables for entities in the lexical scope, just the array a in this case, but for entities that become defined due to the dynamic extent being executed you can’t do this! Instead OpenMP has a number of rules, which in simple terms are

  1. The scope of subprogram arguments is inherited from the calling point, i.e. if you scoped them as private at the start of the lexical extent they stay private, and if shared they stay shared
  2. Local variables to subprograms are by default private (so i in the above is private, as you want) unless they are declared with the SAVE attribute (either explicitly or implicitly) in which case they are shared.

And in my experience that gets you most of the way! Use of the dynamic extent combined with orphaned directives is a great way to keep an OpenMP program under control, and I have to say I disagree with the above comment, I find orphaned workshare directives very useful indeed! So you can combine all of the above to do things like

Program dot_test
  Implicit None
  Real, Dimension( 1:100 ) :: a, b
  Real :: r
  a = 1.0
  b = 2.0
  !$omp parallel default( none ) shared( a, b, r )
  Call dot( a, b, r )
  Write( *, * ) r
  !$omp end parallel
Contains
  Subroutine dot( a, b, r )
    Real, Dimension( : ), Intent( In    ) :: a, b
    Real,                 Intent(   Out ) :: r
    Real, Save :: s
    Integer :: i
    !$omp single
    s = 0.0
    !$omp end single
    !$omp do reduction( +:s )
    Do i = 1, Size( a )
       s = s + a( i ) * b( i )
    End Do
    !$omp end do
    !$omp single
    r = s
    !$omp end single
  End Subroutine dot
End Program dot_test
Wot now? gfortran -std=f95 -fopenmp -O -Wall -Wextra dot.f90 
Wot now? export OMP_NUM_THREADS=3
Wot now? ./a.out
   200.000000    
   200.000000    
   200.000000

This simple situation is a bit complicated by module variables and common blocks, so don’t use global variables … but if you must they are by default shared unless declared as threadprivate. See

https://computing.llnl.gov/tutorials/openMP/#THREADPRIVATE

for an example.

More Related Contents:

  1. Why Segmentation fault is happening in this openmp code?
  2. Fortran running error
  3. Fortran 90 kind parameter
  4. Fortran: integer*4 vs integer(4) vs integer(kind=4)
  5. Is There a Better Double-Precision Assignment in Fortran 90?
  6. Fortran assignment on declaration and SAVE attribute gotcha
  7. changing array dimensions in fortran
  8. Why should I use interfaces?
  9. Sending 2D arrays in Fortran with MPI_Gather
  10. Fortran OpenMP program shows no speedup of CPU_TIME()
  11. Where to put `implicit none` in Fortran
  12. Function has no implicit type
  13. Print to standard output from a function defined in an Fortran module
  14. ‘*’ and ‘/’ not recognized on input by a read statement
  15. Reading data file in Fortran with known number of lines but unknown number of entries in each line
  16. how to write wrapper for ‘allocate’
  17. gfortran does not allow character arrays with varying component lengths
  18. How do I do big integers in Fortran?
  19. What is the purpose of result variables in Fortran?
  20. Using a deferred-length character string to read user input
  21. Function in fortran, passing array in, receiving array out
  22. Reading writing fortran direct access unformatted files with different compilers
  23. Strange label usage for an IF condition in a DO loop [duplicate]
  24. Difference between intent(out) and intent(inout)
  25. Error: Nonnegative width required in format string at (1)
  26. Fortran intent(inout) versus omitting intent
  27. Fortran array cannot be returned in function: not a DUMMY variable
  28. Is Fortran unable to do the addition between 865398.78 and -865398.78? Why the answer is -0.03?
  29. How to pass subroutine names as arguments in Fortran?
  30. Confusing double precision real in Fortran

Leave a Comment