ABS VALUE

Converts a global array to contain absolute values of its elements
subroutine ga_abs_value(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

Take the element-wise absolute value of the array.


ABS VALUE PATCH

Converts a patch of a global array to have absolute values of its elements
subroutine ga_abs_value_patch(g_a, lo, hi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerlo(ndim), hi(ndim)g_a patch coordinatesinput

Collective on the processor group inferred from the arguments.

Take the element-wise absolute value of the patch.

See Also:

ABS VALUE

ACC

Accumulates data into a global array
subroutine ga_acc(g_a, ilo, ihi, jlo, jhi, buf, ld, alpha)
TypeNameDescriptionIntent
integerg_ainput
integerilo, ihi, jlo, jhiinput
double precision/complexbuflocal buffer containing datainput
integerldinput
double precision/complexalphascale argument for accumulateinput
subroutine nga_acc(g_a, lo, hi, buf, ld, alpha)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer containing dataoutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput
typealphascale argument for accumulateinput

One-sided (non-collective).

Combines data from local array buffer with data in the global array section. The local array is assumed to be have the same number of dimensions as the global array. global array section (lo[],hi[]) += *alpha * buffer


ACCESS

Accesses data locally allocated for a global array
subroutine ga_access(g_a, ilo, ihi, jlo, jhi, index, ld)
TypeNameDescriptionIntent
integerg_ainput
integerilo, ihi, jlo, jhiinput
integerindexoutput
integerldoutput
subroutine nga_access(g_a, lo, hi, index, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of array dimensionsinput
integerlo(ndim),hi(ndim)patch specificationinput
integerindexreference to local dataoutput
integerld(ndim-1)array of leading dimensionsoutput

Local operation.

Provides access to the specified patch of array. Returns leading dimension ld and and MA-like index for the data. This routine is intended for writing new GA operations. A call to ga_access should normally follow a call to ga_distribution that returns coordinates of the patch associated with a processor. You need to make sure that the coordinates of the patch are valid (test values returned from ga_distribution). Your code should include a MA include file, mafdecls.h.

          dbl_mb(index)  - for double precision data
          int_mb(index)  - for integer data
          dcpl_mb(index) - for double complex data

The addressing convention refers the first element of the patch. However, you can only pass that reference to another subroutine where it could be used like a normal array, see the following example. Example For a given subroutine:

          subroutine foo(A,  nrows, ncols lda)
          double precision A(lda,*)
          integer nrows, ncols
             ....
          end

you can reference A(ilo:ihi,jlo:jhi) in the following way:

          call foo(dbl_mb(index), ihi-ilo+1, jhi-jlo+1, lda)

Note that the size of the integer index must match the platform, 32-bit platforms need to use 4-byte integers and 64-bit platforms need to use 8-byte integers, regardless of whether the other integers in the program are compiled as 4 or 8-byte integers. This can create portability problems when code is being built on different platforms. Users can use the preprocessors symbol GA_ACCESS_INDEX_TYPE to correctly size the integers used as indices across different architectures. The GA_ACCESS_INDEX_TYPE is used instead of an integer declaration and the the global.fh file needs to be included in the subroutine. This will result in code that works for both 32 and 64-bit platforms without having to explicity convert the integer size.


ACCESS BLOCK

Accesses a block in a block-cyclic distributed global array
subroutine nga_access_block(g_a, idx, index, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of array dimensionsinput
integeridxblock indexinput
integerindexreference to local dataoutput
integerld(ndim-1)array of leading dimensionsoutput

Local operation.

This function can be used to gain direct access to the data represented by a single block in a global array with a block-cyclic data distribution. The index idx is the index of the block in the array assuming that blocks are numbered sequentially in a column-major order. A quick way of determining whether a block with index idx is held locally on a processor is to calculate whether mod(idx,nproc) equals the processor ID, where nproc is the total number of processors. Once the index has been returned, local data can be accessed as described in the documentation for nga_access. Each call to nga_access_block should be followed by a call to either nga_release_block or nga_release_update_block. Please check the documentation for the nga_access function for more information on how to use the index returned by this subroutine to access locally held data.

See Also:

ACCESS, RELEASE BLOCK, RELEASE UPDATE BLOCK

ACCESS BLOCK GRID

Accesses data block in a block-cyclic distributed global array
subroutine nga_access_block_grid(g_a, subscript, index, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of array dimensionsinput
integersubscript(ndim)subscript of block in arrayinput
integerindexreference to local dataoutput
integerld(ndim-1)array of leading dimensionsoutput

Local operation.

This function can be used to gain direct access to the data represented by a single block in a global array with a SCALAPACK block-cyclic data distribution that is based on an underlying processor grid. The subscript array contains the subscript of the block in the array of blocks. This subscript is based on the location of the block in a grid, each of whose dimensions is equal to the number of blocks that fit along that dimension. Once the index has been returned, local data can be accessed as described in the documentation for nga_access. Each call to nga_access_block_grid should be followed by a call to either nga_release_block_grid or nga_release_update_block_grid.

See Also:

ACCESS, RELEASE BLOCK GRID, RELEASE UPDATE BLOCK GRID

ACCESS BLOCK SEGMENT

Accesses local data for a specific global array block
subroutine nga_access_block_segment(g_a, proc, index, len)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerprocprocessor IDinput
integerindexreference to local dataoutput
integerlenlength of data on processoroutput

Local operation.

This function can be used to gain access to the all the locally held data on a particular processor that is associated with a block-cyclic distributed array. Once the index has been returned, local data can be accessed as described in the documentation for nga_access. The parameter len is the number of data elements that are held locally. The data inside this segment has a lot of additional structure so this function is not generally useful to developers. It is primarily used inside the GA library to implement other GA routines. Each call to nga_access_block_segment should be followed by a call to either nga_release_block_segment or nga_release_update_block_segment.

See Also:

ACCESS, RELEASE BLOCK SEGMENT, RELEASE UPDATE BLOCK SEGMENT

ACCESS GHOST ELEMENT

Accesses a specific ghost element locally allocated on a GA
subroutine nga_access_ghost_element(g_a, index, subscript, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerindexindex pointing to location of element indexed by subscript()output
integersubscript(ndim)array of integers that index desired elementinput
integerld(ndim-1)array of strides for local data patch. These include ghost cell widths.output

Local operation.

This function can be used to return a pointer to any data element in the locally held portion of the global array and can be used to directly access ghost cell data. The array subscript refers to the local index of the element relative to the origin of the local patch (which is assumed to be indexed by (0,0,...)).

To use the index returned by the nga_access_ghost_element subroutine, see the documentation on nga_access.

See Also:

ACCESS, RELEASE GHOST ELEMENT, RELEASE UPDATE GHOST ELEMENT

ACCESS GHOSTS

Accesses the ghost cells allocated locally on a GA
subroutine nga_access_ghosts(g_a, dims, index, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerdims(ndim)array of dimensions of local patch, including ghost cellsoutput
integerindexreturns an index corresponding to the origin the global array patch held locally on the processoroutput
integerld(ndim)physical dimenstions of the local array patch, including ghost cellsoutput

Local operation.

Provides access to the local patch of the global array. Returns leading dimension ld and and pointer for the data. This routine will provide access to the ghost cell data residing on each processor. Calls to nga_access_ghosts should normally follow a call to nga_distribution that returns coordinates of the visible data patch associated with a processor. You need to make sure that the coordinates of the patch are valid (test values returned from nga_distribution). You can only access local data. To see how to use the index returned by this subroutine, check the documentation on nga_acces.

See Also:

ACCESS, RELEASE GHOSTS, RELEASE UPDATE GHOSTS

ADD

Adds corresponding values in two global arrays
subroutine ga_add(alpha, g_a, beta, g_b, g_c)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerg_barray handleinput
integerg_carray handleinput
double precision/complex/integeralpha,betainput

Collective on the processor group inferred from the arguments.

The arrays (which must be the same shape and identically aligned) are added together element-wise.

        c = alpha * a  +  beta * b;

The result (c) may replace one of the input arrays (a/b).


ADD CONSTANT

Adds a constant to all elements in a global array
subroutine ga_add_constant(g_a,  alpha)
TypeNameDescriptionIntent
integerg_aarray handleinput
double/complex/integer/floatalphaadded valueinput

Collective on the processor group inferred from the arguments.

Add the constant pointed by alpha to each element of the array.


ADD CONSTANT PATCH

Adds a constant to all elements in a global array patch
subroutine ga_add_constant_patch(g_a, lo, hi, alpha)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of dimensionsinput
integerlo(ndim), hi(ndim)patch coordinatesinput
double/complex/integer/floatalphaadded valueinput

Collective on the processor group inferred from the arguments.

Add the constant pointed by alpha to each element of the patch.

See Also:

ADD CONSTANT

ADD DIAGONAL

Adds to the diagonal elements of a global array
subroutine ga_add_diagonal(g_a, g_v)
TypeNameDescriptionIntent
integerg_a,g_varray handlesinput

Collective on the processor group inferred from the arguments.

Adds the elements of the vector g_v to the diagonal of this matrix g_a.


ADD PATCH

Adds patches of global arrays
subroutine ga_add_patch(alpha, g_a, ailo, aihi, ajlo, ajhi,
                        beta,  g_b, bilo, bihi, bjlo, bjhi,
                               g_c, cilo, cihi, cjlo, cjhi)
TypeNameDescriptionIntent
integerg_a, g_b, g_cinput
double precision/complex/integeralpha, betascale factors patchesinput
integerailo, aihi, ajlo, ajhig_a patch coordinatesinput
integerbilo, bihi, bjlo, bjhig_b patch coordinatesinput
integercilo, cihi, cjlo, cjhig_c patch coordinatesinput
subroutine nga_add_patch(alpha, g_a, alo, ahi, beta, g_b, blo, bhi
                         g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a, g_b, g_cinput
double precision/complex/integeralpha,betascale factors for patchesinput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput
integerblo(ndim), bhi(ndim)g_b patch coordinatesinput
integerclo(ndim), chi(ndim)g_c patch coordinatesinput

Collective on the processor group inferred from the arguments.

Patches of arrays (which must have the same number of elements) are added together element-wise.

         c[ ][ ] = alpha * a[ ][ ] + beta * b[ ][ ]

See Also:

ADD

ALLOC GATSCAT BUF

Allocates an internal buffer for gather/scatter operations
void nga_alloc_gatscat_buf(nelems)
TypeNameDescriptionIntent
integernelemsmaximum number of elements to scatter/gatherinput

Local operation.

This function can be used to enhance the performance when the gather/scatter operations are being called multiple times in succession. If the maximum number of elements being called in any gather/scatter operation is known prior to executing a code segment, then some internal buffers used in the gather/scatter operations can be allocated beforehand instead of at every individual call. This can result in substantial performance boosts in some cases. When the buffers are no longer needed they can be removed using the corresponding free call.

See Also:

FREE GATSCAT BUF

ALLOCATE

Allocates the array specified by a GA handle
logical function ga_allocate(g_a)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
logical.TRUE. if allocation of g_a was successfuloutput

Collective on the processor group inferred from the arguments.

This function allocates the memory for the global array handle originally obtained using the GA_Create_handle function. At a minimum, the GA_Set_data function must be called before the memory is allocated. Other GA_Set_xxx functions can also be called before invoking this function. Returns True if allocation of g_a was successful.


BRDCST

Broadcasts elements among all processes
subroutine ga_brdcst(type, buf, lenbuf, root)
TypeNameDescriptionIntent
integertypeinput
bytebuf(lenbuf)buffer contain broadcasted/received datainput/output
integerlenbufinput
integerrootinput

Collective on the world processor group.

Broadcast from process root to all other processes a message of length lenbuf. This is operation is provided only for convenience purposes: it is available regardless of the message-passing library that GA is running.


CHECK HANDLE

Checks whether a GA handle is valid
subroutine ga_check_handle(g_a, string)
TypeNameDescriptionIntent
integerg_ainput
character(*)*stringmessage stringinput

Local operation.

Check that the global array handle g_a is valid ... if not, call ga_error with the string provided and some more info.


CLUSTER NNODES

Returns total number of cluster (shared memory) nodes
integer function ga_cluster_nnodes()

Local operation.

This functions returns the total number of nodes that the program is running on. On SMP architectures, this will be less than or equal to the total number of processors.


CLUSTER NODEID

Returns cluster node Rank of the invoking process
integer function ga_cluster_nodeid()

Local operation.

This function returns the node ID of the process. On SMP architectures with more than one processor per node, several processes may return the same node id.


CLUSTER NPROCS

Returns number of processes in a given cluster node
integer function ga_cluster_nprocs(inode)
TypeNameDescriptionIntent
integerinodenode idinput

Local operation.

This function returns the number of processors available on node inode.


CLUSTER PROC NODEID

Returns cluster node rank of a specified process
integer function ga_cluster_proc_nodeid(proc)
TypeNameDescriptionIntent
integerprocprocess idinput

Local operation.

This function returns the node ID of the specified process proc. On SMP architectures with more than one processor per node, several processes may return the same node id.


CLUSTER PROCID

Returns rank of a process from a cluster node rank and intra-node rank
integer function ga_cluster_procid(inode,iproc)
TypeNameDescriptionIntent
integerinodenode idinput
integeriprocprocessor idinput

Local operation.

This function returns the processor id associated with node inode and the local processor ID iproc. If node inode has N processors, then the value of iproc lies between 0 and N-1.


COMPARE DISTR

Compares distributions of two global arrays
logical function ga_compare_distr(g_a, g_b)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
logical.TRUE. if distributions are identicaloutput

Collective on the processor group inferred from the arguments.

Compares distributions of two global arrays. Returns 0 if distributions are identical and 1 when they are not.


COPY

Copies a global array to another global array
subroutine ga_copy(g_a, g_b)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerg_barray handleinput

Collective on the processor group inferred from the arguments.

Copies elements in array represented by g_a into the array represented by g_b. The arrays must be the same type, shape, and identically aligned. For patch operations, the patches of arrays may be of different shapes but must have the same number of elements. Patches must be nonoverlapping (if g_a=g_b). Transposes are allowed for patch operations.


COPY PATCH

Copies a patch of a global array to another global array patch
subroutine ga_copy_patch(trans, g_a, ailo, aihi, ajlo, ajhi,
                         g_b, bilo, bihi, bjlo, bjhi)
TypeNameDescriptionIntent
charactertranstranspose operatorinput
integerg_a, g_binput
integerailo, aihi, ajlo, ajhig_a patch coordinatesinput
integerbilo, bihi, bjlo, bjhig_b patch coordinatesinput
subroutine nga_copy_patch(trans, g_a, alo, ahi, g_b, blo, bhi)
TypeNameDescriptionIntent
charactertranstranspose operatorinput
integerg_a, g_binput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput
integerblo(ndim), bhi(ndim)g_b patch coordinatesinput

Collective on the processor group inferred from the arguments.

Copies elements in a patch of one array into another one. The patches of arrays may be of different shapes but must have the same number of elements. Patches must be non-overlapping (if g_a=g_b).

    trans = `N' or `n' means that the transpose operator should
             not be applied.
    trans = `T' or `t' means that transpose operator should be applied.

See Also:

COPY

CREATE

Creates a GA
logical function ga_create(type, dim1, dim2, array_name, chunk1, chunk2, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerdim1,dim2array (dim1,dim2) as in FORTRANinput
integerchunk1,chunk2minimum size that dimensions should be chunked up intoinput
integerg_ahandle for future referencesoutput
logical function nga_create(type, ndim, dims, array_name, chunk, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerchunk(ndim)array of chunks, each element specifies minimum size that given dimensions should be chunked up intoinput
integerg_ainteger handle for future referencesoutput
logical.TRUE. if array creation was successfuloutput

Collective on the default processor group.

Creates an ndim-dimensional array using the regular distribution model and returns an integer handle representing the array. The array can be distributed evenly or not. The control over the distribution is accomplished by specifying chunk (block) size for all or some of array dimensions. For example, for a 2-dimensional array, setting chunk[0]=dim[0] gives distribution by vertical strips (chunk[0]*dims[0]); setting chunk[1]=dim[1] gives distribution by horizontal strips (chunk[1]*dims[1]). Actual chunks will be modified so that they are at least the size of the minimum and each process has either zero or one chunk. Specifying chunk[i] as less than 1 will cause that dimension to be distributed evenly. As a convenience, when chunk is specified as NULL, the entire array is distributed evenly. Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE CONFIG, CREATE GHOSTS IRREG, CREATE GHOSTS, CREATE GHOSTS CONFIG, CREATE GHOSTS IRREG CONFIG, CREATE HANDLE, CREATE IRREG, CREATE IRREG CONFIG

CREATE CONFIG

Creates a GA for a specific processor group
logical function nga_create_config(type, ndim, dims, array_name, chunk,
                                   p_handle, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerchunk(ndim)array of chunks, each element specifies minimum size that given dimensions should be chunked up intoinput
integerp_handleprocessor group handleinput
integerg_ainteger handle for future referencesoutput
logical.TRUE. if array creation successfuloutput

Collective on the default processor group.

Creates an ndim-dimensional array using the regular distribution model but with an explicitly specified processor group handle and returns an integer handle representing the array.

This call is essentially the same as the nga_create call, except for the processor group handle p_handle. It can also be used to create mirrored arrays.

Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET PGROUP

CREATE GHOST IRREG

Creates an irregular-distributed GA with ghost cells
logical function nga_create_ghosts_irreg(type, ndim, dims, width, array_name, map, nblock, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerwidth(ndim)array of ghost cell widthsinput
integernblock(ndim)no. of blocks each dimension is divided intoinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integerg_ainteger handle for future referencesoutput

Collective on the default processor group.

Creates an array with ghost cells by following the user-specified distribution and returns an integer handle representing the array. The distribution is specified as a Cartesian product of distributions for each dimension. Figure "crghostir" below demonstrates distribution of a 2-dimensional array 8x10 on 6 (or more) processors.

nblock(2)={3,2}, the size of map array is s=5 and the array map contains the following elements map={1,3,7, 1, 6}. The distribution is nonuniform because, P1 and P4 get 20 elements each and processors P0, P2, P3, and P5 only 10 elements each.

The array width is used to control the width of the ghost cell boundary around the visible data on each processor. The local data of the Global Array residing on each processor will have a layer width[n] ghosts cells wide on either side of the visible data along the dimension n. Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET GHOSTS, SET IRREG DISTR

CREATE GHOSTS

Creates a GA with ghost cells
logical function nga_create_ghosts(type, ndim, dims, width, array_name,
                                   chunk, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerwidth(ndim)array of ghost cell widthsinput
integerchunk(ndim)array of chunks, each element specifies minimum size that given dimensions should be chunked up intoinput
integerg_ainteger handle for future referencesoutput
logical.TRUE. if array creation succesfuloutput

Collective on the default processor group.

Creates an ndim-dimensional array with a layer of ghost cells around the visible data on each processor using the regular distribution model and returns an integer handle representing the array. The array can be distributed evenly or not evenly. The control over the distribution is accomplished by specifying chunk (block) size for all or some of the array dimensions. For example, for a 2-dimensional array, setting chunk(1)=dim(1) gives distribution by vertical strips (chunk(1)*dims(1)); setting chunk(2)=dim(2) gives distribution by horizontal strips (chunk(2)*dims(2)). Actual chunks will be modified so that they are at least the size of the minimum and each process has either zero or one chunk. Specifying chunk(i) as < 1 will cause that dimension (i-th) to be distributed evenly. The width of the ghost cell layer in each dimension is specified using the array width(). The local data of the global array residing on each processor will have a layer width[n] ghosts cells wide on either side of the visible data along the dimension n. Return value: a non-zero array handle means the call was successful.

See Also:

CREATE, SET GHOSTS

CREATE GHOSTS CONFIG

Creates a GA with ghost cells and specific processor group
logical function nga_create_ghosts_config(type, ndim, dims, width, array_name,
                                          chunk, p_handle, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerwidth(ndim)array of ghost cell widthsinput
integerchunk(ndim)array of chunks, each element specifies minimum size that given dimensions should be chunked up intoinput
integerp_handleprocessor group handleinput
integerg_ainteger handle for future referencesoutput
logical.TRUE. if array creation successfuloutput

Collective on the default processor group.

Creates an ndim-dimensional array with a layer of ghost cells around the visible data on each processor using the regular distribution model and an explicitly specified processor list and returns an integer handle representing the array. This call is essentially the same as the NGA_Create_ghosts call, except for the processor list handle p_handle. It can be used to create mirrored arrays. Return value: a non-zero array handle means the call was successful.

See Also:

CREATE, SET GHOSTS, SET PGROUP

CREATE GHOSTS IRREG

Creates an irregular-distributed GA with ghost cells
logical function nga_create_ghosts_irreg(type, ndim, dims, width, array_name, map, nblock, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerwidth(ndim)array of ghost cell widthsinput
integernblock(ndim)no. of blocks each dimension is divided intoinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integerg_ainteger handle for future referencesoutput

Collective on the default processor group.

Creates an array with ghost cells by following the user-specified distribution and returns an integer handle representing the array. The distribution is specified as a Cartesian product of distributions for each dimension. Figure "crghostir" below demonstrates distribution of a 2-dimensional array 8x10 on 6 (or more) processors.

nblock(2)={3,2}, the size of map array is s=5 and the array map contains the following elements map={1,3,7, 1, 6}. The distribution is nonuniform because, P1 and P4 get 20 elements each and processors P0, P2, P3, and P5 only 10 elements each.

The array width is used to control the width of the ghost cell boundary around the visible data on each processor. The local data of the Global Array residing on each processor will have a layer width[n] ghosts cells wide on either side of the visible data along the dimension n. Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET GHOSTS, SET IRREG DISTR

CREATE GHOSTS IRREG CONFIG

Creates an irregular-distributed GA with ghost cells and a specific processor group
logical function nga_create_ghosts_irreg_config(type, ndim,
                                                dims, width, array_name,
                                                map, nblock,
                                                p_handle, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integerwidth(ndim)array of ghost cell widthsinput
integernblock(ndim)no. of blocks each dimension is divided intoinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integerp_handleprocessor group handleinput
integerg_ainteger handle for future referencesoutput

Collective on the default processor group.

Creates an array with ghost cells by following the user-specified distribution and returns an integer handle representing the array. The user can specify that the array is created on a particular processor group.

This call is similar to the nga_create_ghosts_irreg call.

Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET GHOSTS, SET IRREG DISTR, SET PGROUP

CREATE HANDLE

Creates an inactive handle to a global array
integer function ga_create_handle()

Collective on the default processor group.

This function returns a Global Array handle that can then be used to create a new Global Array. This is part of a new API for creating Global Arrays that is designed to replace the old interface built around the NGA_Create_xxx calls. The sequence of operations is to begin with a call to GA_Greate_handle to get a new array handle. The attributes of the array, such as dimension, size, type, etc., can then be set using successive calls to the GA_Set_xxx subroutines. When all array attributes have been set, the GA_Allocate subroutine is called and the Global Array is actually created and memory for it is allocated.

See Also:

ALLOCATE, SET ARRAY NAME, SET BLOCK CYCLIC, SET BLOCK CYCLIC PROC GRID, SET CHUNK, SET DATA, SET GHOSTS, SET IRREG DISTR, SET PGROUP, SET RESTRICTED, SET RESTRICTED RANGE

CREATE IRREG

Creates an irregular-distributed GA
logical function ga_create_irreg(type, dim1, dim2, array_name, map1,
                                 nblock1, map2, nblock2, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerdim1,dim2array (dim1,dim2) as in FORTRANinput
integernblock1no. of blocks first dimension is divided intoinput
integernblock2no. of blocks second dimension is divided intoinput
integermap1(*)ilo for each blockinput
integermap2(*)jlo for each blockinput
integerg_ainteger handle for future referencesoutput
logical.TRUE. if array creation successfuloutput
logical function nga_create_irreg(type, ndim, dims, array_name, map,
                                  nblock, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integernblock(ndim)no. of blocks each dimension is divided intoinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integerg_ainteger handle for future referencesoutput

Collective on the default processor group.

Creates an array by following the user-specified distribution and returns an integer handle representing the array. The distribution is specified as a Cartesian product of distributions for each dimension. The array indices start at 0. For example, Figure "crirreg" below demonstrates the distribution of a 2-dimensional 8x10 array on 6 (or more) processors.

nblock(2)={3,2}, the size of the map array is s=5 and the array map contains the following elements map={1,3,7,1,6}. The distribution is nonuniform because P1 and P4 get 20 elements each and processors P0, P2, P3, and P5 only 10 elements each.

Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET IRREG DISTR

CREATE IRREG CONFIG

Creates an irregular-distributed GA with a specific processor group
logical function nga_create_irreg_config(type, ndim, dims, array_name,
                                         map, nblock, p_handle, g_a)
TypeNameDescriptionIntent
character*(*)array_namea unique character stringinput
integertypedata type (MT_DBL,MT_INT,MT_DCPL,etc.)input
integerndimnumber of array dimensionsinput
integerdims(ndim)array of dimensionsinput
integernblock(ndim)no. of blocks each dimension is divided intoinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integerp_handleprocessor group handleinput
integerg_ainteger handle for future referencesoutput

Collective on the default processor group.

Creates an array by following the user-specified distribution and an explicitly specified processor group handle and returns an integer handle representing the array.

This call is essentially the same as the nga_create_irreg call, except for the processor group handle p_handle. It can also be used to create arrays on mirrored arrays.

Return value: a non-zero array handle means the call was succesful.

See Also:

CREATE, SET IRREG DISTR, SET PGROUP

CREATE MUTEXES

Creates mutexes
logical function ga_create_mutexes(number)
TypeNameDescriptionIntent
integernumberinput

Collective on the world processor group.

Creates a set containing the number of mutexes. Returns 0 if the operation succeeded or 1 if it has failed. Mutex is a simple synchronization object used to protect Critical Sections. Only one set of mutexes can exist at a time. An array of mutexes can be created and destroyed as many times as needed. Mutexes are numbered: 0, ..., number-1. Returns: True on success, False on failure

See Also:

DESTROY MUTEXES

DESTROY

Destroys a global array
logical function ga_destroy(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

Deallocates the array and frees any associated resources.


DESTROY MUTEXES

Destroys mutexes
logical function ga_destroy_mutexes()

Collective on the world processor group.

Destroys the set of mutexes created with ga_create_mutexes. Returns 0 if the operation succeeded or 1 when failed.

See Also:

CREATE MUTEXES

DIAG

Diagonalizes a global array
subroutine ga_diag(g_a, g_s, g_v, eval)
TypeNameDescriptionIntent
integerg_aMatrix to diagonalizeinput
integerg_sMetricinput
integerg_vGlobal matrix to return evecsoutput
double precisioneval(*)Local array to return evalsoutput

Collective on the processor group inferred from the arguments.

Solve the generalized eigenvalue problem returning all eigenvectors and values in ascending order. The input matrices are not overwritten or destroyed. All eigen-values as a vector in ascending order.


DIAG REUSE

Diagonalizes a global array for repeated diagonalizations
subroutine ga_diag_reuse(control, g_a, g_s, g_v, eval)
TypeNameDescriptionIntent
integercontrolControl flaginput
integerg_aMatrix to diagonalizeinput
integerg_sMetricinput
integerg_vGlobal matrix to return evecsoutput
double precisioneval(*)Local array to return evalsoutput

Collective on the processor group inferred from the arguments.

Solve the generalized eigenvalue problem returning all eigenvectors and values in ascending order. Recommended for REPEATED calls if g_s is unchanged. Values of the control flag:

          value       action/purpose
            0          indicates first call to the eigensolver
           >0          consecutive calls (reuses factored g_s)
           <0          only erases factorized g_s; g_v and eval unchanged
                       (should be called after previous use if another
                        eigenproblem, i.e., different g_a and g_s, is to
                        be solved)

The input matrices are not destroyed. Returns: All eigen-values as a vector in ascending order.


DIAG STD

Diagonalizes a global array using a standard algorithm
subroutine ga_diag_std(g_a, g_v, eval)
TypeNameDescriptionIntent
integerg_aMatrix to diagonalizeinput
integerg_vGlobal matrix to return evecsoutput
double precisioneval(*)Local array to return evalsoutput

Collective on the processor group inferred from the arguments.

Solve the standard (non-generalized) eigenvalue problem returning all eigenvectors and values in the ascending order. The input matrix is neither overwritten nor destroyed. Returns: all eigenvectors via the g_v global array, and eigenvalues as an array in ascending order


DISTRIBUTION

Inquires for the data range on a specified processor
subroutine ga_distribution(g_a, iproc, ilo, ihi, jlo, jhi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integeriprocprocess numberinput
integerilo,ihii-range held by process iprocoutput
integerjlo,jhij-range held by process iprocoutput
subroutine nga_distribution(g_a, iproc, lo, hi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integeriprocprocess numberinput
integerndimnumber of dimensionsinput
integerlo(ndim),hi(ndim)range held by process iprocoutput

Local operation.

This function returns the bounding indices of the block owned by the process iproc. These indices are inclusive. If no array elements are owned by process iproc, the range is returned as lo()=0 and hi()= -1 for all dimensions.


DOT

Dot product of two global arrays
double precision function ga_ddot(g_a, g_b)
double complex function ga_zdot(g_a, g_b)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerg_barray handleinput

Collective on the processor group inferred from the arguments.

Computes the element-wise dot product of the two arrays which must be of the same types and same number of elements. Return value = SUM_ij a(i,j)*b(i,j)


DOT PATCH

Dot product of patches of global arrays
double precision function ga_ddot_patch (g_a, ta, ailo, aihi, ajlo, ajhi,
                                         g_b, tb, bilo, bihi, bjlo, bjhi)
double complex function ga_zdot_patch (g_a, ta, ailo, aihi, ajlo, ajhi,
                                       g_b, tb, bilo, bihi, bjlo, bjhi)
TypeNameDescriptionIntent
integerg_a, g_binput
integerailo, aihi, ajlo, ajhig_a patch coordinatesinput
integerbilo, bihi, bjlo, bjhig_b patch coordinatesinput
character*1ta, tbtranspose flagsinput
double precision function nga_ddot_patch (g_a, ta, alo, ahi,
                                          g_b, tb, bio, bhi)
double complex function nga_zdot_patch (g_a, ta, alo, ahi,
                                        g_b, tb, blo, bhi)
TypeNameDescriptionIntent
integerg_a, g_binput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput
integerblo(ndim), bhi(ndim)g_b patch coordinatesinput
character*1ta, tbtranspose flagsinput

Collective on the processor group inferred from the arguments.

Computes the element-wise dot product of the two (possibly transposed) patches which must be of the same type and have the same number of elements.

See Also:

DOT

DUPLICATE

Creates a new array with the same properties as the given array
logical function ga_duplicate(g_a, g_b, array_name)
TypeNameDescriptionIntent
character*(*)array_namea character stringinput
integerg_aInteger handle for reference arrayinput
integerg_bInteger handle for new arrayoutput
logical.TRUE. if array creation successfuloutput

Collective on the processor group inferred from the arguments.

Creates a new array by applying all the properties of another existing array. It returns an array handle. Return value: a non-zero array handle means the call was succesful.


ELEM DIVIDE

Element-wise division of global arrays
subroutine ga_elem_divide(g_a, g_b, g_c)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput

Collective on the processor group inferred from the arguments.

Computes the element-wise quotient of the two arrays which must be of the same types and same number of elements. For two-dimensional arrays,

        c(i,j) = a(i,j)/b(i,j)

The result (c) may replace one of the input arrays (a/b). If one of the elements of array g_b is zero, the quotient for the element of g_c will be set to GA_NEGATIVE_INFINITY.


ELEM DIVIDE PATCH

Element-wise division of global array patches
subroutine ga_elem_divide_patch(g_a, alo, ahi,
                                g_b, blo, bhi,
                                g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch dimensionsinput
integerblo(ndim), bhi(ndim)g_b patch dimensionsinput
integerclo(ndim), chi(ndim)g_c patch dimensionsinput

Collective on the processor group inferred from the arguments.

Computes the element-wise quotient of the two patches which must be of the same types and same number of elements. For two-dimensional arrays,

        c(i,j)  = a(i,j)/b(i,j)

The result (c) may replace one of the input arrays (a/b).

See Also:

ELEM DIVIDE

ELEM MAXIMUM

Element-wise maximum of global arrays
subroutine ga_elem_maximum(g_a, g_b, g_c)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput

Collective on the processor group inferred from the arguments.

Computes the element-wise maximum of the two arrays which must be of the same types and same number of elements. For two dimensional arrays,

    c(i,j)  = max{a(i,j), b(i,j)}

The result (c) may replace one of the input arrays (a/b).


ELEM MAXIMUM PATCH

Element-wise maximum of global array patches
subroutine ga_elem_maximum_patch(g_a, alo, ahi,
                                 g_b, blo, bhi,
                                 g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch dimensionsinput
integerblo(ndim), bhi(ndim)g_b patch dimensionsinput
integerclo(ndim), chi(ndim)g_c patch dimensionsinput

Collective on the processor group inferred from the arguments.

Computes the element-wise maximum of the two patches which must be of the same types and same number of elements. For two-dimensional noncomplex arrays,

        c(i,j)  = max{a(i,j), b(i,j)}

If the data type is complex, then

        c(i,j).real = max{ |a(i,j)|, |b(i,j)| } while c(i,j).image = 0.

The result (c) may replace one of the input arrays (a/b).


ELEM MINIMUM

Element-wise minimum of global arrays
subroutine ga_elem_minimum(g_a, g_b, g_c)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput

Collective on the processor group inferred from the arguments.

Computes the element-wise minimum of the two arrays which must be of the same types and same number of elements. For two dimensional arrays,

        c(i,j)  = min{a(i,j), b(i,j)}

The result (c) may replace one of the input arrays (a/b).


ELEM MINIMUM PATCH

Element-wise minimum of global array patches
subroutine ga_elem_minimum_patch(g_a, alo, ahi,
                                 g_b, blo, bhi,
                                 g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a,g_barray handlesinput
integerg_carray handleoutput
integerndimnumber of dimensionsinput
integeralo(ndim),ahi(ndim)g_a patch dimensionsinput
integerblo(ndim),bhi(ndim)g_b patch dimensionsinput
integerclo(ndim),chi(ndim)g_c patch dimensionsinput

Collective on the processor group inferred from the arguments.

Computes the element-wise minimum of the two patches which must be of the same types and same number of elements. For two-dimensional of noncomplex arrays,

        c(i,j)  = min{a(i,j), b(i,j)}

If the data type is complex, then

        c(i,j).real = min{ |a(i,j)|, |b(i,j)| } while c(i,j).image = 0.

The result (c) may replace one of the input arrays (a/b).

See Also:

ELEM MINIMUM

ELEM MULTIPLY

Element-wise multiplication of global arrays
subroutine ga_elem_multiply(g_a, g_b, g_c)
TypeNameDescriptionIntent
integerg_a, g_binput array handlesinput
integerg_coutput array handleoutput

Collective on the processor group inferred from the arguments.

Computes the element-wise product of the two arrays which must be of the same types and same number of elements. For two-dimensional arrays,

        c(i, j)  = a(i,j)*b(i,j)

The result (c) may replace one of the input arrays (a/b).


ELEM MULTIPLY PATCH

Element-wise multiplication of global array patches
subroutine ga_elem_multiply_patch(g_a, alo, ahi,
                                  g_b, blo, bhi,
                                  g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a, g_barray handlesinput
integerg_carray handleoutput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch dimensionsinput
integerblo(ndim), bhi(ndim)g_b patch dimensionsinput
integerclo(ndim), chi(ndim)g_c patch dimensionsinput

Collective on the processor group inferred from the arguments.

Computes the element-wise product of the two patches which must be of the same types and same number of elements. For two-dimensional arrays,

        c(i,j)  = a(i,j)*b(i,j)

The result (c) may replace one of the input arrays (a/b).

See Also:

ELEM MULTIPLY

ERROR

Aborts with an error
subroutine ga_error(message, code)
TypeNameDescriptionIntent
character*1message(*)input
integercodeinput

Local operation.

To be called in case of an error. Print an error message and an integer value that represents an error code as well as releasing some system resources. This is the required way of aborting the program execution.


FENCE

Fences all GA data movement operations initiated by the calling process
subroutine ga_fence()

One-sided (non-collective).

Blocks the calling process until all the data transfers corresponding to GA operations called after ga_init_fence complete. For example, since ga_put might return before the data reaches the final destination, ga_init_fence and ga_fence allow the process to wait until the data tranfer is fully completed:

        ga_init_fence();
        ga_put(g_a, ...);
        ga_fence();

ga_fence must be called after ga_init_fence. A barrier, ga_sync, assures the completion of all data transfers and implicitly cancels all outstanding ga_init_fence calls. ga_init_fence and ga_fence must be used in pairs, multiple calls to ga_fence require the same number of corresponding ga_init_fence calls. ga_init_fence/ga_fence pairs can be nested. ga_fence works for multiple GA operations. For example:

        ga_init_fence();
        ga_put(g_a, ...);
        ga_scatter(g_a, ...);
        ga_put(g_b, ...);
        ga_fence();

The calling process will be blocked until data movements initiated by two calls to ga_put and one ga_scatter complete.


FILL

Fills a global array with a specific value
subroutine ga_fill(g_a, s)
TypeNameDescriptionIntent
integerg_aarray handleinput
double precision/complex/integersfill valueinput

Collective on the processor group inferred from the arguments.

Assign a single value to all elements in the array.


FILL PATCH

Fills a patch of a global array with a specified value
subroutine ga_fill_patch(g_a, ailo, aihi, ajlo, ajhi, s)
TypeNameDescriptionIntent
integerg_ainput
double precision/complex/integersfill valueinput
integerailo, aihi, ajlo, ajhig_a patch coordinatesinput
subroutine nga_fill_patch (g_a, alo, ahi, s)
TypeNameDescriptionIntent
integerg_ainput
double precision/complex/integersfill valueinput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput

Collective on the processor group inferred from the arguments.

Fill the patch of g_a with value of `val'

See Also:

FILL

FREE GATSCAT BUF

Frees an internal buffer for gather/scatter operations
void nga_free_gatscat_buf()

Local operation.

This function is used to free up internal buffers that were set with the corresponding allocation call. The buffers can be used to improve performance if multiple calls are being made to the gather/scatter operations.

See Also:

ALLOC GATSCAT BUF

GATHER

Gathers elements from a global array
subroutine ga_gather(g_a, v, i, j, n)
TypeNameDescriptionIntent
integerg_ainput
double precisionv(n)output
integeri(n), j(n), ninput
subroutine nga_gather(g_a, v, subsArray, n)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integernnumber of elementsinput
typev(n)array containing valuesoutput
integerndimnumber of array dimensionsinput
integersubsArray(ndim,n)array of subscripts for each elementinput

One-sided (non-collective).

Gathers array elements from a global array into a local array. The contents of the input arrays (v, subsArray) are preserved.

for (k=0; k<= n; k++)
   {v[k] = a[subsArray[k][0]][subsArray[k][1]][subsArray[k][2]]...;}

See Also:

GET

GEMM

Performs matrix multiplication of global arrays
subroutine GA_Dgemm(ta, tb, m, n, k, alpha, g_a, g_b, beta, g_c)
subroutine GA_Sgemm(ta, tb, m, n, k, alpha, g_a, g_b, beta, g_c)
subroutine GA_Zgemm(ta, tb, m, n, k, alpha, g_a, g_b, beta, g_c)
TypeNameDescriptionIntent
integerg_a, g_bhandles to input arraysinput
integerg_chandle to output arrayoutput
character(1)ta, tbtranspose operatorsinput
integermnumber of rows of op(A) and of matrix Cinput
integernnumber of columns of op(B) and of matrix Cinput
integerknumber of columns of op(A) and rows of matrix op(B)input
double precision/double complex/realalpha, betascale factorsinput

Collective on the processor group inferred from the arguments.

Performs one of the matrix-matrix operations:

      C := alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

      op( X ) = X   or   op( X ) = X',

alpha and beta are scalars, and A, B, and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix. On entry, transa specifies the form of op( A ) to be used in the matrix multiplication as follows:

           ta = `N' or `n', op( A ) = A.
           ta = `T' or `t', op( A ) = A'.


GET

Gets data from a global array
subroutine ga_get(g_a, ilo, ihi, jlo, jhi, buf, ld)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerilo, ihi, jlo, jhiinput
double precision/complex/integerbuflocal buffer where data goes tooutput
integerldleading dimensioninput
subroutine nga_get(g_a, lo, hi, buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer array where the data goes tooutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput

One-sided (non-collective).

Copies data from global array section to the local array buffer. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsistencies or errors in the input arguments are fatal. Example: For the ga_get operation transfering data from the [10:14, 0:4] section of 2-dimensional 15x10 global array into a local buffer 5x10 array we have:

lo={10,0,} hi={14,4}, ld={10}

Figure "get" below shows the GET operation. Return: The local array buffer.


GET BLOCK INFO

Returns information on block-cyclic distribution for a GA
subroutine ga_get_block_info(g_a, num_blocks, block_dims)
TypeNameDescriptionIntent
integerg_aarray handleinput
integernum_blocks(ndim)number of blocks along each axisoutput
integerblock_dims(ndim)dimensions of blockoutput

Local operation.

This subroutine returns information about the block-cyclic distribution associated with global array g_a. The number of blocks along each of the array axes are returned in the array num_blocks and the dimensions of the individual blocks, specified in the GA_Set_block_cyclic or GA_Set_block_cyclic_proc_grid subroutines, are returned in block_dims. This is a local function.

See Also:

SET BLOCK CYCLIC, SET BLOCK CYCLIC PROC GRID

GET DEBUG

Returns value of GA debug flag
logical function ga_get_debug()

Local operation.

This function returns the value of an internal flag in the GA library whose value can be set using the GA_Set_debug subroutine.


GET DIAG

Copies diagonal elements of a global array into another global array
subroutine ga_get_diag(g_a, g_v)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerg_varray handleinput

Collective on the processor group inferred from the arguments.

Inserts the diagonal elements of this matrix g_a into the vector g_v.


GOP

Global commutative vector operations of elements among all processes
subroutine ga_igop(type, x, n, op)
subroutine ga_sgop(type, x, n, op)
subroutine ga_dgop(type, x, n, op)
subroutine ga_cgop(type, x, n, op)
subroutine ga_zgop(type, x, n, op)
TypeNameDescriptionIntent
integertypethis argument is deprecatedinput
integerx(n)local array of initial/final valuesinput/output
realx(n)local array of initial/final valuesinput/output
double precisionx(n)local array of initial/final valuesinput/output
single complexx(n)local array of initial/final valuesinput/output
double complexx(n)local array of initial/final valuesinput/output
character*(*)opglobal operationinput

Collective on the world processor group.

Global OPeration. X(1:N) is a vector present on each process. GOP `sums' elements of X accross all nodes using the commutative operator OP. The result is broadcast to all nodes. Supported operations include `+', `*', `max', `min', `absmax', `absmin'. The use of lowerecase for operators is necessary. This operation is provided only for convenience purposes: it is available regardless of the message-passing library that GA is running with.


HAS GHOSTS

Checks whether a GA has ghost cells
logical function ga_has_ghosts(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput
logical.TRUE. if array has ghost cellsoutput

Collective on the processor group inferred from the arguments.

This function returns 1 if the global array has some dimensions for which the ghost cell width is greater than zero, it returns 0 otherwise.


INIT FENCE

Initializes tracing of completion of data movement operations
subroutine ga_init_fence()

Local operation.

Initializes tracing of the completion status of data movement operations.


INITIALIZE

Initializes GA
subroutine nga_initialize()
subroutine ga_initialize()

Collective on the processor group inferred from the arguments.

Allocate and initialize internal data structures in Global Arrays.

See Also:

INITIALIZE LTD

INITIALIZE LTD

Initializes GA with memory limit
subroutine ga_initialize_ltd(limit)
TypeNameDescriptionIntent
integerlimitamount of memory in bytes per processinput

Collective on the processor group inferred from the arguments.

Allocate and initialize internal data structures and set the limit for memory used in Global Arrays. The limit is per process: it is the amount of memory that the given processor can contribute to collective allocation of Global Arrays. It does not include temporary storage that GA might be allocating (and releasing) during execution of a particular operation. *limit < 0 means "allow unlimited memory usage" in which case this operation is equivalent to GA_initialize.

See Also:

INITIALIZE, SET MEMORY LIMIT

INQUIRE

Inquires the data type and shape of a global array
subroutine ga_inquire(g_a, type, dim1, dim2)
TypeNameDescriptionIntent
integerg_ainput
integertypeoutput
integerdim1output
integerdim2output
subroutine nga_inquire(g_a, type, ndim, dims)
TypeNameDescriptionIntent
integerg_aarray handleinput
integertypedata type idoutput
integerndimnumber of dimensionsoutput
integerdims(ndim)array of dimensionsoutput

Local operation.

Returns data type and dimensions of the array.


INQUIRE MEMORY

Inquires the memory used by global arrays on the calling processor
integer function ga_inquire_memory()

Returns the amount of memory (in bytes) used in the allocated global arrays on the calling processor.


INQUIRE NAME

Inquires a global array's name
subroutine ga_inquire_name(g_a, array_name)
TypeNameDescriptionIntent
integerg_ainput
character*(*)array_nameoutput

Local operation.

Returns the name of an array represented by the handle g_a.


IS MIRRORED

Checks whether a global array is mirrored
integer ga_is_mirrored(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Local operation.

This subroutine checks if the array is a mirrored array or not. Returns 1 if it is a mirrored array, else it returns 0.


LLT SOLVE

Cholesky factorization of a global array
integer function ga_llt_solve(g_a, g_b)
TypeNameDescriptionIntent
integerg_acoefficient matrixinput
integerg_brhs/solution matrixinput/output

Collective on the processor group inferred from the arguments.

Solves a system of linear equations

            A * X = B

using the Cholesky factorization of an NxN double precision symmetric positive definite matrix A (represented by handle g_a). On successful exit B will contain the solution X. It returns:

         = 0 : successful exit
         > 0 : the leading minor of this order is not positive
               definite and the factorization could
               not be completed.


LOCATE

Locates the processor containing a specified element of a global array
logical function ga_locate(g_a, i, j, owner)
TypeNameDescriptionIntent
integerg_aarray handleinput
integeri, jelement subscriptinput
integerownerprocess idoutput
logical function nga_locate(g_a, subscript, owner)
TypeNameDescriptionIntent
integerg_aarray handleinput
integersubscriptelement subscriptinput
integerownerprocess idoutput

Local operation.

Return the GA compute process ID that `owns' the data. If any element of subscript[] is out of bounds "-1" is returned.


LOCATE REGION

Locates a region of a global array
logical function ga_locate_region(g_a, ilo, ihi, jlo, jhi, map, np)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerilo, ihi, jlo, jhibounding indices for array sectioninput
integermap(5,*)array containing mapping informationoutput
integernpnumber of processors containing dataoutput
logical function nga_locate_region(g_a, lo, hi, map, proclist, np)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of dimensionsinput
integerlo(ndim),hi(ndim)region(patch) specificationsinput
integermap(2*ndim,*)patch ownership arrayoutput
integerproclist(np)list of processesoutput
integernpnumber of processes containing dataoutput
map(1:ndim,i)contains lower bound dimensions for part owned by process proclist(i)input
map(ndim+1:2*ndim,i)contains upper bound dimensions for part owned by process proclist(i)input

Local operation.

Return a list of the GA processes ID that `own' the data. Parts of the specified patch might be actually `owned' by several processes. If lo/hi are out of bounds "0" is returned, otherwise the return value is equal to the number of processes that hold the data.

     map(1:ndim,i)            - lo(1:ndim)
     map(ndim+1:2*ndim,i)     - hi(1:ndim)
     procs(i)                 - processor id that owns data in patch
                                described by lo,hi

See Also:

LOCATE

LOCK

Locks a specific mutex
subroutine ga_lock(mutex)
TypeNameDescriptionIntent
integermutexmutex idinput

One-sided (non-collective).

Locks a mutex object identified by the mutex number. It is a fatal error for a process to attempt to lock a mutex which was already locked by this process.

See Also:

CREATE MUTEXES, DESTROY MUTEXES, UNLOCK

LU SOLVE

LU decomposition of a global array
subroutine ga_lu_solve(trans, g_a, g_b)
TypeNameDescriptionIntent
charactertranstranspose or not transposeinput
integerg_acoefficient matrixinput
integerg_brhs/solution matrixinput/output

Collective on the processor group inferred from the arguments.

Solve the system of linear equations op(A)X = B based on the LU factorization. op(A) = A or A' depending on the parameter trans:

     trans = `N' or `n' means that the transpose operator should not be applied.
     trans = `T' or `t' means that the transpose operator should be applied.

Matrix A is a general real matrix. Matrix B contains possibly multiple rhs vectors. The array associated with the handle g_b is overwritten by the solution matrix X.


MASK SYNC

Masks GA synchronization operations
subroutine ga_mask_sync(first,last)
TypeNameDescriptionIntent
logicalfirstmask for prior internal synchronizationinput
logicallastmask for post internal synchronizationinput

Collective on the default processor group.

This subroutine can be used to remove synchronization calls from around collective operations. Setting the parameter first = .false. removes the synchronization prior to the collective operation, setting last = .false. removes the synchronization call after the collective operation. This call is applicable to all collective operations. It most be invoked before each collective operation.

See Also:

SYNC

MATMUL PATCH

Performs matrix multiplication of patches of global arrays
subroutine ga_matmul_patch (transa, transb, alpha, beta,
                            g_a, ailo, aihi, ajlo, ajhi,
                            g_b, bilo, bihi, bjlo, bjhi,
                            g_c, cilo, cihi, cjlo, cjhi)
TypeNameDescriptionIntent
integerg_a, ailo, aihi, ajlo, ajhipatch of g_ainput
integerg_b, bilo, bihi, bjlo, bjhipatch of g_binput
integerg_c, cilo, cihi, cjlo, cjhipatch of g_cinput
double precision/complexalpha, betascale factorsinput
character*1transa, transbtranspose operatorsinput
subroutine nga_matmul_patch(transa, transb, alpha, beta,
                            g_a, alo, ahi,
                            g_b, blo, bhi,
                            g_c, clo, chi)
TypeNameDescriptionIntent
integerg_a, alo, ahipatch of g_ainput
integerg_b, blo, bhipatch of g_binput
integerg_c, clo, chipatch of g_cinput
double precision/complexalpha, betascale factorsinput
character*1transa, transbtranspose operatorsinput

Collective on the processor group inferred from the arguments.

ga_matmul_patch is a patch version of ga_dgemm and comes in 2-D and N-D versions. The 2-D interface performs the operation:

         C[cilo:cihi,cjlo:cjhi] := alpha* AA[ailo:aihi,ajlo:ajhi] *
                                   BB[bilo:bihi,bjlo:bjhi] ) +
                                   beta*C[cilo:cihi,cjlo:cjhi],

where AA = op(A), BB = op(B), and op(X) is one of

      op(X) = X   or   op(X) = X',

Valid values for transpose arguments: `n', `N', `t', `T'. It works for both double and double complex data tape. nga_matmul_patch is a N-dimensional patch version of ga_dgemm and is similar to the 2-D interface:

      C[clo[]:chi[]] := alpha* AA[alo[]:ahi[]] *
                               BB[blo[]:bhi[]] ) + beta*C[clo[]:chi[]],

See Also:

GEMM

MEDIAN

Computes the element-wise median of three arrays
subroutine ga_median(g_a, g_b, g_c, g_m)
TypeNameDescriptionIntent
integerg_ainput array handleinput
integerg_binput array handleinput
integerg_cinput array handleinput
integerg_moutput array handleinput

Collective on the processor group inferred from the arguments.

Computes the componentwise Median of three arrays g_a, g_b, and g_c, and stores the result in this array g_m. The result (m) may replace one of the input arrays (a/b/c).


MEDIAN PATCH

Computes the element-wise median of three global array patches
subroutine ga_median_patch(g_a, alo, ahi,
                           g_b, blo, bhi,
                           g_c, clo, chi,
                           g_m, mlo, mhi)
TypeNameDescriptionIntent
integerg_ainput array handleinput
integerg_binput array handleinput
integerg_cinput array handleinput
integerg_moutput array handleinput
integerndimnumber of dimensionsinput
integeralo(ndim),ahi(ndim)g_a patch dimensionsinput
integerblo(ndim),bhi(ndim)g_b patch dimensionsinput
integerclo(ndim),chi(ndim)g_c patch dimensionsinput
integermlo(ndim),mhi(ndim)g_m patch dimensionsinput

Collective on the processor group inferred from the arguments.

Computes the componentwise Median of three patches g_a, g_b, and g_c, and stores the result in this patch g_m. The result (m) may replace one of the input patches (a/b/c).

See Also:

MEDIAN

MEMORY AVAIL

Inquires about memory available on the invoking processor to allocate global arrays
integer function ga_memory_avail()

Local operation.

Returns amount of memory (in bytes) left for allocation of new global arrays on the calling processor. Note: If GA_uses_ma returns true, then GA_Memory_avail returns the lesser of the amount available under the GA limit and the amount available from MA (according to ma_inquire_avail operation). If no GA limit has been set, it returns what MA says is available. If ( !GA_Uses_ma() && !GA_Memory_limited() ) returns < 0, indicating that the bound on currently available memory cannot be determined.


MEMORY LIMITED

Checks whether memory available to GA's runtime is limited
logical function ga_memory_limited()

Local operation.

Indicates if limit is set on memory usage in Global Arrays on the calling processor. "1" means "yes", "0" means "no". Returns: True for "yes", False for "no"


MERGE DISTR PATCH

Merges a patched of a mirrored global array
integer nga_merge_distr_patch(g_a, alo, ahi, g_b, blo, bhi)
TypeNameDescriptionIntent
integerg_a,g_barray handlesinput
integeralo(ndim),ahi(ndim)g_a patch coordinatesinput
integerblo(ndim),bhi(ndim)g_b patch coordinatesinput

Collective on the processor group inferred from the arguments.

This function merges all copies of a patch of a mirrored array (g_a) into a patch in a distributed array (g_b).

See Also:

MERGE MIRRORED

MERGE MIRRORED

Merges a mirrored global array
subroutine ga_merge_mirrored(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

This subroutine merges mirrored arrays by adding the contents of each array across nodes. The result is that each mirrored copy of the array represented by g_a is the sum of the individual arrays before the merge operation. After the merge, all mirrored arrays are equal.


NBACC

Accumulates data into a global array without blocking the calling process
subroutine ga_nbacc(g_a, ilo, ihi, jlo, jhi, buf, ld, alpha, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerilo,ihistarting indices for global array sectioninput
integerjlo,jhiending indices for global array sectioninput
buflocal buffer array where the data isinput
integerldleading dimension/stride/extent for buffer arrayinput
double precision/complexalphascale factorinput
integernbhandlenon-blocking request handleoutput
subroutine nga_nbacc(g_a, lo, hi, buf, ld, alpha, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo[ndim]array of starting indices for global array sectioninput
integerhi[ndim]array of ending indices for global array sectioninput
buflocal buffer array where the data isinput
integerld[ndim-1]array specifying leading dimensions/strides/extents for buffer arrayinput
double precision/complexalphascale factorinput
integernbhandlenon-blocking request handleoutput

One-sided (non-collective).

A non-blocking version of the blocking accumulate operation. The accumulate operation can be completed locally by making a call to the wait (e.g., NGA_NbWait) routine. Non-blocking version of ga.acc. The accumulate operation can be completed locally by making a call to the ga.nbwait() routine. Combines data from buffer with data in the global array patch. The buffer array is assumed to be have the same number of dimensions as the global array. If the buffer is not contiguous, a contiguous copy will be made. global array section (lo[],hi[]) += alpha * buffer

See Also:

ACC

NBGET

Gets data from a global array without blocking the calling process
subroutine ga_nbget(g_a, ilo, ihi, jlo, jhi, buf, ld, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerilo,ihistarting indices for global array sectioninput
integerjlo,jhiending indices for global array sectioninput
typebuflocal buffer array where the data goesinput/output
integerldleading dimension/stride/extent for buffer arrayinput
integernbhandlenon-blocking request handleoutput
subroutine nga_nbget(g_a, lo, hi, buf, ld, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerlo[ndim]array of starting indices for global array sectioninput
integerhi[ndim]array of ending indices for global array sectioninput
typebuflocal buffer array where the data goesinput/output
integerld[ndim-1]array specifying leading dimensions/strides/extents for buffer arrayinput
integernbhandlenon-blocking request handleoutput

One-sided (non-collective).

A non-blocking version of the blocking get operation. The get operation can be completed locally by making a call to the wait (e.g., NGA_NbWait) routine. Copies data from global array section to the local array buffer. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in the input arguments are fatal. Returns: The local array buffer.

See Also:

GET

NBLOCK

Inquires the number of blocks along each dimension of a global array
subroutine ga_nblock(g_a, nblock)
TypeNameDescriptionIntent
integerg_aarray handleinput
integernblock[ndim]number of partitions for each dimensionoutput

Local operation.

Given a distribution of an array represented by the handle g_a, returns the number of partitions of each array dimension.


NBPUT

Puts data into a global array without blocking the calling process
subroutine ga_nbput(g_a, ilo, ihi, jlo, jhi, buf, ld, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerilo,ihistarting indices for global array sectioninput
integerjlo,jhiending indices for global array sectioninput
typebuflocal buffer array where the data isinput
integerldleading dimension/stride/extent for buffer arrayinput
integernbhandlenon-blocking request handleoutput
subroutine nga_nbput(g_a, lo, hi, buf, ld, nbhandle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerlo[ndim]array of starting indices for global array sectioninput
integerhi[ndim]array of ending indices for global array sectioninput
typebuflocal buffer array where the data isinput
integerld[ndim-1]array specifying leading dimensions/strides/extents for buffer arrayinput
integernbhandlenon-blocking request handleoutput

One-sided (non-collective).

A non-blocking version of the blocking put operation. The put operation can be completed locally by making a call to the wait (e.g., NGA_NbWait) routine. Copies data from local array buffer to the global array section. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in input arguments are fatal.

See Also:

PUT

NBWAIT

Waits for a non-blocking GA operation
subroutine ga_nbwait(nbhandle)
TypeNameDescriptionIntent
integernbhandlenon-blocking request handleinput
subroutine nga_nbwait(nbhandle)
TypeNameDescriptionIntent
integernbhandlenon-blocking request handleinput

One-sided (non-collective).

This function completes a non-blocking one-sided operation locally. Waiting on a nonblocking put or an accumulate operation assures that data was injected into the network and the user buffer can now be reused. Completing a get operation assures data has arrived into the user memory and is ready for use. The wait operation ensures only local completion. Unlike their blocking counterparts, the nonblocking operations are not ordered with respect to the destination. Performance being one reason, the other reason is that by ensuring ordering we incur additional and possibly unnecessary overhead on applications that do not require their operations to be ordered. For cases where ordering is necessary, it can be done by calling a fence operation. The fence operation is provided to the user to confirm remote completion if needed.

See Also:

NBGET, NBPUT, NBACC

NDIM

Inquires the number of dimensions in a global array
integer function ga_ndim(g_a)
TypeNameDescriptionIntent
integerg_ainput

Local operation.

Returns the number of dimensions in the array represented by the handle g_a.


NNODES

Returns the total number of GA ranks
integer function ga_nnodes()

Local operation.

Returns the number of the GA compute (user) processes.


NODEID

Returns the GA rank of the invoking process
integer function ga_nodeid()

Local operation.

Returns the GA process id (0, ..., ga_Nnodes()-1) of the requesting compute process.


NORM INFINITY

Computes a global array's infinite norm
subroutine ga_norm_infinity(g_a, nm)
TypeNameDescriptionIntent
integerg_aarray handleinput
double precisionnmmatrix/vector infinity-norm valueoutput

Collective on the processor group inferred from the arguments.

Computes the infinity-norm of the matrix or vector g_a.


NORM1

Computes a global array's 1-norm
subroutine ga_norm1(g_a, nm)
TypeNameDescriptionIntent
integerg_aarray handleinput
double precisionnmmatrix/vector 1-norm valueoutput

Collective on the processor group inferred from the arguments.

Computes the 1-norm of the matrix or vector g_a.


PACK

Compresses values from a source vector based on a corresponding integer mask
subroutine ga_pack(g_src, g_dest, g_mask, lo, hi, icount)
TypeNameDescriptionIntent
integerg_srchandle for source arrayinput
integerg_desthandle for destination arrayoutput
integerg_maskhandle for integer array representing a bit maskinput
integerlo,hilow and high values of range on which operation is performedinput
integericountnumber of values in compressed arrayoutput

Collective on the processor group inferred from the arguments.

The pack subroutine is designed to compress the values in the source vector g_src into a smaller destination array g_dest based on the values in an integer mask array g_mask. The values lo and hi denote the range of elements that should be compressed and icount is a variable that on output lists the number of values placed in the compressed array. This operation is the complement of the GA_Unpack operation. An example is shown below

GA_Pack(g_src, g_dest, g_mask, 1, n, &icount);

g_mask:   1  0  0  0  0  0  1  0  1  0  0  1  0  0  1  1  0
g_src:    1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
g_dest:   1  7  9 12 15 16
icount:   6

The current implementation requires that the distribution of the g_mask array matches the distribution of the g_src array.


PATCH ENUM

Enumerates a global array patch
subroutine ga_patch_enum(g_a, lo, hi, start, inc)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerlo,hilow and high values of array patchinput
startinteger/double precision/complex starting value of enumerationinput
incinteger/double precision/complex increment valueinput

Collective on the processor group inferred from the arguments.

This subroutine enumerates the values of an array between elements lo and hi starting with the value start and incrementing each subsequent value by inc. This operation is only applicable to 1-dimensional arrays. An example of its use is shown below:

GA_Patch_enum(g_a, 1, n, 7, 2);

g_a:  7  9 11 13 15 17 19 21 23 ...


PERIODIC ACC

Accumulates data into a global array using periodic boundary conditions
subroutine nga_periodic_acc(g_a, lo, hi, buf, ld, alpha)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer array where the local data isoutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput
typealphascale argument for accumulateinput

One-sided (non-collective).

Same as nga_acc except the indices can extend beyond the array boundary/dimensions in which case the library wraps them around. For Python, this is the periodic version of ga.acc. Combines data from buffer with data in the global array patch. The buffer array is assumed to be have the same number of dimensions as the global array. If the buffer is not contiguous, a contiguous copy will be made. global array section (lo[],hi[]) += alpha * buffer

See Also:

ACC

PERIODIC GET

Gets data from a global array using periodic boundary conditions
subroutine nga_periodic_get(g_a, lo, hi,  buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer array where the data goes tooutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput

One-sided (non-collective).

Same as nga_get except the indices can extend beyond the array boundary/dimensions in which case the library wraps them around. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in the input arguments are fatal. Returns: The local Array buffer.

See Also:

GET

PERIODIC PUT

Puts data into a global array using periodic boundary conditions
subroutine nga_periodic_put(g_a, lo, hi,  buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer array where the data comes fromoutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput

One-sided (non-collective).

Same as nga_put except the indices can extend beyond the array boundary/dimensions in which case the library wraps them around. The indices can extend beyond the array boundary/dimensions in which case the libray wraps them around. Copies data from local array buffer to the global array section. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in input arguments are fatal.

See Also:

PUT

PGROUP BRDCST

Broadcasts elements among processes in a processor group
subroutine ga_pgroup_brdcst(p_handle, type, buf, lenbuf, root)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput
integertypemessage indexinput
bytebuf(lenbuf)local message bufferinput/output
integerlenbuflength of messageinput
integerrootprocessor sending messageinput

Collective on the processor group inferred from the arguments.

Broadcast data from processor specified by root to all other processors in the processor group specified by p_handle. The length of the message in bytes is specified by lenbuf. The initial and broadcasted data can be found in the buffer specified by the pointer buf. If the buffer is not contiguous, an error is raised. This operation is provided only for convenience purposes: it is available regardless of the message-passing library that GA is running with. Returns: The buffer in case a temporary was passed in.

See Also:

BRDCST

PGROUP CREATE

Creates a GA processor group
integer function ga_pgroup_create(list, size)
TypeNameDescriptionIntent
integersizenumber of processors in groupinput
integerlist(size)list of processors in processor groupinput
integerpgroup handleoutput

Collective on the default processor group.

This command is used to create a processor group. At present, it must be invoked by all processors in the current default processor group. The list of processors use the indexing scheme of the default processor group. If the default processor group is the world group, then these indices are the usual processor indices. This function returns a process group handle that can be used to reference this group by other functions.

See Also:

PGROUP DESTROY, PGROUP SET DEFAULT

PGROUP DESTROY

Destroys a GA processor group
logical function ga_pgroup_destroy(p_handle)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput
integer.FALSE. if processor group was not previously activeoutput

Collective on the processor group inferred from the arguments.

This command is used to free up a processor group handle. It returns 0 if the processor group handle was not previously active.

See Also:

PGROUP CREATE, PGROUP SET DEFAULT

PGROUP GET DEFAULT

Sets default GA processor group
integer function ga_pgroup_get_default()

Local operation.

This function will return a handle to the default processor group, which can then be used to create a global array using one of the NGA_create_*_config or GA_Set_pgroup calls.


PGROUP GET MIRROR

Gets the mirrored processor group
integer function ga_pgroup_get_mirror()

Local operation.

This function will return a handle to the mirrored processor group, which can then be used to create a global array using one of the NGA_create_*_config or GA_Set_pgroup calls.


PGROUP GET WORLD

Gets the world processor group
integer function ga_pgroup_get_world()

Local operation.

This function will return a handle to the world processor group, which can then be used to create a global array using one of the NGA_create_*_config or GA_Set_pgroup calls.


PGROUP GOP

Global operation with a processor group
subroutine ga_pgroup_igop(p_handle, type, buf, n, op)
subroutine ga_pgroup_sgop(p_handle, type, buf, n, op)
subroutine ga_pgroup_dgop(p_handle, type, buf, n, op)
subroutine ga_pgroup_cgop(p_handle, type, buf, n, op)
subroutine ga_pgroup_zgop(p_handle, type, buf, n, op)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput
integertypemessage index (deprecated)input
integerbuf(n)arrayinput/output
realbuf(n)arrayinput/output
double precisionbuf(n)arrayinput/output
single complexbuf(n)arrayinput/output
double complexbuf(n)arrayinput/output
integernnumber elements in arrayinput
character*(*)opoperation on datainput

Collective on the processor group inferred from the arguments.

The buf[n] is an array present on each processor in the processor group p_handle. The GA_Pgroup_dgop `sums' all elements in buf[n] across all processors in the group specified by p_handle using the commutative operation specified by the character string op. The result is broadcast to all processor in p_handle. Allowed strings are `+', `*', `max', `min', `absmax', `absmin'. The use of lowerecase for operators is necessary.

See Also:

GOP

See Also:

GOP

PGROUP NNODES

Returns number of GA ranks in a processor group
integer function ga_pgroup_nnodes(p_handle)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput

Local operation.

This function returns the number of processors contained in the group specified by p_handle. Returns the number of processors contained in the group specified by pgroup.

See Also:

NNODES

PGROUP NODEID

Returns GA rank of invoking process in a processor group
integer function ga_pgroup_nodeid(p_handle)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput

Local operation.

This function returns the relative index of the processor in the processor group specified by p_handle. This index will generally differ from the absolute processor index returned by GA_Nodeid if the processor group is not the world group. Returns the relative index of the processor in the processor group specified by pgroup.

See Also:

NODEID

PGROUP SET DEFAULT

Sets a default GA processor group
subroutine ga_pgroup_set_default(p_handle)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput

Collective on the processor group inferred from the arguments.

This function can be used to reset the default processor group on a collection of processors. All processors in the group referenced by p_handle must make a call to this function. Any standard global array call that is made after resetting the default processor group will be restricted to processors in that group. Global arrays that are created after resetting the default processor group will only be defined on that group and global operations, such as GA_Sync or GA_Igop, and will be restricted to processors in that group. The GA_Pgroup_set_default call can be used to rapidly convert large applications, written with GA, into routines that run on processor groups. The default processor group can be overridden by using GA calls that require an explicit group handle as one of the arguments.

See Also:

PGROUP CREATE, PGROUP DESTROY

PGROUP SYNC

Synchronizes processes in a processor group
subroutine ga_pgroup_sync(p_handle)
TypeNameDescriptionIntent
integerp_handleprocessor group handleinput

Collective on the processor group inferred from the arguments.

This operation executes a synchronization group across the processors in the processor group specified by p_handle. Nodes outside this group are unaffected.

See Also:

SYNC

PRINT

Prints the contents of a global array
subroutine ga_print(g_a)
TypeNameDescriptionIntent
integerg_ainput

Collective on the processor group inferred from the arguments.

Prints an entire array to the standard output.


Prints the distribution of a global array
subroutine ga_print_distribution(g_a)
TypeNameDescriptionIntent
integerg_ainput

Collective on the processor group inferred from the arguments.

Prints the array distribution.


Prints the contents of a global array to a file

Collective on the processor group inferred from the arguments.

Prints an entire array to a file.


Prints a patch of a global array to stdout
subroutine ga_print_patch(g_a,ilo,ihi,jlo,jhi,pretty)
TypeNameDescriptionIntent
integerg_ainput
integerilo,ihi,jlo,jhiinput
integerprettyinput

Collective on the processor group inferred from the arguments.

Prints a patch of g_a array to the standard output. If the variable pretty has the value 0 then output is printed in a dense fashion. If pretty has the value 1 then output is formatted and rows/columns are labeled.


Prints GA runtime statistics
subroutine ga_print_stats()

Local operation.

This non-collective (MIMD) operation prints information about:


PROC TOPOLOGY

Inquires the linear location of a processor in the processor topology employed by a global array
subroutine ga_proc_topology(g_a, proc, prow, pcol)
TypeNameDescriptionIntent
integerg_ainput
integerprocinput
integerprow, pcoloutput

Local operation.

Based on the distribution of an array associated with handle g_a, determines coordinates of the specified processor in the virtual processor grid corresponding to the distribution of array g_a. The numbering starts from 0. The values of -1 means that the processor doesn't "own" any section of the array represented by g_a.

See Also:

SET BLOCK CYCLIC PROC GRID

PUT

Puts data into a global array
subroutine ga_put(g_a, ilo, ihi, jlo, jhi, buf, ld)
TypeNameDescriptionIntent
integerg_ainput
integerilo, ihi, jlo, jhibounding indices for global array sectioninput
double precision/complex/integerbuflocal buffer where data comes fromoutput
integerldinput
subroutine nga_put(g_a, lo, hi, buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
typebuflocal buffer array where the data comes fromoutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput

One-sided (non-collective).

Copies data from the local array buffer to the global array section. The local array is assumed to have the same number of dimensions as the global array. Any detected inconsistencies or errors in input arguments are fatal.


READ INC

Atomically read and increment an element in a global array
integer function ga_read_inc(g_a, i, j, inc)
TypeNameDescriptionIntent
integerg_ainput
integeri, j, incinput
integer function nga_read_inc(g_a, subscript, inc)
TypeNameDescriptionIntent
integerg_ainput
subscript(ndim)subscript array for the referenced elementinput
incamount element is incremented after readinput

One-sided (non-collective).

Atomically read and increment an element in an integer array.

   *BEGIN CRITICAL SECTION*
   old_value = a(subscript)
   a(subscript) += inc
   *END CRITICAL SECTION*
   return old_value


RECIP

Translates a global array to contain reciprocal of its elements
subroutine ga_recip(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

Take the element-wise reciprocal of the array.


RECIP PATCH

Translates a global array patch to contain reciprocal of its elements
subroutine ga_recip_patch(g_a, lo, hi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of dimensionsinput
integerlo(ndim), hi(ndim)patch coordinatesinput

Collective on the processor group inferred from the arguments.

Take element-wise reciprocal of the patch.

See Also:

RECIP

RELEASE

Releases access to a global array
subroutine ga_release(g_a, ilo, ihi, jlo, jhi)
TypeNameDescriptionIntent
integerg_ainput
integerilo, ihi, jlo, jhiinput
subroutine nga_release(g_a, lo, hi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of array dimensionsinput
integerlo(ndim),hi(ndim)patch specificationinput

Local operation.

Releases access to a global array when the data was read only. Your code should look like:

        NGA_Distribution(g_a, myproc, lo,hi);
        NGA_Access(g_a, lo, hi, \&ptr, ld);

             
        GA_Release(g_a, lo, hi);

NOTE: see restrictions specified for ga_access.

See Also:

ACCESS

RELEASE BLOCK

Releases access to a block of a global array
subroutine nga_release_block(g_a, index)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerindexblock indexinput

Local operation.

Releases access to the block of data specified by the integer index when data was accessed as read only. This is only applicable to block-cyclic data distributions created using the simple block-cyclic distribution.

See Also:

ACCESS BLOCK

RELEASE BLOCK GRID

Releases access to a block-cyclic distributed global array
subroutine nga_release_block_grid(g_a, subscript)
TypeNameDescriptionIntent
integerg_aarray handleinput
integersubscript(ndim)indices of block in arrayinput

Local operation.

Releases access to the block of data specified by the subscript array when data was accessed as read only. This is only applicable to block-cyclic data distributions created using the SCALAPACK data distribution.

See Also:

ACCESS BLOCK GRID

RELEASE BLOCK SEGMENT

Releases access to a block in a GA
subroutine nga_release_block_segment(g_a, iproc)
TypeNameDescriptionIntent
integerg_aarray handleinput
integeriprocprocessor IDinput

Local operation.

Releases access to the block of locally held data for a block-cyclic array, when data was accessed as read-only.

See Also:

ACCESS BLOCK SEGMENT

RELEASE GHOST ELEMENT

Releases access to ghost cells in a GA
subroutine nga_release_ghost_element(g_a, subscript)
TypeNameDescriptionIntent
integerg_aarray handleinput
integersubscript(ndim)element subscriptinput

Local operation.

Releases access to the locally held data for an array with ghost elements, when data was accessed as read-only.

See Also:

ACCESS GHOST ELEMENT

RELEASE GHOSTS

Releases access to ghost cells
subroutine nga_release_ghosts(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Local operation.

Releases access to the locally held block of data containing ghost elements, when data was accessed as read-only.

See Also:

ACCESS GHOSTS

RELEASE UPDATE

Releases access to a global array after an update
subroutine ga_release_update(g_a, ilo, ihi, jlo, jhi)
TypeNameDescriptionIntent
integerg_ainput
integerilo, ihi, jlo, jhiinput
subroutine nga_release_update(g_a, lo, hi)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerndimnumber of array dimensionsinput
integerlo(ndim),hi(ndim)patch specificationinput

Local operation.

Releases access to the data. It must be used if the data was accessed for writing. NOTE: see restrictions specified for ga_access.

See Also:

ACCESS

RELEASE UPDATE BLOCK

Releases after update access to a block in a global array
subroutine nga_release_update_block(g_a, index)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerindexblock indexinput

Local operation.

Releases access to the block of data specified by the integer index when data was accessed in read-write mode. This is only applicable to block-cyclic data distributions created using the simple block-cyclic distribution.

See Also:

ACCESS BLOCK

RELEASE UPDATE BLOCK GRID

Releases after update access to a block in a block-cyclic distributed global array
subroutine nga_release_update_block_grid(g_a, subscript)
TypeNameDescriptionIntent
integerg_aarray handleinput
integersubscript(ndim)indices of block in arrayinput

Local operation.

Releases access to the block of data specified by the subscript array when data was accessed in read-write mode. This is only applicable to block-cyclic data distributions created using the SCALAPACK data distribution.

See Also:

ACCESS BLOCK GRID

RELEASE UPDATE BLOCK SEGMENT

Releases access to a block of a GA
subroutine nga_release_update_block_segment(g_a, iproc)
TypeNameDescriptionIntent
integerg_aarray handleinput
integeriprocprocessor IDinput

Local operation.

Releases access to the block of locally held data for a block-cyclic array, when data was accessed as read-only.

See Also:

ACCESS BLOCK SEGMENT

RELEASE UPDATE GHOST ELEMENT

Releases after update access to ghost cells in a GA
subroutine nga_release_update_ghost_element(g_a, subscript)
TypeNameDescriptionIntent
integerg_aarray handleinput
integersubscript(ndim)element subscriptinput

Local operation.

Releases access to the locally held data for an array with ghost elements, when data was accessed in read-write mode.

See Also:

ACCESS GHOST ELEMENT

RELEASE UPDATE GHOSTS

Releases after access to ghosts
subroutine nga_release_update_ghosts(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Local operation.

Releases access to the locally held block of data containing ghost elements, when data was accessed in read-write mode.

See Also:

ACCESS GHOSTS

SCALE

Scales a global array by the specified value
subroutine ga_scale(g_a, s)
TypeNameDescriptionIntent
integerg_aarray handleinput
double precision/complex/integersscale factorinput

Collective on the processor group inferred from the arguments.

Scales an array by the constant s. Note that the library is unable to detect errors when the pointed value is of a different type than the array.


SCALE COLS

Scales columns of a global array with elements in another gobal array
subroutine ga_scale_cols(g_a, g_v)
TypeNameDescriptionIntent
integerg_a,g_varray handlesinput

Collective on the processor group inferred from the arguments.

Scales the columns of this matrix g_a using the vector g_v.


SCALE PATCH

Scales elements in the patch of a global array
subroutine ga_scale_patch(g_a, ailo, aihi, ajlo, ajhi, s)
TypeNameDescriptionIntent
integerg_ainput
double precision/complex/integersscale factorinput
integerailo, aihi, ajlo, ajhig_a patch coordinatesinput
subroutine nga_scale_patch(g_a, alo, ahi, s)
TypeNameDescriptionIntent
integerg_ainput
double precision/complex/integersscale factorinput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput

Collective on the processor group inferred from the arguments.

Scale an array by the factor `val'

See Also:

SCALE

SCALE ROWS

Scales the rows of a global array with elements in another global array
subroutine ga_scale_rows(g_a, g_v)
TypeNameDescriptionIntent
integerg_a,g_varray handlesinput

Collective on the processor group inferred from the arguments.

Scales the rows of this matrix g_a using the vector g_v.


SCAN ADD

Adds successive elements in a source vector based on a corresponding intenger mask
subroutine ga_scan_add(g_src, g_dest, g_mask, lo, hi, excl)
TypeNameDescriptionIntent
integerg_srchandle for source arrayinput
integerg_desthandle for destination arrayoutput
integerg_maskhandle for integer array representing a bit maskinput
integerlo,hilow and high values of range on which operation is performedinput
integerexclvalue to signify if masked values are included in addinput

Collective on the processor group inferred from the arguments.

This operation will add successive elements in a source vector g_src and put the results in a destination vector g_dest. The addition will restart based on the values of the integer mask vector g_mask. The scan is performed within the range specified by the integer values lo and hi. Note that this operation can only be applied to 1-dimensional arrays. The excl flag determines whether the sum starts with the value in the source vector corresponding to the location of a 1 in the mask vector (excl=0) or whether the first value is set equal to 0 (excl=1). Some examples of this operation are given below.

GA_Scan_add(g_src, g_dest, g_mask, 1, n, 0);

g_mask:   1  0  0  0  0  0  1  0  1  0  0  1  0  0  1  1  0
g_src:    1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
g_dest:   1  3  6 10 16 21  7 15  9 19 30 12 25 39 15 16 33

GA_Scan_add(g_src, g_dest, g_mask, 1, n, 1);

g_mask:   1  0  0  0  0  0  1  0  1  0  0  1  0  0  1  1  0
g_src:    1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
g_dest:   0  1  3  6 10 15  0  7  0  9 19  0 12 25  0  0 16


SCAN COPY

Copies successive elements in a source vector based on a corresponding intenger mask
subroutine ga_scan_copy(g_src, g_dest, g_mask, lo, hi)
TypeNameDescriptionIntent
integerg_srchandle for source arrayinput
integerg_desthandle for destination arrayoutput
integerg_maskhandle for integer array representing a bit maskinput
integerlo,hilow and high values of range on which operation is performedinput

Collective on the processor group inferred from the arguments.

This subroutine does a segmented scan-copy of values in the source array g_src into a destination array g_dest with segments defined by values in the integer mask array g_mask. The scan-copy operation is only applied to the range between the lo and hi indices. This operation is restriced to 1-dimensional arrays. The resulting destination array will consist of segments of consecutive elements with the same value. An example is shown below.

GA_Scan_copy(g_src, g_dest, g_mask, 1, n);

g_mask:   1  0  0  0  0  0  1  0  1  0  0  1  0  0  1  1  0
g_src:    1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17
g_dest:   1  1  1  1  1  1  7  7  9  9  9 12 12 12 15 16 16


SCATTER

Scatters elements into a global array
subroutine ga_scatter(g_a, v, i, j, n)
TypeNameDescriptionIntent
integerg_ainput
double precisionv(n)vector of values to be scatteredinput
integeri(n), j(n)array of subscripts for each destination elementinput
integernnumber of elements to be scatteredinput
subroutine nga_scatter(g_a, v, subsArray, n)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integernnumber of elementsinput
typev(n)array containing valuesinput
integerndimnumber of array dimensionsinput
integersubsArray(ndim,n)array of subscripts for each elementinput

One-sided (non-collective).

Scatters array elements into a global array. The contents of the input arrays (v,subsArray) are preserved.

for (k=0; k<= n; k++)
   {a[[subsArray[k][0]][subsArray[k][1]][subsArray[k][2]]... = v[k];}

See Also:

PUT

SCATTER ACC

Scatters and accumulates elements into a global array
subroutine ga_scatter_acc(g_a, v, i, j, n, alpha)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integernnumber of elementsinput
typev(n)array containing valueinput
integeri(n),j(n)arrays of indicesinput
double precision/complexalphamultiplicative valueinput
subroutine nga_scatter_acc(g_a, v, subsArray, n, alpha)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integernnumber of elementsinput
typev(n)array containing valueinput
integerndimnumber of array dimensionsinput
integersubsArray(ndim,n)array of subscriptsinput
double precision/complexalphamultiplicative valueinput

One-sided (non-collective).

Scatters array elements from a local array into a global array. Adds values from the local array to existing values in the global array after multiplying by alpha. The contents of the input arrays (v, subsArray) are preserved.

for (k=0; k<= n; k++)
   {a[subsArray[k][0]][subsArray[k][1]][subsArray[k][2]]... += v[k];}

Like scatter, but adds values to existing values in the global array after multiplying by alpha.

See Also:

ACC

SELECT ELEM

Selects an element in a global returned by the chosen operation (eg., min, max, etc.)
subroutine nga_select_elem(g_a, op, val, index)
TypeNameDescriptionIntent
integerg_aarray handle Controlinput
character(*)*opoperator {`min',`max'}input
valaddress where selected value should be storedoutput
integerindex(ndim)array index for the selected elementoutput

Collective on the processor group inferred from the arguments.

Returns the value and index for an element that is selected by the specified operator ("min" or "max") in a global array corresponding to g_a handle.


SET ARRAY NAME

Specifies what the name will be for the GA handle
subroutine ga_set_array_name(g_a, name)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
character*(*)namea unique character stringinput

Collective on the processor group inferred from the arguments.

This function can be used to assign a unique character string name to a Global Array handle that was obtained using the GA_Create_handle function.

See Also:

ALLOCATE

SET BLOCK CYCLIC

Specifies GA handle will have a round-robin distribution
subroutine ga_set_block_cyclic(g_a, dims)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerdims(ndim)array of block dimensionsinput

Collective on the processor group inferred from the arguments.

This subroutine is used to create a global array with a simple block-cyclic data distribution. The array is broken up into blocks of size dims and each block is numbered sequentially using a column major indexing scheme. The blocks are then assigned in a simple round-robin fashion to processors. Figure "stblkcy" below illustrates an array containing 25 blocks distributed on 4 processors. Blocks at the edge of the array may be smaller than the block size specified in dims. In the example below, blocks 4, 9, 14, 19, 20, 21, 22, 23, and 24 might be smaller than the remaining blocks. Most global array operations are insensitive to whether or not a block-cyclic data distribution is used, although performance may be slower in some cases if the global array is using a block-cyclic data distribution. Individual data blocks can be accessesed using the block-cyclic access functions.


SET BLOCK CYCLIC PROC GRID

Specifies the GA handle will have a block-cyclic processor distribution
subroutine ga_set_block_cyclic_proc_grid(g_a, dims, proc_grid)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerdims(ndim)array of block dimensionsinput

Collective on the processor group inferred from the arguments.

This subroutine is used to create a global array with a SCALAPACK-type block cyclic data distribution. The user specifies the dimensions of the processor grid in the array proc_grid. The product of the processor grid dimensions must equal the number of total number of processors and the number of dimensions in the processor grid must be the same as the number of dimensions in the global array. The data blocks are mapped onto the processor grid in a cyclic manner along each of the processor grid axes. Figure "setblkcyprocgrid" below illustrates an array consisting of 25 data blocks distributed on 6 processors. The 6 processors are configured in a 3 by 2 processor grid. Blocks at the edge of the array may be smaller than the block size specified in dims. Most global array operations are insensitive to whether or not a block-cyclic data distribution is used, although performance may be slower in some cases if the global array is using a block-cyclic data distribution. Individual data blocks can be accessesed using the block-cyclic access functions.


SET CHUNK

Specifies GA handle will have the given chunk size
subroutine ga_set_chunk(g_a, chunk)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerchunk(ndim)array of chunk widthsinput

Collective on the processor group inferred from the arguments.

This function is used to set the chunk array for a global array handle that was obtained using the GA_Create_handle function. The chunk array is used to determine the minimum number of array elements assigned to each processor along each coordinate direction.


SET DATA

Specifies what the array shape and data type wlll be for a GA handle
subroutine ga_set_data (g_a, ndim, dims, type)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimdimension of arrayinput
integerdims(ndim)array dimensionsinput
integertypedata type (MT_DBL,MT_INT,etc.)input

Collective on the processor group inferred from the arguments.

This function can be used to set the array dimension, the coordinate dimensions, and the data type assigned to a Global Array handle obtained using the GA_Create_handle function.

See Also:

ALLOCATE

SET DEBUG

Sets GA debug flag
subroutine ga_set_debug(flag)
TypeNameDescriptionIntent
logicalflagvalue to set internal debug flaginput

Local operation.

This function sets an internal flag in the GA library to either true or false. The value of this flag can be recovered at any time using the GA_Get_debug function. The flag is set to false when the the GA library is initialized. This can be useful in a number of debugging situations, especially when examining the behavior of routines that are called in multiple locations in a code.


SET DIAGONAL

Sets the diagonal elements of a global array
subroutine ga_set_diagonal(g_a, g_v)
TypeNameDescriptionIntent
integerg_a,g_varray handlesinput

Collective on the processor group inferred from the arguments.

Sets the diagonal elements of this matrix g_a with the elements of the vector g_v.


SET GHOSTS

Specifies the GA handle will have ghost cells
subroutine ga_set_ghosts(g_a, width)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerwidth(ndim)array of ghost cell widthsinput

Collective on the processor group inferred from the arguments.

This function can be used to set the ghost cell widths for a global array handle that was obtained using the GA_Create_handle function. The ghosts cells widths indicate how many ghost cells are used to pad the locally held array data along each dimension. The padding can be set independently for each coordinate dimension.


SET IRREG DISTR

Specifies that the GA handle will have an irregular distribution
subroutine ga_set_irreg_distr(g_a, mapc, nblock)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integermap(s)starting index for for each block; the size s is a sum of all elements of nblock arrayinput
integernblock(ndim)no. of blocks each dimension is divided intoinput

Collective on the processor group inferred from the arguments.

This function can be used to partition the array data among the individual processors for a global array handle obtained using the GA_Create_handle function.

The distribution is specified as a Cartesian product of distributions for each dimension. For example, the following figure demonstrates distribution of a 2-dimensional array 8x10 on 6 processors. nblock(2)={3,2}, the size of mapc array is s=5 and array mapc contains the following elements mapc={1, 3, 7, 1, 6}. The distribution is nonuniform because, P1 and P4 get 20 elements each and processors P0, P2, P3, and P5 only 10 elements each.

The array width() is used to control the width of the ghost cell boundary around the visible data on each processor. The local data of the global array residing on each processor will have a layer width(n) ghosts cells wide on either side of the visible data along the dimension n. An example is shown in Figure "setirregdist" below .

See Also:

ALLOCATE

SET MEMORY LIMIT

Limits the internal memory used by the GA runtime
subroutine ga_set_memory_limit(limit)
TypeNameDescriptionIntent
integerlimitthe amount of memory in bytes per processinput

Local operation.

Sets the amount of memory to be used (in bytes) per process

See Also:

INITIALIZE LTD

SET PGROUP

Specifies what the processor group will be for a GA handle
subroutine ga_set_pgroup(g_a, p_handle)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerp_handleprocessor group handleinput

Collective on the processor group inferred from the arguments.

This function can be used to set the processor configuration assigned to a global array handle that was obtained using the GA_Create_handle function. It can be used to create mirrored arrays by using the mirrored array processor configuration in this function call. It can also be used to create an array on a processor group by using a processor group handle in this call.

See Also:

ALLOCATE

SET RESTRICTED

Specifies a GA handle will be allocated on a subset of processors
subroutine ga_set_restricted(g_a, list, nproc)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerlist(nproc)list of processor IDs that contain datainput
integernprocnumber of processors that contain datainput

Collective on the processor group inferred from the arguments.

This function restricts data in the global array g_a to only the nproc processors listed in the array list. The value of nproc must be less than or equal to the number of available processors. If this call is used in conjunction with GA_Set_irreg_distr, then the decomposition in the GA_Set_irreg_distr call must be done assuming that the number of processors is nproc. The data that ordinarily would be mapped to process 0 is mapped to the process in list[0], the data that would be mapped to process 1 will be mapped to list[1], etc. This can be used to remap the data distribution to different processors, even if nproc equals the number of available processors.

See Also:

SET RESTRICTED RANGE

SET RESTRICTED RANGE

Specifies a GA handle will be created on a subset (as a range) of processors
subroutine ga_set_restricted_range(g_a, lo_proc, hi_proc)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerlo_procrange of processors (inclusive) that contain datainput
integerhi_procrange of processors (inclusive) that contain datainput

Collective on the processor group inferred from the arguments.

This function restricts data in the global array to the range of processors beginning with lo_proc and ending with hi_proc. Both lo_proc and hi_proc must be less than or equal to the total number of processors minus one (e.g., in the range [0,N-1], where N is the total number of processors) and lo_proc must be less than or equal to hi_proc. If lo_proc = 0 and hi_proc = N-1 then this call has no effect on the data distribution.

See Also:

SET RESTRICTED

SHIFT DIAGONAL

Adds specified constant to diagonal elements of a global array
subroutine ga_shift_diagonal(g_a, c)
TypeNameDescriptionIntent
integerg_aarray handleinput
double/complex/integer/floatcshift valueinput

Collective on the processor group inferred from the arguments.

Adds this constant to the diagonal elements of the matrix.


SOLVE

Solves a system of linear equations
integer function ga_solve(g_a, g_b)
TypeNameDescriptionIntent
integerg_acoefficient matrixinput
integerg_brhs/solution matrixinput

Collective on the processor group inferred from the arguments.

Solves a system of linear equations

            A * X = B

It first will call the Cholesky factorization routine and, if sucessfully, will solve the system with the Cholesky solver. If Cholesky will be not be able to factorize A, then it will call the LU factorization routine and will solve the system with forward/backward substitution. On exit B will contain the solution X. It returns

         = 0 : Cholesky factoriztion was succesful
         > 0 : the leading minor of this order
               is not positive definite, Cholesky factorization
               could not be completed and LU factoriztion was used


SPD INVERT

Inverts a symmetric positive definite matrix
integer function ga_spd_invert(g_a)
TypeNameDescriptionIntent
integerg_amatrixinput/output

Collective on the processor group inferred from the arguments.

It computes the inverse of a double precision using the Cholesky factorization of a NxN double precision symmetric positive definite matrix A stored in the global array represented by g_a. On successful exit, A will contain the inverse. It returns

         = 0 : successful exit
         > 0 : the leading minor of this order is not positive
               definite and the factorization could not be completed
         < 0 : it returns the index i of the (i,i)
               element of the factor L/U that is zero and
               the inverse could not be computed


STEP MAX

Computes a global array's step max
subroutine ga_step_max(g_a, g_b, step)
TypeNameDescriptionIntent
integerg_a,g_barray handlesinput
stepdouble precision/integer; the maximum stepoutput

Collective on the processor group inferred from the arguments.

Calculates the largest multiple of a vector g_b that can be added to this vector g_a while keeping each element of this vector non-negative.


STEP MAX PATCH

Computes a global array patch's step max
subroutine ga_step_max_patch(g_a, alo, ahi, g_b, blo, bhi, step)
TypeNameDescriptionIntent
integerg_a,g_barray handles where g_b is step directioninput
integeralo,ahi,blo,bhipatch coordinates of g_a and g_binput
double precisionstepthe maximum stepoutput

Collective on the processor group inferred from the arguments.

Calculates the largest multiple of a vector g_b that can be added to this vector g_a while keeping each element of this vector non-negative.


STRIDED ACC

Accumulates strided data into a global array
subroutine nga_strided_acc(g_a, lo, hi, skip, buf, ld, alpha)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
integerskip(ndim)array of strides for each dimensioninput
typebuflocal buffer array where the data comes frominput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput
typealphascale argument for accumulateinput

One-sided (non-collective).

This operation is the same as NGA_Acc, except that the values corresponding to dimension n in buf are accumulated to every skip[n] values of the global array g_a. Combines data from buffer with data in the global array patch. The buffer array is assumed to be have the same number of dimensions as the global array. global array section (lo[],hi[]) += alpha * buffer

See Also:

ACC

STRIDED GET

Get strided data from a global array
subroutine nga_strided_get(g_a, lo, hi, skip, buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for global array sectioninput
integerhi(ndim)array of ending indices for global array sectioninput
integerskip(ndim)array of strides for each dimensioninput
typebuflocal buffer array where the data comes fromoutput
integerld(ndim-1)array specifying leading dimensions for buffer arrayinput

One-sided (non-collective).

This operation is the same as NGA_Get, except that the values corresponding to dimension n in buf correspond to every skip[n] values of the global array g_a. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in the input arguments are fatal. Returns: The local array buffer.

See Also:

GET

STRIDED PUT

Puts strided data into a global array
subroutine nga_strided_put(g_a, lo, hi, skip, buf, ld)
TypeNameDescriptionIntent
integerg_aglobal array handleinput
integerndimnumber of dimensions of the global arrayinput
integerlo(ndim)array of starting indices for globalinput
integerhi(ndim)array of ending indices for global arrayinput
integerskip(ndim)array of strides for each dimensioninput
typebuflocal buffer array where the data comes fromoutput
integerld(ndim-1)array specifying leading dimensions for array sectioninput

One-sided (non-collective).

Strided version of put. This operation is the same as NGA_Put, except that the values corresponding to dimension n in buf are copied to every skip[n] values of the global array g_a. Copies data from local array buffer to the global array section. The local array is assumed to be have the same number of dimensions as the global array. Any detected inconsitencies/errors in input arguments are fatal.

See Also:

PUT

SUMMARIZE

Prints summary information on a global array
subroutine ga_summarize(verbose)
TypeNameDescriptionIntent
logicalverboseIf true print distribution infoinput

Local operation.

Prints info about allocated arrays.


SYMMETRIZE

Symmetrizes a global array
subroutine ga_symmetrize(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput/output

Collective on the processor group inferred from the arguments.

Symmetrizes matrix A represented with handle g_a: A:= .5 * (A+A').


SYNC

Synchronizes all processes in the default processor group
subroutine ga_sync()

Collective on the default processor group.

Synchronize processes (a barrier) and ensure that all GA operations completed.


TERMINATE

Terminates GA
subroutine ga_terminate()

Collective on the world processor group.

Delete all active arrays and destroy internal data structures.


TOTAL BLOCKS

Returns number of blocks allocated when using block-cyclic distribution
integer function ga_total_blocks(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput
integertotal number of blocks in the block-cyclic distributionoutput

Local operation.

This function returns the total number of blocks contained in a global array with a block-cyclic data distribution.

See Also:

SET BLOCK CYCLIC, SET BLOCK CYCLIC PROC GRID

TRANSPOSE

Transposes a global array
subroutine ga_transpose(g_a, g_b)
TypeNameDescriptionIntent
integerg_aremains unchangedinput
integerg_bsolution matrixinput

Collective on the processor group inferred from the arguments.

Transposes a matrix: B = A', where A and B are represented by handles g_a and g_b.


UNLOCK

Unlocks a mutex
subroutine ga_unlock(mutex)
TypeNameDescriptionIntent
integermutexmutex idinput

One-sided (non-collective).

Unlocks a mutex object identified by the mutex number. It is a fatal error for a process to attempt to unlock a mutex which has not been locked by this process.

See Also:

CREATE MUTEXES, DESTROY MUTEXES, LOCK

UNPACK

Expands values from a source vector based on a corresponding integer mask
subroutine ga_unpack(g_src, g_dest, g_mask, lo, hi, icount)
TypeNameDescriptionIntent
integerg_srchandle for source arrayinput
integerg_desthandle for destination arrayoutput
integerg_maskhandle for integer array representing a bit maskinput
integerlo,hilow and high values of range on which operation is performedinput
integericountnumber of values in uncompressed arrayoutput

Collective on the processor group inferred from the arguments.

The unpack subroutine is designed to expand the values in the source vector g_src into a larger destination array g_dest based on the values in an integer mask array g_mask. The values lo and hi denote the range of elements that should be compressed and icount is a variable that on output lists the number of values placed in the uncompressed array. This operation is the complement of the GA_Pack operation. An example is shown below.

GA_Unpack(g_src, g_dest, g_mask, 1, n, &icount);

g_src:    1  7  9 12 15 16
g_mask:   1  0  0  0  0  0  1  0  1  0  0  1  0  0  1  1  0
g_dest:   1  0  0  0  0  0  7  0  9  0  0 12  0  0 15 16  0
icount:   6

The current implementation requires that the distribution of the g_mask array matches the distribution of the g_dest array.


UPDATE GHOST DIR

Updates ghost cells along a specific direction
logical function nga_update_ghost_dir(g_a,dimension,idir,cflag)
TypeNameDescriptionIntent
integerg_aarray handleinput
integerdimensionarray dimension that is to be updatedinput
integeridirdirection of update (+/-1)input
logicalcflagflag to include corners in updateinput

Collective on the processor group inferred from the arguments.

This function can be used to update the ghost cells along individual directions. It is designed for algorithms that can overlap updates with computation. The variable dimension indicates which coordinate direction is to be updated (e.g. dimension = 1 would correspond to the y axis in a two or three dimensional system), the variable idir can take the values +/-1 and indicates whether the side that is to be updated lies in the positive or negative direction, and cflag indicates whether or not the corners on the side being updated are to be included in the update. The following calls would be equivalent to a call to GA_Update_ghosts for a 2-dimensional system:

     status = NGA_Update_ghost_dir(g_a,0,-1,1);
     status = NGA_Update_ghost_dir(g_a,0,1,1);
     status = NGA_Update_ghost_dir(g_a,1,-1,0);
     status = NGA_Update_ghost_dir(g_a,1,1,0);

The variable cflag is set equal to 1 (or non-zero) in the first two calls so that the corner ghost cells are update, it is set equal to 0 in the second two calls to avoid redundant updates of the corners. Note that updating the ghosts cells using several independent calls to the nga_update_ghost_dir functions is generally not as efficient as using GA_Update_ghosts unless the individual calls can be effectively overlapped with computation.


UPDATE GHOSTS

Updates ghost cells
subroutine ga_update_ghosts(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

This call updates the ghost cell regions on each processor with the corresponding neighbor data from other processors. The operation assumes that all data is wrapped around using periodic boundary data so that ghost cell data that goes beyound an array boundary is wrapped around to the other end of the array. The GA_Update_ghosts call contains two GA_Sync calls before and after the actual update operation. For some applications these calls may be unecessary, if so they can be removed using the GA_Mask_sync subroutine.


USES MA

Checks whether GA uses MA
logical function ga_uses_ma()

Local operation.

Returns "1" if memory in global arrays comes from the Memory Allocator (MA). "0" means that memory comes from another source, for example System V shared memory is used. TODO


WTIME

Returns time in seconds since an arbitrary time in the past
double precision function ga_wtime()

Local operation.

This function returns a wall (or elapsed) time on the calling processor. Returns time in seconds representing elapsed wall-clock time since an arbitrary time in the past. Example:

double starttime, endtime;
starttime = GA_Wtime();
.... code snippet to be timed ....
endtime   = GA_Wtime();
printf(\"Time taken = \%lf secondsn\", endtime-starttime);

This function is only available in release 4.1 or greater.


ZERO

Zeros a global array
subroutine ga_zero(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

Sets value of all elements in the array to zero.


ZERO DIAGONAL

Zeros the diagonal elements of a global array
subroutine ga_zero_diagonal(g_a)
TypeNameDescriptionIntent
integerg_aarray handleinput

Collective on the processor group inferred from the arguments.

Sets the diagonal elements of this matrix g_a with zeros.


ZERO PATCH

Zeros a patch of a global array
subroutine nga_zero_patch(g_a, alo, ahi)
TypeNameDescriptionIntent
integerg_ainput
integerndimnumber of dimensionsinput
integeralo(ndim), ahi(ndim)g_a patch coordinatesinput

Collective on the processor group inferred from the arguments.

Set all the elements in the patch to zero.

See Also:

ZERO