SHMEM_LONG_IPUT(3)

📦

version 5.0.10 · 4 versions

💖 NAME 💖

Bestie. Gather round. SHMEM_LONG_IPUT(3) is not one function, it's a whole squad of Open MPI routines that show up together like a group chat that all texts at once 💅

Say hi to: shmem_complex_iput(3), shmem_double_iput(3), shmem_float_iput(3), shmem_int_iput(3), shmem_integer_iput(3), shmem_iput4(3), shmem_iput8(3), shmem_iput32(3), shmem_iput64(3), shmem_iput128(3), shmem_logical_iput(3), shmem_long_iput(3), shmem_longdouble_iput(3), shmem_longlong_iput(3), shmem_real_iput(3), and shmem_short_iput(3).

And what do they do, you ask? 🦋 They transfer strided data to a specified processing element (PE). That's the whole vibe. Periodt.

✨ SYNOPSIS ✨

C or C++:

#include <mpp/shmem.h>

void shmem_double_iput(double *target, const double *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_float_iput(float *target, const float *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_int_iput(int *target, const int *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_iput32(void *target, const void *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_iput64(void *target, const void *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_iput128(void *target, const void *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_long_iput(long *target, const long *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

void shmem_longdouble_iput(long double *target,
  const long double *source, ptrdiff_t tst, ptrdiff_t sst,
  size_t len, int pe)

void shmem_longlong_iput(long long *target,
  const long long *source, ptrdiff_t tst, ptrdiff_t sst,
  size_t len, int pe)

void shmem_short_iput(short *target, const short *source,
  ptrdiff_t tst, ptrdiff_t sst, size_t len, int pe)

Fortran:

INCLUDE "mpp/shmem.fh"

INTEGER tst, sst, len, pe

CALL SHMEM_COMPLEX_IPUT(target, source, tst, sst, len,
& pe)

CALL SHMEM_DOUBLE_IPUT(target, source, tst, sst, len,
& pe)

CALL SHMEM_INTEGER_IPUT(target, source, tst, sst, len,
& pe)

CALL SHMEM_IPUT4(target, source, tst, sst, len, pe)

CALL SHMEM_IPUT8(target, source, tst, sst, len, pe)

CALL SHMEM_IPUT32(target, source, tst, sst, len, pe)

CALL SHMEM_IPUT64(target, source, tst, sst, len, pe)

CALL SHMEM_IPUT128(target, source, tst, sst, len, pe)

CALL SHMEM_LOGICAL_IPUT(target, source, tst, sst, len,
& pe)

CALL SHMEM_REAL_IPUT(target, source, tst, sst, len, pe)

Look at that Fortran with the cute little & line continuations. Adorable. 🎀

🌸 DESCRIPTION 🌸

So here's the tea, bestie ☕ — these shmem_iput routines read the elements of a local array (source) and write them to a remote array (target) on the PE that pe points at.

And the timing? Iconic but specific. These routines return when the data has been copied out of the source array on the local PE, but not necessarily before the data has been delivered to the remote data object. Read that twice. It matters 😭

🫶 The arguments 🫶

target — the array to be updated on the remote PE. This data object must be remotely accessible. Non-negotiable, babe.
source — the array containing the data to be copied. She's the origin story.
tst — the stride between consecutive elements of the target array. It gets scaled by the element size of the target array. A value of 1 means contiguous data. tst must be of type integer. Fortran girlies: it must be a default integer value.
sst — the stride between consecutive elements of the source array. Scaled by the element size of the source array. A value of 1 means contiguous data. sst must be of type integer. Fortran girlies: default integer value, again.
len — the number of elements in the target and source arrays. len must be of type integer. In Fortran it must be a constant, variable, or array element of default integer type.
pe — the PE number of the remote PE. pe must be of type integer. In Fortran it must be a constant, variable, or array element of default integer type.

🧚 Typing constraints (the vibe check) 🧚

The target and source data objects must conform to these, no exceptions:

shmem_iput32, shmem_iput4: any noncharacter type that has a storage size equal to 32 bits.
shmem_iput64, shmem_iput8: any noncharacter type that has a storage size equal to 64 bits.
shmem_iput128: any noncharacter type that has a storage size equal to 128 bits.
shmem_short_iput: elements of type short.
shmem_int_iput: elements of type int.
shmem_long_iput: elements of type long.
shmem_longlong_iput: elements of type long long.
shmem_float_iput: elements of type float.
shmem_double_iput: elements of type double.
shmem_longdouble_iput: elements of type long double.
SHMEM_COMPLEX_IPUT: elements of type complex of default size.
SHMEM_DOUBLE_IPUT: (Fortran) elements of type double precision.
SHMEM_INTEGER_IPUT: elements of type integer.
SHMEM_LOGICAL_IPUT: elements of type logical.
SHMEM_REAL_IPUT: elements of type real.
SHMEM_LOGICAL_IPUT: elements of type logical.
SHMEM_REAL_IPUT: elements of type real.

Not me listing SHMEM_LOGICAL_IPUT and SHMEM_REAL_IPUT twice 💀 That's literally what the page says, so I'm saying it too. She repeated herself for emphasis, and honestly? Respect. 💅

And one more thing for the Fortran besties: data types must be of default size. So for example, a real variable has to be declared as REAL, REAL*4 or REAL(KIND=4). Don't get fancy 🌸

💜 NOTES 💜

If you're sitting there like "okay but what even is remotely accessible" — go read intro_shmem(3), because that's where the term is defined. 🫶

🔥 EXAMPLES 🔥

Okay so picture this: a simple shmem_long_iput example, but for C/C++ programs (yes, that's exactly how the page frames it, it's giving chaos but we move):

#include <mpp/shmem.h>

main()
{
  short source[10] = { 1, 2, 3, 4, 5,
  6, 7, 8, 9, 10 };
  static short target[10];

  shmem_init();
  if (shmem_my_pe() == 0) {
    /* put 10 words into target on PE 1 */
    shmem_short_iput(target, source, 1, 2, 5, 1);
  }
  shmem_barrier_all(); /* sync sender and receiver */
  if (shmem_my_pe() == 1) {
    shmem_udcflush(); /* not required on IRIX systems */
    printf("target on PE %d is %d %d %d %d %d0, shmem_my_pe(),
    (int)target[0], (int)target[1], (int)target[2],
    (int)target[3], (int)target[4] );
  }
  shmem_barrier_all(); /* sync before exiting */
}

And yes, that printf line is character-for-character what the manpage shows — the quote situation in there is exactly as written, don't @ me 🙈