If a dummy argument of an
`EXTRINSIC( "0DHPF"0D,"0DLOCAL"0D)`
routine is a scalar, then the corresponding dummy argument of the local
procedure
must be a scalar of the same type and type parameters. Only scalars
of intrinsic types, or of derived types that are not explicitly mapped,
may be passed from a global to an

If a dummy argument of an
`EXTRINSIC( "0DHPF"0D,"0DLOCAL"0D)` routine is
an array, then the corresponding dummy argument in the specification
of the local procedure must be an array of the same rank, type, and
type parameters.

If the array is sequential in the extrinsic interface, the
corresponding actual argument will be passed by replicatation on all
processors, just as scalar arguments are passed. Each local dummy
argument will be associated with a full copy of the actual array
argument. The dummy argument in the extrinsic interface and the
corresponding dummy argument in the specification of the local
procedure may be declared with the same explicit shape. All
sequential dummy arguments passed by replication to an
`EXTRINSIC( "0DHPF"0D,"0DLOCAL"0D)`
procedure must either be

If the dummy argument is a nonsequential array, then, when the extrinsic procedure is invoked, the local dummy argument is associated with the local array that consists of the subgrid of the global array that is stored locally. This local array will be a valid HPF array.

If an `EXTRINSIC( "0DHPF"0D,"0DLOCAL"0D)`
routine is a function, then
the local procedure is a function that returns a scalar of the same
type and type parameters as the HPF extrinsic function. The value
returned by each local invocation must be the same.

Each physical processor has at most one copy of each HPF variable.

Consider the following extrinsic interface:

INTERFACE EXTRINSIC('HPF','LOCAL') FUNCTION MATZOH(X, Y) RESULT(Z) REAL, DIMENSION(:,:) :: X REAL, DIMENSION(:) :: Y REAL Z !HPF$ ALIGN WITH X(:,*) :: Y(:) ! note that this asserts that size(Y) = size(X,1) !HPF$ DISTRIBUTE X(BLOCK, CYCLIC) END FUNCTION END INTERFACE

The corresponding local HPF procedure is specified as follows.

EXTRINSIC('HPF','LOCAL') FUNCTION MATZOH(XX, YY) RESULT(ZZ) REAL, DIMENSION(:,:) :: XX REAL, DIMENSION(5:) :: YY ! assumed shape with lower bound of 5 REAL ZZ NX1 = SIZE(XX, 1) LX1 = LBOUND(XX, 1) UX1 = UBOUND(XX, 1) NX2 = SIZE(XX, 2) LX2 = LBOUND(XX, 2) UX2 = UBOUND(XX, 2) NY = SIZE(YY, 1) LY = LBOUND(YY, 1) UY = UBOUND(YY, 1) ... END FUNCTION

Assume that the function is invoked with an actual (global) array
`X` of shape and an actual vector `Y`
of length on a 4-processor machine, using a
processor arrangement (assuming one abstract processor per physical
processor).

Then each local invocation of the function `MATZOH` receives the
following actual arguments:

Processor (1,1) Processor (1,2) X(1,1) X(1,3) X(1,2) X(2,1) X(2,3) X(2,2) Y(1) Y(1) Y(2) Y(2) Processor (2,1) Processor (2,2) X(3,1) X(3,3) X(3,2) Y(3) Y(3)

Here are the values to which each processor would set `NX1`,
`LX1`, `UX1`, `NX2`, `LX2`, `UX2`, `NY`, `LY`, and
`UY`:

Processor (1,1) Processor (1,2) NX1=2 LX1=1 UX1=2 NX1=2 LX1=1 UX1=2 NX2=2 LX2=1 UX2=2 NX2=1 LX2=1 UX2=1 NY=2 LY=5 UY=6 NY=2 LY=5 UY=6 Processor (2,1) NX1=2 LX1=1 UX1=2 NX1=2 LX1=1 UX1=2 NX2=2 LX2=1 UX2=2 NX2=1 LX2=1 UX2=1 NY=1 LY=5 UY=5 NY=1 LY=5 UY=5

An actual argument to an extrinsic procedure may be a pointer. Since
the corresponding dummy argument may not have the `POINTER`
attribute, the dummy argument becomes associated with the target of
the HPF global pointer. In no way may a local pointer become pointer
associated with a global HPF target. Therefore, an actual argument
may not be of a derived-type containing a pointer component.

*Rationale.*It is expected that global pointer variables will have a different representation from that of local pointer variables, at least on distributed memory machines, because of the need to carry additional information for global addressing. This restriction could be lifted in the future. (*End of rationale.*)

Other inquiry intrinsics, such as `ALLOCATED` or
`PRESENT`, should also behave as expected. Note that when a
global array is passed to a local routine, some processors may receive
an empty set of elements.