Subject: Re: hpff: July HPFF Meeting Minutes

From: [email-masked] (Rob Schreiber)
Date: Wed, 13 Sep 1995 11:31:59 -0700

---------------------------------------------------------------------------
[email-masked] is a mailing list for announcements related to High
Performance Fortran.  Instructions for adding or deleting yourself
from this list appear at the bottom of this message.
---------------------------------------------------------------------------

	   Date: Tue, 12 Sep 1995 14:17:49 -0700
	   From: [email-masked] (Rob Schreiber)

	   I think that a standard descriptor format would be
	   a good idea, but it should be in the form of a fortran 90
	   derived type, that can be replicated, for example, and passed as
	   an ordinary parameter to an extrinsic routine; then a library
	   routine would be used to set it up:

		   interface
		      extrinsic (c_local) function c_local_fn(desc)
		      integer c_local_fn
		      type (mapped_array_descriptor) desc
		   end interface

		   type (mapped_array_descriptor) x_desc
		   real, x(100,200)
	   !hpf$ distribute x(block, *)

	   !
	   !   call an hpf library routne to create the exportable 
	   !   array descriptor for x
	   !
		   x_desc = create_mapped_array_descriptor(x)
		   call c_local_fn(x_desc)

	H'mmm... I had assumed that HPF implementations generally passed data
	mapped array arguments as the address of a descriptor object.  The code
	fragment above seems to assume that the mapped_array_descriptor object
	doesn't already exist and needs to be created as a preamble to the call to
	c_local_fn.  Why wouldn't HPF simply pass the descriptor address and count
	on the called routine to examine the descriptor and do what was necessary?
	This might make sense in the absence of an interface block, or in an
	interface block containing transcriptive data mappings for x, or in an
	interface block for certain types of extrinsic function.

The reason I had in mind was this:  every implementation will want to
choose its own particular internal format for a mapped array
descriptor; but I would like to write an extrinsic subprogram that will
work with any implementation.  That is the reason for defining and
using a standard "external" descriptor as a fortran derived type.

Rob

---------------------------------------------------------------------------
To (un)subscribe to this list, send mail to [email-masked].  Leave
the subject line blank, and in the body put the line
(un)subscribe <email-address>
---------------------------------------------------------------------------

---

From: Doug MacDonald <[email-masked]>
Date: Wed, 13 Sep 95 16:45:47 EDT

Date: Wed, 13 Sep 1995 11:31:59 -0700
   From: [email-masked] (Rob Schreiber)

		      interface

	      !

   Rob

I'm also interested in the reverse: an SPMD main program written in C or
f77 with message passing wants to call a subroutine that was written and
compiled in HPF.  Either the user doesn't have HPF available in his
installation (maybe the HPF routine is part of a subroutine library he
purchased from a commercial vendor) or he has some other reason for not
wanting to have an HPF main program.

Can your proposal also take care of this case?

---

From: [email-masked] (Scott B. Baden)
Date: Wed, 13 Sep 1995 15:22:55 -0700 (PDT)

Doug,
This is a subject of another discussion.  Rob and I
have been chatting about this.. I'm quite interested
in calling HPF SPMD code.  Have you seen our email?

Scott

---

From: Doug MacDonald <[email-masked]>
Date: Thu, 14 Sep 95 12:17:27 EDT

From: [email-masked] (Scott B. Baden)
   Date: Wed, 13 Sep 1995 15:22:55 -0700 (PDT)

   Doug,

Hi Scott,

I don't think I did see it.  If it was an ongoing conversation between you
two CC'd to hpff-external, I wouldn't have seen it previously to yesterday,
when I added myself to that list.  I've done some thinking about this as
regards HPF 1.0.  I would be interested in seeing your earlier remarks
and/or proposal, as well as participating in any standardization of these
things.

Regards,
Doug MacDonald

   Scott