SHMEM_LONG_WAIT_UNTIL(3)

💖 NAME 💖

okay so this is the shmem_long_wait_until(3) page from Open MPI, bestie ✨ and it's actually a whole friend group, not a solo act. Every single one of these is a way to wait for a variable on the local processing element (PE) to change 👑:

• shmem_int_wait <#shmem-int-wait>(3)
• shmem_int_wait <#shmem-int-wait>(3)_until
• shmem_int4_wait(3)
• shmem_int4_wait(3)_until
• shmem_int8_wait(3)
• shmem_int8_wait(3)_until
• shmem_long_wait <#shmem-long-wait>(3)
• shmem_long_wait <#shmem-long-wait>(3)_until
• shmem_longlong_wait <#shmem-longlong-wait>(3)
• shmem_longlong_wait <#shmem-longlong-wait>(3)_until
• shmem_short_wait <#shmem-short-wait>(3)
• shmem_short_wait <#shmem-short-wait>(3)_until
• shmem_wait <#shmem-wait>(3)
• shmem_wait <#shmem-wait>(3)_until

like. the whole squad showed up. no cap 💅

---

✨ SYNOPSIS ✨

C or C++:

#include <mpp/shmem.h>

void shmem_int_wait(volatile int *var, int value)

void shmem_int_wait_until(volatile int *var, int cond, int value)

void shmem_long_wait(volatile long *var, long value)

void shmem_long_wait_until(volatile long *var, int cond, long value)

void shmem_longlong_wait(volatile long long *var, long long value)

void shmem_longlong_wait_until(volatile long long *var, int cond,
  long long value)

void shmem_short_wait(volatile short *var, short value)

void shmem_short_wait_until(volatile short *var, int cond,
  short value)

void shmem_wait(volatile long *ivar, long cmp_value)

void shmem_wait_until(volatile long *ivar, int cmp, long value)

Fortran:

INCLUDE "mpp/shmem.fh"

CALL SHMEM_INT4_WAIT(ivar, cmp_value)

CALL SHMEM_INT4_WAIT_UNTIL(ivar, cmp, cmp_value)

CALL SHMEM_INT8_WAIT(ivar, cmp_value)

CALL SHMEM_INT8_WAIT_UNTIL(ivar, cmp, cmp_value)

CALL SHMEM_WAIT(ivar, cmp_value)

CALL SHMEM_WAIT_UNTIL(ivar, cmp, cmp_value)

copy these exactly, bestie, the compiler is NOT forgiving 🫶

---

🌸 DESCRIPTION 🌸

shmem_wait <#shmem-wait> and shmem_wait_until <#shmem-wait-until> are out here waiting for ivar to get changed by a remote write or an atomic swap issued by a different processor. yes. another PE has to do it. you cannot do it to yourself, this is not that kind of party 🙈

These routines are for point-to-point directed synchronization — aka "hey bestie, tell me when you're done" energy.

So here's the vibe:

• A call to shmem_wait <#shmem-wait> does not return until some other processor writes a value into ivar on the waiting processor that is not equal to cmp_value.
• A call to shmem_wait_until <#shmem-wait-until> does not return until some other processor changes ivar so that it satisfies the condition implied by cmp and cmp_value.

This mechanism is literally iconic when a processor needs to tell another processor that it has completed some action. it's giving "i'm done, you may proceed" 💅

🎀 The arguments

okay bestie, quick heads up: the original page lists target, value and pe here too, so we're keeping them, no skipping, that's the rule 💀

• target — The remotely accessible integer data object to be updated on the remote PE. If you're in C/C++, the type of target should match what the SYNOPSIS says. If you're on a Fortran compiler, it must be of type integer with an element size of 4 bytes for SHMEM_INT4_ADD and 8 bytes for SHMEM_INT8_ADD.
• value — The value to be atomically added to target. In C/C++, the type of value should match what the SYNOPSIS says. In Fortran, it must be of type integer with an element size of target.
• pe — An integer that indicates the PE number upon which target is to be updated. In Fortran, it must be a default integer value.
• ivar — A remotely accessible integer variable that is being updated by another PE. In C/C++, the type of ivar should match what the SYNOPSIS says. In Fortran, ivar must be a specific sized integer type according to the function being called, like this:
  • shmem_wait <#shmem-wait>, shmem_wait_until <#shmem-wait-until>: default INTEGER
  • shmem_int4_wait, shmem_int4_wait_until: INTEGER*4
  • shmem_int8_wait, shmem_int8_wait_until: INTEGER*8
• cmp — The compare operator that compares ivar with cmp_value. cmp must be of type integer. In Fortran it must be of default kind. In C/C++ the type of cmp should match what the SYNOPSIS says. Here are the supported cmp values, slay:
  • SHMEM_CMP_EQ — Equal
  • SHMEM_CMP_NE — Not equal
  • SHMEM_CMP_GT — Greater than
  • SHMEM_CMP_LE — Less than or equal to
  • SHMEM_CMP_LT — Less than
  • SHMEM_CMP_GE — Greater than or equal to
• cmp_value — cmp_value must be of type integer. In C/C++, the type of cmp_value should match what the SYNOPSIS says. In Fortran, cmp_value must be an integer of the same size and kind as ivar. The shmem_wait <#shmem-wait> routines return when ivar is no longer equal to cmp_value. The shmem_wait_until <#shmem-wait-until> routines return when the compare condition is true. That compare condition is defined by the ivar argument compared with cmp_value using the comparison operator, cmp. periodt 🎀

---

🦋 EXAMPLES 🦋

Example 1: The following call returns when variable ivar is not equal to 100:

INTEGER*8 IVAR

CALL SHMEM_INT8_WAIT(IVAR, INT8(100))

Example 2: The following call to SHMEM_INT8_WAIT_UNTIL is equivalent to the call to SHMEM_INT8_WAIT in example 1:

INTEGER*8 IVAR

CALL SHMEM_INT8_WAIT_UNTIL(IVAR, SHMEM_CMP_NE, INT8(100))

Example 3: The following C/C++ call waits until the sign bit in ivar is set by a transfer from a remote PE:

int ivar;

shmem_int_wait_until(&ivar, SHMEM_CMP_LT, 0);

Example 4: The following Fortran example is in the context of a subroutine:

SUBROUTINE EXAMPLE()
  INTEGER FLAG_VAR
  COMMON/FLAG/FLAG_VAR
  . . .
  FLAG_VAR = FLAG_VALUE ! initialize the event variable
  . . .
  IF (FLAG_VAR .EQ. FLAG_VALUE) THEN
    CALL SHMEM_WAIT(FLAG_VAR, FLAG_VALUE)
  ENDIF
  FLAG_VAR = FLAG_VALUE ! reset the event variable for next time
  . . .
END

---

💜 SEE ALSO 💜

obviously go read these next, bestie, iykyk:

• intro_shmem(3)
• shmem_put(3)

---

📜 Copyright

2003-2026, The Open MPI Community

---

and that's the whole page, bestie 🫶 this was Open MPI's SHMEM_LONG_WAIT_UNTIL(3), dated Sep 10, 2026, and you ate every single word of it. mwah 💅✨