ABS VALUE

subroutine ga_abs_value(g_a)

Collective on the processor group inferred from the arguments.

Take the element-wise absolute value of the array.

ABS VALUE PATCH

subroutine ga_abs_value_patch(g_a, lo, hi)

Collective on the processor group inferred from the arguments.

Take the element-wise absolute value of the patch.

See Also:

ACC

subroutine ga_acc(g_a, ilo, ihi, jlo, jhi, buf, ld, alpha)

subroutine nga_acc(g_a, lo, hi, buf, ld, alpha)

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

subroutine ga_access(g_a, ilo, ihi, jlo, jhi, index, ld)

subroutine nga_access(g_a, lo, hi, index, ld)

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

subroutine nga_access_block(g_a, idx, index, ld)

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 BLOCK GRID

subroutine nga_access_block_grid(g_a, subscript, index, ld)

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 BLOCK SEGMENT

subroutine nga_access_block_segment(g_a, proc, index, len)

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 GHOST ELEMENT

subroutine nga_access_ghost_element(g_a, index, subscript, ld)

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 GHOSTS

subroutine nga_access_ghosts(g_a, dims, index, ld)

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:

ADD

subroutine ga_add(alpha, g_a, beta, g_b, g_c)

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

subroutine ga_add_constant(g_a,  alpha)

Collective on the processor group inferred from the arguments.

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

ADD CONSTANT PATCH

subroutine ga_add_constant_patch(g_a, lo, hi, alpha)

Collective on the processor group inferred from the arguments.

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

See Also:

ADD DIAGONAL

subroutine ga_add_diagonal(g_a, g_v)

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

subroutine ga_add_patch(alpha, g_a, ailo, aihi, ajlo, ajhi,
                        beta,  g_b, bilo, bihi, bjlo, bjhi,
                               g_c, cilo, cihi, cjlo, cjhi)

subroutine nga_add_patch(alpha, g_a, alo, ahi, beta, g_b, blo, bhi
                         g_c, clo, chi)

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:

ALLOC GATSCAT BUF

void nga_alloc_gatscat_buf(nelems)

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:

ALLOCATE

logical function ga_allocate(g_a)

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

subroutine ga_brdcst(type, buf, lenbuf, root)

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

subroutine ga_check_handle(g_a, string)

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

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

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

integer function ga_cluster_nprocs(inode)

Local operation.

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

CLUSTER PROC NODEID

integer function ga_cluster_proc_nodeid(proc)

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

integer function ga_cluster_procid(inode,iproc)

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

logical function ga_compare_distr(g_a, g_b)

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

subroutine ga_copy(g_a, g_b)

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

subroutine ga_copy_patch(trans, g_a, ailo, aihi, ajlo, ajhi,
                         g_b, bilo, bihi, bjlo, bjhi)

subroutine nga_copy_patch(trans, g_a, alo, ahi, g_b, blo, bhi)

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:

CREATE

logical function ga_create(type, dim1, dim2, array_name, chunk1, chunk2, g_a)

logical function nga_create(type, ndim, dims, array_name, chunk, g_a)

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

logical function nga_create_config(type, ndim, dims, array_name, chunk,
                                   p_handle, g_a)

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 GHOSTS

logical function nga_create_ghosts(type, ndim, dims, width, array_name,
                                   chunk, g_a)

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 GHOSTS CONFIG

logical function nga_create_ghosts_config(type, ndim, dims, width, array_name,
                                          chunk, p_handle, g_a)

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 GHOSTS IRREG

logical function nga_create_ghosts_irreg(type, ndim, dims, width, array_name, map, nblock, g_a)

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 GHOSTS IRREG CONFIG

logical function nga_create_ghosts_irreg_config(type, ndim,
                                                dims, width, array_name,
                                                map, nblock,
                                                p_handle, g_a)

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 HANDLE

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:

CREATE IRREG

logical function ga_create_irreg(type, dim1, dim2, array_name, map1,
                                 nblock1, map2, nblock2, g_a)

logical function nga_create_irreg(type, ndim, dims, array_name, map,
                                  nblock, g_a)

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 IRREG CONFIG

logical function nga_create_irreg_config(type, ndim, dims, array_name,
                                         map, nblock, p_handle, g_a)

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 MUTEXES

logical function ga_create_mutexes(number)

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

logical function ga_destroy(g_a)

