docs.it4i/src/ompi/connectivity_c.c

+/*
+ * Copyright (c) 2007      Sun Microsystems, Inc.  All rights reserved.
+ */
+
+/*
+ * Test the connectivity between all processes.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <mpi.h>
+
+int
+main(int argc, char **argv)
+{
+    MPI_Status  status;
+    int         verbose = 0;
+    int         rank;
+    int         np;        /* number of processes in job */
+    int         peer;
+    int         i;
+    int         j;
+    int         length;
+    char        name[MPI_MAX_PROCESSOR_NAME+1];
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &np);
+
+    /*
+     * If we cannot get the name for whatever reason, just
+     * set it to unknown. */
+    if (MPI_SUCCESS != MPI_Get_processor_name(name, &length)) {
+        strcpy(name, "unknown");
+    }
+
+    if (argc>1 && strcmp(argv[1], "-v")==0)
+        verbose = 1;
+
+    for (i=0; i<np; i++) {
+        if (rank==i) {
+            /* rank i sends to and receives from each higher rank */
+            for(j=i+1; j<np; j++) {
+                if (verbose)
+                    printf("checking connection between rank %d on %s and rank %-4d\n",
+                           i, name, j);
+                MPI_Send(&rank, 1, MPI_INT, j, rank, MPI_COMM_WORLD);
+                MPI_Recv(&peer, 1, MPI_INT, j, j, MPI_COMM_WORLD, &status);
+            }
+        } else if (rank>i) {
+            /* receive from and reply to rank i */
+            MPI_Recv(&peer, 1, MPI_INT, i, i, MPI_COMM_WORLD, &status);
+            MPI_Send(&rank, 1, MPI_INT, i, rank, MPI_COMM_WORLD);
+        }
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+    if (rank==0)
+        printf("Connectivity test on %d processes PASSED.\n", np);
+
+    MPI_Finalize();
+    return 0;
+}

docs.it4i/src/ompi/hello_c.c

+/*
+ * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+ *
+ * Sample MPI "hello world" application in C
+ */
+
+#include <stdio.h>
+#include "mpi.h"
+
+int main(int argc, char* argv[])
+{
+    int rank, size, len;
+    char version[MPI_MAX_LIBRARY_VERSION_STRING];
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    MPI_Get_library_version(version, &len);
+    printf("Hello, world, I am %d of %d, (%s, %d)\n",
+           rank, size, version, len);
+    MPI_Finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/hello_cxx.cc

+//
+// Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+//                         University Research and Technology
+//                         Corporation.  All rights reserved.
+// Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+//
+// Sample MPI "hello world" application in C++
+//
+// NOTE: The MPI C++ bindings were deprecated in MPI-2.2 and removed
+// from the standard in MPI-3.  Open MPI still provides C++ MPI
+// bindings, but they are no longer built by default (and may be
+// removed in a future version of Open MPI).  You must
+// --enable-mpi-cxx when configuring Open MPI to enable the MPI C++
+// bindings.
+//
+
+#include "mpi.h"
+#include <iostream>
+
+int main(int argc, char **argv)
+{
+    int rank, size, len;
+    char version[MPI_MAX_LIBRARY_VERSION_STRING];
+
+    MPI::Init();
+    rank = MPI::COMM_WORLD.Get_rank();
+    size = MPI::COMM_WORLD.Get_size();
+    MPI_Get_library_version(version, &len);
+    std::cout << "Hello, world!  I am " << rank << " of " << size
+              << "(" << version << ", " << len << ")" << std::endl;
+    MPI::Finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/hello_mpifh.f

+C
+C Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+C                         University Research and Technology
+C                         Corporation.  All rights reserved.
+C Copyright (c) 2006-2015 Cisco Systems, Inc.  All rights reserved.
+C $COPYRIGHT$
+C
+C Sample MPI "hello world" application using the Fortran mpif.h
+C bindings.
+C
+        program main
+        implicit none
+        include 'mpif.h'
+        integer ierr, rank, size, len
+        character(len=MPI_MAX_LIBRARY_VERSION_STRING) version
+
+        call MPI_INIT(ierr)
+        call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr)
+        call MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierr)
+        call MPI_GET_LIBRARY_VERSION(version, len, ierr)
+
+        write(*, '("Hello, world, I am ", i2, " of ", i2, ": ", a)')
+     &        rank, size, version
+
+        call MPI_FINALIZE(ierr)
+
+        end

