• Definition
• Examples
  • General
  • Tariff Program
• Exercises (long)

  INTERFACE
  EXTRINSIC ( HPF | HPF_LOCAL | other ) 
  Description of the called routine
  END INTERFACE

This example assumes some prior knowledge of DISTRIBUTE and INDEPENDENT.

If you have a sequential Fortran program that simulates a physical system, you often have a loop nest in which a random number generator provides pseudo-random input:

         do i = ...
            do j = ...
               :
               x = rand(x)
               :
            end do
         end do

!hpf$ independent,new(j)         ! parallelize the "do i" loop
         do i = ...
            do j = ...
               :
               x(i) = prng_next(i)  ! next number from generator "i"
               :
            end do
         end do

There are just two more steps to parallelizing the above loop: you need a distributed array in order to get HPF to spread the loop iterations, and you need to tell the compiler that prng_next is "safe" to call in parallel.

The first is easily done by distributing x, so that the "owner" of x(i) will execute iteration "i":

      real*8, dimension(NMAX):: x
!hpf$ distribute x(BLOCK)

The second step is to tell HPF that prng_next is "pure," in that it contains no cross-iteration dependencies:

       interface
            pure function prng_next(i)
               integer,intent(in)::i
               real*8:: prng_next
            end function prng_next
        :
        end interface

In this example, assuming that the loop nest contains no other data dependencies, the "do i" loop will be spread in BLOCK fashion across the processors being used in the parallel job. This means that node 0 will execute iterations 1, 2, ... k, while node 1 will execute iterations k+1, k+2 ..., and so on.

          INTERFACE
          EXTRINSIC(HPF_LOCAL) & 
          SUBROUTINE sayit (t1,t2,message)
             real*8, intent(in)   :: t1,t2
             character*(*), intent(in) :: message
          END SUBROUTINE sayit
          EXTRINSIC(HPF_LOCAL) & 
	  SUBROUTINE getdata(sslope,shxlin,dslope,dhxlin,thxlin,ind1,ind2,tar)
             real,intent(out)::  sslope(:, :), shxlin(:)
             real,intent(out)::  dslope(:, :), dhxlin(:)
             real,intent(out)::  thxlin(:, :),tar(:, :)
             integer,intent(out):: ind1(:, :), ind2(:, :)
	  END SUBROUTINE getdata
          END INTERFACE

These subroutines will be run on each node as a normal Fortran subroutine, not as HPF. I/O statements are executed on each node. The interface block tells the HPF compiler exactly how the subroutine is to be called. This was done to eliminate the I/O bottleneck that occurred when reading in the data using HPF.

• Virtual Workshop Companion

• Part 5 (lab instructions only)
• Part 6 (lab instructions only)