xmpco_internal.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "xmp_internal.h"
#include "xmp_data_struct.h"
#include "xmpco_params.h"

Include dependency graph for xmpco_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	BOOL   int
#define	TRUE   1
#define	FALSE   0
#define	_ROUND_UP(n, p)   (((((size_t)(n))-1)/(p)+1)*(p))
#define	_ROUND_UP_PLUS(n, p)   (((n)>0) ? _ROUND_UP(n,p) : (p))
#define	ROUND_UP_COMM(n)   _ROUND_UP((n),COMM_UNIT)
#define	ROUND_UP_MALLOC(n)   _ROUND_UP_PLUS((n),MALLOC_UNIT)

Typedefs
typedef enum _SyncMode	SyncMode
typedef struct _resourceSet_t	ResourceSet_t
typedef struct _memoryChunk_t	MemoryChunk_t
typedef struct _coarrayInfo_t	CoarrayInfo_t
typedef struct _memoryChunkOrder_t	MemoryChunkOrder_t
typedef struct _sortedChunkTable_t	SortedChunkTable_t

Enumerations
enum	_SyncMode { syncNONBLOCK = 0 , syncBLOCK = 1 , syncATOMIC = 2 , syncRUNTIME = 3 }

Functions
size_t	xmp_coarray_malloc_bytes (void)
size_t	xmp_coarray_allocated_bytes (void)
size_t	xmp_coarray_garbage_bytes (void)
CoarrayInfo_t *	XMPCO_malloc_coarray (char **addr, int count, size_t element, ResourceSet_t *rset)
CoarrayInfo_t *	XMPCO_regmem_coarray (void *var, int count, size_t element, ResourceSet_t *rset)
CoarrayInfo_t *	XMPCO_malloc_staticCoarray (char **addr, int count, size_t element, int namelen, char *name)
	have a share of memory in the pool (if not larger than threshold) or allocate individually (if larger than threshold) out: return : pointer to descriptor CoarrayInfo_t addr : address of the coarray object to be allocated in: count : count of elements element: element size namelen: character length of name (for debugging) name : name of the coarray (for debugging) More...
CoarrayInfo_t *	XMPCO_regmem_staticCoarray (void *var, int count, size_t element, int namelen, char *name)
	Similar to _alloc_static_coarray() except that the coarray is allocated not by the runtime but by the Fortran system. More...
void	XMPCO_free_coarray (CoarrayInfo_t *cinfo)
void	XMPCO_deregmem_coarray (CoarrayInfo_t *cinfo)
void	XMPCO_malloc_pool (void)
void	XMPCO_count_size (int count, size_t element)
void	XMPCO_prolog (ResourceSet_t **rset, int namelen, char *name)
void	XMPCO_epilog (ResourceSet_t **rset)
CoarrayInfo_t *	XMPCO_find_descptr (char *addr, int namelen, char *name)
	generate and return a descriptor for a coarray DUMMY ARGUMENT More...
void	XMPCO_sync_all (void)
void	XMPCO_sync_all_auto (void)
void	XMPCO_sync_all_withComm (MPI_Comm comm)
void	XMPCO_GET_arrayStmt (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *localAddr, int rank, int skip[], int skip_local[], int count[])
void	XMPCO_GET_scalarExpr (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *result)
void	XMPCO_GET_arrayExpr (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *result, int rank, int skip[], int count[])
void	XMPCO_PUT_scalarStmt (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *rhs, SyncMode sync_mode)
void	XMPCO_PUT_arrayStmt (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *rhsAddr, int rank, int skip[], int skip_rhs[], int count[], SyncMode sync_mode)
void	XMPCO_PUT_spread (CoarrayInfo_t *descPtr, char *baseAddr, int element, int coindex, char *rhs, int rank, int skip[], int count[], SyncMode sync_mode)
int	XMPCO_this_image_coarray_dim (CoarrayInfo_t *cinfo, int corank, int dim)
void	XMPCO_this_image_coarray (CoarrayInfo_t *cinfo, int corank, int image[])
void	_XMPCO_set_poolThreshold (unsigned size)
void	_XMPCO_set_localBufSize (unsigned size)
void	_XMPCO_set_isMsgMode (BOOL sw)
void	_XMPCO_set_isMsgMode_quietly (BOOL sw)
void	_XMPCO_set_isSafeBufferMode (BOOL sw)
void	_XMPCO_set_isSyncPutMode (BOOL sw)
void	_XMPCO_set_isEagerCommMode (BOOL sw)
void	_XMPCO_reset_isMsgMode (void)
unsigned	_XMPCO_get_poolThreshold (void)
size_t	_XMPCO_get_localBufSize (void)
BOOL	_XMPCO_get_isMsgMode (void)
BOOL	_XMPCO_get_isSafeBufferMode (void)
BOOL	_XMPCO_get_isSyncPutMode (void)
BOOL	_XMPCO_get_isEagerCommMode (void)
char *	_XMPCO_get_nameOfCoarray (CoarrayInfo_t *cinfo)
char *	_XMPCO_get_baseAddrOfCoarray (CoarrayInfo_t *cinfo)
size_t	_XMPCO_get_sizeOfCoarray (CoarrayInfo_t *cinfo)
size_t	_XMPCO_get_offsetInCoarray (CoarrayInfo_t *cinfo, char *addr)
void	_XMPCO_set_corank (CoarrayInfo_t *cp, int corank)
void	_XMPCO_set_codim_withBounds (CoarrayInfo_t *cp, int dim, int lb, int ub)
void	_XMPCO_set_codim_withSize (CoarrayInfo_t *cp, int dim, int lb, int size)
void	_XMPCO_set_varname (CoarrayInfo_t *cp, int namelen, char *name)
CoarrayInfo_t *	_XMPCO_set_nodes (CoarrayInfo_t *cinfo, _XMP_nodes_t *nodes)
void *	_XMPCO_get_descForMemoryChunk (CoarrayInfo_t *cinfo)
char *	_XMPCO_get_orgAddrOfMemoryChunk (CoarrayInfo_t *cinfo)
size_t	_XMPCO_get_sizeOfMemoryChunk (CoarrayInfo_t *cinfo)
size_t	_XMPCO_get_offsetInMemoryChunk (CoarrayInfo_t *cinfo, char *addr)
BOOL	_XMPCO_isAddrInMemoryChunk (char *localAddr, CoarrayInfo_t *cinfo)
void *	_XMPCO_get_infoOfCtrlData (char **baseAddr, size_t *offset, char **name)
void *	_XMPCO_get_infoOfLocalBuf (char **baseAddr, size_t *offset, char **name)
void *	_XMPCO_get_desc_fromLocalAddr (char *localAddr, char **orgAddr, size_t *offset, char **name)
MPI_Comm	_XMPCO_get_comm_fromCoarrayInfo (CoarrayInfo_t *cinfo)
void	_XMPCO_fatal (char *format,...)
void	_XMPCO_debugPrint (char *format,...)
void	_XMPCO_coarrayInit_get (void)
void	_XMPCO_coarrayInit_getsub (void)
void	_XMPCO_coarrayInit_put (void)
int	_XMPCO_nowInTask (void)
void	_XMPCO_checkIfInTask (char *msgopt)
void	_XMPCO_set_initialThisImage (void)
void	_XMPCO_set_initialNumImages (void)
int	_XMPCO_get_initialThisImage (void)
int	_XMPCO_get_initialNumImages (void)
int	_XMPCO_get_currentThisImage (void)
int	_XMPCO_get_currentNumImages (void)
MPI_Comm	_XMPCO_get_currentComm (void)
BOOL	_XMPCO_is_subset_exec (void)
int	_XMPCO_transImage_withComm (MPI_Comm comm1, int image1, MPI_Comm comm2)
int	_XMPCO_transImage_current2initial (int image)
int	_XMPCO_get_initial_image_withDescPtr (int image, CoarrayInfo_t *descPtr)
void	_XMPCO_clean_imageDirNodes (void)
void	_XMPCO_set_imageDirNodes (_XMP_nodes_t *nodes)
_XMP_nodes_t *	_XMPCO_get_imageDirNodes (void)
_XMP_nodes_t *	_XMPCO_consume_imageDirNodes (void)
MPI_Comm	_XMPCO_get_comm_of_nodes (_XMP_nodes_t *nodes)
int	_XMPCO_num_images_onNodes (_XMP_nodes_t *nodes)
int	_XMPCO_this_image_onNodes (_XMP_nodes_t *nodes)
MPI_Comm	_XMPCO_get_comm_current (void)
MPI_Comm	_XMPCO_consume_comm_current (void)
void	xmp_sync_memory (const int *status)
	Execute sync_memory() More...
void	xmp_sync_all (const int *status)
	Execute sync_all() More...
void	xmp_sync_image (int image, int *status)
	Execute sync_image() More...
void	xmp_sync_images (const int num, int *image_set, int *status)
	Execute sync_images() More...
void	xmp_sync_images_all (int *status)
	Execute sync_images_all() More...
void	_XMP_coarray_malloc_info_1 (const long, const size_t)
	Set 1-dim coarray information. More...
void	_XMP_coarray_malloc_image_info_1 ()
	Set 1-dim image information. More...
void	_XMP_coarray_malloc (void **, void *)
	Create coarray object and allocate coarray. More...
void	_XMP_coarray_regmem (void **, void *)
	Create coarray object but not allocate coarray. More...