docs.it4i/src/ompi/hello_oshmem_c.c

+/*
+ * Copyright (c) 2014      Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * Copyright (c) 2015 Cisco Systems, Inc.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <stdio.h>
+#include "shmem.h"
+
+#if !defined(OSHMEM_SPEC_VERSION) || OSHMEM_SPEC_VERSION < 10200
+#error This application uses API 1.2 and up
+#endif
+
+int main(int argc, char* argv[])
+{
+    int proc, nproc;
+    char name[SHMEM_MAX_NAME_LEN];
+    int major, minor;
+
+    shmem_init();
+    nproc = shmem_n_pes();
+    proc = shmem_my_pe();
+    shmem_info_get_name(name);
+    shmem_info_get_version(&major, &minor);
+
+    printf("Hello, world, I am %d of %d: %s (version: %d.%d)\n",
+           proc, nproc, name, major, minor);
+    shmem_finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/hello_oshmem_cxx.cc

+/*
+ * Copyright (c) 2014      Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * Copyright (c) 2015      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2017      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <iostream>
+#include "shmem.h"
+
+#if !defined(OSHMEM_SPEC_VERSION) || OSHMEM_SPEC_VERSION < 10200
+#error This application uses API 1.2 and up
+#endif
+
+int main(int argc, char* argv[])
+{
+    int proc, nproc;
+    char name[SHMEM_MAX_NAME_LEN];
+    int major, minor;
+
+    shmem_init();
+    nproc = shmem_n_pes();
+    proc = shmem_my_pe();
+    shmem_info_get_name(name);
+    shmem_info_get_version(&major, &minor);
+
+    std::cout << "Hello, world, I am " << proc << " of " << nproc << ": " << name
+              << " (version: " << major << "." << minor << ")" << std::endl;
+
+    shmem_finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/hello_oshmemfh.f90

+!
+! Copyright (c) 2014      Mellanox Technologies, Inc.
+!                         All rights reserved.
+! Copyright (c) 2014-2015 Cisco Systems, Inc.  All rights reserved.
+! $COPYRIGHT$
+!
+! Additional copyrights may follow
+!
+! $HEADER$
+!
+program hello_oshmem
+    implicit none
+    include 'shmem.fh'
+
+    integer proc, nproc
+    integer shmem_my_pe, shmem_n_pes
+    integer major, minor, len
+    character(len=SHMEM_MAX_NAME_LEN) name
+
+    call SHMEM_INIT()
+    proc = SHMEM_MY_PE()
+    nproc = SHMEM_N_PES()
+    call SHMEM_INFO_GET_VERSION(major, minor)
+    call SHMEM_INFO_GET_NAME(name)
+
+    write(*, '("Hello, world, I am ", i2, " of ", i2, ": (version: ", i0, ".", i0, ")")') proc, nproc, major, minor
+    call SHMEM_FINALIZE()
+
+end program hello_oshmem

docs.it4i/src/ompi/hello_usempi.f90

+!
+! Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+!                         University Research and Technology
+!                         Corporation.  All rights reserved.
+! Copyright (c) 2004-2005 The Regents of the University of California.
+!                         All rights reserved.
+! Copyright (c) 2006-2015 Cisco Systems, Inc.  All rights reserved.
+! $COPYRIGHT$
+!
+! Sample MPI "hello world" application using the Fortran mpi module
+! bindings.
+!
+program main
+    use mpi
+    implicit none
+    integer :: ierr, rank, size, len
+    character(len=MPI_MAX_LIBRARY_VERSION_STRING) :: version
+
+    call MPI_INIT(ierr)
+    call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr)
+    call MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierr)
+    call MPI_GET_LIBRARY_VERSION(version, len, ierr)
+
+    write(*, '("Hello, world, I am ", i2, " of ", i2, ": ", a)') &
+          rank, size, version
+
+    call MPI_FINALIZE(ierr)
+end

docs.it4i/src/ompi/hello_usempif08.f90

+! -*- f90 -*-
+!
+! Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+!                         University Research and Technology
+!                         Corporation.  All rights reserved.
+! Copyright (c) 2004-2005 The Regents of the University of California.
+!                         All rights reserved.
+! Copyright (c) 2006-2015 Cisco Systems, Inc.  All rights reserved.
+! Copyright (c) 2009-2012 Los Alamos National Security, LLC.
+!                         All rights reserved.
+! $COPYRIGHT$
+!
+! Sample MPI "hello world" application using the Fortran mpi_f08
+! module bindings.
+!
+program main
+    use mpi_f08
+    implicit none
+    integer :: rank, size, len
+    character(len=MPI_MAX_LIBRARY_VERSION_STRING) :: version
+
+    call MPI_INIT()
+    call MPI_COMM_RANK(MPI_COMM_WORLD, rank)
+    call MPI_COMM_SIZE(MPI_COMM_WORLD, size)
+    call MPI_GET_LIBRARY_VERSION(version, len)
+
+    write(*, '("Hello, world, I am ", i2, " of ", i2, ": ", a)') &
+          rank, size, version
+
+    call MPI_FINALIZE()
+end

docs.it4i/src/ompi/oshmem_circular_shift.c

+/*
+ * Copyright (c) 2014-2016 Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <stdio.h>
+#include <shmem.h>
+
+int main (void)
+{
+    static int aaa, bbb;
+    int num_pes, my_pe, peer;
+
+    shmem_init();
+
+    num_pes = shmem_n_pes();
+    my_pe = shmem_my_pe();
+
+    peer = (my_pe + 1) % num_pes;
+
+    printf("Process %d gets message from %d (%d processes in ring)\n", my_pe, peer, num_pes);
+    shmem_int_get(&aaa, &bbb, 1, peer);
+
+    shmem_barrier_all();
+    printf("Process %d exiting\n", my_pe);
+    shmem_finalize();
+
+    return 0;
+}
+

docs.it4i/src/ompi/oshmem_max_reduction.c

+/*
+ * Copyright (c) 2014-2016 Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * reduce [0,1,2] + _my_pe() across 4 PEs with MAX()
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <shmem.h>
+
+long pSync[_SHMEM_BCAST_SYNC_SIZE];
+
+#define N 3
+
+long src[N];
+long dst[N];
+long pWrk[_SHMEM_REDUCE_SYNC_SIZE];
+
+int  main(void)
+{
+    int i;
+    int my_pe, num_pes;
+
+    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
+        pSync[i] = _SHMEM_SYNC_VALUE;
+    }
+
+    shmem_init();
+
+    my_pe = shmem_my_pe();
+    num_pes = shmem_n_pes();
+
+    for (i = 0; i < N; i += 1) {
+        src[i] = my_pe + i;
+    }
+
+    shmem_barrier_all();
+
+    shmem_long_max_to_all(dst, src, N, 0, 0, num_pes, pWrk, pSync);
+
+    printf("%d/%d dst =", my_pe, num_pes);
+
+    for (i = 0; i < N; i+= 1) {
+        printf(" %ld", dst[i]);
+    }
+
+    printf("\n");
+    shmem_finalize();
+
+    return 0;
+}
+

docs.it4i/src/ompi/oshmem_shmalloc.c

+/*
+ * Copyright (c) 2014-2016 Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * This sample allocates (shmalloc) symmetric memory (1 long integer),
+ * and then frees it. Success of allocation is not checked.
+ *
+ * Produces no output.
+ */
+
+#include <shmem.h>
+
+int main(void)
+{
+    long *x;
+
+    shmem_init();
+
+    x = (long *) shmem_malloc(sizeof(*x));
+
+    shmem_free(x);
+
+    shmem_finalize();
+}
+

