oshmem: Add man3 pages

These man pages to OpenSHMEM API are received from openshmem.org
and ported with minimum modifications.
Thanks Tony Curtis for sharing man files.

Signed-off-by: Igor Ivanov <Igor.Ivanov@itseez.com>

oshmem/Makefile.am

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2013      Mellanox Technologies, Inc.
+# Copyright (c) 2013-2015 Mellanox Technologies, Inc.
 #                         All rights reserved.
 # Copyright (c) 2013-2014 Cisco Systems, Inc.  All rights reserved.
 # Copyright (c) 2014      Intel, Inc.  All rights reserved.
@@ -94,6 +94,25 @@ include proc/Makefile.am
 include request/Makefile.am
 include runtime/Makefile.am
 include shmem/Makefile.am
+include shmem/man/man3/Makefile.extra
 include mca/Makefile.am
 include tools/Makefile.am
 include util/Makefile.am
+
+# Ensure that the man page directory exists before we try to make man
+# page files (because ompi/mpi/man/man3 has no config.status-generated
+# Makefile)
+dir_stamp = $(top_builddir)/$(subdir)/shmem/man/man3/.dir-stamp
+
+# Also ensure that the man pages are rebuilt if the opal_config.h file
+# changes (e.g., configure was run again, meaning that the release
+# date or version may have changed)
+$(nodist_man_MANS): $(dir_stamp) $(top_builddir)/opal/include/opal_config.h
+
+$(dir_stamp):
+	$(MKDIR_P) `dirname $@`
+	touch "$@"
+
+# Remove the generated man pages
+distclean-local:
+	rm -f $(nodist_man_MANS) $(dir_stamp)

oshmem/shmem/Makefile.am

@@ -7,6 +7,8 @@
 # $HEADER$
 #
 
+EXTRA_DIST =
+
 headers += shmem/shmem_api_logger.h \
            shmem/shmem_lock.h
 

oshmem/shmem/man/man3/Makefile.extra

@@ -0,0 +1,180 @@
+# -*- makefile -*-
+# Copyright (c) 2015      Mellanox Technologies, Inc.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+include $(top_srcdir)/Makefile.ompi-rules
+
+shmem_api_man_pages = \
+        shmem/man/man3/intro_shmem.3 \
+        shmem/man/man3/OpenSHMEM.3 \
+        shmem/man/man3/start_pes.3 \
+        shmem/man/man3/_num_pes.3 \
+        shmem/man/man3/_my_pe.3 \
+        shmem/man/man3/shmem_pe_accessible.3 \
+        shmem/man/man3/shmem_addr_accessible.3 \
+        shmem/man/man3/shmalloc.3 \
+        shmem/man/man3/shmemalign.3 \
+        shmem/man/man3/shrealloc.3 \
+        shmem/man/man3/shfree.3 \
+        shmem/man/man3/shmem_ptr.3 \
+        shmem/man/man3/shmem_char_p.3 \
+        shmem/man/man3/shmem_short_p.3 \
+        shmem/man/man3/shmem_int_p.3 \
+        shmem/man/man3/shmem_long_p.3 \
+        shmem/man/man3/shmem_float_p.3 \
+        shmem/man/man3/shmem_double_p.3 \
+        shmem/man/man3/shmem_longlong_p.3 \
+        shmem/man/man3/shmem_longdouble_p.3 \
+        shmem/man/man3/shmem_char_put.3 \
+        shmem/man/man3/shmem_short_put.3 \
+        shmem/man/man3/shmem_int_put.3 \
+        shmem/man/man3/shmem_long_put.3 \
+        shmem/man/man3/shmem_float_put.3 \
+        shmem/man/man3/shmem_double_put.3 \
+        shmem/man/man3/shmem_longlong_put.3 \
+        shmem/man/man3/shmem_longdouble_put.3 \
+        shmem/man/man3/shmem_put32.3 \
+        shmem/man/man3/shmem_put64.3 \
+        shmem/man/man3/shmem_put128.3 \
+        shmem/man/man3/shmem_putmem.3 \
+        shmem/man/man3/shmem_short_iput.3 \
+        shmem/man/man3/shmem_int_iput.3 \
+        shmem/man/man3/shmem_long_iput.3 \
+        shmem/man/man3/shmem_float_iput.3 \
+        shmem/man/man3/shmem_double_iput.3 \
+        shmem/man/man3/shmem_longlong_iput.3 \
+        shmem/man/man3/shmem_longdouble_iput.3 \
+        shmem/man/man3/shmem_iput32.3 \
+        shmem/man/man3/shmem_iput64.3 \
+        shmem/man/man3/shmem_iput128.3 \
+        shmem/man/man3/shmem_char_g.3 \
+        shmem/man/man3/shmem_short_g.3 \
+        shmem/man/man3/shmem_int_g.3 \
+        shmem/man/man3/shmem_long_g.3 \
+        shmem/man/man3/shmem_float_g.3 \
+        shmem/man/man3/shmem_double_g.3 \
+        shmem/man/man3/shmem_longlong_g.3 \
+        shmem/man/man3/shmem_longdouble_g.3 \
+        shmem/man/man3/shmem_char_get.3 \
+        shmem/man/man3/shmem_short_get.3 \
+        shmem/man/man3/shmem_int_get.3 \
+        shmem/man/man3/shmem_long_get.3 \
+        shmem/man/man3/shmem_float_get.3 \
+        shmem/man/man3/shmem_double_get.3 \
+        shmem/man/man3/shmem_longlong_get.3 \
+        shmem/man/man3/shmem_longdouble_get.3 \
+        shmem/man/man3/shmem_get32.3 \
+        shmem/man/man3/shmem_get64.3 \
+        shmem/man/man3/shmem_get128.3 \
+        shmem/man/man3/shmem_getmem.3 \
+        shmem/man/man3/shmem_short_iget.3 \
+        shmem/man/man3/shmem_int_iget.3 \
+        shmem/man/man3/shmem_long_iget.3 \
+        shmem/man/man3/shmem_float_iget.3 \
+        shmem/man/man3/shmem_double_iget.3 \
+        shmem/man/man3/shmem_longlong_iget.3 \
+        shmem/man/man3/shmem_longdouble_iget.3 \
+        shmem/man/man3/shmem_iget32.3 \
+        shmem/man/man3/shmem_iget64.3 \
+        shmem/man/man3/shmem_iget128.3 \
+        shmem/man/man3/shmem_swap.3 \
+        shmem/man/man3/shmem_int_swap.3 \
+        shmem/man/man3/shmem_long_swap.3 \
+        shmem/man/man3/shmem_longlong_swap.3 \
+        shmem/man/man3/shmem_float_swap.3 \
+        shmem/man/man3/shmem_double_swap.3 \
+        shmem/man/man3/shmem_int_cswap.3 \
+        shmem/man/man3/shmem_long_cswap.3 \
+        shmem/man/man3/shmem_longlong_cswap.3 \
+        shmem/man/man3/shmem_int_fadd.3 \
+        shmem/man/man3/shmem_long_fadd.3 \
+        shmem/man/man3/shmem_longlong_fadd.3 \
+        shmem/man/man3/shmem_int_finc.3 \
+        shmem/man/man3/shmem_long_finc.3 \
+        shmem/man/man3/shmem_longlong_finc.3 \
+        shmem/man/man3/shmem_int_add.3 \
+        shmem/man/man3/shmem_long_add.3 \
+        shmem/man/man3/shmem_longlong_add.3 \
+        shmem/man/man3/shmem_int_inc.3 \
+        shmem/man/man3/shmem_long_inc.3 \
+        shmem/man/man3/shmem_longlong_inc.3 \
+        shmem/man/man3/shmem_set_lock.3 \
+        shmem/man/man3/shmem_clear_lock.3 \
+        shmem/man/man3/shmem_test_lock.3 \
+        shmem/man/man3/shmem_wait.3 \
+        shmem/man/man3/shmem_short_wait.3 \
+        shmem/man/man3/shmem_int_wait.3 \
+        shmem/man/man3/shmem_long_wait.3 \
+        shmem/man/man3/shmem_longlong_wait.3 \
+        shmem/man/man3/shmem_wait_until.3 \
+        shmem/man/man3/shmem_short_wait_until.3 \
+        shmem/man/man3/shmem_int_wait_until.3 \
+        shmem/man/man3/shmem_long_wait_until.3 \
+        shmem/man/man3/shmem_longlong_wait_until.3 \
+        shmem/man/man3/shmem_barrier.3 \
+        shmem/man/man3/shmem_barrier_all.3 \
+        shmem/man/man3/shmem_fence.3 \
+        shmem/man/man3/shmem_quiet.3 \
+        shmem/man/man3/shmem_broadcast32.3 \
+        shmem/man/man3/shmem_broadcast64.3 \
+        shmem/man/man3/shmem_collect32.3 \
+        shmem/man/man3/shmem_collect64.3 \
+        shmem/man/man3/shmem_fcollect32.3 \
+        shmem/man/man3/shmem_fcollect64.3 \
+        shmem/man/man3/shmem_short_and_to_all.3 \
+        shmem/man/man3/shmem_int_and_to_all.3 \
+        shmem/man/man3/shmem_long_and_to_all.3 \
+        shmem/man/man3/shmem_longlong_and_to_all.3 \
+        shmem/man/man3/shmem_short_or_to_all.3 \
+        shmem/man/man3/shmem_int_or_to_all.3 \
+        shmem/man/man3/shmem_long_or_to_all.3 \
+        shmem/man/man3/shmem_longlong_or_to_all.3 \
+        shmem/man/man3/shmem_short_xor_to_all.3 \
+        shmem/man/man3/shmem_int_xor_to_all.3 \
+        shmem/man/man3/shmem_long_xor_to_all.3 \
+        shmem/man/man3/shmem_longlong_xor_to_all.3 \
+        shmem/man/man3/shmem_short_max_to_all.3 \
+        shmem/man/man3/shmem_int_max_to_all.3 \
+        shmem/man/man3/shmem_long_max_to_all.3 \
+        shmem/man/man3/shmem_longlong_max_to_all.3 \
+        shmem/man/man3/shmem_float_max_to_all.3 \
+        shmem/man/man3/shmem_double_max_to_all.3 \
+        shmem/man/man3/shmem_longdouble_max_to_all.3 \
+        shmem/man/man3/shmem_short_min_to_all.3 \
+        shmem/man/man3/shmem_int_min_to_all.3 \
+        shmem/man/man3/shmem_long_min_to_all.3 \
+        shmem/man/man3/shmem_longlong_min_to_all.3 \
+        shmem/man/man3/shmem_float_min_to_all.3 \
+        shmem/man/man3/shmem_double_min_to_all.3 \
+        shmem/man/man3/shmem_longdouble_min_to_all.3 \
+        shmem/man/man3/shmem_short_sum_to_all.3 \
+        shmem/man/man3/shmem_int_sum_to_all.3 \
+        shmem/man/man3/shmem_long_sum_to_all.3 \
+        shmem/man/man3/shmem_longlong_sum_to_all.3 \
+        shmem/man/man3/shmem_float_sum_to_all.3 \
+        shmem/man/man3/shmem_double_sum_to_all.3 \
+        shmem/man/man3/shmem_complexf_sum_to_all.3 \
+        shmem/man/man3/shmem_complexd_sum_to_all.3 \
+        shmem/man/man3/shmem_short_prod_to_all.3 \
+        shmem/man/man3/shmem_int_prod_to_all.3 \
+        shmem/man/man3/shmem_long_prod_to_all.3 \
+        shmem/man/man3/shmem_longlong_prod_to_all.3 \
+        shmem/man/man3/shmem_float_prod_to_all.3 \
+        shmem/man/man3/shmem_double_prod_to_all.3 \
+        shmem/man/man3/shmem_longdouble_prod_to_all.3 \
+        shmem/man/man3/shmem_complexf_prod_to_all.3 \
+        shmem/man/man3/shmem_complexd_prod_to_all.3 \
+        shmem/man/man3/shmem_udcflush.3 \
+        shmem/man/man3/shmem_udcflush_line.3 \
+        shmem/man/man3/shmem_set_cache_inv.3 \
+        shmem/man/man3/shmem_set_cache_line_inv.3 \
+        shmem/man/man3/shmem_clear_cache_inv.3 \
+        shmem/man/man3/shmem_clear_cache_line_inv.3
+
+nodist_man_MANS += $(shmem_api_man_pages)
+EXTRA_DIST += $(shmem_api_man_pages:.3=.3in)

