[ HPF Home | Versions | Compilers | Projects | Publications | Applications | Benchmarks | Events | Contact ]

---

The Effect of a Call

  A call to an extrinsic procedure must be semantically equivalent to a call of an ordinary HPF procedure that does not remap its arguments. Thus a call to an extrinsic procedure must behave as if the following actions occur. The HPF technical term as if means that the described actions should appear to a user as if they occurred, in the order specified; an implementation may carry out any actions in any order that provide the correct user-visible effects.

1. All actions of the caller preceding the subprogram invocation should be completed before any action of the subprogram is executed; and all actions of the subprogram should be completed before any action of the caller following the subprogram invocation is executed.
2. Each actual argument is remapped, if necessary, according to the directives (explicit or implicit) in the declared interface for the extrinsic procedure. Thus, HPF mapping directives appearing in the interface are binding--the compiler must obey these directives in calling local extrinsic procedures. As in the case of non-extrinsic subprograms, actual arguments may be mapped in any way; if necessary, they are copied automatically to correctly mapped temporaries before invocation of--and copied back to the actual arguments after return from--the extrinsic procedure. Scalar dummy arguments and scalar function results behave as if they are replicated on each processor. These mappings may, optionally, be explicit in the interface, but any other explicit mapping is not HPF conforming.
3. IN, OUT, and INOUT intent restrictions should be observed.
4. No HPF variable is modified unless it could be modified by an HPF procedure with the same explicit interface. Note that even though HPF_LOCAL and HPF_SERIAL routines are not permitted to access and modify HPF global data, other kinds of extrinsic routines may do so to the extent that an HPF procedure could.
5. When a procedure returns and the caller resumes execution, all objects accessible to the caller after the call are mapped exactly as they were before the call. In particular, the original distribution of arguments is restored, if necessary.
6. Exactly the same set of processors is visible to the HPF environment before and after the subprogram call.

Advice to implementors.

To ensure that all actions that logically precede the call are completed, multiple processors may need to be synchronized before the call is made.

If a variable accessible to the called routine has a replicated representation, then all copies may need to be updated prior to the call to contain the correct current value according to the sequential semantics of the source program.

Replicated variables, if updated in the procedure, must be updated consistently. More precisely, if a variable accessible to a procedure has a replicated representation and is updated by (one or more copies of) the procedure, then all copies of the replicated variable must have identical values when the last processor returns from the local procedure.

An implementation might check, before returning from the local subprogram, to make sure that replicated variables have been updated consistently by the subprogram. Note, however, that there is no requirement for an implementation to do so; it is merely an implementation tradeoff between speed and, for instance, debuggability.

Note that, as with a global HPF subprogram, actual arguments may be copied or remapped in any way, so long as the effect is undone on return from the subprogram.

To ensure that all actions of the procedure logically complete before execution in the caller is resumed, multiple processors may need to be synchronized after the call.

(End of advice to implementors.)