docs.it4i/src/ompi/oshmem_strided_puts.c

+/*
+ * Copyright (c) 2014-2016 Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * This program is an adaptation of examples found in the man pages
+ * of SGI’s SHMEM implementation.
+ *
+ * In this program, iput is used to select 5 elements from array source separated by
+ * a stride of 2 and write them to array target using a stride of 1.
+ *
+ * Given the array source = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
+ * iput will select 5 elements from array source on PE 0, using a stride of 2:
+ *
+ * selected elements = { 1, 3, 5, 7, 9 }
+ *
+ * These elements will then be written to the array source on PE 1 using a stride of 1:
+ *
+ * target = { 1, 3, 5, 7, 9 }
+ *
+ */
+
+#include <stdio.h>
+#include <shmem.h>
+
+int main(void)
+{
+    short source[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    static short target[10];
+    int me;
+
+    shmem_init();
+    me = shmem_my_pe();
+
+    if (me == 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 (me == 1) {
+        printf("target on PE %d is %hd %hd %hd %hd %hd\n", me,
+        target[0], target[1], target[2],
+        target[3], target[4] );
+    }
+    shmem_barrier_all(); /* sync before exiting */
+    shmem_finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/oshmem_symmetric_data.c

+/*
+ * Copyright (c) 2014-2016 Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <stdio.h>
+#include <shmem.h>
+
+#define SIZE 16
+
+int main(int argc, char* argv[])
+{
+    short source[SIZE];
+    static short target[SIZE];
+    int i;
+    int num_pe, my_pe;
+
+    shmem_init();
+
+    num_pe = shmem_n_pes();
+    my_pe = shmem_my_pe();
+
+    if (my_pe == 0) {
+        /* initialize array */
+        for(i = 0; i < SIZE; i++) {
+            source[i] = i;
+        }
+        /* local, not symmetric */
+        /* static makes it symmetric */
+        /* put "size" words into target on each PE */
+        for(i = 1; i < num_pe; i++) {
+            shmem_short_put(target, source, SIZE, i);
+        }
+    }
+
+    shmem_barrier_all(); /* sync sender and receiver */
+
+    if (my_pe != 0) {
+        printf("Target on PE %d is \t", my_pe);
+
+        for(i = 0; i < SIZE; i++) {
+            printf("%hd \t", target[i]);
+        }
+        printf("\n");
+    }
+
+    shmem_barrier_all(); /* sync before exiting */
+    shmem_finalize();
+
+    return 0;
+}

docs.it4i/src/ompi/ring_c.c

+/*
+ * Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+ *
+ * Simple ring test program in C.
+ */
+
+#include <stdio.h>
+#include "mpi.h"
+
+int main(int argc, char *argv[])
+{
+    int rank, size, next, prev, message, tag = 201;
+
+    /* Start up MPI */
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    /* Calculate the rank of the next process in the ring.  Use the
+       modulus operator so that the last process "wraps around" to
+       rank zero. */
+
+    next = (rank + 1) % size;
+    prev = (rank + size - 1) % size;
+
+    /* If we are the "master" process (i.e., MPI_COMM_WORLD rank 0),
+       put the number of times to go around the ring in the
+       message. */
+
+    if (0 == rank) {
+        message = 10;
+
+        printf("Process 0 sending %d to %d, tag %d (%d processes in ring)\n",
+               message, next, tag, size);
+        MPI_Send(&message, 1, MPI_INT, next, tag, MPI_COMM_WORLD);
+        printf("Process 0 sent to %d\n", next);
+    }
+
+    /* Pass the message around the ring.  The exit mechanism works as
+       follows: the message (a positive integer) is passed around the
+       ring.  Each time it passes rank 0, it is decremented.  When
+       each processes receives a message containing a 0 value, it
+       passes the message on to the next process and then quits.  By
+       passing the 0 message first, every process gets the 0 message
+       and can quit normally. */
+
+    while (1) {
+        MPI_Recv(&message, 1, MPI_INT, prev, tag, MPI_COMM_WORLD,
+                 MPI_STATUS_IGNORE);
+
+        if (0 == rank) {
+            --message;
+            printf("Process 0 decremented value: %d\n", message);
+        }
+
+        MPI_Send(&message, 1, MPI_INT, next, tag, MPI_COMM_WORLD);
+        if (0 == message) {
+            printf("Process %d exiting\n", rank);
+            break;
+        }
+    }
+
+    /* The last process does one extra send to process 0, which needs
+       to be received before the program can exit */
+
+    if (0 == rank) {
+        MPI_Recv(&message, 1, MPI_INT, prev, tag, MPI_COMM_WORLD,
+                 MPI_STATUS_IGNORE);
+    }
+
+    /* All done */
+
+    MPI_Finalize();
+    return 0;
+}

docs.it4i/src/ompi/ring_cxx.cc

+//
+// Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+//                         University Research and Technology
+//                         Corporation.  All rights reserved.
+// Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+//
+// Simple ring test program in C++.
+//
+// NOTE: The MPI C++ bindings were deprecated in MPI-2.2 and removed
+// from the standard in MPI-3.  Open MPI still provides C++ MPI
+// bindings, but they are no longer built by default (and may be
+// removed in a future version of Open MPI).  You must
+// --enable-mpi-cxx when configuring Open MPI to enable the MPI C++
+// bindings.
+//
+
+#include "mpi.h"
+#include <iostream>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, next, prev, message, tag = 201;
+
+    // Start up MPI
+
+    MPI::Init();
+    rank = MPI::COMM_WORLD.Get_rank();
+    size = MPI::COMM_WORLD.Get_size();
+
+    // Calculate the rank of the next process in the ring.  Use the
+    // modulus operator so that the last process "wraps around" to
+    // rank zero.
+
+    next = (rank + 1) % size;
+    prev = (rank + size - 1) % size;
+
+    // If we are the "master" process (i.e., MPI_COMM_WORLD rank 0),
+    // put the number of times to go around the ring in the message.
+
+    if (0 == rank) {
+        message = 10;
+
+        std::cout << "Process 0 sending " << message << " to " << next
+                  << ", tag " << tag << " (" << size << " processes in ring)"
+                  << std::endl;
+        MPI::COMM_WORLD.Send(&message, 1, MPI::INT, next, tag);
+        std::cout << "Process 0 sent to " << next << std::endl;
+    }
+
+    // Pass the message around the ring.  The exit mechanism works as
+    // follows: the message (a positive integer) is passed around the
+    // ring.  Each time it passes rank 0, it is decremented.  When
+    // each processes receives a message containing a 0 value, it
+    // passes the message on to the next process and then quits.  By
+    // passing the 0 message first, every process gets the 0 message
+    // and can quit normally.
+
+    while (1) {
+        MPI::COMM_WORLD.Recv(&message, 1, MPI::INT, prev, tag);
+
+        if (0 == rank) {
+            --message;
+            std::cout << "Process 0 decremented value: " << message
+                      << std::endl;
+        }
+
+        MPI::COMM_WORLD.Send(&message, 1, MPI::INT, next, tag);
+        if (0 == message) {
+            std::cout << "Process " << rank << " exiting" << std::endl;
+            break;
+        }
+    }
+
+    // The last process does one extra send to process 0, which needs
+    // to be received before the program can exit */
+
+    if (0 == rank) {
+        MPI::COMM_WORLD.Recv(&message, 1, MPI::INT, prev, tag);
+    }
+
+    // All done
+
+    MPI::Finalize();
+    return 0;
+}

