upc_all_gather_all

Date:: 05-03-2013

NAME

upc_all_gather_all - collectively copies shared memory to multiple threads

SYNOPSIS

void upc_all_gather_all( shared void * restrict dst, shared const void * restrict src,
                                                             size_t nbytes, upc_flag_t flags );

IMPLEMENTATION

Cray Linux Environment (CLE)

DESCRIPTION

The upc_all_gather_all collective function copies a block of memory from one shared memory area (src) with affinity to the i-th thread to the i-th block of a shared memory area (dst) on each thread. The number of bytes in each block is nbytes, where nbytes > 0.

The upc_all_gather_all function treats the src pointer as if it pointed to a shared memory area of nbytes bytes on each thread and therefore had type:

shared [nbytes] char[nbytes * THREADS]

and it treats the dst pointer as if it pointed to a shared memory area with the type:

shared [nbytes * THREADS] char[nbytes * THREADS * THREADS]

The targets of the src and dst pointers must have affinity to thread 0. The src and dst pointers are treated as if they have phase 0.

The effect is equivalent to copying the i-th block of nbytes bytes pointed to by src to the i-th block of nbytes bytes pointed to by dst that has affinity to each thread.

Controlling Data Synchronization

The argument flag is of type upc_flag_t and is used to specify the data synchronization semantics for the collective function. The value of flag is formed by or-ing together a constant of the form UPC_IN_XSYNC and a constant of the form UPC_OUT_YSYNC, where X and Y may be NO, MY, or ALL. If X is:

NO: The function may begin to read or write data when the first thread has entered the collective function call.
MY: The function may begin to read or write only data which has affinity to threads that have entered the collective function call.
ALL: The function may begin to read or write data only after all threads have entered the function call.

And if Y is:

NO: The function may read and write data until the last thread has returned from the collective function call.
MY: The function call may return in a thread only after all reads and writes of data with affinity to the thread are complete.
ALL: The function call may return only after all reads and writes of data are complete.

For further information, see upc_flag_t(3c).

EXAMPLES

Example 1 upc_all_gather_all for the static THREADS translation environment.

#include <upc.h>
#include <upc_collective.h>
#define NELEMS 10
shared [NELEMS] int A[NELEMS*THREADS];
shared [NELEMS*THREADS] int B[THREADS][NELEMS*THREADS];

// Initialize A.
upc_barrier;
upc_all_gather_all( B, A, sizeof(int)*NELEMS, UPC_IN_NOSYNC | UPC_OUT_NOSYNC );

Example 2: upc_all_gather_all for the dynamic THREADS translation environment.

#include <upc.h>
#include <upc_collective.h>
#define NELEMS 10
shared [NELEMS] int A[NELEMS*THREADS];
shared int *Bdata;
shared [] int *myB,

Bdata = upc_all_alloc(THREADS*THREADS, NELEMS*sizeof(int));
myB = (shared [] int *)&B[MYTHREAD];

// Bdata contains THREADS*THREADS*NELEMS elements.
// myB is MYTHREAD's row of Bdata.
// Initialize A.
upc_all_gather_all( Bdata, A, NELEMS*sizeof(int),
                     UPC_IN_ALLSYNC | UPC_OUT_ALLSYNC );