void	_XMP_coarray_contiguous_put (const int, void *, const void *, const long, const long, const long, const long)
void	_XMP_coarray_contiguous_get (const int, void *, const void *, const long, const long, const long, const long)
void	_XMP_coarray_rdma_coarray_set_1 (const long, const long, const long)
	Set transfer 1-dim coarray information. More...
void	_XMP_coarray_rdma_array_set_1 (const long, const long, const long, const long, const size_t)
	Set transfer 1-dim array information. More...
void	_XMP_coarray_rdma_image_set_1 (const int)
	Set 1-dim image information. More...
void	_XMP_coarray_put (void *, void *, void *)
void	_XMP_coarray_get (void *, void *, void *)

Macro Definition Documentation

_ROUND_UP

#define _ROUND_UP	(		n,
			p
	)		(((((size_t)(n))-1)/(p)+1)*(p))

_ROUND_UP_PLUS

#define _ROUND_UP_PLUS	(		n,
			p
	)		(((n)>0) ? _ROUND_UP(n,p) : (p))

BOOL

#define BOOL   int

FALSE

#define FALSE   0

ROUND_UP_COMM

#define ROUND_UP_COMM

(

n

)

_ROUND_UP((n),COMM_UNIT)

ROUND_UP_MALLOC

#define ROUND_UP_MALLOC

(

n

)

_ROUND_UP_PLUS((n),MALLOC_UNIT)

TRUE

#define TRUE   1

Typedef Documentation

CoarrayInfo_t

typedef struct _coarrayInfo_t CoarrayInfo_t

MemoryChunk_t

typedef struct _memoryChunk_t MemoryChunk_t

MemoryChunkOrder_t

typedef struct _memoryChunkOrder_t MemoryChunkOrder_t

ResourceSet_t

typedef struct _resourceSet_t ResourceSet_t

SortedChunkTable_t

typedef struct _sortedChunkTable_t SortedChunkTable_t

SyncMode

typedef enum _SyncMode SyncMode

Enumeration Type Documentation

_SyncMode

enum _SyncMode

Enumerator
syncNONBLOCK
syncBLOCK
syncATOMIC
syncRUNTIME

               {
  syncNONBLOCK   = 0,
  syncBLOCK      = 1,
  syncATOMIC     = 2,
  syncRUNTIME    = 3
};

Function Documentation

_XMP_coarray_contiguous_get()

void _XMP_coarray_contiguous_get	(	const int	,
		void *	,
		const void *	,
		const long	,
		const long	,
		const long	,
		const long
	)

_XMP_coarray_contiguous_put()

void _XMP_coarray_contiguous_put	(	const int	,
		void *	,
		const void *	,
		const long	,
		const long	,
		const long	,
		const long
	)

_XMP_coarray_get()

void _XMP_coarray_get	(	void *	remote_coarray,
		void *	local_array,
		void *	local_coarray
	)