docs.it4i/src/ompi/ring_mpifh.f

+C
+C Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
+C                         University Research and Technology
+C                         Corporation.  All rights reserved.
+C Copyright (c) 2006-2015 Cisco Systems, Inc.  All rights reserved.
+C $COPYRIGHT$
+C
+C Simple ring test program using the mpif.h Fortran bindings.
+C
+      program ring_f77
+      implicit none
+      include 'mpif.h'
+      integer rank, size, tag, next, from, message, ierr
+
+C     Start up MPI */
+
+      call MPI_INIT(ierr)
+      call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr)
+      call MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierr)
+
+C     Calculate the rank of the next process in the ring.  Use the
+C     modulus operator so that the last process "wraps around" to rank
+C     zero.
+
+      tag = 201
+      next = mod((rank + 1), size)
+      from = mod((rank + size - 1), size)
+
+C     If we are the "master" process (i.e., MPI_COMM_WORLD rank 0), put
+C     the number of times to go around the ring in the message.
+
+      if (rank .eq. 0) then
+         message = 10
+
+         write(*, '("Process 0 sending ", i2, " to ", i2, " tag ",
+     &        i3, " (", i2, " processes in ring)")')
+     &        message, next, tag, size
+         call MPI_SEND(message, 1, MPI_INTEGER, next, tag,
+     &        MPI_COMM_WORLD, ierr)
+         write(*, '("Process 0 sent to ", i2)')
+     &        next
+      endif
+
+C     Pass the message around the ring.  The exit mechanism works as
+C     follows: the message (a positive integer) is passed around the
+C     ring.  Each time it passes rank 0, it is decremented.  When each
+C     processes receives a message containing a 0 value, it passes the
+C     message on to the next process and then quits.  By passing the 0
+C     message first, every process gets the 0 message and can quit
+C     normally.
+
+ 10   call MPI_RECV(message, 1, MPI_INTEGER, from, tag,
+     &     MPI_COMM_WORLD, MPI_STATUS_IGNORE, ierr)
+
+      if (rank .eq. 0) then
+         message = message - 1
+         write(*, '("Process 0 decremented value: ", i2)') message
+      endif
+
+      call MPI_SEND(message, 1, MPI_INTEGER, next, tag,
+     &     MPI_COMM_WORLD, ierr)
+
+      if (message .eq. 0) then
+         write(*, '("Process ", i2, " exiting")') rank
+         goto 20
+      endif
+      goto 10
+
+C     The last process does one extra send to process 0, which needs to
+C     be received before the program can exit
+
+ 20   if (rank .eq. 0) then
+         call MPI_RECV(message, 1, MPI_INTEGER, from, tag,
+     &        MPI_COMM_WORLD, MPI_STATUS_IGNORE, ierr)
+      endif
+
+C     All done
+
+      call MPI_FINALIZE(ierr)
+      end
+