Collective on the processor group inferred from the arguments.

Deallocates the array and frees any associated resources.

DESTROY 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:

DIAG

subroutine ga_diag(g_a, g_s, g_v, eval)

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

subroutine ga_diag_reuse(control, g_a, g_s, g_v, eval)

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

subroutine ga_diag_std(g_a, g_v, eval)

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

subroutine ga_distribution(g_a, iproc, ilo, ihi, jlo, jhi)

subroutine nga_distribution(g_a, iproc, lo, hi)

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

double precision function ga_ddot(g_a, g_b)
double complex function ga_zdot(g_a, g_b)

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

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)

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)

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:

DUPLICATE

logical function ga_duplicate(g_a, g_b, array_name)

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

subroutine ga_elem_divide(g_a, g_b, g_c)

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

subroutine ga_elem_divide_patch(g_a, alo, ahi,
                                g_b, blo, bhi,
                                g_c, clo, chi)

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 MAXIMUM

subroutine ga_elem_maximum(g_a, g_b, g_c)

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

subroutine ga_elem_maximum_patch(g_a, alo, ahi,
                                 g_b, blo, bhi,
                                 g_c, clo, chi)

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

subroutine ga_elem_minimum(g_a, g_b, g_c)

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

subroutine ga_elem_minimum_patch(g_a, alo, ahi,
                                 g_b, blo, bhi,
                                 g_c, clo, chi)

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 MULTIPLY

subroutine ga_elem_multiply(g_a, g_b, g_c)

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

subroutine ga_elem_multiply_patch(g_a, alo, ahi,
                                  g_b, blo, bhi,
                                  g_c, clo, chi)

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:

ERROR

subroutine ga_error(message, code)

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

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

subroutine ga_fill(g_a, s)

Collective on the processor group inferred from the arguments.

Assign a single value to all elements in the array.

FILL PATCH

subroutine ga_fill_patch(g_a, ailo, aihi, ajlo, ajhi, s)

subroutine nga_fill_patch (g_a, alo, ahi, s)

Collective on the processor group inferred from the arguments.

