shmem_iget.tex

\apisummary{
    Copies strided data from a specified \ac{PE}.
}

\begin{apidefinition}

\begin{C11synopsis}
void shmem_iget(TYPE *dest, const TYPE *source, ptrdiff_t dst, ptrdiff_t sst, size_t nelems, int pe);
\end{C11synopsis}
where \TYPE{} is one of the standard \ac{RMA} types specified by Table \ref{stdrmatypes}.

\begin{Csynopsis}
void shmem_<TYPENAME>_iget(TYPE *dest, const TYPE *source, ptrdiff_t dst, ptrdiff_t sst, size_t nelems, int pe);
\end{Csynopsis}
where \TYPE{} is one of the standard \ac{RMA} types and has a corresponding \TYPENAME{} specified by Table \ref{stdrmatypes}.

\begin{CsynopsisCol}
void shmem_iget<SIZE>(void *dest, const void *source, ptrdiff_t dst, ptrdiff_t sst, size_t  nelems, int pe);
\end{CsynopsisCol}
where \SIZE{} is one of \CONST{8, 16, 32, 64, 128}.

\begin{Fsynopsis}
INTEGER dst, sst, nelems, pe
CALL SHMEM_COMPLEX_IGET(dest, source, dst, sst, nelems, pe)
CALL SHMEM_DOUBLE_IGET(dest, source, dst, sst, nelems, pe)
CALL SHMEM_IGET4(dest, source, dst, sst, nelems, pe)
CALL SHMEM_IGET8(dest, source, dst, sst, nelems, pe)
CALL SHMEM_IGET32(dest, source, dst, sst, nelems, pe)
CALL SHMEM_IGET64(dest, source, dst, sst, nelems, pe)
CALL SHMEM_IGET128(dest, source, dst, sst, nelems, pe)
CALL SHMEM_INTEGER_IGET(dest, source, dst, sst, nelems, pe)
CALL SHMEM_LOGICAL_IGET(dest, source, dst, sst, nelems, pe)
CALL SHMEM_REAL_IGET(dest, source, dst, sst, nelems, pe)
\end{Fsynopsis}

\begin{apiarguments}
    \apiargument{OUT}{dest}{Array to be updated on the local \ac{PE}. }
    \apiargument{IN}{source}{Array containing the data to be copied on the remote \ac{PE}.}
    \apiargument{IN}{dst}{The stride between consecutive elements of the \dest{}
        array.  The stride is scaled by the element size of the \dest{} array.
        A  value of \CONST{1} indicates contiguous data. \VAR{dst} must be of
        type \textit{ptrdiff\_t}.  When using  \Fortran,  it  must
        be a default integer value.}
    \apiargument{IN}{sst}{The stride between consecutive elements of the
        \source{} array.  The stride is scaled by the element size of the \source{}
        array.  A  value of \CONST{1} indicates contiguous data.  \VAR{sst} must be
        of type \textit{ptrdiff\_t}.  When using  \Fortran,  it  must
        be a default integer value.}
    \apiargument{IN}{nelems}{Number of elements in the \dest{} and \source{}
        arrays.  \VAR{nelems} must be of type \VAR{size\_t} for \Cstd. When
        using \Fortran, it must be  a constant, variable, or array element of
        default integer type.}
    \apiargument{IN}{pe}{\ac{PE} number of the remote \ac{PE}.  \VAR{pe} must be
        of type integer. When using  \Fortran, it must be a constant,
        variable, or array element of default integer type.}
\end{apiarguments}

\apidescription{
    The \FUNC{iget} routines provide a method for copying strided data elements from
    a symmetric array from a specified remote \ac{PE} to strided locations on a
    local array.  The routines return when the data has been copied into the local
    \VAR{dest} array.
}

\apidesctable{
    The \VAR{dest} and \VAR{source} data objects must conform to typing
    constraints, which are as follows:}
    {Routine}{Data type of \VAR{dest} and \VAR{source}}
    \apitablerow{shmem\_iget4, shmem\_iget32}{Any noncharacter type
        that has a storage size equal to \CONST{32} bits.}
    \apitablerow{shmem\_iget8}{\Cstd: Any noncharacter type that
        has a storage size equal to \CONST{8} bits.}
    \apitablerow{}{\Fortran: Any noncharacter type that
        has a storage size equal to \CONST{64} bits.}
    \apitablerow{shmem\_iget64}{Any noncharacter type that
        has a storage size equal to \CONST{64} bits.}
    \apitablerow{shmem\_iget128}{Any noncharacter type that has a
        storage size equal to \CONST{128} bits.}
    \apitablerow{SHMEM\_COMPLEX\_IGET}{Elements of type complex of default size.}
    \apitablerow{SHMEM\_DOUBLE\_IGET}{\Fortran: Elements of type double precision.}
    \apitablerow{SHMEM\_INTEGER\_IGET}{Elements of type integer.}
    \apitablerow{SHMEM\_LOGICAL\_IGET}{Elements of type logical.}
    \apitablerow{SHMEM\_REAL\_IGET}{Elements of type real.}

\apireturnvalues{
    None.
}

\apinotes{
    When using \Fortran, data types must be of default size. For example, a
    real variable must be declared as \CONST{REAL}, \CONST{REAL*4}, or
    \CONST{REAL(KIND=KIND(1.0))}. 
}

\begin{apiexamples}

\apifexample
    {The following example uses \FUNC{shmem\_logical\_iget}  in a \Fortran
    program.} 
    {./example_code/shmem_iget_example.f90}
    {}

\end{apiexamples}

\end{apidefinition}