docs.it4i/src/ompi/ring_oshmem_c.c

+/*
+ * Copyright (c) 2014      Mellanox Technologies, Inc.
+ *                         All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include <shmem.h>
+#include <stdio.h>
+
+#if !defined(OSHMEM_SPEC_VERSION) || OSHMEM_SPEC_VERSION < 10200
+#error This application uses API 1.2 and up
+#endif
+
+int main (int argc, char * argv[])
+{
+    static int rbuf = -1;
+    int proc, nproc, next;
+    int message = 10;
+
+    shmem_init();
+    nproc = shmem_n_pes();
+    proc = shmem_my_pe();
+
+    /* Calculate the PE number of the next process in the ring.  Use the
+       modulus operator so that the last process "wraps around" to PE 0. */
+
+    next = (proc + 1) % nproc;
+
+    if(proc == 0)
+    {
+        printf("Process 0 puts message %d to %d (%d processes in ring)\n", message, next, nproc);
+        shmem_int_put(&rbuf, &message, 1, next);
+    }
+
+    /* Pass the message around the ring.  The exit mechanism works as
+       follows: the message (a positive integer) is passed around the
+       ring.  Each time it passes PE 0, it is decremented.  When each
+       processes receives a message containing a 0 value, it passes the
+       message on to the next process and then quits.  By passing the 0
+       message first, every process gets the 0 message and can quit
+       normally. */
+
+    while(message > 0) {
+        shmem_int_wait_until(&rbuf, SHMEM_CMP_EQ, message);
+        if(proc == 0) {
+            --message;
+            printf("Process 0 decremented value: %d\n", message);
+        }
+        shmem_int_put(&rbuf, &message, 1, next);
+        if(proc != 0) {
+            --message;
+        }
+    }
+    shmem_finalize();
+
+    /* All done */
+
+    printf("Process %d exiting\n", proc);
+
+    return 0;
+}

