On 5/23/11 12:44 PM, Rolf Rabenseifner wrote:

A) If we are doing BIND(C), I defined for MPI-3.0:

INTERFACE SUBROUTINE MPI_Sizeof(x, size, ierror) BIND(C) IMPLICIT NONE TYPE(*) :: x INTEGER, INTENT(OUT) :: size INTEGER, OPTIONAL, INTENT(OUT) :: ierror END SUBROUTINE END INTERFACE

This seems to be ***bad*** because TYPE(*) is not enough to get the dope vector

Correct. No dope vector here - just an address. Not useful in this case.

TR 29113, 5.2.2, CFI_cdesc_t, especially its structure element

size_t elem_len; If the object corresponds to a Fortran CHARACTER object, the value equals the length of the CHARACTER object times the sizeof() of a scalar of the character type; otherwise, the value equals the sizeof() of an element of the object.

We should do

TYPE(*), DIMENSION(..) :: x

Better. dimension(..) will result in a (point to the) dope vector being passed.

which extends the current definition (in a backward compatible way).

Then size = elem_len of the dope vector.

Correct?

Yes, assuming the caller knows the type. If you want the particular capitalization shown, you should make the first line of the routine subroutine MPI_Sizeof (x, size, ierror) BIND(C, name="MPI_Sizeof") Without the name= specifier, the external name will be mpi_sizeof (all lower case). This option seems like the best one - Fortran interface with C implementation. I assume this is not a performance sensitive routine, since there is overhead involved in creating the dope vector.

B) If an implementation choose Fortran binding:

B1) Does (without assumed-rank)

SUBROUTINE MPI_Sizeof(x, size, ierror) IMPLICIT NONE TYPE(*) :: x INTEGER, INTENT(OUT) :: size INTEGER, OPTIONAL, INTENT(OUT) :: ierror size = SIZEOF(x) END SUBROUTINE

work?

No. SIZEOF is not a Fortran intrinsic, and there is no interface visible that indicates SIZEOF takes a type(*) argument. There is a STORAGE_SIZE intrinsic that provides similar functionality, but it is not in the list of intrinsics that allow a type(*) argument.

B2) Does (with assumed-rank)

SUBROUTINE MPI_Sizeof(x, size, ierror) IMPLICIT NONE TYPE(*), DIMENSION(..) :: x INTEGER, INTENT(OUT) :: size INTEGER, OPTIONAL, INTENT(OUT) :: ierror size = SIZEOF(x) END SUBROUTINE

work, or how can it be programmed?

This suffers from the same problem as the previous example, since it fails the restrictions on what can be done with a type(*) variable. An assumed-rank variable (dimension(..)) is allowed as an argument to STORAGE_SIZE, so it could be used in combination with explicit type arguments to greatly reduce the number of specifics in a generic interface. Still would need interfaces for (typically) 4 (integer) * 4 (logical) * 2 (real) * 2 (complex) * 1 (character) = 64 types. Compared to the C implementation, this seems clumsy. Cheers, Bill

Best regards Rolf

----- Original Message -----

...

From: "Bill Long"<[email protected]> To: [email protected] Sent: Monday, May 23, 2011 4:47:26 PM Subject: Re: [MPI3 Fortran] MPI_SIZEOF question

The difficulty in writing things like this in Fortran is why the standard provides intrinsics. In this case, see STORAGE_SIZE, which returns the size of an array element of the type of the argument in bits. Dividing by 8 and multiplying by the array size (if the argument is not a scalar) should be simple enough for the user.

On 5/23/11 8:30 AM, Jeff Squyres wrote:

...

I'm re-working Open MPI's Fortran implementation with Craig.

The MPI_SIZEOF function is supposed to return the size of any Fortran intrinsic data type. MPI-2.2 16.2.5 p494:31-44 says:

----- The following functions allow a user to obtain a size-specific MPI datatype for any intrinsic Fortran type.

MPI_SIZEOF(x, size) IN x a Fortran variable of numeric intrinsic type (choice) OUT size size of machine representation of that type (integer)

This one is very close to STORAGE_SIZE. Just divide by 8.

...

MPI_SIZEOF(X, SIZE, IERROR) <type> X INTEGER SIZE, IERROR

This one would require also multiplying by the size of an array argument. I assume the IERROR is there only to provide a distinction for the generic interface. It is hard to imagine an actual run-time error with a routine like this.

Ultimately, I'd be inclined to just scrap the routine as redundant.

Cheers, Bill

...

This function returns the size in bytes of the machine representation of the given variable. It is a generic Fortran routine and has a Fortran binding only. -----

Is there any way of implementing that other than an interface with an overloaded subroutine for every single intrinsic type (including dimension)?

-- Bill Long [email protected] Fortran Technical Support& voice: 651-605-9024 Bioinformatics Software Development fax: 651-605-9142 Cray Inc./Cray Plaza, Suite 210/380 Jackson St./St. Paul, MN 55101

_______________________________________________ mpi3-fortran mailing list [email protected] http://lists.mpi-forum.org/mailman/listinfo.cgi/mpi3-fortran

-- Bill Long [email protected] Fortran Technical Support & voice: 651-605-9024 Bioinformatics Software Development fax: 651-605-9142 Cray Inc./Cray Plaza, Suite 210/380 Jackson St./St. Paul, MN 55101