oshmem/shmem/man/man3/OpenSHMEM.3in

@@ -0,0 +1 @@
+.so man3/intro_shmem.3

oshmem/shmem/man/man3/_my_pe.3in

@@ -0,0 +1,41 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "MY\\_PE" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+my_pe, _my_pe, shmem_my_pe \- Returns the virtual PE number of the calling PE.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+int _my_pe (void);
+int shmem_my_pe (void);
+.Ve
+Fortran:
+.Vb
+include 'mpp/shmem.fh'
+I = MY_PE ()
+I = SHMEM_MY_PE ()
+.Ve
+.SH DESCRIPTION
+
+my_pe() or shmem_my_pe() return the processing element (PE) number of the calling PE. It accepts no
+arguments. The result is an integer between 0 and npes \- 1, where npes is the total
+number of PEs executing the current program.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fInum_pes\fP(3),
+\fIstart_pes\fP(3)

oshmem/shmem/man/man3/_num_pes.3in

@@ -0,0 +1,39 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "NUM\\_PES" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+num_pes, _num_pes, shmem_n_pes \- Returns the number of processing elements (PEs) used to run the application.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+int _num_pes (void);
+int shmem_n_pes (void);
+.Ve
+Fortran:
+.Vb
+include 'mpp/shmem.fh'
+I = NUM_PES ()
+I = SHMEM_N_PES ()
+.Ve
+.SH DESCRIPTION
+
+num_pes() or shmem_n_pes() return the total number of PEs running in an application.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fImy_pe\fP(3),
+\fIstart_pes\fP(3)

oshmem/shmem/man/man3/shfree.3in

@@ -0,0 +1 @@
+.so man3/shmalloc.3

oshmem/shmem/man/man3/shmalloc.3in

@@ -0,0 +1,105 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMALLOC" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmalloc\fP(3),
+\fIshfree\fP(3),
+\fIshmemalign\fP(3),
+\fIshrealloc\fP(3)
+\- Symmetric heap memory management functions.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void *shmalloc(size_t size);
+
+void shfree(void *ptr);
+
+void *shrealloc(void *ptr, size_t size);
+
+void *shmemalign(size_t alignment, size_t size);
+
+extern long malloc_error;
+.Ve
+.SH DESCRIPTION
+
+The \fBshmalloc\fP
+function returns a pointer to a block of at least size bytes
+suitably aligned for any use. This space is allocated from the symmetric heap (in contrast
+to \fImalloc\fP(3C),
+which allocates from the private heap).
+.PP
+The \fBshmemalign\fP
+function allocates a block in the symmetric heap that has a
+byte alignment specified by the alignment argument.
+.PP
+The \fBshfree\fP
+function causes the block to which ptr points to, to be deallocated,
+that is, made available for further allocation. If ptr is a null pointer, no action
+occurs; otherwise, if the argument does not match a pointer earlier returned by a symmetric
+heap function, or if the space has already been deallocated, malloc_error is set to indicate the
+error, and shfree returns.
+.PP
+The \fBshrealloc\fP
+function changes the size of the block to which ptr points to, to the
+size (in bytes) specified by size.
+.PP
+The contents of the block are unchanged up to the lesser of the new and old sizes. If the new
+size is larger, the value of the newly allocated portion of the block is indeterminate. If ptr is a
+null pointer, the shrealloc function behaves like the shmalloc function for the specified size. If
+size is 0 and ptr is not a null pointer, the block to which it points to is freed. Otherwise, if ptr
+does not match a pointer earlier returned by a symmetric heap function, or if the space has
+already been deallocated, the malloc_error variable is set to indicate the error, and shrealloc
+returns a null pointer. If the space cannot be allocated, the block to which ptr points to is
+unchanged.
+.PP
+The shmalloc, shfree, and shrealloc functions are provided so that multiple PEs in an
+application can allocate symmetric, remotely accessible memory blocks. These memory
+blocks can then be used with (shmem) communication routines. Each of these functions call
+the \fIshmem_barrier_all\fP(3)
+function before returning; this ensures that all PEs
+participate in the memory allocation, and that the memory on other PEs can be used as soon
+as the local PE returns.
+.PP
+The user is responsible for calling these functions with identical argument(s) on all PEs; if
+differing size arguments are used, subsequent calls may not return the same symmetric heap
+address on all PEs.
+.PP
+.SH NOTES
+
+The total size of the symmetric heap is determined at job startup. One can adjust the size of
+the heap using the SHMEM_SYMMETRIC_HEAP_SIZE environment variable. See the
+\fIintro_shmem\fP(3)
+man page for futher details.
+The shmalloc, shfree, and shrealloc functions differ from the private heap allocation functions
+in that all PEs in an application must call them (a barrier is used to ensure this).
+.PP
+.SH RETURN VALUES
+
+The \fBshmalloc\fP
+function returns a pointer to the allocated space (which should
+be identical on all PEs); otherwise, it returns a null pointer (with malloc_error set).
+The \fBshfree\fP
+function returns no value.
+The \fBshrealloc\fP
+function returns a pointer to the allocated space (which
+may have moved); otherwise, it returns a null pointer (with malloc_error set).
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fImy_pe\fP(3I),
+\fIstart_pes\fP(3)