Fill the patch of g_a with value of `val'

See Also:

FREE GATSCAT BUF

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:

GATHER

subroutine ga_gather(g_a, v, i, j, n)

subroutine nga_gather(g_a, v, subsArray, n)

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:

GEMM

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)

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

subroutine ga_get(g_a, ilo, ihi, jlo, jhi, buf, ld)

subroutine nga_get(g_a, lo, hi, buf, ld)

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

subroutine ga_get_block_info(g_a, num_blocks, block_dims)

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:

GET DEBUG

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

subroutine ga_get_diag(g_a, g_v)

Collective on the processor group inferred from the arguments.

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

GET GHOST BLOCK

subroutine nga_get_ghost_block(g_a, lo, hi, buf, ld)

One-sided (non-collective).

This operation behaves similarly to the GA Get operation and will default to a standard Get if the global array has no ghost cells or the request does not fit into the ghost cell region of the calling processor. It is easier to use than the NGA_Access_ghosts function but it may be slower and requires more memory. The operation will copy data from the locally held portions of the global array, including the ghost cells, if the requested block falls within the region defined by visible block held by the process plus the ghost cell region. For example, if the process holds the visible block [2:8, 2:8] with a ghost cell width that is one element deep, then a request for the block [1:9,1:9] will use the local ghost cells to fill the local buffer. In this case, the data transfer is completely local. If the request is for a block such as [1:10,1:10], which would require data from another process, then the NGA_Get_ghost_block call reverts to an ordinary NGA_Get operation and ignores the locally held ghost data.

Return: The local array buffer.

See Also:

GOP

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)

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

logical function ga_has_ghosts(g_a)

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

subroutine ga_init_fence()

Local operation.

Initializes tracing of the completion status of data movement operations.

INITIALIZE

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

subroutine ga_initialize_ltd(limit)

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:

INQUIRE

subroutine ga_inquire(g_a, type, dim1, dim2)

subroutine nga_inquire(g_a, type, ndim, dims)

Local operation.

Returns data type and dimensions of the array.

INQUIRE MEMORY

integer function ga_inquire_memory()

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

INQUIRE NAME

subroutine ga_inquire_name(g_a, array_name)

Local operation.

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

IS MIRRORED

integer ga_is_mirrored(g_a)

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

integer function ga_llt_solve(g_a, g_b)

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

logical function ga_locate(g_a, i, j, owner)

logical function nga_locate(g_a, subscript, owner)

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

logical function ga_locate_region(g_a, ilo, ihi, jlo, jhi, map, np)

logical function nga_locate_region(g_a, lo, hi, map, proclist, np)

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:

LOCK

subroutine ga_lock(mutex)

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:

LU SOLVE

subroutine ga_lu_solve(trans, g_a, g_b)

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

subroutine ga_mask_sync(first,last)

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:

MATMUL PATCH

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)

subroutine nga_matmul_patch(transa, transb, alpha, beta,
                            g_a, alo, ahi,
                            g_b, blo, bhi,
                            g_c, clo, chi)

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:

MEDIAN

subroutine ga_median(g_a, g_b, g_c, g_m)

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

subroutine ga_median_patch(g_a, alo, ahi,
                           g_b, blo, bhi,
                           g_c, clo, chi,
                           g_m, mlo, mhi)

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:

MEMORY AVAIL

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

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

integer nga_merge_distr_patch(g_a, alo, ahi, g_b, blo, bhi)

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

subroutine ga_merge_mirrored(g_a)

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

subroutine ga_nbacc(g_a, ilo, ihi, jlo, jhi, buf, ld, alpha, nbhandle)

subroutine nga_nbacc(g_a, lo, hi, buf, ld, alpha, nbhandle)

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:

NBGET

subroutine ga_nbget(g_a, ilo, ihi, jlo, jhi, buf, ld, nbhandle)

subroutine nga_nbget(g_a, lo, hi, buf, ld, nbhandle)

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:

NBLOCK

subroutine ga_nblock(g_a, nblock)

Local operation.

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

NBPUT

subroutine ga_nbput(g_a, ilo, ihi, jlo, jhi, buf, ld, nbhandle)

subroutine nga_nbput(g_a, lo, hi, buf, ld, nbhandle)

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:

NBTEST

logical function ga_nbtest(nbhandle)

logical function nga_nbtest(nbhandle)

One-sided (non-collective).

This function tests a non-blocking one-sided operation for completion. If true, the function is completed locally and the buffer is available for either use or reuse, depending on the operation. Once this operation has returned true, there is no need to call nbwait on the handle. The test function is properly implemented only on the Progress Ranks and RMA runtimes. For other runtimes, it defaults to the non-blocking wait function and always returns true.

See Also:

NBWAIT

subroutine ga_nbwait(nbhandle)

subroutine nga_nbwait(nbhandle)

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. Not all runtimes support true non-blocking capability. For those that don't all operations are blocking and the wait function is a no-op.

Unlike their blocking counterparts, the nonblocking operations are not ordered with respect to the destination. Performance being one reason, the other reason is that ensuring ordering would 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:

NDIM

integer function ga_ndim(g_a)

Local operation.

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

NNODES

integer function ga_nnodes()

Local operation.

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

NODEID

integer function ga_nodeid()

Local operation.

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

NORM INFINITY

subroutine ga_norm_infinity(g_a, nm)

Collective on the processor group inferred from the arguments.

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

NORM1

subroutine ga_norm1(g_a, nm)

Collective on the processor group inferred from the arguments.

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

OVERLAY

logical function ga_overlay(g_a, g_p)

Collective on the processor group inferred from the arguments.

The overlay function is designed to allow users to create a global array on top of an existing global array. This can be used in situations where it is desirable to create and destroy a large number of global arrays in rapid succession and where the size of these global arrays can be bounded beforehand. A large global array is created at the start using conventional create or allocate calls and then is used as the parent for new global arrays that are allocated using the overlay call. This approach removes some collectives and memory allocation and deallocation calls from the process of creating a global array and should result in improved performance. Note that the parent global array should not be used while another array is overlayed on top of it.

Collective on the processor group inferred from the arguments.

See Also:

PACK

subroutine ga_pack(g_src, g_dest, g_mask, lo, hi, icount)

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

subroutine ga_patch_enum(g_a, lo, hi, start, inc)

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

subroutine nga_periodic_acc(g_a, lo, hi, buf, ld, alpha)

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:

PERIODIC GET

subroutine nga_periodic_get(g_a, lo, hi,  buf, ld)

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:

PERIODIC PUT

subroutine nga_periodic_put(g_a, lo, hi,  buf, ld)

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:

PGROUP BRDCST

subroutine ga_pgroup_brdcst(p_handle, type, buf, lenbuf, root)

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:

PGROUP CREATE

integer function ga_pgroup_create(list, size)

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

logical function ga_pgroup_destroy(p_handle)

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 DUPLICATE

integer function ga_pgroup_duplicate(p_handle)

Return a copy of an existing processor group.

Collective on the processor group inferred from the arguments.

See Also:

PGROUP GET DEFAULT

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

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

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

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)

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:

See Also:

PGROUP NNODES

integer function ga_pgroup_nnodes(p_handle)

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:

PGROUP NODEID

integer function ga_pgroup_nodeid(p_handle)

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:

PGROUP SELF

integer function ga_pgroup_self()

Return a processor group that only contains the calling process.

One-sided (non-collective).

See Also:

PGROUP SET DEFAULT

subroutine ga_pgroup_set_default(p_handle)

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 SYNC

subroutine ga_pgroup_sync(p_handle)

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:

PRINT

subroutine ga_print(g_a)

Collective on the processor group inferred from the arguments.

Prints an entire array to the standard output.

PRINT DISTRIBUTION

subroutine ga_print_distribution(g_a)

Collective on the processor group inferred from the arguments.

Prints the array distribution.

PRINT FILE

Collective on the processor group inferred from the arguments.

Prints an entire array to a file.

PRINT PATCH

subroutine ga_print_patch(g_a,ilo,ihi,jlo,jhi,pretty)

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.

PRINT STATS

subroutine ga_print_stats()

Local operation.

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

• Number of calls to the GA create/duplicate, destroy, get, put, scatter, gather, and read_and_inc operations
• Total amount of data moved in the GA primitive operations
• Amount of data moved in GA primitive operations to logicaly remote locations
• Maximum memory consumption in global arrays, and
• Number of requests serviced in the interrupt-driven implementations by the calling process.

PROC TOPOLOGY

subroutine ga_proc_topology(g_a, proc, prow, pcol)

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:

PUT

subroutine ga_put(g_a, ilo, ihi, jlo, jhi, buf, ld)

subroutine nga_put(g_a, lo, hi, buf, ld)

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

integer function ga_read_inc(g_a, i, j, inc)

integer function nga_read_inc(g_a, subscript, inc)

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

subroutine ga_recip(g_a)

Collective on the processor group inferred from the arguments.

Take the element-wise reciprocal of the array.

RECIP PATCH

subroutine ga_recip_patch(g_a, lo, hi)

Collective on the processor group inferred from the arguments.

Take element-wise reciprocal of the patch.

See Also:

RELEASE

subroutine ga_release(g_a, ilo, ihi, jlo, jhi)

subroutine nga_release(g_a, lo, hi)

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:

RELEASE BLOCK

subroutine nga_release_block(g_a, index)

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:

RELEASE BLOCK GRID

subroutine nga_release_block_grid(g_a, subscript)

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:

RELEASE BLOCK SEGMENT

subroutine nga_release_block_segment(g_a, iproc)

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:

RELEASE GHOST ELEMENT

subroutine nga_release_ghost_element(g_a, subscript)

Local operation.

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

See Also:

RELEASE GHOSTS

subroutine nga_release_ghosts(g_a)

Local operation.

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

See Also:

RELEASE UPDATE

subroutine ga_release_update(g_a, ilo, ihi, jlo, jhi)

subroutine nga_release_update(g_a, lo, hi)

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:

RELEASE UPDATE BLOCK

subroutine nga_release_update_block(g_a, index)

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:

RELEASE UPDATE BLOCK GRID

subroutine nga_release_update_block_grid(g_a, subscript)

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:

RELEASE UPDATE BLOCK SEGMENT

subroutine nga_release_update_block_segment(g_a, iproc)

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:

RELEASE UPDATE GHOST ELEMENT

subroutine nga_release_update_ghost_element(g_a, subscript)

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:

RELEASE UPDATE GHOSTS

subroutine nga_release_update_ghosts(g_a)

Local operation.

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

See Also:

SCALE

subroutine ga_scale(g_a, s)

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

subroutine ga_scale_cols(g_a, g_v)

Collective on the processor group inferred from the arguments.

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

SCALE PATCH

subroutine ga_scale_patch(g_a, ailo, aihi, ajlo, ajhi, s)