{
  if(_transfer_coarray_elmts == 0 || _transfer_array_elmts == 0) return;
 
  if(_transfer_coarray_elmts != _transfer_array_elmts && _transfer_coarray_elmts != 1){
    _XMP_fatal("Coarray Error ! transfer size is wrong.\n") ;
    // e.g. a[0:3] = b[0:2]:[3] is NG, but a[0:3] = b[0:1]:[3] is OK
  }
 
  int target_rank = 0;
  for(int i=0;i<_image_dims;i++)
    target_rank += ((_XMP_coarray_t*)remote_coarray)->distance_of_image_elmts[i] * _image_num[i];
 
  check_target_rank(target_rank);
  
  for(int i=0;i<_coarray_dims;i++){
    _coarray[i].elmts    = ((_XMP_coarray_t*)remote_coarray)->coarray_elmts[i];
    _coarray[i].distance = ((_XMP_coarray_t*)remote_coarray)->distance_of_coarray_elmts[i];
  }
 
  int remote_coarray_is_contiguous = _check_contiguous(_coarray, _coarray_dims, _transfer_coarray_elmts);
  int local_array_is_contiguous    = _check_contiguous(_array,   _array_dims,   _transfer_array_elmts);
 
  // _XMP_local_put(), _XMP_gasnet_put(), ... don't support to transfer long data size now.
  // _XMP_check_less_than_SIZE_MAX() checks whether the trasfer size is less than SIZE_MAX, defined in <limits.h>.
  size_t elmt_size  = ((_XMP_coarray_t*)remote_coarray)->elmt_size;
  _XMP_check_less_than_SIZE_MAX(_transfer_coarray_elmts*elmt_size); // fix me
  _XMP_check_less_than_SIZE_MAX(_transfer_array_elmts*elmt_size);   // fix me
 
  if(target_rank == _XMP_world_rank){
    _XMP_local_get(local_array, remote_coarray, local_array_is_contiguous, remote_coarray_is_contiguous,
                   _array_dims, _coarray_dims, _array, _coarray, (size_t)_transfer_array_elmts, (size_t)_transfer_coarray_elmts);
  }
  else{
#ifdef _XMP_GASNET
    _XMP_gasnet_get(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank,
                    _coarray_dims, _array_dims, _coarray, _array, remote_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_FJRDMA
    _XMP_fjrdma_get(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims,
                    _coarray, _array, remote_coarray, local_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_UTOFU
    _XMP_utofu_get(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims,
                    _coarray, _array, remote_coarray, local_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_MPI3_ONESIDED
    _XMP_mpi_get(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims,
                 _coarray, _array, remote_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts,
                 _XMP_N_INT_FALSE);
#endif
  }
 
  free(_coarray);
  free(_array);
  free(_image_num);
}

_XMP_coarray_malloc()

void _XMP_coarray_malloc	(	void **	coarray_desc,
		void *	addr
	)

Create coarray object and allocate coarray.

{
  _XMP_coarray_t* c = _XMP_alloc(sizeof(_XMP_coarray_t));
  _XMP_coarray_set_info(c);
  *coarray_desc = c;
 
  long transfer_size = _total_coarray_elmts*_elmt_size;
  _XMP_check_less_than_SIZE_MAX(transfer_size);
  
#ifdef _XMP_GASNET
  _XMP_gasnet_coarray_malloc(*coarray_desc, addr, (size_t)transfer_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_coarray_malloc(*coarray_desc, addr, (size_t)transfer_size);
#elif _XMP_UTOFU
  _XMP_utofu_coarray_malloc(*coarray_desc, addr, (size_t)transfer_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_coarray_malloc(*coarray_desc, addr, (size_t)transfer_size, false);
#endif
  
  _push_coarray_queue(c);
}

_XMP_coarray_malloc_image_info_1()

void _XMP_coarray_malloc_image_info_1

(

)

Set 1-dim image information.

{
  _image_dims     = 1;
  _image_elmts    = malloc(sizeof(int) * _image_dims);
  _image_elmts[0] = 1;
}

_XMP_coarray_malloc_info_1()

void _XMP_coarray_malloc_info_1	(	const long	n1,
		const	size_t
	)

Set 1-dim coarray information.

{
  _elmt_size           = elmt_size;
  _coarray_dims        = 1;
  _coarray_elmts       = malloc(sizeof(long) * _coarray_dims);
  _coarray_elmts[0]    = n1;
  _total_coarray_elmts = n1;
}

_XMP_coarray_put()

void _XMP_coarray_put	(	void *	remote_coarray,
		void *	local_array,
		void *	local_coarray
	)

{
  if(_transfer_coarray_elmts == 0 || _transfer_array_elmts == 0) return;
 
  if(_transfer_coarray_elmts != _transfer_array_elmts && _transfer_array_elmts != 1){
      _XMP_fatal("Coarray Error ! transfer size is wrong.\n");
    // e.g. a[0:3]:[3] = b[0:2] is NG, but a[0:3]:[3] = b[0:1] is OK.
  }
 
  int target_rank = 0;
  for(int i=0;i<_image_dims;i++)
    target_rank += ((_XMP_coarray_t*)remote_coarray)->distance_of_image_elmts[i] * _image_num[i];
 
  check_target_rank(target_rank);
  
  for(int i=0;i<_coarray_dims;i++){
    _coarray[i].elmts    = ((_XMP_coarray_t*)remote_coarray)->coarray_elmts[i];
    _coarray[i].distance = ((_XMP_coarray_t*)remote_coarray)->distance_of_coarray_elmts[i];
  }
 
  int remote_coarray_is_contiguous = _check_contiguous(_coarray, _coarray_dims, _transfer_coarray_elmts);
  int local_array_is_contiguous    = _check_contiguous(_array,   _array_dims,   _transfer_array_elmts); 
 
  // _XMP_local_put(), _XMP_gasnet_put(), ... don't support to transfer long data size now.
  // _XMP_check_less_than_SIZE_MAX() checks whether the trasfer size is less than SIZE_MAX, defined in <limits.h>.
  size_t elmt_size  = ((_XMP_coarray_t*)remote_coarray)->elmt_size;
  _XMP_check_less_than_SIZE_MAX(_transfer_coarray_elmts*elmt_size); // fix me
  _XMP_check_less_than_SIZE_MAX(_transfer_array_elmts*elmt_size);   // fix me
  
  if(target_rank == _XMP_world_rank){
    _XMP_local_put(remote_coarray, local_array, remote_coarray_is_contiguous, local_array_is_contiguous, 
                   _coarray_dims, _array_dims, _coarray, _array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
  }
  else{
#ifdef _XMP_GASNET
    _XMP_gasnet_put(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims, 
                    _coarray, _array, remote_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_FJRDMA
    _XMP_fjrdma_put(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims, 
                    _coarray, _array, remote_coarray, local_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_UTOFU
    _XMP_utofu_put(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims, 
                    _coarray, _array, remote_coarray, local_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts);
#elif _XMP_MPI3_ONESIDED
    _XMP_mpi_put(remote_coarray_is_contiguous, local_array_is_contiguous, target_rank, _coarray_dims, _array_dims,
                 _coarray, _array, remote_coarray, local_array, (size_t)_transfer_coarray_elmts, (size_t)_transfer_array_elmts,
                 _XMP_N_INT_FALSE);
#endif
  }
 
  free(_coarray);
  free(_array);
  free(_image_num);
}

_XMP_coarray_rdma_array_set_1()

void _XMP_coarray_rdma_array_set_1	(	const long	start1,
		const long	length1,
		const long	stride1,
		const long	elmts1,
		const	size_t
	)

Set transfer 1-dim array information.

{
  _transfer_array_elmts = length1;
  _array_dims           = 1;
  _array                = malloc(sizeof(_XMP_array_section_t) * _array_dims);
 
  _array[0].start       = start1;
  _array[0].length      = length1;
  _array[0].stride      = ((length1 == 1)? 1 : stride1);
  _array[0].elmts       = elmts1;
  _array[0].distance    = (long)elmt;
}

_XMP_coarray_rdma_coarray_set_1()

void _XMP_coarray_rdma_coarray_set_1	(	const long	start1,
		const long	length1,
		const long	stride1
	)

Set transfer 1-dim coarray information.

{
  _transfer_coarray_elmts = length1;
  _coarray_dims           = 1;
  _coarray                = malloc(sizeof(_XMP_array_section_t) * _coarray_dims);
 
  _coarray[0].start       = start1;
  _coarray[0].length      = length1;
  _coarray[0].stride      = ((length1 == 1)? 1 : stride1);
}

_XMP_coarray_rdma_image_set_1()

void _XMP_coarray_rdma_image_set_1

(

const int

n1

)

Set 1-dim image information.

{
  _image_dims   = 1;
  _image_num    = malloc(sizeof(int) * _image_dims);
  _image_num[0] = n1;
}

_XMP_coarray_regmem()

void _XMP_coarray_regmem	(	void **	coarray_desc,
		void *	addr
	)

Create coarray object but not allocate coarray.

{
  _XMP_coarray_t* c = _XMP_alloc(sizeof(_XMP_coarray_t));
  _XMP_coarray_set_info(c);
  *coarray_desc = c;
 
  long transfer_size = _total_coarray_elmts*_elmt_size;
  _XMP_check_less_than_SIZE_MAX(transfer_size);
  
#if _XMP_GASNET
  //not implemented
  _XMP_fatal("_XMP_coarray_regmem_do is not supported over GASNet.\n");
#elif _XMP_FJRDMA
  _XMP_fjrdma_regmem(*coarray_desc, addr, (size_t)transfer_size);
#elif _XMP_UTOFU
  _XMP_utofu_regmem(*coarray_desc, addr, (size_t)transfer_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_coarray_regmem(*coarray_desc, addr, (size_t)transfer_size, false);
#endif
 
  _push_coarray_queue(c);
}

_XMPCO_checkIfInTask()

void _XMPCO_checkIfInTask

(

char *

msgopt

)

{
  if (_XMPCO_nowInTask())
    _XMPCO_fatal("current restriction: "
                 "cannot use %s in any task construct\n", msgopt);
}

Here is the call graph for this function:

_XMPCO_clean_imageDirNodes()

void _XMPCO_clean_imageDirNodes

(

void

)

{
  _imageDirNodes = NULL;
}

_XMPCO_coarrayInit_get()

void _XMPCO_coarrayInit_get

(

void

)

{
  _localBuf_desc = _XMPCO_get_infoOfLocalBuf(&_localBuf_baseAddr,
                                              &_localBuf_offset,
                                              &_localBuf_name);
}

Here is the call graph for this function:

_XMPCO_coarrayInit_getsub()

void _XMPCO_coarrayInit_getsub

(

void

)

{
  _localBuf_desc = _XMPCO_get_infoOfLocalBuf(&_localBuf_baseAddr,
                                              &_localBuf_offset,
                                              &_localBuf_name);
  _localBuf_size = _XMPCO_get_localBufSize();
}

Here is the call graph for this function:

_XMPCO_coarrayInit_put()

void _XMPCO_coarrayInit_put

(

void

)

{
  _localBuf_desc = _XMPCO_get_infoOfLocalBuf(&_localBuf_baseAddr,
                                              &_localBuf_offset,
                                              &_localBuf_name);
  _localBuf_size = _XMPCO_get_localBufSize();
}

Here is the call graph for this function:

_XMPCO_consume_comm_current()

MPI_Comm _XMPCO_consume_comm_current

(

void

)

{
  _XMP_nodes_t *imageNodes = _XMPCO_consume_imageDirNodes();
  if (imageNodes != NULL)
    return *(MPI_Comm*)(imageNodes->comm);
 
  MPI_Comm *commp = (MPI_Comm*)(_XMP_get_execution_nodes()->comm);
  if (commp != NULL)
    return *commp;
  return MPI_COMM_WORLD;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_consume_imageDirNodes()

_XMP_nodes_t* _XMPCO_consume_imageDirNodes

(

void

)

{
  _XMP_nodes_t *ret = _imageDirNodes;
  _imageDirNodes = NULL;
  return ret;
}

Here is the caller graph for this function:

_XMPCO_debugPrint()

void _XMPCO_debugPrint	(	char *	format,
			...
	)

{
  int current, initial;
  char work[800];
 
  if (! _XMPCO_get_isMsgMode())
    return;
 
  va_list list;
  va_start(list, format);
  vsprintf(work, format, list);
  va_end(list);
 
  current = _XMPCO_get_currentThisImage();
  initial = _XMPCO_get_initialThisImage();
  if (current == initial)
    fprintf(stderr, "XMPCO[%d] %s", initial, work);
  else
    fprintf(stderr, "XMPCO[%d(current=%d)] %s", initial, current, work);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_fatal()

void _XMPCO_fatal	(	char *	format,
			...
	)

{
  int rank;
  char work[800];
 
  va_list list;
  va_start(list, format);
  vsprintf(work, format, list);
  va_end(list);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  fprintf(stderr, "XMPCO [rank=%d] %s\n", rank, work);
 
  _XMP_fatal("...fatal error in XMP/F Coarray runtime");
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_get_baseAddrOfCoarray()

char* _XMPCO_get_baseAddrOfCoarray

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->baseAddr;
}

_XMPCO_get_comm_current()

MPI_Comm _XMPCO_get_comm_current

(

void

)

{
  if (_imageDirNodes != NULL)
    return *(MPI_Comm*)(_imageDirNodes->comm);
 
  MPI_Comm *commp = (MPI_Comm*)(_XMP_get_execution_nodes()->comm);
  if (commp != NULL)
    return *commp;
  return MPI_COMM_WORLD;
}

_XMPCO_get_comm_fromCoarrayInfo()

MPI_Comm _XMPCO_get_comm_fromCoarrayInfo

(

CoarrayInfo_t *

cinfo

)

{
  if (cinfo == NULL)
    return MPI_COMM_NULL;
 
  _XMP_nodes_t *nodes = cinfo->nodes;
 
  if (nodes == NULL)
    return MPI_COMM_NULL;
 
  return *(MPI_Comm*)(nodes->comm);
}

Here is the caller graph for this function:

_XMPCO_get_comm_of_nodes()

MPI_Comm _XMPCO_get_comm_of_nodes

(

_XMP_nodes_t *

nodes

)

{
  if (!nodes->is_member)
    return MPI_COMM_NULL;
  return *(MPI_Comm*)(nodes->comm);
}

_XMPCO_get_currentComm()

MPI_Comm _XMPCO_get_currentComm

(

void

)

{
  MPI_Comm *commp;
  _XMP_nodes_t *nodes;
 
  if ((nodes = _XMPCO_get_imageDirNodes()) == NULL)
    nodes = _XMP_get_execution_nodes();
 
  commp = (MPI_Comm*)nodes->comm;
  return *commp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_get_currentNumImages()

int _XMPCO_get_currentNumImages

(

void

)

{
  _XMP_nodes_t *nodes;
 
  if ((nodes = _XMPCO_get_imageDirNodes()) == NULL)
    nodes = _XMP_get_execution_nodes();
 
  return nodes->comm_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_get_currentThisImage()

int _XMPCO_get_currentThisImage

(

void

)

{
  _XMP_nodes_t *nodes;
 
  if ((nodes = _XMPCO_get_imageDirNodes()) == NULL)
    nodes = _XMP_get_execution_nodes();
 
  return nodes->comm_rank + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_get_desc_fromLocalAddr()

void* _XMPCO_get_desc_fromLocalAddr	(	char *	localAddr,
		char **	orgAddr,
		size_t *	offset,
		char **	name
	)

{
  MemoryChunk_t* chunk = _findMemoryChunkInSortedChunkTable(localAddr);
  if (chunk == NULL) {
    *orgAddr = NULL;
    *offset = 0;
    *name = "(not found)";
    return NULL;
  }
 
  *orgAddr = chunk->orgAddr;
  *offset = localAddr - *orgAddr;
  *name = chunk->headCoarray->next->name;
  return chunk->desc;
}

Here is the caller graph for this function:

_XMPCO_get_descForMemoryChunk()

void* _XMPCO_get_descForMemoryChunk

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->parent->desc;
}

Here is the caller graph for this function:

_XMPCO_get_imageDirNodes()

_XMP_nodes_t* _XMPCO_get_imageDirNodes

(

void

)

{
  return _imageDirNodes;
}

Here is the caller graph for this function:

_XMPCO_get_infoOfCtrlData()

void* _XMPCO_get_infoOfCtrlData	(	char **	baseAddr,
		size_t *	offset,
		char **	name
	)

{
  MemoryChunk_t *chunk = _cinfo_ctrlData->parent;
  char *orgAddr = chunk->orgAddr;                    // origin address of the memory pool
 
  *baseAddr = _cinfo_ctrlData->baseAddr;             // base address of the control data
  *offset = orgAddr - *baseAddr;                     // offset of the control data in the memory pool
  *name = _cinfo_ctrlData->name;                     // name of the control data
  return chunk->desc;                                // descriptor of the memory pool
}

_XMPCO_get_infoOfLocalBuf()

void* _XMPCO_get_infoOfLocalBuf	(	char **	baseAddr,
		size_t *	offset,
		char **	name
	)

{
  MemoryChunk_t *chunk = _cinfo_localBuf->parent;
  char *orgAddr = chunk->orgAddr;                    // origin address of the memory pool
 
  *baseAddr = _cinfo_localBuf->baseAddr;             // base address of the local buffer
  *offset = orgAddr - *baseAddr;                     // offset of the local buffer in the memory pool
  *name = _cinfo_localBuf->name;                     // name of the local buffer
  return chunk->desc;                                // descriptor of the memory pool
}

Here is the caller graph for this function:

_XMPCO_get_initial_image_withDescPtr()

int _XMPCO_get_initial_image_withDescPtr	(	int	image,
		CoarrayInfo_t *	descPtr
	)

{
  if (descPtr == NULL)
    return _XMPCO_transImage_current2initial(image);
 
  MPI_Comm nodesComm =
    _XMPCO_get_comm_fromCoarrayInfo(descPtr);
  if (nodesComm == MPI_COMM_NULL)
    return _XMPCO_transImage_current2initial(image);
 
  // The coarray is specified with a COARRAY directive.
 
  int initImage =  _XMPCO_transImage_withComm(nodesComm, image,
                                             MPI_COMM_WORLD);
 
  _XMPCO_debugPrint("*** got the initial image (%d) from the image mapping to nodes (%d)\n",
                    initImage, image);
 
  return initImage;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_get_initialNumImages()

int _XMPCO_get_initialNumImages

(

void

)

{
  return _initialNumImages;
}

Here is the caller graph for this function:

_XMPCO_get_initialThisImage()

int _XMPCO_get_initialThisImage

(

void

)

{
  return _initialThisImage;
}

Here is the caller graph for this function:

_XMPCO_get_isEagerCommMode()

BOOL _XMPCO_get_isEagerCommMode

(

void

)

{ return _isEagerCommMode; }

Here is the caller graph for this function:

_XMPCO_get_isMsgMode()

BOOL _XMPCO_get_isMsgMode

(

void

)

{ return _isMsgMode; }

Here is the caller graph for this function:

_XMPCO_get_isSafeBufferMode()

BOOL _XMPCO_get_isSafeBufferMode

(

void

)

{ return _isSafeBufferMode; }

_XMPCO_get_isSyncPutMode()

BOOL _XMPCO_get_isSyncPutMode

(

void

)

{ return _isSyncPutMode; }

_XMPCO_get_localBufSize()

size_t _XMPCO_get_localBufSize

(

void

)

{ return _localBufSize; }

Here is the caller graph for this function:

_XMPCO_get_nameOfCoarray()

char* _XMPCO_get_nameOfCoarray

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->name;
}

Here is the caller graph for this function:

_XMPCO_get_offsetInCoarray()

size_t _XMPCO_get_offsetInCoarray	(	CoarrayInfo_t *	cinfo,
		char *	addr
	)

{
  size_t offset = addr - cinfo->baseAddr;
  return offset;
}

_XMPCO_get_offsetInMemoryChunk()

size_t _XMPCO_get_offsetInMemoryChunk	(	CoarrayInfo_t *	cinfo,
		char *	addr
	)

{
  char* orgAddr = cinfo->parent->orgAddr;
  size_t offset = addr - orgAddr;
  return offset;
}

Here is the caller graph for this function:

_XMPCO_get_orgAddrOfMemoryChunk()

char* _XMPCO_get_orgAddrOfMemoryChunk

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->parent->orgAddr;
}

Here is the caller graph for this function:

_XMPCO_get_poolThreshold()

unsigned _XMPCO_get_poolThreshold

(

void

)

{ return _poolThreshold; }

Here is the caller graph for this function:

_XMPCO_get_sizeOfCoarray()

size_t _XMPCO_get_sizeOfCoarray

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->size;
}

_XMPCO_get_sizeOfMemoryChunk()

size_t _XMPCO_get_sizeOfMemoryChunk

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->parent->nbytes;
}

Here is the caller graph for this function:

_XMPCO_is_subset_exec()

BOOL _XMPCO_is_subset_exec

(

void

)

{
  if (_XMPCO_get_currentNumImages() < _initialNumImages)
    // now executing in a task region
    return TRUE;
  if (_XMPCO_get_imageDirNodes() != NULL)
    // image directive is now valid
    return TRUE;
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_isAddrInMemoryChunk()

BOOL _XMPCO_isAddrInMemoryChunk	(	char *	localAddr,
		CoarrayInfo_t *	cinfo
	)

{
  char *orgAddr = _XMPCO_get_orgAddrOfMemoryChunk(cinfo);
  size_t size = _XMPCO_get_sizeOfMemoryChunk(cinfo);
  size_t offset = localAddr - orgAddr;
  BOOL result = (offset < size);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_nowInTask()

int _XMPCO_nowInTask

(

void

)

{
  return _XMPCO_get_currentNumImages() < _XMPCO_get_initialNumImages();
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_num_images_onNodes()

int _XMPCO_num_images_onNodes

(

_XMP_nodes_t *

nodes

)

{
  return nodes->comm_size;
}

_XMPCO_reset_isMsgMode()

void _XMPCO_reset_isMsgMode

(

void

)

{
  _isMsgMode = _isMsgMode_last;
}

_XMPCO_set_codim_withBounds()

void _XMPCO_set_codim_withBounds	(	CoarrayInfo_t *	cp,
		int	dim,
		int	lb,
		int	ub
	)

{
  int i, count, n_images, size;
 
  if (0 <= dim && dim < cp->corank - 1) {        // not last dimension
    cp->lcobound[dim] = lb;
    cp->ucobound[dim] = ub;
    size = ub - lb + 1;
    cp->cosize[dim] = size;
    if (cp->cosize[dim] <= 0)
      _XMPCO_fatal("upper cobound less than lower cobound");
  }
  else if (dim == cp->corank - 1) {   // last dimension
    // ub is ignored. 
    cp->lcobound[dim] = lb;
    n_images = _XMPCO_get_currentNumImages();
    for (i = 0, count = 1; i < cp->corank - 1; i++)
      count *= cp->cosize[i];
    size = DIV_CEILING(n_images, count);
    cp->cosize[dim] = size;
    cp->ucobound[dim] = lb + size - 1;
  }
  else {                               // illegal
    _XMPCO_fatal("spedified dim (%d) is too large or less than zero.\n", dim);
  }
}

Here is the call graph for this function:

_XMPCO_set_codim_withSize()

void _XMPCO_set_codim_withSize	(	CoarrayInfo_t *	cp,
		int	dim,
		int	lb,
		int	size
	)

{
  int i, count, n_images, ub;
 
  if (0 <= dim && dim < cp->corank - 1) {        // not last dimension
    if (size < 0)
      _XMPCO_fatal("Size should not be less than zero.");
    cp->lcobound[dim] = lb;
    cp->cosize[dim] = size;
    ub = lb + size - 1;
    cp->ucobound[dim] = ub;
  }
  else if (dim == cp->corank - 1) {   // last dimension
    // size is ignored. 
    cp->lcobound[dim] = lb;
    n_images = _XMPCO_get_currentNumImages();
    for (i = 0, count = 1; i < cp->corank - 1; i++)
      count *= cp->cosize[i];
    size = DIV_CEILING(n_images, count);
    cp->cosize[dim] = size;
    cp->ucobound[dim] = lb + size - 1;
  }
  else {   // last dimension or more
    _XMPCO_fatal("Spedified dim (%d) is too large or less than zero.\n", dim);
  }
}

Here is the call graph for this function:

_XMPCO_set_corank()

void _XMPCO_set_corank	(	CoarrayInfo_t *	cp,
		int	corank
	)

{
  cp->corank = corank;
  cp->lcobound = (int*)_MALLOC(sizeof(int) * corank);
  cp->ucobound = (int*)_MALLOC(sizeof(int) * corank);
  cp->cosize = (int*)_MALLOC(sizeof(int) * corank);
 
  _XMPCO_debugPrint("*** set corank of CoarrayInfo %s, corank=%d\n",
                          _dispCoarrayInfo(cp), cp->corank);
}

_XMPCO_set_imageDirNodes()

void _XMPCO_set_imageDirNodes

(

_XMP_nodes_t *

nodes

)

{
  if (_imageDirNodes != NULL)
    _XMP_fatal("INTERNAL: _imageDirNodes was not consumed but is defined.");
  _imageDirNodes = nodes;
 
  _XMPCO_debugPrint("SET _imageDirNodes (%d nodes) done.\n", nodes->comm_size);
}

_XMPCO_set_initialNumImages()

void _XMPCO_set_initialNumImages

(

void

)

{
  int size;
 
  if (MPI_Comm_size(MPI_COMM_WORLD, &size) != 0)
    _XMPCO_fatal("INTERNAL ERROR: "
                 "MPI_Comm_size(MPI_COMM_WORLD, ) failed");
  _initialNumImages = size;
}

Here is the call graph for this function:

_XMPCO_set_initialThisImage()

void _XMPCO_set_initialThisImage

(

void

)

{
  int rank;
 
  if (MPI_Comm_rank(MPI_COMM_WORLD, &rank) != 0)
    _XMPCO_fatal("INTERNAL ERROR: "
                 "MPI_Comm_rank(MPI_COMM_WORLD, ) failed");
 
  _initialThisImage = rank + 1;
}

Here is the call graph for this function:

_XMPCO_set_isEagerCommMode()

void _XMPCO_set_isEagerCommMode

(

BOOL

sw

)

{ _isEagerCommMode = sw; }

_XMPCO_set_isMsgMode()

void _XMPCO_set_isMsgMode

(

BOOL

sw

)

{
  _isMsgMode_last = _isMsgMode;
 
  switch (sw) {
  case FALSE:
  default:
    if (_XMPCO_get_isMsgMode())
      _XMPCO_debugPrint("Switch off _isMsgMode. Bye!\n");
    _isMsgMode = FALSE;
    return;
 
  case TRUE:
    if (_XMPCO_get_isMsgMode() == 0)
      _XMPCO_debugPrint("Switch on _isMsgMode.\n");
    _isMsgMode = TRUE;
    break;
  }
}

_XMPCO_set_isMsgMode_quietly()

void _XMPCO_set_isMsgMode_quietly

(

BOOL

sw

)

{
  _isMsgMode_last = _isMsgMode;
  _isMsgMode = sw;
}

_XMPCO_set_isSafeBufferMode()

void _XMPCO_set_isSafeBufferMode

(

BOOL

sw

)

{ _isSafeBufferMode = sw; }

_XMPCO_set_isSyncPutMode()

void _XMPCO_set_isSyncPutMode

(

BOOL

sw

)

{ _isSyncPutMode = sw; }

_XMPCO_set_localBufSize()

void _XMPCO_set_localBufSize

(

unsigned

size

)

{
  unsigned sizeRU = ROUND_UP_MALLOC(size);
 
  _localBufSize = sizeRU;
 
  _XMPCO_debugPrint("set _localBufSize = %u\n",
                          _localBufSize);
}

_XMPCO_set_nodes()

CoarrayInfo_t* _XMPCO_set_nodes	(	CoarrayInfo_t *	cinfo,
		_XMP_nodes_t *	nodes
	)

{
  if (cinfo != NULL) {
    cinfo->nodes = nodes;
    return cinfo;
  }
 
  CoarrayInfo_t* cinfo1 = _newCoarrayInfo_empty();
  cinfo1->nodes = nodes;
  return cinfo1;
}

_XMPCO_set_poolThreshold()

void _XMPCO_set_poolThreshold

(

unsigned

size

)

{
  _poolThreshold = size;
 
  _XMPCO_debugPrint("set _poolThreshold = %u\n",
                          _poolThreshold);
}

_XMPCO_set_varname()

void _XMPCO_set_varname	(	CoarrayInfo_t *	cp,
		int	namelen,
		char *	name
	)

{
  cp->name = _xmp_strndup(name, namelen);
  _XMPCO_debugPrint("*** set name of CoarrayInfo %s\n",
                          _dispCoarrayInfo(cp));
}

_XMPCO_this_image_onNodes()

int _XMPCO_this_image_onNodes

(

_XMP_nodes_t *

nodes

)

{
  if (!nodes->is_member)
    return 0;   // This image is out of the node.
  return nodes->comm_rank + 1;
}

Here is the caller graph for this function:

_XMPCO_transImage_current2initial()

int _XMPCO_transImage_current2initial

(

int

image

)

{
  int num = _XMPCO_get_currentNumImages();
 
  if (image <= 0 || num < image)
    _XMPCO_fatal("ERROR: image index (%d) not specified within the range (1 to %d)\n",
                       image, num);
 
  if (!_XMPCO_is_subset_exec())
    return image;
 
  int initImage = _XMPCO_transImage_withComm(_XMPCO_get_currentComm(), image,
                                             MPI_COMM_WORLD);
 
  _XMPCO_debugPrint("*** got the initial image (%d) from the current image (%d)\n",
                    initImage, image);
 
  return initImage;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMPCO_transImage_withComm()

int _XMPCO_transImage_withComm	(	MPI_Comm	comm1,
		int	image1,
		MPI_Comm	comm2
	)

{
  int image2, rank1, rank2;
  MPI_Group group1, group2;
  int stat1, stat2, stat3;
 
  rank1 = image1 - 1;
  stat1 = MPI_Comm_group(comm1, &group1);
  stat2 = MPI_Comm_group(comm2, &group2);
  _XMPCO_debugPrint("gege comm1=%d, comm2=%d, image1=%d\n", comm1, comm2, image1);
 
  stat3 = MPI_Group_translate_ranks(group1, 1, &rank1, group2, &rank2);
  //                           (in:Group1, n, rank1[n], Group2, out:rank2[n])
  if (rank2 == MPI_UNDEFINED)
    image2 = 0;
  else 
    image2 = rank2 + 1;
 
  if (stat1 != 0 || stat2 != 0 || stat3 != 0)
    _XMPCO_fatal("INTERNAL: _transimage_withComm failed with "
                       "stat1=%d, stat2=%d, stat3=%d",
                       stat1, stat2, stat3);
 
  _XMPCO_debugPrint("***IMAGE NUMBER translated from %d to %d\n",
                          image1, image2);
 
  return image2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmp_coarray_allocated_bytes()

size_t xmp_coarray_allocated_bytes

(

void

)

{
  MemoryChunkOrder_t *chunkp;
  MemoryChunk_t *chunk;
  size_t size, size1;
 
  // sum all sizes of MemoryChunks
  size = 0;
  forallMemoryChunkOrder(chunkp) {
    chunk = chunkp->chunk;
    size1 = size + chunk->nbytes;
    if (size1 < size)
      _XMPCO_fatal("More than %llu-bytes of memory required for static coarrays\n",
                         ~(size_t)0 );
    size = size1;
  }
 
  // subtract the size of the localBuf and ctrlData CoarrayInfos
  // because this is not allocated by the user
  size -= _cinfo_ctrlData->size + _cinfo_localBuf->size;
 
  return size;
}

Here is the call graph for this function:

xmp_coarray_garbage_bytes()

size_t xmp_coarray_garbage_bytes

(

void

)

{
  MemoryChunkOrder_t *chunkp;
  MemoryChunk_t *chunk;
  size_t size;
 
  size = 0;
  forallMemoryChunkOrder(chunkp) {
    chunk = chunkp->chunk;
    if (chunk->isGarbage)
      size += chunk->nbytes;
  }
 
  return size;
}

xmp_coarray_malloc_bytes()

size_t xmp_coarray_malloc_bytes

(

void

)

{
  return _mallocSize;
}

xmp_sync_all()

void xmp_sync_all

(

const int *

status

)

Execute sync_all()

{
#ifdef _XMP_GASNET
  _XMP_gasnet_sync_all();
#elif _XMP_FJRDMA
  _XMP_fjrdma_sync_all();
#elif _XMP_UTOFU
  _XMP_utofu_sync_all();
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_sync_all();
#endif
}

xmp_sync_image()

void xmp_sync_image	(	int	image,
		int *	status
	)

Execute sync_image()

{
  xmp_sync_images(1, &image, status);
}

xmp_sync_images()

void xmp_sync_images	(	const int	num,
		int *	image_set,
		int *	status
	)

Execute sync_images()

{
#ifdef _XMP_GASNET
  _XMP_gasnet_sync_images(num, image_set, status);
#elif _XMP_FJRDMA
  _XMP_fjrdma_sync_images(num, image_set, status);
#elif _XMP_UTOFU
  _XMP_utofu_sync_images(num, image_set, status);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_sync_images(num, image_set, status);
#endif
}

Here is the caller graph for this function:

xmp_sync_images_all()

void xmp_sync_images_all

(

int *

status

)

Execute sync_images_all()

{
  _XMP_fatal("Not implement xmp_sync_images_all()");
}

xmp_sync_memory()

void xmp_sync_memory

(

const int *

status

)

Execute sync_memory()

{
#ifdef _XMP_GASNET
  _XMP_gasnet_sync_memory();
#elif _XMP_FJRDMA
  _XMP_fjrdma_sync_memory();
#elif _XMP_UTOFU
  _XMP_utofu_sync_memory();
#elif _XMP_TCA
  _XMP_tca_sync_memory();
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_sync_memory();
#endif
}

XMPCO_count_size()

void XMPCO_count_size	(	int	count,
		size_t	element
	)

{
  size_t thisSize = count * element;
  size_t mallocSize = ROUND_UP_MALLOC(thisSize);
 
  if (mallocSize > _XMPCO_get_poolThreshold()) {
    _XMPCO_debugPrint("XMPCO_COUNT_SIZE_: no count because of the large size\n"
                            "  pooling threshold :%10u bytes\n"
                            "  data size         :%10u bytes\n",
                            _XMPCO_get_poolThreshold(), mallocSize);
    return;
  }
 
  pool_totalSize += mallocSize;
  _XMPCO_debugPrint("XMPCO_COUNT_SIZE_: count up\n"
                          "  %u bytes, totally %u bytes\n",
                          mallocSize, pool_totalSize);
}

Here is the call graph for this function:

XMPCO_deregmem_coarray()

void XMPCO_deregmem_coarray

(

CoarrayInfo_t *

cinfo

)

{
  MemoryChunk_t *chunk = cinfo->parent;
 
  // SYNCALL_AUTO
  XMPCO_sync_all_auto();
 
  _XMPCO_debugPrint("_XMPCO_DEREGMEM_COARRAY for MemoryChunk %s\n",
                          _dispMemoryChunk(chunk));
 
  // unlink and free CoarrayInfo keeping MemoryChunk
  _unlinkCoarrayInfo(cinfo);
  _freeCoarrayInfo(cinfo);
 
  if (IsEmptyMemoryChunk(chunk)) {
    // unlink this memory chunk
    _unlinkMemoryChunk(chunk);
  }
}

Here is the call graph for this function:

XMPCO_epilog()

void XMPCO_epilog

(

ResourceSet_t **

rset

)

{
  if (*rsetp == NULL)
    return;
 
  _XMPCO_debugPrint("XMPCO_EPILOG_ (procedure name=\'%s\', *rsetp=%p)\n",
                          (*rsetp)->name, *rsetp);
 
  _freeResourceSet(*rsetp);     // with or without automatic SYNCALL
  *rsetp = NULL;
}

Here is the call graph for this function:

XMPCO_find_descptr()

CoarrayInfo_t* XMPCO_find_descptr	(	char *	addr,
		int	namelen,
		char *	name
	)

generate and return a descriptor for a coarray DUMMY ARGUMENT

1. find the memory chunk that contains the coarray data object,
2. generate coarrayInfo for the coarray dummy argument and link it to the memory chunk, and
3. return coarrayInfo as descPtr

{
  MemoryChunk_t *myChunk;
 
  _XMPCO_debugPrint("_XMF_CO_FIND_DESCPTR_ "
                          "(varname=\'%.*s\')\n",
                          namelen, name);
 
  // generate a new descPtr for an allocatable dummy coarray
  CoarrayInfo_t *cinfo = _newCoarrayInfo_empty();
 
  // search my MemoryChunk only from addr
  myChunk = _findMemoryChunkInSortedChunkTable(addr);
 
  if (myChunk != NULL) {
    _XMPCO_debugPrint("*** found my home MemoryChunk %s\n",
                            _dispMemoryChunk(myChunk));
    // return coarrayInfo as descPtr
    _addCoarrayInfo(myChunk, cinfo);
    return cinfo;
  }
 
  _XMPCO_debugPrint("*** found no MemoryChunk of mine\n");
  return NULL;
}

Here is the call graph for this function:

XMPCO_free_coarray()

void XMPCO_free_coarray

(

CoarrayInfo_t *

cinfo

)

{
  MemoryChunk_t *chunk = cinfo->parent;
 
  // SYNCALL_AUTO
  XMPCO_sync_all_auto();
 
  _XMPCO_debugPrint("_XMPCO_FREE_COARRAY for MemoryChunk %s\n",
                          _dispMemoryChunk(chunk));
 
  // unlink and free CoarrayInfo keeping MemoryChunk
  _unlinkCoarrayInfo(cinfo);
  _freeCoarrayInfo(cinfo);
 
  if (IsEmptyMemoryChunk(chunk)) {
    // unlink this memory chunk as a garbage
    _unlinkMemoryChunk(chunk);
    // now chance to cellect and free garbages
    _garbageCollectMallocHistory();
  }
}

Here is the call graph for this function:

XMPCO_GET_arrayExpr()

void XMPCO_GET_arrayExpr	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	result,
		int	rank,
		int	skip[],
		int	count[]
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  if (element % COMM_UNIT != 0) {
    _XMPCO_fatal("violation of boundary in reference of a coindexed object\n"
              "  xmpf_coarray_get_array_, " __FILE__);
    return;
  }
 
  /*--------------------------------------*\
   * Confirm that baseAddr is located in  *
   * the memory chunk corresponding to    *
   * descptr.                             *
  \*--------------------------------------*/
  BOOL pass = _XMPCO_isAddrInMemoryChunk(baseAddr, descPtr);
  if (!pass) {
    _XMPCO_fatal("INTERNAL : illegal baseAddr of mold coarray (in xmpf_coarray_get_array_)\n"
                       "  possibly because of unexpected copy-in interface\n"
                       "  coarray_name=\"%s\", chunk_size=%ud; offset_in_chunk=%ud",
                       _XMPCO_get_nameOfCoarray(descPtr),
                       (unsigned)_XMPCO_get_sizeOfMemoryChunk(descPtr),
                       (unsigned)_XMPCO_get_offsetInMemoryChunk(descPtr, baseAddr));
  }
 
  /*--------------------------------------*\
   * Check whether the local address      *
   * result is already registered for DMA *
   * and, if so, get the descriptor, etc. *
  \*--------------------------------------*/
  void *descDMA;
  size_t offsetDMA;
  char *orgAddrDMA;
  char *nameDMA;
  BOOL avail_DMA;
 
  descDMA = _XMPCO_get_isEagerCommMode() ? NULL :
      _XMPCO_get_desc_fromLocalAddr(result, &orgAddrDMA, &offsetDMA, &nameDMA);
  avail_DMA = descDMA ? TRUE : FALSE;
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  int scheme = _select_scheme_get_array(avail_DMA);
 
  /*--------------------------------------*\
   * action                               *
  \*--------------------------------------*/
  switch (scheme) {
  case SCHEME_DirectGet:
    _XMPCO_debugPrint("select SCHEME_DirectGet/array\n");
    _getCoarray(descPtr, baseAddr, coindex0, result,
                element, rank, skip, count,
                descDMA, offsetDMA, nameDMA);
    break;
 
  case SCHEME_BufferGet:
    _XMPCO_debugPrint("select SCHEME_BufferGet/array\n");
    _getCoarray(descPtr, baseAddr, coindex0, result,
                element, rank, skip, count,
                NULL, 0, "(localBuf)");
    break;
 
  default:
    _XMPCO_fatal("undefined scheme number in " __FILE__);
  }
}

Here is the call graph for this function:

XMPCO_GET_arrayStmt()

void XMPCO_GET_arrayStmt	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	localAddr,
		int	rank,
		int	skip[],
		int	skip_local[],
		int	count[]
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  if (element % COMM_UNIT != 0) {
    _XMPCO_fatal("violation of boundary writing to a coindexed variable\n"
               "  xmpf_coarray_getsub_array_, " __FILE__);
    return;
  }
 
  /*--------------------------------------*\
   * Check whether the local address local  *
   * is already registered for DMA and,   *
   * if so, get the descriptor, etc.      *
  \*--------------------------------------*/
  void *descDMA;
  size_t offsetDMA;
  char *orgAddrDMA;
  char *nameDMA;
  BOOL avail_DMA;
 
  descDMA = _XMPCO_get_isEagerCommMode() ? NULL :
      _XMPCO_get_desc_fromLocalAddr(localAddr, &orgAddrDMA, &offsetDMA, &nameDMA);
  avail_DMA = descDMA ? TRUE : FALSE;
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  int scheme = _select_scheme_getsub_array(avail_DMA);
 
  /*--------------------------------------*\
   * action                               *
  \*--------------------------------------*/
  switch (scheme) {
  case SCHEME_DirectGetsub:
    _XMPCO_debugPrint("SCHEME_DirectGetsub/array selected\n");
    _getsubCoarray_DMA(descPtr, baseAddr, coindex0, localAddr,
                    element, rank, skip, skip_local, count,
                    descDMA, offsetDMA, nameDMA);
    break;
 
  case SCHEME_BufferGetsub:
    _XMPCO_debugPrint("SCHEME_BufferGetsub/array selected\n");
    _getsubCoarray_buffer(descPtr, baseAddr, coindex0, localAddr,
                       element, rank, skip, skip_local, count);
    break;
 
  default:
    _XMPCO_fatal("unexpected scheme number in " __FILE__);
  }
}

Here is the call graph for this function:

XMPCO_GET_scalarExpr()

void XMPCO_GET_scalarExpr	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	result
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  /*--------------------------------------*\
   * Confirm that *baseAddr is located in *
   * the memory chunk corresponding to    *
   * descptr.                             *
  \*--------------------------------------*/
  BOOL pass = _XMPCO_isAddrInMemoryChunk(baseAddr, descPtr);
  if (!pass) {
    _XMPCO_fatal("INTERNAL: illegal baseAddr of mold coarray (in xmpf_coarray_get_scalar_)\n"
                       "  possibly because of unexpected copy-in interface\n"
                       "  coarray_name=\"%s\", chunk_size=%ud; offset_in_chunk=%ud",
                       _XMPCO_get_nameOfCoarray(descPtr),
                       (unsigned)_XMPCO_get_sizeOfMemoryChunk(descPtr),
                       (unsigned)_XMPCO_get_offsetInMemoryChunk(descPtr, baseAddr));
  }
 
  /*--------------------------------------*\
   * Check whether the local address      *
   * result is already registered for DMA *
   * and, if so, get the descriptor, etc. *
  \*--------------------------------------*/
  void *descDMA;
  size_t offsetDMA;
  char *orgAddrDMA;
  char *nameDMA;
  BOOL avail_DMA;
 
  descDMA = _XMPCO_get_isEagerCommMode() ? NULL :
      _XMPCO_get_desc_fromLocalAddr(result, &orgAddrDMA, &offsetDMA, &nameDMA);
  avail_DMA = descDMA ? TRUE : FALSE;
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  int scheme = _select_scheme_get_scalar(element, avail_DMA);
 
  switch (scheme) {
  case SCHEME_DirectGet:
    _XMPCO_debugPrint("SCHEME_DirectGet/scalar selected\n");
 
    assert(avail_DMA);
    _XMPCO_getVector_DMA(descPtr, baseAddr, element, coindex0,
                   descDMA, offsetDMA, nameDMA);
    break;
 
  case SCHEME_BufferGet:
    _XMPCO_debugPrint("select SCHEME_BufferGet/scalar\n");
 
    _XMPCO_getVector_buffer(descPtr, baseAddr, element, coindex0,
                      result, element);
    break;
 
  case SCHEME_ExtraBufferGet:
    {
      size_t elementRU = ROUND_UP_COMM(element);
 
      _XMPCO_debugPrint("select SCHEME_ExtraBufferGet/scalar. elementRU=%ud\n",
                              elementRU);
 
      _XMPCO_getVector_buffer(descPtr, baseAddr, elementRU, coindex0,
                        result, element);
    }
    break;
 
  default:
    _XMPCO_fatal("undefined scheme number in " __FILE__);
  }
}

Here is the call graph for this function:

XMPCO_malloc_coarray()

CoarrayInfo_t* XMPCO_malloc_coarray	(	char **	addr,
		int	count,
		size_t	element,
		ResourceSet_t *	rset
	)

{
  size_t nbytes = count * element;
 
  _XMPCO_debugPrint("_XMPCO_MALLOC_COARRAY\n");
 
  // malloc
  MemoryChunk_t *chunk = _mallocMemoryChunk(count, element);
  _XMPCO_debugPrint("*** new MemoryChunk %s\n",
                          _dispMemoryChunk(chunk));
 
  if (rset != NULL) {
    _addMemoryChunkInResourceSet(rset, chunk);
 
    _XMPCO_debugPrint("*** MemoryChunk %s added to rset=%p\n",
                            _dispMemoryChunk(chunk), rset);
  }
 
  // make coarrayInfo and linkage
  CoarrayInfo_t *cinfo = _newCoarrayInfo(chunk->orgAddr, nbytes);
 
  _addCoarrayInfo(chunk, cinfo);
 
  *addr = cinfo->baseAddr;   // == chunk->orgAddr
  return cinfo;
}

Here is the call graph for this function:

XMPCO_malloc_pool()

void XMPCO_malloc_pool

(

void

)

{
  size_t ctrlDataSize = sizeof(int) * 8;
  size_t localBufSize = _XMPCO_get_localBufSize();
 
  _XMPCO_debugPrint("XMPCO_MALLOC_POOL_ contains:\n"
                          "  system-defined local buffer :%10u bytes\n"
                          "  system-defined control data :%10u bytes\n"
                          "  user-defined coarays        :%10u bytes\n",
                          localBufSize, ctrlDataSize, pool_totalSize);
 
  pool_totalSize += localBufSize + ctrlDataSize;
 
  // init malloc/free history (STRUCTURE-II)
  _initMallocHistory();
 
  // init sorted chunk table (STRUCTURE-III)
  _initSortedChunkTable();
 
  // malloc the pool
  pool_chunk = _mallocMemoryChunk(1, pool_totalSize);
  pool_currentAddr = pool_chunk->orgAddr;
 
  // share communication buffer in the pool
  _cinfo_localBuf = _getShareOfStaticCoarray(localBufSize);
  _cinfo_localBuf->name = "(localBuf)";
  _setSimpleCoshapeToCoarrayInfo(_cinfo_localBuf);
 
  // share control data area in the pool
  _cinfo_ctrlData = _getShareOfStaticCoarray(ctrlDataSize);
  _cinfo_ctrlData->name = "(ctrlData)";
  _setSimpleCoshapeToCoarrayInfo(_cinfo_ctrlData);
}

Here is the call graph for this function:

XMPCO_malloc_staticCoarray()

CoarrayInfo_t* XMPCO_malloc_staticCoarray	(	char **	addr,
		int	count,
		size_t	element,
		int	namelen,
		char *	name
	)

have a share of memory in the pool (if not larger than threshold) or allocate individually (if larger than threshold) out: return : pointer to descriptor CoarrayInfo_t addr : address of the coarray object to be allocated in: count : count of elements element: element size namelen: character length of name (for debugging) name : name of the coarray (for debugging)

{
  size_t nbytes = count * element;
  CoarrayInfo_t *cinfo;
 
  _XMPCO_debugPrint("_XMPCO_ALLOC_STATIC_COARRAY varname=\'%.*s\'\n"
                          "  count=%d, element=%d, nbytes=%u\n",
                          namelen, name, count, element, nbytes);
 
  if (nbytes > _XMPCO_get_poolThreshold()) {
    _XMPCO_debugPrint("*** LARGER (%u bytes) than threshold\n", nbytes);
    cinfo = _allocLargeStaticCoarray(nbytes);
  } else {
    size_t nbytesRU = ROUND_UP_MALLOC(nbytes);
    _XMPCO_debugPrint("*** Not LARGER (%u bytes) than threshold\n", nbytesRU);
    cinfo = _getShareOfStaticCoarray(nbytesRU);
  }
  cinfo->name = _xmp_strndup(name, namelen);
 
  *addr = cinfo->baseAddr;
  return cinfo;
}

Here is the call graph for this function:

XMPCO_prolog()

void XMPCO_prolog	(	ResourceSet_t **	rset,
		int	namelen,
		char *	name
	)

{
  *rsetp = _newResourceSet(name, namelen);
 
  _XMPCO_debugPrint("XMPCO_PROLOG (procedure name=\'%s\', *rsetp=%p)\n",
                          (*rsetp)->name, *rsetp);
}

XMPCO_PUT_arrayStmt()

void XMPCO_PUT_arrayStmt	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	rhsAddr,
		int	rank,
		int	skip[],
		int	skip_rhs[],
		int	count[],
		SyncMode	sync_mode
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  if (element % COMM_UNIT != 0) {
    _XMPCO_fatal("violation of boundary writing to a coindexed variable\n"
                 "  xmpf_coarray_put_array_, " __FILE__);
    return;
  }
 
  /*--------------------------------------*\
   * Check whether the local address rhs  *
   * is already registered for DMA and,   *
   * if so, get the descriptor, etc.      *
  \*--------------------------------------*/
  void *descDMA;
  size_t offsetDMA;
  char *orgAddrDMA;
  char *nameDMA;
  BOOL avail_DMA;
  int scheme;
 
  descDMA = _XMPCO_get_isEagerCommMode() ? NULL :
      _XMPCO_get_desc_fromLocalAddr(rhsAddr, &orgAddrDMA, &offsetDMA, &nameDMA);
  avail_DMA = descDMA ? TRUE : FALSE;
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  scheme = _select_scheme_put_array(avail_DMA);
 
  /*--------------------------------------*\
   * action                               *
  \*--------------------------------------*/
  switch (scheme) {
  case SCHEME_DirectPut:
    _XMPCO_debugPrint("SCHEME_DirectPut/array selected\n");
    _putCoarray_DMA(descPtr, baseAddr, coindex0, rhsAddr,
                    element, rank, skip, skip_rhs, count,
                    descDMA, offsetDMA, nameDMA, sync_mode);
    break;
 
  case SCHEME_BufferPut:
    _XMPCO_debugPrint("SCHEME_BufferPut/array selected\n");
    _putCoarray_buffer(descPtr, baseAddr, coindex0, rhsAddr,
                       element, rank, skip, skip_rhs, count, sync_mode);
    break;
 
  default:
    _XMPCO_fatal("unexpected scheme number in " __FILE__);
  }
}

Here is the call graph for this function:

XMPCO_PUT_scalarStmt()

void XMPCO_PUT_scalarStmt	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	rhs,
		SyncMode	sync_mode
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  /*--------------------------------------*\
   * Check whether the local address rhs  *
   * is already registered for DMA and,   *
   * if so, get the descriptor, etc.      *
  \*--------------------------------------*/
  void *descDMA;
  size_t offsetDMA;
  char *orgAddrDMA;
  char *nameDMA;
  BOOL avail_DMA;
 
  descDMA = _XMPCO_get_isEagerCommMode() ? NULL :
    _XMPCO_get_desc_fromLocalAddr(rhs, &orgAddrDMA, &offsetDMA, &nameDMA);
  avail_DMA = descDMA ? TRUE : FALSE;
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  int scheme = _select_scheme_put_scalar(element, avail_DMA);
 
  /*--------------------------------------*\
   * action                               *
  \*--------------------------------------*/
  size_t elementRU;
 
  switch (scheme) {
  case SCHEME_DirectPut:
    _XMPCO_debugPrint("SCHEME_DirectPut/scalar selected\n");
    assert(avail_DMA);
 
    _putVector_DMA(descPtr, baseAddr, element, coindex0,
                   descDMA, offsetDMA, nameDMA, sync_mode);
    break;
    
  case SCHEME_ExtraDirectPut:
    elementRU = ROUND_UP_COMM(element);
    _XMPCO_debugPrint("SCHEME_ExtraDirectPut/scalar selected. elementRU=%ud\n",
                      elementRU);
    assert(avail_DMA);
 
    _putVector_DMA(descPtr, baseAddr, elementRU, coindex0,
                   descDMA, offsetDMA, nameDMA, sync_mode);
    break;
 
  case SCHEME_BufferPut:
    _XMPCO_debugPrint("SCHEME_BufferPut/scalar selected\n");
 
    _putVector_buffer(descPtr, baseAddr, element, coindex0,
                      rhs, element, sync_mode);
    break;
 
  case SCHEME_ExtraBufferPut:
    elementRU = ROUND_UP_COMM(element);
    _XMPCO_debugPrint("SCHEME_ExtraBufferPut/scalar selected. elementRU=%ud\n",
                      elementRU);
 
    _putVector_buffer(descPtr, baseAddr, elementRU, coindex0,
                      rhs, element, sync_mode);
    break;
 
  default:
    _XMPCO_fatal("unexpected scheme number in " __FILE__);
  }
}

Here is the call graph for this function:

XMPCO_PUT_spread()

void XMPCO_PUT_spread	(	CoarrayInfo_t *	descPtr,
		char *	baseAddr,
		int	element,
		int	coindex,
		char *	rhs,
		int	rank,
		int	skip[],
		int	count[],
		SyncMode	sync_mode
	)

{
  int coindex0 = _XMPCO_get_initial_image_withDescPtr(coindex, descPtr);
 
  if (element % COMM_UNIT != 0) {
    _XMPCO_fatal("violation of boundary writing a scalar to a coindexed variable\n"
               "   xmpf_coarray_put_spread_, " __FILE__);
    return;
  }
 
 
  /*--------------------------------------*\
   * select scheme                        *
  \*--------------------------------------*/
  // only BufferPut
  _XMPCO_debugPrint("SCHEME_BufferPut/spread selected\n");
 
  /*--------------------------------------*\
   * action                               *
  \*--------------------------------------*/
  _spreadCoarray(descPtr, baseAddr, coindex0, rhs,
                 element, rank, skip, count, element, sync_mode);
}

Here is the call graph for this function:

XMPCO_regmem_coarray()

CoarrayInfo_t* XMPCO_regmem_coarray	(	void *	var,
		int	count,
		size_t	element,
		ResourceSet_t *	rset
	)

{
  size_t nbytes = count * element;
 
  _XMPCO_debugPrint("_XMPCO_REGMEM_COARRAY\n");
 
  // regmem
  MemoryChunk_t *chunk = _regmemMemoryChunk_core(var, nbytes);
  _XMPCO_debugPrint("*** new MemoryChunk for RegMem variable %s\n",
                          _dispMemoryChunk(chunk));
 
  // make coarrayInfo and linkage
  CoarrayInfo_t *cinfo = _newCoarrayInfo(chunk->orgAddr, nbytes);
 
  _addCoarrayInfo(chunk, cinfo);
  return cinfo;
}

Here is the call graph for this function:

XMPCO_regmem_staticCoarray()

CoarrayInfo_t* XMPCO_regmem_staticCoarray	(	void *	var,
		int	count,
		size_t	element,
		int	namelen,
		char *	name
	)

Similar to _alloc_static_coarray() except that the coarray is allocated not by the runtime but by the Fortran system.

out: return : pointer to descriptor CoarrayInfo_t in: var : pointer to the coarray count : count of elements element : element size name : name of the coarray (for debugging) namelen : character length of name (for debugging)

{
  CoarrayInfo_t *cinfo;
 
  _XMPCO_debugPrint("_XMPCO_REGMEM_STATIC_COARRAY varname=\'%.*s\'\n"
                          "  count=%d, element=%ud\n",
                          namelen, name, count, element);
 
  // boundary check
  if ((size_t)var % MALLOC_UNIT != 0) {  // check base address
    /* restriction */
    _XMPCO_fatal("boundary violation detected for coarray \'%.*s\'\n"
                 "  var=%p\n",
                 namelen, name, var);
  }
 
  size_t nbytes = count * element;
  //size_t nbytesRU = ROUND_UP_MALLOC(nbytes);
 
  _XMPCO_debugPrint("COARRAY_REGMEM_STATIC_ varname=\'%.*s\'\n",
                          namelen, name);
 
  cinfo = _regmemStaticCoarray(var, nbytes);
  //cinfo = _regmemStaticCoarray(var, nbytesRU);
  cinfo->name = _xmp_strndup(name, namelen);
 
  return cinfo;
}

Here is the call graph for this function:

XMPCO_sync_all()

void XMPCO_sync_all

(

void

)

{
  int stat = 0;
 
  if (_XMPCO_is_subset_exec()) {
    XMPCO_sync_all_withComm(_XMPCO_consume_comm_current());
    _XMPCO_debugPrint("SYNCALL on subset(%d images) done\n",
                      _XMPCO_get_currentNumImages());
    return;
  }
 
  _count_syncall += 1;
  xmp_sync_all(&stat);
  if (stat != 0)
    _XMPCO_fatal("SYNCALL failed with stat=%d", stat);
 
  _XMPCO_debugPrint("SYNCALL done (_count_syncall=%d, stat=%d)\n",
                    _count_syncall, stat);
}

Here is the call graph for this function:

XMPCO_sync_all_auto()

void XMPCO_sync_all_auto

(

void

)

{
  int stat = 0;
 
  if (_XMPCO_is_subset_exec()) {
    XMPCO_sync_all_withComm(_XMPCO_consume_comm_current());
    _XMPCO_debugPrint("SYNCALL AUTO on subset(%d images) done\n",
                      _XMPCO_get_currentNumImages());
    return;
  } 
 
  _count_syncall_auto += 1;
  xmp_sync_all(&stat);
  if (stat != 0)
    _XMPCO_fatal("SYNCALL_AUTO failed with stat=%d", stat);
 
  _XMPCO_debugPrint("SYNCALL_AUTO done (_count_syncall_auto=%d, stat=%d)\n",
                    _count_syncall_auto, stat);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XMPCO_sync_all_withComm()

void XMPCO_sync_all_withComm

(

MPI_Comm

comm

)

{
  int stat = 0;
  
  xmp_sync_memory(&stat);
  if (stat != 0)
    _XMPCO_fatal("SYNC MEMORY inside SYNC ALL failed with stat=%d", stat);
  stat = MPI_Barrier(comm);
  if (stat != 0)
    _XMPCO_fatal("MPI_Barrier inside SYNC ALL failed with stat=%d", stat);
  return;
}

Here is the caller graph for this function:

XMPCO_this_image_coarray()

void XMPCO_this_image_coarray	(	CoarrayInfo_t *	cinfo,
		int	corank,
		int	image[]
	)

{
  int size, index, image_coarray, magic;
  _XMP_nodes_t *nodes;
 
  nodes = cinfo->nodes;
  if (nodes != NULL) {
    image_coarray = _XMPCO_this_image_onNodes(nodes);
  } else {
    image_coarray = _XMPCO_get_currentThisImage();
  }
 
  if (image_coarray == 0) {    // This image is out of the nodes.
    for (int i = 0; i < corank; i++)
      image[i] = 0;
    return;
  }
 
  magic = image_coarray - 1;
  for (int i = 0; i < corank; i++) {
    size = cinfo->cosize[i];
    index = magic % size;
    image[i] = index + cinfo->lcobound[i];
    magic /= size;
  }
}

Here is the call graph for this function:

XMPCO_this_image_coarray_dim()

int XMPCO_this_image_coarray_dim	(	CoarrayInfo_t *	cinfo,
		int	corank,
		int	dim
	)

{
  int size, index, image_coarray, magic;
  //int image_init;
  int k;
  _XMP_nodes_t *nodes;
  //MPI_Comm comm_coarray;
 
  if (dim <= 0 || corank < dim)
    _XMPCO_fatal("Too large or non-positive argument 'dim' of this_image:"
                 "%d\n", dim);
 
  nodes = cinfo->nodes;
  if (nodes != NULL) {
    image_coarray = _XMPCO_this_image_onNodes(nodes);
  } else {
    image_coarray = _XMPCO_get_currentThisImage();
  }
 
  if (image_coarray == 0)    // This image is out of the nodes.
    return 0;
 
  magic = image_coarray - 1;
  k = dim - 1;
  for (int i = 0; i < k; i++) {
    size = cinfo->cosize[i];
    magic /= size;
  }
  size = cinfo->cosize[k];
  index = magic % size;
  return index + cinfo->lcobound[k];
}

Here is the call graph for this function: