2015-07-31 21:44:50 +03:00
|
|
|
.\" -*- nroff -*-
|
|
|
|
.\" Copyright (c) 2015 University of Houston. All rights reserved.
|
|
|
|
.\" Copyright (c) 2015 Mellanox Technologies, Inc.
|
|
|
|
.\" $COPYRIGHT$
|
|
|
|
.de Vb
|
|
|
|
.ft CW
|
|
|
|
.nf
|
|
|
|
..
|
|
|
|
.de Ve
|
|
|
|
.ft R
|
|
|
|
|
|
|
|
.fi
|
|
|
|
..
|
|
|
|
.TH "SHMEM\\_PUT" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
|
|
|
|
.SH NAME
|
|
|
|
|
|
|
|
\fIshmem_character_put\fP(3),
|
|
|
|
\fIshmem_complex_put\fP(3),
|
|
|
|
\fIshmem_double_put\fP(3),
|
|
|
|
\fIshmem_float_put\fP(3),
|
|
|
|
\fIshmem_int_put\fP(3),
|
|
|
|
\fIshmem_integer_put\fP(3),
|
|
|
|
\fIshmem_logical_put\fP(3),
|
|
|
|
\fIshmem_long_put\fP(3),
|
|
|
|
\fIshmem_longdouble_put\fP(3),
|
|
|
|
\fIshmem_longlong_put\fP(3),
|
|
|
|
\fIshmem_put4\fP(3),
|
|
|
|
\fIshmem_put8\fP(3),
|
|
|
|
\fIshmem_put32\fP(3),
|
|
|
|
\fIshmem_put64\fP(3),
|
|
|
|
\fIshmem_put128\fP(3),
|
|
|
|
\fIshmem_putmem\fP(3),
|
|
|
|
\fIshmem_real_put\fP(3),
|
|
|
|
\fIshmem_short_put\fP(3)
|
|
|
|
\- Transfers data to a specified
|
|
|
|
processing element (PE)
|
|
|
|
.SH SYNOPSIS
|
|
|
|
|
|
|
|
C or C++:
|
|
|
|
.Vb
|
|
|
|
#include <mpp/shmem.h>
|
|
|
|
|
|
|
|
void shmem_double_put(double *target, const double *source,
|
|
|
|
size_t len, int pe);
|
|
|
|
|
|
|
|
void shmem_float_put(float *target, const float *source,
|
|
|
|
size_t len, int pe);
|
|
|
|
|
|
|
|
void shmem_int_put(int *target, const int *source, size_t len,
|
|
|
|
int pe);
|
|
|
|
|
|
|
|
void shmem_long_put(long *target, const long *source,
|
|
|
|
size_t len, int pe);
|
|
|
|
|
|
|
|
void shmem_longdouble_put(long double *target,
|
|
|
|
const long double *source, size_t len, int pe);
|
|
|
|
|
|
|
|
void shmem_longlong_put(long long *target,
|
|
|
|
const long long *source, size_t len, int pe);
|
|
|
|
|
|
|
|
void shmem_put32(void *target, const void *source, size_t len,
|
|
|
|
int pe);
|
|
|
|
|
|
|
|
void shmem_put64(void *target, const void *source, size_t len,
|
|
|
|
int pe);
|
|
|
|
|
|
|
|
void shmem_put128(void *target, const void *source, size_t len,
|
|
|
|
int pe);
|
|
|
|
|
|
|
|
void shmem_putmem(void *target, const void *source, size_t len,
|
|
|
|
int pe);
|
|
|
|
|
|
|
|
void shmem_short_put(short *target, const short *source,
|
|
|
|
size_t len, int pe);
|
|
|
|
.Ve
|
|
|
|
Fortran:
|
|
|
|
.Vb
|
|
|
|
INCLUDE "mpp/shmem.fh"
|
|
|
|
|
|
|
|
INTEGER len, pe
|
|
|
|
|
|
|
|
CALL SHMEM_CHARACTER_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_COMPLEX_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_DOUBLE_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_INTEGER_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_LOGICAL_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT4(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT8(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT32(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT64(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUT128(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_PUTMEM(target, source, len, pe)
|
|
|
|
|
|
|
|
CALL SHMEM_REAL_PUT(target, source, len, pe)
|
|
|
|
.Ve
|
|
|
|
.SH DESCRIPTION
|
|
|
|
|
|
|
|
These routines transfer \fBnelems\fP
|
|
|
|
elements of the data object at address
|
|
|
|
\fBsource\fP
|
|
|
|
on the calling PE, to the data object at address \fBtarget\fP
|
|
|
|
on the remote
|
|
|
|
PE \fBpe\fP\&.
|
|
|
|
These routines start the remote transfer and may return before the data is
|
|
|
|
delivered to the remote PE.
|
|
|
|
.PP
|
|
|
|
The delivery of data into the data object on the destination PE from different put calls may
|
|
|
|
occur in any order. Because of this, two successive put operations may deliver data out of
|
|
|
|
order unless a call to \fIshmem_fence\fP(3)
|
|
|
|
is introduced between the two calls.
|
|
|
|
.PP
|
|
|
|
The arguments are as follows:
|
|
|
|
.TP
|
|
|
|
target
|
|
|
|
Data object to be updated on the remote PE. This data object must be remotely
|
|
|
|
accessible.
|
|
|
|
.TP
|
|
|
|
source
|
|
|
|
Data object containing the data to be copied.
|
|
|
|
.TP
|
|
|
|
len
|
|
|
|
Number of elements in the target and source arrays. len must be of type integer. If
|
|
|
|
you are using Fortran, it must be a constant, variable, or array element of default integer
|
|
|
|
type.
|
|
|
|
.TP
|
|
|
|
pe
|
|
|
|
PE number of the remote PE. pe must be of type integer. If you are using Fortran, it
|
|
|
|
must be a constant, variable, or array element of default integer type.
|
|
|
|
.PP
|
|
|
|
The target and source data objects must conform to certain typing constraints, which are as
|
|
|
|
follows:
|
|
|
|
.TP
|
|
|
|
\fBshmem_putmem\fP: Fortran: Any noncharacter type. C: Any data type. len is scaled in
|
|
|
|
bytes.
|
|
|
|
.TP
|
|
|
|
\fBshmem_put4, shmem_put32:\fP Any noncharacter type that has a storage size
|
|
|
|
equal to 32 bits.
|
|
|
|
.TP
|
|
|
|
\fBshmem_put8, shmem_put64:\fP Any noncharacter type that has a storage size
|
|
|
|
equal to 64 bits.
|
|
|
|
.TP
|
|
|
|
\fBshmem_put128:\fP Any noncharacter type that has a storage size equal to 128
|
|
|
|
bits.
|
|
|
|
.TP
|
|
|
|
\fBshmem_short_put:\fP Elements of type short.
|
|
|
|
.TP
|
|
|
|
\fBshmem_int_put:\fP Elements of type int.
|
|
|
|
.TP
|
|
|
|
\fBshmem_long_put:\fP Elements of type long.
|
|
|
|
.TP
|
|
|
|
\fBshmem_longlong_put:\fP Elements of type long long.
|
|
|
|
.TP
|
|
|
|
\fBshmem_float_put:\fP Elements of type float.
|
|
|
|
.TP
|
|
|
|
\fBshmem_double_put:\fP Elements of type double.
|
|
|
|
.TP
|
|
|
|
\fBshmem_longdouble_put:\fP Elements of type long double.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_CHARACTER_PUT:\fP Elements of type character. len is the number of
|
|
|
|
characters to transfer. The actual character lengths of the source and target variables are
|
|
|
|
ignored.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_COMPLEX_PUT:\fP Elements of type complex of default size.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_DOUBLE_PUT:\fP (Fortran) Elements of type double precision.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_INTEGER_PUT:\fP Elements of type integer.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_LOGICAL_PUT:\fP Elements of type logical.
|
|
|
|
.TP
|
|
|
|
\fBSHMEM_REAL_PUT:\fP Elements of type real.
|
|
|
|
If you are using Fortran, data types must be of default size. For example, a real variable must
|
|
|
|
be declared as REAL, REAL*4, or REAL(KIND=4).
|
|
|
|
.PP
|
|
|
|
.SH EXAMPLES
|
|
|
|
|
|
|
|
The following shmem_put example is for C/C++ programs:
|
|
|
|
.Vb
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <mpp/shmem.h>
|
|
|
|
|
|
|
|
main()
|
|
|
|
{
|
|
|
|
long source[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
|
|
|
|
static long target[10];
|
2015-11-20 19:36:38 +03:00
|
|
|
shmem_init();
|
2015-07-31 21:44:50 +03:00
|
|
|
|
2015-11-20 19:36:38 +03:00
|
|
|
if (shmem_my_pe() == 0) {
|
2015-07-31 21:44:50 +03:00
|
|
|
/* put 10 words into target on PE 1 */
|
|
|
|
shmem_long_put(target, source, 10, 1);
|
|
|
|
}
|
|
|
|
shmem_barrier_all(); /* sync sender and receiver */
|
2015-11-20 19:36:38 +03:00
|
|
|
if (shmem_my_pe() == 1)
|
2015-07-31 21:44:50 +03:00
|
|
|
shmem_udcflush(); /* not required on Altix systems */
|
2015-11-20 19:36:38 +03:00
|
|
|
printf("target[0] on PE %d is %d\\n", shmem_my_pe(), target[0]);
|
2015-07-31 21:44:50 +03:00
|
|
|
}
|
|
|
|
.Ve
|
|
|
|
.SH SEE ALSO
|
|
|
|
|
|
|
|
\fIintro_shmem\fP(3),
|
|
|
|
\fIshmem_iput\fP(3),
|
|
|
|
\fIshmem_quiet\fP(3)
|