oshmem/shmem/man/man3/shmem_addr_accessible.3in

@@ -0,0 +1,56 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_ADDR\\_ACCESSIBLE" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+shmem_addr_accessible \- Indicates if an address is accessible via OpenSHMEM operations
+from the specified remote PE.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+int shmem_addr_accessible(void *addr, int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+LOGICAL LOG, SHMEM_ADDR_ACCESSIBLE
+INTEGER pe
+
+LOG = SHMEM_ADDR_ACCESSIBLE(addr, pe)
+.Ve
+.SH DESCRIPTION
+
+shmem_addr_accessible is a query function that indicates whether a local address is
+accessible via SHMEM operations from the specified remote PE.
+.PP
+This function verifies that the remote PE is accessible via SHMEM data transfer functions from
+the local PE, and that the specified address is in a symmetric data segment with respect to the
+remote PE.
+.PP
+.SH RETURN VALUES
+
+C: The return value is 1 if addr is a symmetric data object and accessible via SHMEM
+operations from the specified remote PE; otherwise, it is 0.
+.PP
+Fortran: The return value is \&.TRUE. if addr is a symmetric data object and accessible via
+SHMEM operations from the specified remote PE; otherwise, it is \&.FALSE..
+.PP
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_pe_accessible\fP(3)

oshmem/shmem/man/man3/shmem_barrier.3in

@@ -0,0 +1,112 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_BARRIER" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+shmem_barrier \- Performs a barrier operation on a subset of processing elements (PEs).
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_barrier(int PE_start, int logPE_stride, int PE_size,
+  long *pSync);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER PE_start, logPE_stride, PE_size
+INTEGER pSync(SHMEM_BARRIER_SYNC_SIZE)
+
+CALL SHMEM_BARRIER(PE_start, logPE_stride, PE_size, pSync)
+.Ve
+.SH DESCRIPTION
+
+The shmem_barrier routine does not return until the subset of PEs specified by
+\fBPE_start\fP,
+\fBlogPE_stride\fP
+and \fBPE_size\fP,
+has entered this routine at the
+same point of the execution path.
+.PP
+As with all SHMEM collective routines, each of these routines assumes that only PEs in the
+active set call the routine. If a PE not in the active set calls a SHMEM collective routine,
+undefined behavior results.
+.PP
+The arguments are as follows:
+.TP
+PE_start
+The lowest virtual PE number of the active set of PEs. PE_start must be of
+type integer. If you are using Fortran, it must be a default integer value.
+.TP
+logPE_stride
+The log (base 2) of the stride between consecutive virtual PE numbers in
+the active set. logPE_stride must be of type integer. If you are using Fortran, it must be a
+default integer value.
+.TP
+PE_size
+The number of PEs in the active set. PE_size must be of type integer. If you
+are using Fortran, it must be a default integer value.
+.TP
+pSync
+A symmetric work array. In C/C++, pSync must be of type int and size
+_SHMEM_BARRIER_SYNC_SIZE. In Fortran, pSync must be of type integer and size
+SHMEM_BARRIER_SYNC_SIZE. If you are using Fortran, it must be a default integer type.
+Every element of this array must be initialized to 0 before any of the PEs in the active set enter
+shmem_barrier the first time.
+.PP
+The values of arguments PE_start, logPE_stride, and PE_size must be equal on all PEs in the
+active set. The same work array must be passed in pSync to all PEs in the active set.
+.PP
+shmem_barrier ensures that all previously issued local stores and previously issued remote
+memory updates done by any of the PEs in the active set (by using SHMEM calls, for
+example \fIshmem_put\fP(3))
+are complete before returning.
+.PP
+The same pSync array may be reused on consecutive calls to shmem_barrier if the same
+active PE set is used.
+.PP
+.SH NOTES
+
+The term symmetric is defined in \fIintro_shmem\fP(3)\&.
+.PP
+If the pSync array is initialized at run time, be sure to use some type of synchronization, for
+example, a call to \fIshmem_barrier_all\fP(3),
+before calling shmem_barrier for the first
+time.
+.PP
+If the active set does not change, shmem_barrier can be called repeatedly with the same
+pSync array. No additional synchronization beyond that implied by shmem_barrier itself is
+necessary in this case.
+.PP
+.SH EXAMPLES
+
+C/C++ example:
+.Vb
+shmem_barrier(PE_start, logPE_stride, size, pSync);
+.Ve
+Fortran example:
+.Vb
+INTEGER PSYNC(SHMEM_BARRIER_SYNC_SIZE)
+INTEGER PE_START, LOGPE_STRIDE, PE_SIZE, PSYNC
+DATA PSYNC /SHMEM_BARRIER_SYNC_SIZE*0/
+
+CALL SHMEM_BARRIER(PE_START, LOGPE_STRIDE, PE_SIZE, PSYNC)
+.Ve
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_barrier_all\fP(3)

oshmem/shmem/man/man3/shmem_barrier_all.3in

@@ -0,0 +1,59 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_BARRIER\\_ALL" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+shmem_barrier_all \- Suspends the execution of the calling PE until all other PEs issue a call
+to this particular shmem_barrier_all() statement.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_barrier_all(void);
+.Ve
+Fortran:
+.Vb
+include 'mpp/shmem.h'
+
+CALL SHMEM_BARRIER_ALL
+.Ve
+.SH DESCRIPTION
+
+The shmem_barrier_all routine does not return until all other PEs have entered this routine
+at the same point of the execution path.
+.PP
+Prior to synchronizing with other PEs, shmem_barrier_all ensures completion of all
+previously issued local memory stores and remote memory updates issued via SHMEM
+functions such as \fIshmem_put32\fP(3)\&.
+.PP
+.SH EXAMPLES
+
+.Vb
+setup_data()
+{
+  if (_my_pe() == 0) {
+    setup();
+  }
+
+  /* All PEs wait for PE 0 to complete setup().  */
+  shmem_barrier_all();
+}
+.Ve
+.PP
+.SH SEE ALSO
+
+\fIshmem_barrier\fP(3),
+\fIstart_pes\fP(3)

oshmem/shmem/man/man3/shmem_broadcast32.3in

@@ -0,0 +1,186 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_BROADCAST" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_broadcast4\fP(3),
+\fIshmem_broadcast8\fP(3),
+\fIshmem_broadcast32\fP(3),
+\fIshmem_broadcast64\fP(3)
+\- Copy a data object from a designated PE to a target
+location on all other PEs of the active set.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_broadcast32(void *target, const void *source,
+  size_t nelems, int PE_root, int PE_start, int logPE_stride,
+  int PE_size, long *pSync);
+
+void shmem_broadcast64(void *target, const void *source,
+  size_t nelems, int PE_root, int PE_start, int logPE_stride,
+  int PE_size, long *pSync);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER nelems, PE_root, PE_start, logPE_stride, PE_size
+INTEGER pSync(SHMEM_BCAST_SYNC_SIZE)
+
+CALL SHMEM_BROADCAST4(target, source, nelems, PE_root,
+& PE_start, logPE_stride, PE_size, fIpSync)
+
+CALL SHMEM_BROADCAST8(target, source, nelems, PE_root,
+& PE_start, logPE_stride, PE_size, pSync)
+
+CALL SHMEM_BROADCAST32(target, source, nelems,
+& PE_root, PE_start, logPE_stride, PE_size, pSync)
+
+CALL SHMEM_BROADCAST64(target, source, nelems,
+& PE_root, PE_start, logPE_stride, PE_size, pSync)
+.Ve
+.SH DESCRIPTION
+
+The broadcast routines write the data at address source of the PE specified by
+\fBPE_root\fP
+to address \fBtarget\fP
+on all other PEs in the active set. The active set of
+PEs is defined by the triplet \fBPE_start\fP,
+\fBlogPE_stride\fP
+and \fBPE_size\fP\&.
+The data is not copied to the target address on the PE specified by \fBPE_root\fP\&.
+Before returning, the broadcast routines ensure that the elements of the pSync array are
+restored to their initial values.
+.PP
+As with all SHMEM collective routines, each of these routines assumes that only PEs in the
+active set call the routine. If a PE not in the active set calls a SHMEM collective routine,
+undefined behavior results.
+.PP
+The arguments are as follows:
+.TP
+target
+A symmetric data object with one of the following data types:
+.RS
+.TP
+\fBshmem_broadcast8, shmem_broadcast64\fP: Any noncharacter type that
+has an element size of 64 bits. No Fortran derived types or C/C++ structures are allowed.
+.TP
+\fBshmem_broadcast32\fP: Any noncharacter type that has an element size
+of 32 bits. No Fortran derived types or C/C++ structures are allowed.
+.TP
+\fBshmem_broadcast4\fP: Any noncharacter type that has an element size
+of 32 bits.
+.RE
+.RS
+.PP
+.RE
+.TP
+source
+A symmetric data object that can be of any data type that is permissible for the
+target argument.
+.TP
+nelems
+The number of elements in source. For shmem_broadcast32 and
+shmem_broadcast4, this is the number of 32\-bit halfwords. nelems must be of type integer.
+If you are using Fortran, it must be a default integer value.
+.TP
+PE_root
+Zero\-based ordinal of the PE, with respect to the active set, from which the
+data is copied. Must be greater than or equal to 0 and less than PE_size. PE_root must be of
+type integer. If you are using Fortran, it must be a default integer value.
+.TP
+PE_start
+The lowest virtual PE number of the active set of PEs. PE_start must be of
+type integer. If you are using Fortran, it must be a default integer value.
+.TP
+logPE_stride
+The log (base 2) of the stride between consecutive virtual PE numbers in
+the active set. log_PE_stride must be of type integer. If you are using Fortran, it must be a
+default integer value.
+.TP
+PE_size
+The number of PEs in the active set. PE_size must be of type integer. If you
+are using Fortran, it must be a default integer value.
+.PP
+.TP
+pSync
+A symmetric work array. In C/C++, pSync must be of type long and size
+_SHMEM_BCAST_SYNC_SIZE.
+In Fortran, pSync must be of type integer and size SHMEM_BCAST_SYNC_SIZE. Every
+element of this array must be initialized with the value _SHMEM_SYNC_VALUE (in C/C++)
+or SHMEM_SYNC_VALUE (in Fortran) before any of the PEs in the active set enter
+shmem_barrier().
+.PP
+The values of arguments PE_root, PE_start, logPE_stride, and PE_size must be equal on
+all PEs in the active set. The same target and source data objects and the same pSync work
+array must be passed to all PEs in the active set.
+.PP
+Before any PE calls a broadcast routine, you must ensure that the following conditions exist
+(synchronization via a barrier or some other method is often needed to ensure this): The
+pSync array on all PEs in the active set is not still in use from a prior call to a broadcast
+routine. The target array on all PEs in the active set is ready to accept the broadcast data.
+.PP
+Upon return from a broadcast routine, the following are true for the local PE: If the current PE
+is not the root PE, the target data object is updated. The values in the pSync array are
+restored to the original values.
+.SH NOTES
+
+The terms collective and symmetric are defined in \fIintro_shmem\fP(3)\&.
+.PP
+All SHMEM broadcast routines restore pSync to its original contents. Multiple calls to SHMEM
+routines that use the same pSync array do not require that pSync be reinitialized after the
+first call.
+.PP
+You must ensure the that the pSync array is not being updated by any PE in the active set
+while any of the PEs participates in processing of a SHMEM broadcast routine. Be careful to
+avoid these situations: If the pSync array is initialized at run time, some type of
+synchronization is needed to ensure that all PEs in the working set have initialized pSync
+before any of them enter a SHMEM routine called with the pSync synchronization array. A
+pSync array may be reused on a subsequent SHMEM broadcast routine only if none of the PEs
+in the active set are still processing a prior SHMEM broadcast routine call that used the same
+pSync array. In general, this can be ensured only by doing some type of synchronization.
+However, in the special case of SHMEM routines being called with the same active set, you
+can allocate two pSync arrays and alternate between them on successive calls.
+.PP
+.SH EXAMPLES
+
+In the following examples, the call to shmem_broadcast64 copies source on PE 4 to target
+on PEs 5, 6, and 7.
+.PP
+C/C++ example:
+.Vb
+for (i=0; i < _SHMEM_BCAST_SYNC_SIZE; i++) {
+  pSync[i] = _SHMEM_SYNC_VALUE;
+}
+shmem_barrier_all(); /* Wait for all PEs to initialize pSync */
+shmem_broadcast64(target, source, nelems, 0, 4, 0, 4, pSync);
+.Ve
+Fortran example:
+.Vb
+INTEGER PSYNC(SHMEM_BCAST_SYNC_SIZE)
+INTEGER TARGET, SOURCE, NELEMS, PE_ROOT, PE_START,
+& LOGPE_STRIDE, PE_SIZE, PSYNC
+COMMON /COM/ TARGET, SOURCE
+DATA PSYNC /SHMEM_BCAST_SYNC_SIZE*SHMEM_SYNC_VALUE/
+
+CALL SHMEM_BROADCAST64(TARGET, SOURCE, NELEMS, 0, 4, 0, 4,
+& PSYNC)
+.Ve
+.PP
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_broadcast64.3in

@@ -0,0 +1 @@
+.so man3/shmem_broadcast32.3

oshmem/shmem/man/man3/shmem_char_g.3in

@@ -0,0 +1,64 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_CHAR\\_G" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_char_g\fP(3),
+\fIshmem_float_g\fP(3),
+\fIshmem_int_g\fP(3),
+\fIshmem_long_g\fP(3),
+\fIshmem_short_g\fP(3),
+\fIshmem_longlong_g\fP(3),
+\fIshmem_longdouble_g\fP(3)
+\- These routines provide a low latency mechanism to read basic types (char, short, int, float, double, long, long long, long double) from symmetric data objects on remote PEs.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+
+char shmem_char_g(char *addr, int pe);
+
+short shmem_short_g(short *addr, int pe);
+
+int shmem_int_g(int *addr, int pe);
+
+long shmem_long_g(long *addr, int pe);
+
+long shmem_longlong_g(long long *addr, int pe);
+
+float shmem_float_g(float *addr, int pe);
+
+double shmem_double_g(double *addr, int pe);
+
+long shmem_longdouble_g(long double *addr, int pe);
+
+.Ve
+.SH DESCRIPTION
+
+These routines provide a very low latency get capability for single elements of most basic types.
+.PP
+The arguments are as follows:
+.TP
+addr
+The remotely accessible array element or scalar data object which will receive the
+data on the remote PE.
+.TP
+pe
+The number of the remote PE.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_get\fP(3)

oshmem/shmem/man/man3/shmem_char_get.3in

@@ -0,0 +1,207 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_GET" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_character_get\fP(3),
+\fIshmem_complex_get\fP(3),
+\fIshmem_double_get\fP(3),
+\fIshmem_float_get\fP(3),
+\fIshmem_get4\fP(3),
+\fIshmem_get8\fP(3),
+\fIshmem_get32\fP(3),
+\fIshmem_get64\fP(3),
+\fIshmem_get128\fP(3),
+\fIshmem_getmem\fP(3),
+\fIshmem_int_get\fP(3),
+\fIshmem_integer_get\fP(3),
+\fIshmem_logical_get\fP(3),
+\fIshmem_long_get\fP(3),
+\fIshmem_longdouble_get\fP(3),
+\fIshmem_longlong_get\fP(3),
+\fIshmem_real_get\fP(3),
+\fIshmem_short_get\fP(3)
+\- Transfers data from a specified processing element (PE).
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_get32(void *target, const void *source,
+  size_t len, int pe);
+
+void shmem_get64(void *target, const void *source,
+  size_t len, int pe);
+
+void shmem_get128(void *target, const void *source,
+  size_t len, int pe);
+
+void shmem_getmem(void *target, const void *source,
+  size_t len, int pe);
+
+void shmem_int_get(int *target, const int *source,
+  size_t len, int pe);
+
+void shmem_double_get(double *target, const double *source,
+  size_t len, int pe);
+
+void shmem_float_get(float *target, const float *source,
+  size_t len, int pe);
+
+void shmem_long_get(long *target, const long *source,
+  size_t len, int pe);
+
+void shmem_longdouble_get(long double *target,
+  const long double *source, size_t len, int pe);
+
+void shmem_longlong_get(long long *target,
+  const long long *source, size_t len, int pe);
+
+void shmem_short_get(short *target,
+  const short *source, size_t len, int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER len, pe
+
+CALL SHMEM_CHARACTER_GET(target, source, len, pe)
+
+CALL SHMEM_COMPLEX_GET(target, source, len, pe)
+
+CALL SHMEM_DOUBLE_GET(target, source, len, pe)
+
+CALL SHMEM_GET4(target, source, len, pe)
+
+CALL SHMEM_GET8(target, source, len, pe)
+
+CALL SHMEM_GET32(target, source, len, pe)
+
+CALL SHMEM_GET64(target, source, len, pe)
+
+CALL SHMEM_GET128(target, source, len, pe)
+
+CALL SHMEM_GETMEM(target, source, len, pe)
+
+CALL SHMEM_INTEGER_GET(target, source, len, pe)
+
+CALL SHMEM_LOGICAL_GET(target, source, len, pe)
+
+CALL SHMEM_REAL_GET(target, source, len, pe)
+.Ve
+.SH DESCRIPTION
+
+The shmem_get routines transfer \fBnelems\fP
+elements of the data object at address \fBsource\fP
+on the remote PE \fBpe\fP,
+to the data object at address \fBtarget\fP
+on the local PE. These routines
+return after the data has been copied to address \fBtarget\fP
+on the local PE.
+.PP
+The arguments are as follows:
+.TP
+target
+Local data object to be updated.
+.TP
+source
+Data object on the PE identified by pe that contains the data to be copied. This
+data object must be remotely accessible.
+.TP
+len
+Number of elements in the target and source arrays. len must be of type integer. If
+you are using Fortran, it must be a constant, variable, or array element of default
+integer type.
+.TP
+pe
+PE number of the remote PE. pe must be of type integer. If you are using Fortran, it
+must be a constant, variable, or array element of default integer type.
+.PP
+The target and source data objects must conform to typing constraints, which are as follows:
+.TP
+\fBshmem_getmem\fP: Fortran: Any noncharacter type. C: Any data type. len is
+scaled in bytes.
+.TP
+\fBshmem_get4, shmem_get32\fP: Any noncharacter type that has a storage size
+equal to 32 bits.
+.TP
+{shmem_get8, shmem_get64}: Any noncharacter type that has a storage size equal to
+64 bits.
+.TP
+\fBshmem_get128\fP: Any noncharacter type that has a storage size equal to 128
+bits.
+.TP
+\fBshmem_short_get\fP: Elements of type short.
+.TP
+\fBshmem_int_get\fP: Elements of type int.
+.TP
+\fBshmem_long_get\fP: Elements of type long.
+.TP
+\fBshmem_longlong_get\fP: Elements of type long long.
+.TP
+\fBshmem_float_get\fP: Elements of type float.
+.TP
+\fBshmem_double_get\fP: Elements of type double.
+.TP
+\fBshmem_longdouble_get\fP: Elements of type long double.
+.TP
+\fBSHMEM_CHARACTER_GET\fP: Elements of type character. len is the number of
+characters to transfer. The actual character lengths of the source and target variables are
+ignored.
+.TP
+\fBSHMEM_COMPLEX_GET\fP: Elements of type complex of default size.
+.TP
+\fBSHMEM_DOUBLE_GET\fP: (Fortran) Elements of type double precision.
+.TP
+\fBSHMEM_INTEGER_GET\fP: Elements of type integer.
+.TP
+\fBSHMEM_LOGICAL_GET\fP: Elements of type logical.
+.TP
+\fBSHMEM_REAL_GET\fP: Elements of type real.
+.PP
+If you are using Fortran, data types must be of default size. For example, a real variable must
+be declared as REAL, REAL*4, or REAL(KIND=4).
+.SH NOTES
+
+See \fIintro_shmem\fP(3)
+for a definition of the term remotely accessible.
+.SH EXAMPLES
+
+Consider this simple example for Fortran.
+.Vb
+PROGRAM REDUCTION
+  REAL VALUES, SUM
+  COMMON /C/ VALUES
+  REAL WORK
+
+  CALL START_PES(0) ! ALLOW ANY NUMBER OF PES
+  VALUES = MY_PE() ! INITIALIZE IT TO SOMETHING
+  CALL SHMEM_BARRIER_ALL
+  SUM = 0.0
+  DO I = 0,NUM_PES()\-1
+    CALL SHMEM_REAL_GET(WORK, VALUES, 1, I)
+    SUM = SUM + WORK
+  ENDDO
+  PRINT *, 'PE ', MY_PE(), ' COMPUTED SUM=', SUM
+  CALL SHMEM_BARRIER_ALL
+END
+.Ve
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_put\fP(3),
+\fIshmem_iget\fP(3),
+\fIshmem_quiet\fP(3)

oshmem/shmem/man/man3/shmem_char_p.3in

@@ -0,0 +1,73 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_CHAR\\_P" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_char_p\fP(3),
+\fIshmem_float_p\fP(3),
+\fIshmem_int_p\fP(3),
+\fIshmem_long_p\fP(3),
+\fIshmem_short_p\fP(3),
+\fIshmem_longlong_p\fP(3),
+\fIshmem_longdouble_p\fP(3)
+\- These routines provide a low latency mechanism to write basic types (char, short, int, float, double, long, long long, long double) to symmetric data objects on remote PEs.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+
+void shmem_char_p(char *addr, char value, int pe);
+
+void shmem_short_p(short *addr, short value, int pe);
+
+void shmem_int_p(int *addr, int value, int pe);
+
+void shmem_long_p(long *addr, long value, int pe);
+
+void shmem_longlong_p(long long *addr, long long value, int pe);
+
+void shmem_float_p(float *addr, float value, int pe);
+
+void shmem_double_p(double *addr, double value, int pe);
+
+void shmem_longdouble_p(long double *addr, long double value, int pe);
+
+.Ve
+.SH DESCRIPTION
+
+These routines provide a very low latency put capability for single elements of most basic types.
+.PP
+The arguments are as follows:
+.TP
+addr
+The remotely accessible array element or scalar data object which will receive the
+data on the remote PE.
+.TP
+value
+The value to be transferred to addr on the remote PE.
+.TP
+pe
+The number of the remote PE.
+.PP
+As with \fIshmem_put\fP(3),
+these functions start the remote transfer and may return before
+the data is delivered to the remote PE. Use \fIshmem_quiet\fP(3)
+to force completion of all
+remote PUT transfers.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_put\fP(3)

oshmem/shmem/man/man3/shmem_char_put.3in

@@ -0,0 +1,214 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_PUT" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_character_put\fP(3),
+\fIshmem_complex_put\fP(3),
+\fIshmem_double_put\fP(3),
+\fIshmem_float_put\fP(3),
+\fIshmem_int_put\fP(3),
+\fIshmem_integer_put\fP(3),
+\fIshmem_logical_put\fP(3),
+\fIshmem_long_put\fP(3),
+\fIshmem_longdouble_put\fP(3),
+\fIshmem_longlong_put\fP(3),
+\fIshmem_put4\fP(3),
+\fIshmem_put8\fP(3),
+\fIshmem_put32\fP(3),
+\fIshmem_put64\fP(3),
+\fIshmem_put128\fP(3),
+\fIshmem_putmem\fP(3),
+\fIshmem_real_put\fP(3),
+\fIshmem_short_put\fP(3)
+\- Transfers data to a specified
+processing element (PE)
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#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);
+.Ve
+Fortran:
+.Vb
+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)
+.Ve
+.SH DESCRIPTION
+
+These routines transfer \fBnelems\fP
+elements of the data object at address
+\fBsource\fP
+on the calling PE, to the data object at address \fBtarget\fP
+on the remote
+PE \fBpe\fP\&.
+These routines start the remote transfer and may return before the data is
+delivered to the remote PE.
+.PP
+The delivery of data into the data object on the destination PE from different put calls may
+occur in any order. Because of this, two successive put operations may deliver data out of
+order unless a call to \fIshmem_fence\fP(3)
+is introduced between the two calls.
+.PP
+The arguments are as follows:
+.TP
+target
+Data object to be updated on the remote PE. This data object must be remotely
+accessible.
+.TP
+source
+Data object containing the data to be copied.
+.TP
+len
+Number of elements in the target and source arrays. len must be of type integer. If
+you are using Fortran, it must be a constant, variable, or array element of default integer
+type.
+.TP
+pe
+PE number of the remote PE. pe must be of type integer. If you are using Fortran, it
+must be a constant, variable, or array element of default integer type.
+.PP
+The target and source data objects must conform to certain typing constraints, which are as
+follows:
+.TP
+\fBshmem_putmem\fP: Fortran: Any noncharacter type. C: Any data type. len is scaled in
+bytes.
+.TP
+\fBshmem_put4, shmem_put32:\fP Any noncharacter type that has a storage size
+equal to 32 bits.
+.TP
+\fBshmem_put8, shmem_put64:\fP Any noncharacter type that has a storage size
+equal to 64 bits.
+.TP
+\fBshmem_put128:\fP Any noncharacter type that has a storage size equal to 128
+bits.
+.TP
+\fBshmem_short_put:\fP Elements of type short.
+.TP
+\fBshmem_int_put:\fP Elements of type int.
+.TP
+\fBshmem_long_put:\fP Elements of type long.
+.TP
+\fBshmem_longlong_put:\fP Elements of type long long.
+.TP
+\fBshmem_float_put:\fP Elements of type float.
+.TP
+\fBshmem_double_put:\fP Elements of type double.
+.TP
+\fBshmem_longdouble_put:\fP Elements of type long double.
+.TP
+\fBSHMEM_CHARACTER_PUT:\fP Elements of type character. len is the number of
+characters to transfer. The actual character lengths of the source and target variables are
+ignored.
+.TP
+\fBSHMEM_COMPLEX_PUT:\fP Elements of type complex of default size.
+.TP
+\fBSHMEM_DOUBLE_PUT:\fP (Fortran) Elements of type double precision.
+.TP
+\fBSHMEM_INTEGER_PUT:\fP Elements of type integer.
+.TP
+\fBSHMEM_LOGICAL_PUT:\fP Elements of type logical.
+.TP
+\fBSHMEM_REAL_PUT:\fP Elements of type real.
+If you are using Fortran, data types must be of default size. For example, a real variable must
+be declared as REAL, REAL*4, or REAL(KIND=4).
+.PP
+.SH EXAMPLES
+
+The following shmem_put example is for C/C++ programs:
+.Vb
+#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];
+  start_pes(2);
+
+  if (_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 (_my_pe() == 1)
+    shmem_udcflush();  /* not required on Altix systems */
+  printf("target[0] on PE %d is %d\\n", _my_pe(), target[0]);
+}
+.Ve
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_iput\fP(3),
+\fIshmem_quiet\fP(3)

oshmem/shmem/man/man3/shmem_clear_cache_inv.3in

@@ -0,0 +1 @@
+.so man3/shmem_udcflush.3

oshmem/shmem/man/man3/shmem_clear_cache_line_inv.3in

@@ -0,0 +1 @@
+.so man3/shmem_udcflush.3

oshmem/shmem/man/man3/shmem_clear_lock.3in

@@ -0,0 +1 @@
+.so man3/shmem_set_lock.3

oshmem/shmem/man/man3/shmem_collect32.3in

@@ -0,0 +1,197 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_COLLECT" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_collect4\fP(3),
+\fIshmem_collect8\fP(3),
+\fIshmem_collect32\fP(3),
+\fIshmem_collect64\fP(3),
+\fIshmem_fcollect\fP(3),
+\fIshmem_fcollect4\fP(3),
+\fIshmem_fcollect8\fP(3),
+\fIshmem_fcollect32\fP(3),
+\fIshmem_fcollect64\fP(3)
+\- Concatenates blocks of data from multiple processing elements (PEs) to an array in every PE
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_collect32(void *target, const void *source,
+  size_t nelems, int PE_start, int logPE_stride, int PE_size,
+  long *pSync);
+
+void shmem_collect64(void *target, const void *source,
+  size_t nelems, int PE_start, int logPE_stride, int PE_size,
+  long *pSync);
+
+void shmem_fcollect32(void *target, const void *source,
+  size_t nelems, int PE_start, int logPE_stride, int PE_size,
+  long *pSync);
+
+void shmem_fcollect64(void *target, const void *source,
+  size_t nelems, int PE_start, int logPE_stride, int PE_size,
+  long *pSync);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER nelems
+INTEGER PE_start, logPE_stride, PE_size
+INTEGER pSync(SHMEM_COLLECT_SYNC_SIZE)
+
+CALL SHMEM_COLLECT4(target, source, nelems, PE_start,
+& logPE_stride, PE_size, pSync)
+
+CALL SHMEM_COLLECT8(target, source, nelems, PE_start,
+& logPE_stride, PE_size, pSync)
+
+CALL SHMEM_FCOLLECT4(target, source, nelems, PE_start,
+& logPE_stride, PE_size, pSync)
+
+CALL SHMEM_FCOLLECT8(target, source, nelems, PE_start,
+& logPE_stride, PE_size, pSync)
+.Ve
+.SH DESCRIPTION
+
+The shared memory (SHMEM) collect and fcollect routines concatenate nelems 64\-bit or 32\-bit
+data items from the source array into the target array, over the set of PEs defined by
+PE_start, log2PE_stride, and PE_size, in processor number order. The resultant target array
+contains the contribution from PE PE_start first, then the contribution from PE PE_start +
+PE_stride second, and so on. The collected result is written to the target array for all PEs in
+the active set.
+.PP
+The fcollect routines require that nelems be the same value in all participating PEs, while the
+collect routines allow nelems to vary from PE to PE.
+.PP
+The resulting target array is as follows:
+.Vb
+\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+   source(1..nelems)
+       from PE (PE_start + 0 * (2**logPE_stride))
+\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+   source(1..nelems)
+       from PE (PE_start + 1 * (2**logPE_stride))
+\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+   ...
+\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+   source(1..nelems) from
+       PE (PE_start + (PE_size \- 1) * (2**logPE_stride))
+\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-
+.Ve
+.PP
+As with all SHMEM collective routines, each of these routines assumes that only PEs in
+the active set call the routine. If a PE not in the active set calls a SHMEM collective routine,
+undefined behavior results.
+.PP
+The arguments are as follows:
+.TP
+target
+A symmetric array. The target argument must be large enough to accept the concatenation of the source arrays on all PEs. The data types are
+as follows:
+.RS
+.TP
+[shmem_collect8, shmem_collect64, shmem_fcollect8, and
+shmem_fcollect64] any data type with an element size of 64 bits. Fortran derived types,
+Fortran character type, and C/C++ structures are not permitted.
+.TP
+[shmem_collect4, shmem_collect32, shmem_fcollect4, and
+shmem_fcollect32] any data type with an element size of 32 bits. Fortran derived types,
+Fortran character type, and C/C++ structures are not permitted.
+.RE
+.RS
+.PP
+.RE
+.TP
+source
+A symmetric data object that can be of any type permissible for the target
+argument.
+.TP
+nelems
+The number of elements in the source array. nelems must be of type integer. If
+you are using Fortran, it must be a default integer value.
+.TP
+PE_start
+The lowest virtual PE number of the active set of PEs. PE_start must be of
+type integer. If you are using Fortran, it must be a default integer value.
+.TP
+logPE_stride
+The log (base 2) of the stride between consecutive virtual PE numbers in
+the active set. logPE_stride must be of type integer. If you are using Fortran, it must be a
+default integer value.
+.TP
+PE_size
+The number of PEs in the active set. PE_size must be of type integer. If you
+are using Fortran, it must be a default integer value.
+.TP
+pSync
+A symmetric work array. In C/C++, pSync must be of type int and size
+_SHMEM_COLLECT_SYNC_SIZE. In Fortran, pSync must be of type integer and size
+SHMEM_COLLECT_SYNC_SIZE. If you are using Fortran, it must be a default integer value.
+Every element of this array must be initialized with the value _SHMEM_SYNC_VALUE in
+C/C++ or SHMEM_SYNC_VALUE in Fortran before any of the PEs in the active set enter
+shmem_barrier().
+.PP
+The values of arguments PE_start, logPE_stride, and PE_size must be equal on all PEs in
+the active set. The same target and source arrays and the same pSync work array must be
+passed to all PEs in the active set.
+.PP
+Upon return from a collective routine, the following are true for the local PE: The target array
+is updated. The values in the pSync array are restored to the original values.
+.SH NOTES
+
+The terms collective and symmetric are defined in \fIintro_shmem\fP(3)\&.
+All SHMEM collective routines reset the values in pSync before they return, so a particular
+pSync buffer need only be initialized the first time it is used.
+.PP
+You must ensure that the pSync array is not being updated on any PE in the active set while
+any of the PEs participate in processing of a SHMEM collective routine. Be careful to
+avoid these situations: If the pSync array is initialized at run time, some type of
+synchronization is needed to ensure that all PEs in the working set have initialized
+pSync before any of them enter a SHMEM routine called with the pSync synchronization array.
+A pSync array can be reused on a subsequent SHMEM collective routine only if none
+of the PEs in the active set are still processing a prior SHMEM collective routine call that used
+the same pSync array. In general, this may be ensured only by doing some type of
+synchronization. However, in the special case of SHMEM routines being called with the same
+active set, you can allocate two pSync arrays and alternate between them on
+successive calls.
+.PP
+The collective routines operate on active PE sets that have a non\-power\-of\-two PE_size
+with some performance degradation. They operate with no performance degradation
+when nelems is a non\-power\-of\-two value.
+.SH EXAMPLES
+
+C/C++:
+.Vb
+for (i=0; i < _SHMEM_COLLECT_SYNC_SIZE; i++) {
+  pSync[i] = _SHMEM_SYNC_VALUE;
+}
+shmem_barrier_all(); /* Wait for all PEs to initialize pSync */
+shmem_collect32(target, source, 64, pe_start, logPE_stride,
+   pe_size, pSync);
+.Ve
+Fortran:
+.Vb
+INTEGER PSYNC(SHMEM_COLLECT_SYNC_SIZE)
+DATA PSYNC /SHMEM_COLLECT_SYNC_SIZE*SHMEM_SYNC_VALUE/
+
+CALL SHMEM_COLLECT4(TARGET, SOURCE, 64, PE_START,
+& LOGPE_STRIDE, PE_SIZE, PSYNC)
+.Ve
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_collect64.3in

@@ -0,0 +1 @@
+.so man3/shmem_collect32.3

oshmem/shmem/man/man3/shmem_complexd_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_complexd_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3

oshmem/shmem/man/man3/shmem_complexf_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_complexf_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3

oshmem/shmem/man/man3/shmem_double_g.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_g.3

oshmem/shmem/man/man3/shmem_double_get.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_double_iget.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_double_iput.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_double_max_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_max_to_all.3

oshmem/shmem/man/man3/shmem_double_min_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_min_to_all.3

oshmem/shmem/man/man3/shmem_double_p.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_p.3

oshmem/shmem/man/man3/shmem_double_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_double_put.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_put.3

oshmem/shmem/man/man3/shmem_double_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3

oshmem/shmem/man/man3/shmem_double_swap.3in

@@ -0,0 +1 @@
+.so man3/shmem_swap.3

oshmem/shmem/man/man3/shmem_fcollect32.3in

@@ -0,0 +1 @@
+.so man3/shmem_collect32.3

oshmem/shmem/man/man3/shmem_fcollect64.3in

@@ -0,0 +1 @@
+.so man3/shmem_collect32.3

oshmem/shmem/man/man3/shmem_fence.3in

@@ -0,0 +1,54 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_FENCE" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+shmem_fence \- Provides a separate ordering on the sequence of puts issued by this PE to each destination
+PE.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_fence(void);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+CALL SHMEM_FENCE
+.Ve
+.SH DESCRIPTION
+
+The \fBshmem_fence()\fP
+routine provides an ordering on the put operations issued by the calling
+PE prior to the call to \fBshmem_fence()\fP
+relative to the put operations issued by the
+calling PE following the call to \fBshmem_fence()\fP\&.
+It guarantees that all such prior put operations
+issued to a particular destination PE are fully written to the symmetric memory of
+that destination PE, before any such following put operations to that same destination PE
+are written to the symmetric memory of that destination PE.
+Note that the ordering is provided separately on the sequences of puts from the calling PE to
+each distinct destination PE. The \fBshmem_quiet()\fP
+routine should be used instead if ordering
+of puts is required when multiple destination PEs are involved.
+.SH NOTES
+
+The shmem_quiet function should be called if ordering of puts is desired when multiple remote
+PEs are involved.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_float_g.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_g.3

oshmem/shmem/man/man3/shmem_float_get.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_float_iget.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_float_iput.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_float_max_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_max_to_all.3

oshmem/shmem/man/man3/shmem_float_min_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_min_to_all.3

oshmem/shmem/man/man3/shmem_float_p.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_p.3

oshmem/shmem/man/man3/shmem_float_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_float_put.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_put.3

oshmem/shmem/man/man3/shmem_float_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3

oshmem/shmem/man/man3/shmem_float_swap.3in

@@ -0,0 +1 @@
+.so man3/shmem_swap.3

oshmem/shmem/man/man3/shmem_get128.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_get32.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_get64.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_getmem.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_iget128.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_iget32.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_iget64.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_int_add.3in

@@ -0,0 +1,76 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_ADD" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_int_add\fP(3),
+\fIshmem_int4_add\fP(3),
+\fIshmem_int8_add\fP(3),
+\fIshmem_long_add\fP(3),
+\fIshmem_longlong_add\fP(3)
+\- Performs an atomic add
+operation.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+void shmem_int_add(int *target, int value, int pe);
+void shmem_long_add(long *target, long value, int pe);
+void shmem_longlong_add(long long *target, long long value,
+  int pe);
+.Ve
+Fortran:
+.Vb
+include 'mpp/shmem.h'
+
+INTEGER pe
+
+CALL SHMEM_INT4_ADD(target, value, pe)
+CALL SHMEM_INT8_ADD(target, value, pe)
+.Ve
+.SH DESCRIPTION
+
+The atomic add routines add \fBvalue\fP
+to the data at address \fBtarget\fP
+on PE
+\fBpe\fP\&.
+The operation completes without the possibility of another process updating
+target between the time of the fetch and the update.
+.PP
+The arguments are as follows:
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. If
+you are using C/C++, the type of target should match that implied in the SYNOPSIS section. If
+you are using the 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.
+.TP
+value
+The value to be atomically added to target. If you are using C/C++, the type of
+value should match that implied in the SYNOPSIS section. If you are using Fortran, it must be
+of type integer with an element size of target.
+.TP
+pe
+An integer that indicates the PE number upon which target is to be updated. If you
+are using Fortran, it must be a default integer value.
+.PP
+.SH NOTES
+
+The term remotely accessible is defined in \fIintro_shmem\fP(3)\&.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_cache\fP(3)

oshmem/shmem/man/man3/shmem_int_and_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_and_to_all.3

oshmem/shmem/man/man3/shmem_int_cswap.3in

@@ -0,0 +1,127 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_CSWAP" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_int_cswap\fP(3),
+\fIshmem_int4_cswap\fP(3),
+\fIshmem_int8_cswap\fP(3),
+\fIshmem_long_cswap\fP(3),
+\fIshmem_longlong_cswap\fP(3)
+\- Performs an atomic conditional swap to a remote data object
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+int shmem_int_cswap(int *target, int cond, int value, int pe);
+
+long shmem_long_cswap(long *target, long cond, long value,
+  int pe);
+
+long long shmem_longlong_cswap(longlong *target,
+  longlong cond, longlong value, int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER pe
+
+INTEGER(KIND=4) SHMEM_INT4_CSWAP
+ires = SHMEM_INT4_CSWAP(target, cond, value, pe)
+
+INTEGER(KIND=8) SHMEM_INT8_CSWAP
+ires = SHMEM_INT8_CSWAP(target, cond, value, pe)
+.Ve
+.SH DESCRIPTION
+
+The conditional swap routines conditionally update a target data object on an arbitrary
+processing element (PE) and return the prior contents of the data object in one atomic
+operation.
+.PP
+The arguments are as follows:
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. If
+you are using C/C++, the type of target should match that implied in the SYNOPSIS section. If
+you are using the 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.
+.TP
+value
+The value to be atomically added to target. If you are using C/C++, the type of
+value should match that implied in the SYNOPSIS section. If you are using Fortran, it must be
+of type integer with an element size of target.
+.TP
+pe
+An integer that indicates the PE number upon which target is to be updated. If you
+are using Fortran, it must be a default integer value.
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. If
+you are using C/C++, the data type of target should match that implied in the SYNOPSIS
+section. If you are using Fortran, it must be of the following type:
+.RS
+.TP
+\fBSHMEM_INT4_CSWAP\fP: 4\-byte integer
+.TP
+\fBSHMEM_INT8_CSWAP\fP: 8\-byte integer
+.RE
+.RS
+.PP
+.RE
+.TP
+cond
+cond is compared to the remote target value. If cond and the remote target are
+equal, then value is swapped into the remote target. Otherwise, the remote target is
+unchanged. In either case, the old value of the remote target is returned as the function return
+value. cond must be of the same data type as target.
+.TP
+value
+The value to be atomically written to the remote PE. value must be the same data
+type as target.
+.TP
+pe
+An integer that indicates the PE number upon which target is to be updated. If you
+are using Fortran, it must be a default integer value.
+.PP
+.SH NOTES
+
+The term remotely accessible is defined in \fIintro_shmem\fP(3)\&.
+.SH RETURN VALUES
+
+The contents that had been in the target data object on the remote PE prior to the conditional
+swap.
+.SH EXAMPLES
+
+The following call ensures that the first PE to execute the conditional swap will successfully
+write its PE number to race_winner on PE 0.
+.Vb
+main()
+{
+  static int race_winner = \-1;
+  int oldval;
+
+  start_pes(2);
+  oldval = shmem_int_cswap(&race_winner, \-1, _my_pe(), 0);
+  if (oldval == \-1)
+    printf("pe %d was first\\n",_my_pe());
+}
+.Ve
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3),
+\fIshmem_cache\fP(3),
+\fIshmem_swap\fP(3)

oshmem/shmem/man/man3/shmem_int_fadd.3in

@@ -0,0 +1,79 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_FADD" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_int4_fadd\fP(3),
+\fIshmem_int8_fadd\fP(3),
+\fIshmem_int_fadd\fP(3),
+\fIshmem_long_fadd\fP(3),
+\fIshmem_longlong_fadd\fP(3)
+\- Performs an atomic fetch\-and\-add operation on a remote data object
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+int shmem_int_fadd(int *target, int value, int pe);
+
+long shmem_long_fadd(long *target, long value, int pe);
+
+long long shmem_longlong_fadd(long long *target, longlong value,
+  int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER pe
+
+INTEGER(KIND=4) SHMEM_INT4_FADD, ires, target, value
+ires = SHMEM_INT4_FADD(target, value, pe)
+
+INTEGER(KIND=8) SHMEM_INT8_FADD, ires, target, value
+ires = SHMEM_INT8_FADD(target, value, pe)
+.Ve
+.SH DESCRIPTION
+
+shmem_fadd functions perform an atomic fetch\-and\-add operation. An atomic
+fetch\-and\-add operation fetches the old target and adds value to target without the
+possibility of another process updating target between the time of the fetch and the update.
+These routines add value to target on Processing Element (PE) pe and return the previous
+contents of target as an atomic operation.
+.PP
+The arguments are as follows:
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. The
+type of target should match that implied in the SYNOPSIS section.
+.TP
+value
+The value to be atomically added to target. The type of value should match that
+implied in the SYNOPSIS section.
+.TP
+pe
+An integer that indicates the PE number on which target is to be updated. If you are
+using Fortran, it must be a default integer value.
+.PP
+.SH NOTES
+
+The term remotely accessible is defined in \fIintro_shmem\fP(3)\&.
+.SH RETURN VALUES
+
+The contents that had been at the target address on the remote PE prior to the atomic addition
+operation.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_int_finc.3in

@@ -0,0 +1,76 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_FINC" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_int4_finc\fP(3),
+\fIshmem_int8_finc\fP(3),
+\fIshmem_int_finc\fP(3),
+\fIshmem_long_finc\fP(3),
+\fIshmem_longlong_finc\fP(3)
+\- Performs an atomic fetch\-and\-increment operation on a remote data object
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+int shmem_int_finc(int *target, int pe);
+
+long shmem_long_finc(long *target, int pe);
+
+long long shmem_longlong_finc(long long *target, int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER pe
+INTEGER(KIND=4) SHMEM_INT4_FINC, target4
+INTEGER(KIND=8) SHMEM_INT8_FINC, target8
+
+ires4 = SHMEM_INT4_FINC(target4, pe)
+
+ires8 = SHMEM_INT8_FINC(target8, pe)
+.Ve
+.SH DESCRIPTION
+
+The fetch and increment routines retrieve the value at address \fBtarget\fP
+on PE
+\fBpe\fP,
+and update \fBtarget\fP
+with the result of incrementing the retrieved value by
+one. The operation must be completed without the possibility of another process updating
+\fBtarget\fP
+between the time of the fetch and the update.
+.PP
+The arguments are as follows:
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. The
+type of target should match that implied in the SYNOPSIS section.
+.TP
+pe
+An integer that indicates the PE number upon which target is to be updated. If you
+are using Fortran, it must be a default integer value.
+.PP
+.SH NOTES
+
+The term remotely accessible is defined in \fIintro_shmem\fP(3)\&.
+.SH RETURN VALUES
+
+The contents that had been at the target address on the remote PE prior to the increment.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_int_g.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_g.3

oshmem/shmem/man/man3/shmem_int_get.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_int_iget.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_int_inc.3in

@@ -0,0 +1,73 @@
+.\" -*- nroff -*-
+.\" Copyright (c) 2015      University of Houston.  All rights reserved.
+.\" Copyright (c) 2015      Mellanox Technologies, Inc.
+.\" $COPYRIGHT$
+.de Vb
+.ft CW
+.nf
+..
+.de Ve
+.ft R
+
+.fi
+..
+.TH "SHMEM\\_INC" "3" "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#"
+.SH NAME
+
+\fIshmem_int4_inc\fP(3),
+\fIshmem_int8_inc\fP(3),
+\fIshmem_int_inc\fP(3),
+\fIshmem_long_inc\fP(3),
+\fIshmem_longlong_inc\fP(3)
+\- These routines perform an atomic increment operation on a remote data object.
+.SH SYNOPSIS
+
+C or C++:
+.Vb
+#include <mpp/shmem.h>
+
+int shmem_int_inc(int *target, int pe);
+
+long shmem_long_inc(long *target, int pe);
+
+long long shmem_longlong_inc(long long *target, int pe);
+.Ve
+Fortran:
+.Vb
+INCLUDE "mpp/shmem.fh"
+
+INTEGER pe
+INTEGER(KIND=4) SHMEM_INT4_INC, target4
+INTEGER(KIND=8) SHMEM_INT8_INC, target8
+
+ires4 = SHMEM_INT4_INC(target4, pe)
+
+ires8 = SHMEM_INT8_INC(target8, pe)
+.Ve
+.SH DESCRIPTION
+
+The atomic increment routines replace the value of \fBtarget\fP
+with its value incremented by
+one. The operation must be completed without the possibility of another process updating
+\fBtarget\fP
+between the time of the fetch and the update.
+.PP
+The arguments are as follows:
+.TP
+target
+The remotely accessible integer data object to be updated on the remote PE. The
+type of target should match that implied in the SYNOPSIS section.
+.TP
+pe
+An integer that indicates the PE number upon which target is to be updated. If you
+are using Fortran, it must be a default integer value.
+.PP
+.SH NOTES
+
+The term remotely accessible is defined in \fIintro_shmem\fP(3)\&.
+.SH RETURN VALUES
+
+None.
+.SH SEE ALSO
+
+\fIintro_shmem\fP(3)

oshmem/shmem/man/man3/shmem_int_iput.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_int_max_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_max_to_all.3

oshmem/shmem/man/man3/shmem_int_min_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_min_to_all.3

oshmem/shmem/man/man3/shmem_int_or_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_or_to_all.3

oshmem/shmem/man/man3/shmem_int_p.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_p.3

oshmem/shmem/man/man3/shmem_int_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_int_put.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_put.3

oshmem/shmem/man/man3/shmem_int_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3

oshmem/shmem/man/man3/shmem_int_swap.3in

@@ -0,0 +1 @@
+.so man3/shmem_swap.3

oshmem/shmem/man/man3/shmem_int_wait.3in

@@ -0,0 +1 @@
+.so man3/shmem_wait.3

oshmem/shmem/man/man3/shmem_int_wait_until.3in

@@ -0,0 +1 @@
+.so man3/shmem_wait.3

oshmem/shmem/man/man3/shmem_int_xor_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_xor_all.3

oshmem/shmem/man/man3/shmem_iput128.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_iput32.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_iput64.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_long_add.3in

@@ -0,0 +1 @@
+.so man3/shmem_int_add.3

oshmem/shmem/man/man3/shmem_long_and_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_and_to_all.3

oshmem/shmem/man/man3/shmem_long_cswap.3in

@@ -0,0 +1 @@
+.so man3/shmem_int_cswap.3

oshmem/shmem/man/man3/shmem_long_fadd.3in

@@ -0,0 +1 @@
+.so man3/shmem_int_fadd.3

oshmem/shmem/man/man3/shmem_long_finc.3in

@@ -0,0 +1 @@
+.so man3/shmem_int_finc.3

oshmem/shmem/man/man3/shmem_long_g.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_g.3

oshmem/shmem/man/man3/shmem_long_get.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_get.3

oshmem/shmem/man/man3/shmem_long_iget.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iget.3

oshmem/shmem/man/man3/shmem_long_inc.3in

@@ -0,0 +1 @@
+.so man3/shmem_int_inc.3

oshmem/shmem/man/man3/shmem_long_iput.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_iput.3

oshmem/shmem/man/man3/shmem_long_max_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_max_to_all.3

oshmem/shmem/man/man3/shmem_long_min_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_min_to_all.3

oshmem/shmem/man/man3/shmem_long_or_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_or_to_all.3

oshmem/shmem/man/man3/shmem_long_p.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_p.3

oshmem/shmem/man/man3/shmem_long_prod_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_prod_to_all.3

oshmem/shmem/man/man3/shmem_long_put.3in

@@ -0,0 +1 @@
+.so man3/shmem_char_put.3

oshmem/shmem/man/man3/shmem_long_sum_to_all.3in

@@ -0,0 +1 @@
+.so man3/shmem_short_sum_to_all.3