The first look at the definitions might indeed be a bit confusing, as it
is strange to see overloaded C functions (even though C11 _Generic has
been around for a while). It is also not clear when the second variant
(using MPI_Count) is available, that is only if C11 _Generic is
supported by my compiler. Even worse, a C99 compiler will happily cast
an MPI_Count argument passed by value to int without complaint or
warning by default. Should we mark in the interface the fact that the
MPI_Count overloads are only available in C11? I'm thinking about
something similar to cppreference's distinction between C/C++ standard
int MPI_Send(const void *buf, int count, MPI_Datatype datatype, int
dest, int tag, MPI_Comm comm)
int MPI_Send(const void *buf, MPI_Count count, MPI_Datatype datatype,
int dest, int tag, MPI_Comm comm) [>C11|C++]
int MPI_Send_x(const void *buf, MPI_Count count, MPI_Datatype datatype,
int dest, int tag, MPI_Comm comm)
That way it is immediately clear that there is a catch here and users
have to be careful. OpenShmem, for example, has that distinction too
(although more explicit using paragraphs for different language flavors).
On 7/30/19 6:13 PM, Jeff Squyres (jsquyres) via mpi-forum wrote:
See the attached two PDFs for how "BigCount" will be rendered in the
MPI-4.0 PDF (pt2pt chapter and pt2pt/external interfaces in Annex A).
Comments / suggestions are welcome, but you may only make comments /
suggestions if you have read all of the "MORE DETAIL" section, below.
We have split the work of the "BigCount" WG into two parts:
1. Updating all the bindings throughout the entire MPI spec. This is
further sub-divided into two parts:
1a. Updating the bindings in the chapters of the MPI spec.
1b. Updating the bindings listing in Annex A.
2. Updating text in various chapters (e.g., Terms&Conventions and
Language Bindings) describing BigCount, language consequences,
describing how the bindings appear in the rest of the doc, ...etc.
We've incorporated all the feedback from the BigCount Virtual Meeting
last week, and I'd like to share samples of how #1a and #1b will look in
the MPI 4.0 PDF.
Text for #2 will be read at the September meeting (stay tuned -- that
text will be published according to the normal 2-week deadline, etc.).
Attached are 2 documents:
1. The point-to-point chapter rendered in the new style. Look at the
bindings for MPI_SEND and MPI_RECV, for example.
2. Annex A rendered in the new style (only some of the bindings have
been updated so far -- such as pt2pt and external interfaces).
If you are confused when looking at these PDFs (e.g., why are there up
to 3 C bindings?), and/or if you weren't at the Virtual Meeting / didn't
watch the Webex after the fact, the feedback we received from the
Virtual Meeting is summarized below. It is a lot of wordswordswords and
is somewhat difficult to follow -- I highly suggest reading the rules
below while simultaneously examining the attached PDFs. The summary
below should make much more sense when looking at concrete examples.
The overall intent is:
A. In MPI-4.0, expose "BigCount" functionality through language
polymorphism in the C bindings and the mpi_f08 module (we are /_not_/
updating mpif.h or the mpi module).
B. C11 _Generic polymorphism kinda sucks, *and* we're in a transition
period where not all C compilers are C11-capable. Hence, we're exposing
up to *3* C bindings per MPI procedure to applications (including
explicitly exposing the "_x" variant where relevant).
C. Fortran polymorphism "just works" (skipping a longer explanation here
-- ask Rolf/Puri if you're interested in the details), so there will
only be up to *2* F08 bindings per MPI procedure.
For each binding in the main text of the document:
1. Show the "plain" MPI_Foo(...) C binding (e.g., as it appeared in MPI-3.1)
2. If the binding has count or displacement arguments:
2a. Show a second MPI_Foo() C binding with count and displacement
arguments as MPI_Count and MPI_Aint, respectively.
2b. If MPI_Foo() DOES NOT HAVE a corresponding MPI_Foo_x() in
MPI-3.1, show a third MPI_Foo_x(...) C binding with count/displacement
3. Show the "plain" MPI_Foo(...) F08 binding (e.g., as it appeared in
4. If the binding has count or displacement arguments:
4a. Show a second MPI_Foo() F08 binding with count and displacement
arguments as INTEGER(KIND=MPI_COUNT_KIND) and INTEGER(MPI_ADDRESS_KIND),
5. Show the "plain" F90 binding
- Slides we presented at the BigCount Virtual Meeting:
- Webex Recording of the BigCount Virtual Meeting:
- Froozle MPI, a no-op MPI implementation showing a bindings
implementation of BigCount: https://github.com/jsquyres/froozle-mpi
If you have read all the way down to this point, comments and feedback
are welcome. :-)
mpi-forum mailing list
mpi-forum mailing list