One of the goals of MPI is to support parallel computations across
heterogeneous environments. Communication in a heterogeneous
heterogeneous
environment may require data conversions.
We use the following terminology.

Type conversion

changes the datatype of a value, for example,
by rounding a REAL to an INTEGER.
type conversionconversion, type

The type matching rules imply that MPI communications never do type
conversion. On the other hand, MPI requires that a representation
conversion be
performed when a typed value is transferred across environments that use
different representations for such a value.
MPI does not specify the detailed rules for representation
conversion. Such a conversion is
expected to preserve integer, logical or character values, and to
convert a floating point value to the nearest value that can be
represented on the target system.

Overflow and underflow exceptions may occur during floating point conversions.
overflowunderflow
Conversion of integers or characters may also lead to exceptions when a value
that can be represented in one system cannot be represented in the other
system. An exception
occurring during representation conversion results in a failure of the
communication. An error occurs either in the send operation, or the receive
operation, or both.

If a value sent in a message is untyped (i.e., of type MPI_BYTE),
MPI_BYTE
MPI_BYTE
then the binary representation of the byte stored at the receiver is
identical to the binary representation of the byte loaded at the sender. This
holds true, whether sender and receiver run in the same or in distinct
environments. No representation conversion is done.
Note that representation conversion may
occur when values of type MPI_CHARACTER or
MPI_CHAR are transferred, for example, from an
EBCDIC encoding to an ASCII encoding.
MPI_CHARACTER
MPI_CHAR

No representation conversion need occur when an MPI program executes in
a homogeneous system, where all processes run in the same environment.

Consider the three examples, -.
The first program is correct, assuming that a and b are
REAL arrays of size >= 10 .
If the sender and receiver execute in different environments,
then the ten real values that are fetched from the send buffer will
be converted to the representation for reals on the receiver site
before they are stored in the receive buffer. While the
number of real elements fetched from the send buffer equal the
number of real elements stored in the receive buffer, the number of
bytes stored need not equal the number of bytes loaded. For example, the
sender may use a four byte representation and the receiver an eight
byte representation for reals.

The second program is erroneous, and its behavior is undefined.

The third program is correct. The exact same
sequence of forty bytes that were loaded from the send buffer will be
stored in the receive buffer, even
if sender and receiver run in a different environment. The message
sent has exactly the same length (in bytes) and the same binary
representation as the message received. If a and b are
of different types,
or if they are of the same type but different data representations are used,
then the bits stored in the receive buffer may encode values that are
different from the values they encoded in the send buffer.

Representation conversion also applies to the envelope of a message.
The source, destination and tag are all integers that may need to be converted.

MPI does not require support for inter-language
communication. The behavior of a program is undefined if messages are sent
by a C process and received by a Fortran process, or vice-versa.
inter-language communication