docs.it4i/src/ompi/ring_oshmemfh.f90

+!
+! Copyright (c) 2014      Mellanox Technologies, Inc.
+!                         All rights reserved.
+! Copyright (c) 2014 Cisco Systems, Inc.  All rights reserved.
+! $COPYRIGHT$
+!
+! Additional copyrights may follow
+!
+! $HEADER$
+!
+
+program ring_oshmem
+    implicit none
+    include 'shmem.fh'
+
+    integer*8, save   :: rbuf
+    integer*8         :: message
+    integer           :: proc, nproc, next
+    integer           :: my_pe, num_pes
+
+    rbuf = -1
+    message = 10
+
+    call start_pes(0)
+    proc = my_pe()
+    nproc = num_pes()
+
+!   Calculate the PE number of the next process in the ring.  Use the
+!   modulus operator so that the last process "wraps around" to PE 0.
+
+    next = mod((proc + 1), nproc)
+
+    if (proc .eq. 0) then
+        write(*, '("Process 0 sending ", i2, " to", i2, " (", i2, " processes in ring)")') message, next, nproc
+        call shmem_put8(rbuf, message, 1, next)
+        write(*, '("Process 0 sent to ", i2)') next
+    end if
+
+!   Pass the message around the ring.  The exit mechanism works as
+!   follows: the message (a positive integer) is passed around the
+!   ring.  Each time it passes PE 0, it is decremented.  When each
+!   processes receives a message containing a 0 value, it passes the
+!   message on to the next process and then quits.  By passing the 0
+!   message first, every process gets the 0 message and can quit
+!   normally.
+
+    do while (message .gt. 0)
+        call shmem_int8_wait_until(rbuf, SHMEM_CMP_EQ, message)
+
+        if (proc .eq. 0) then
+            message = message - 1
+            write(*, '("Process 0 decremented value:", i2)') message
+        end if
+
+        call shmem_put8(rbuf, message, 1, next)
+
+        if (proc .gt. 0) then
+            message = message - 1
+        end if
+    end do
+
+!     All done
+
+    write(*, '("Process", i2," exiting.")') proc
+
+end program ring_oshmem