SHMEM_SHORT_PUT(3)

🌸 SHMEM_SHORT_PUT(3) — Open MPI edition 💅

okay bestie, sit down, grab a boba, because today we're learning how to yeet data across PEs. 🦋 This page covers a whole squad of routines, and honestly? They're all just different flavors of the same slay:

shmem_character_put(3), shmem_complex_put(3), shmem_double_put(3), shmem_float_put(3), shmem_int_put(3), shmem_integer_put(3), shmem_logical_put(3), shmem_long_put(3), shmem_longdouble_put(3), shmem_longlong_put(3), shmem_put4(3), shmem_put8(3), shmem_put32(3), shmem_put64(3), shmem_put128(3), shmem_putmem(3), shmem_real_put(3), and our main character shmem_short_put(3).

And what do they do? They transfer data to a specified processing element (PE). Periodt. ✨

---

✨ SYNOPSIS ✨

C or C++ 🫶

#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)

Fortran 🌈

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)

---

💖 DESCRIPTION 💖

These routines take nelems elements of whatever data object lives at address source on the PE that's calling, and ship them over to the data object at address target on the remote PE pe. 🚀

big ole warning: these routines start the remote transfer and may return before the data is actually delivered to the remote PE. So like… don't assume it's there yet, bestie. 😭

Also, the delivery of data into that destination data object, coming from different put calls? It can happen in any order. Which means two back-to-back put operations may land out of order — unless you slide a call to shmem_fence(3) in between the two calls. 🧚

the arguments (aka the cast of characters) 👑

• target — the data object that's getting updated on the remote PE. This one must be remotely accessible. no exceptions, no cap.
• source — the data object holding the data that's getting copied.
• len — 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.

---

the typing constraints (vibe check for your data 📋)

target and source have to follow certain typing rules, and honestly they're giving very specific. Here's the full list, no skipping:

• shmem_putmem: Fortran: any noncharacter type. C: any data type. len is scaled in bytes.
• shmem_put4, shmem_put32: any noncharacter type that has a storage size equal to 32 bits.
• shmem_put8, shmem_put64: any noncharacter type that has a storage size equal to 64 bits.
• shmem_put128: any noncharacter type that has a storage size equal to 128 bits.
• shmem_short_put: elements of type short.
• shmem_int_put: elements of type int.
• shmem_long_put: elements of type long.
• shmem_longlong_put: elements of type long long.
• shmem_float_put: elements of type float.
• shmem_double_put: elements of type double.
• shmem_longdouble_put: elements of type long double.
• SHMEM_CHARACTER_PUT: elements of type character. len is the number of characters to transfer. The actual character lengths of the source and target variables are ignored — like, fully disregarded, ghosted.
• SHMEM_COMPLEX_PUT: elements of type complex of default size.
• SHMEM_DOUBLE_PUT: (Fortran) elements of type double precision.
• SHMEM_INTEGER_PUT: elements of type integer.
• SHMEM_LOGICAL_PUT: elements of type logical.
• SHMEM_REAL_PUT: elements of type real.

And if you're doing Fortran: data types must be of default size. So like, a real variable has to be declared as REAL, REAL*4, or REAL(KIND=4). 🎀

---

🌟 EXAMPLES 🌟

here's a shmem_put moment for all my C/C++ girlies:

#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];
  shmem_init();

  if (shmem_my_pe() == 0) {
    /* put 10 words into target on PE 1 */
    shmem_long_put(target, source, 10, 1);
  }
  shmem_barrier_all();  /* sync sender and receiver */
  if (shmem_my_pe() == 1)
    shmem_udcflush();  /* not required on Altix systems */
  printf("target[0] on PE %d is %d\n", shmem_my_pe(), target[0]);
}

---

SEE ALSO 👀

no gatekeeping here, go read these too:

intro_shmem(3) shmem_iput(3) shmem_quiet(3)

---

Copyright

2003-2026, The Open MPI Community

---

okay that's the whole page bestie, you absolutely ate that. 💅 go forth and put your data where it belongs. mwah! 🫶

— signed off sweetly from the Open MPI era, dated Sep 10, 2026, courtesy of The Open MPI Community, 2003-2026 💖✨