xmpco_alloc.c File Reference

#include "xmpco_internal.h"
#include "_xmpco_alloc.h"

Include dependency graph for xmpco_alloc.c:

Functions
size_t	xmp_coarray_malloc_bytes ()
size_t	xmp_coarray_allocated_bytes ()
size_t	xmp_coarray_garbage_bytes ()
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	XMPCO_count_size (int count, size_t element)
MPI_Comm	_XMPCO_get_comm_fromCoarrayInfo (CoarrayInfo_t *cinfo)
void	XMPCO_prolog (ResourceSet_t **rsetp, int namelen, char *name)
void	XMPCO_epilog (ResourceSet_t **rsetp)
CoarrayInfo_t *	XMPCO_find_descptr (char *addr, int namelen, char *name)
	generate and return a descriptor for a coarray DUMMY ARGUMENT More...
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)
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_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)
int	_XMPCO_nowInTask ()
void	_XMPCO_checkIfInTask (char *msgopt)

Variables
struct {
MemoryChunkOrder_t *   head
MemoryChunkOrder_t *   tail
}	_mallocStack

Function Documentation

_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_get_baseAddrOfCoarray()

char* _XMPCO_get_baseAddrOfCoarray

(

CoarrayInfo_t *

cinfo

)

{
  return cinfo->baseAddr;
}

_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_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_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_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_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_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_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_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_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));
}

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;
}

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 **

rsetp

)

{
  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_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 **	rsetp,
		int	namelen,
		char *	name
	)

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

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:

Variable Documentation

struct { ... } _mallocStack

head

MemoryChunkOrder_t* head

tail

MemoryChunkOrder_t* tail