xmp.h File Reference

#include <stddef.h>
#include <mpi.h>

Include dependency graph for xmp.h:

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

Go to the source code of this file.

Macros
#define	_XMP_USERAPI
#define	XMP_FAILURE   -2000
#define	XMP_UNDEFINED   -2001
#define	XMP_ENTIRE_NODES   2000
#define	XMP_EXECUTING_NODES   2001
#define	XMP_PRIMARY_NODES   2002
#define	XMP_EQUIVALENCE_NODES   2003
#define	XMP_NOT_DISTRIBUTED   2100
#define	XMP_BLOCK   2101
#define	XMP_CYCLIC   2102
#define	XMP_GBLOCK   2103
#define	XMP_DESC_NODES   2200
#define	XMP_DESC_TEMPLATE   2201
#define	XMP_DESC_ARRAY   2202

Typedefs
typedef void *	xmp_desc_t

Functions
MPI_Comm	xmp_get_mpi_comm (void)
void	xmp_init_mpi (int *argc, char ***argv)
void	xmp_finalize_mpi (void)
void	xmp_init (MPI_Comm comm)
void	xmp_finalize ()
int	xmp_num_nodes (void)
int	xmp_num_images (void)
int	xmp_desc_kind (xmp_desc_t d, int *kind)
int	xmp_node_num (void)
int	xmpc_node_num (void)
int	xmpc_this_image (void)
void	xmp_barrier (void)
int	xmp_all_num_nodes (void)
int	xmp_all_node_num (void)
int	xmpc_all_node_num (void)
double	xmp_wtime (void)
double	xmp_wtick (void)
int	xmp_array_ndims (xmp_desc_t d, int *ndims)
int	xmp_array_lbound (xmp_desc_t d, int dim, int *lbound)
int	xmp_array_ubound (xmp_desc_t d, int dim, int *ubound)
size_t	xmp_array_type_size (xmp_desc_t d)
int	xmp_array_gsize (xmp_desc_t d, int dim)
int	xmp_array_lsize (xmp_desc_t d, int dim, int *lsize)
int	xmp_array_gcllbound (xmp_desc_t d, int dim)
int	xmp_array_gclubound (xmp_desc_t d, int dim)
int	xmp_array_lcllbound (xmp_desc_t d, int dim)
int	xmp_array_lclubound (xmp_desc_t d, int dim)
int	xmp_array_gcglbound (xmp_desc_t d, int dim)
int	xmp_array_gcgubound (xmp_desc_t d, int dim)
int	xmp_array_laddr (xmp_desc_t d, void **laddr)
int	xmp_array_lshadow (xmp_desc_t d, int dim, int *lshadow)
int	xmp_array_ushadow (xmp_desc_t d, int dim, int *ushadow)
int	xmp_array_owner (xmp_desc_t d, int ndims, int index[], int dim)
int	xmp_array_lead_dim (xmp_desc_t d, int size[])
int	xmp_array_gtol (xmp_desc_t d, int dim, int g_idx, int *lidx)
int	xmp_align_axis (xmp_desc_t d, int dim, int *axis)
int	xmp_align_offset (xmp_desc_t d, int dim, int *offset)
int	xmp_align_format (xmp_desc_t d, int dim)
int	xmp_align_size (xmp_desc_t d, int dim)
int	xmp_align_replicated (xmp_desc_t d, int dim, int *replicated)
int	xmp_align_template (xmp_desc_t d, xmp_desc_t *dt)
int	xmp_template_fixed (xmp_desc_t d, int *fixed)
int	xmp_template_ndims (xmp_desc_t d, int *ndims)
int	xmp_template_lbound (xmp_desc_t d, int dim, int *lbound)
int	xmp_template_ubound (xmp_desc_t d, int dim, int *ubound)
int	xmp_template_gsize (xmp_desc_t d, int dim)
int	xmp_template_lsize (xmp_desc_t d, int dim)
int	xmp_dist_format (xmp_desc_t d, int dim, int *format)
int	xmp_dist_blocksize (xmp_desc_t d, int dim, int *blocksize)
int	xmp_dist_stride (xmp_desc_t d, int dim)
int	xmp_dist_nodes (xmp_desc_t d, xmp_desc_t *dn)
int	xmp_dist_axis (xmp_desc_t d, int dim, int *axis)
int	xmp_dist_gblockmap (xmp_desc_t d, int dim, int *map)
int	xmp_nodes_ndims (xmp_desc_t d, int *ndims)
int	xmp_nodes_index (xmp_desc_t d, int dim, int *index)
int	xmp_nodes_size (xmp_desc_t d, int dim, int *size)
int	xmp_nodes_rank (xmp_desc_t d, int *rank)
int	xmp_nodes_comm (xmp_desc_t d, void **comm)
int	xmp_nodes_equiv (xmp_desc_t d, xmp_desc_t *dn, int lb[], int ub[], int st[])
void	xmp_sched_template_index (int *local_start_index, int *local_end_index, const int global_start_index, const int global_end_index, const int step, const xmp_desc_t template, const int template_dim)
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 (const 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_sort_up (xmp_desc_t a_desc, xmp_desc_t b_desc)
void	xmp_sort_down (xmp_desc_t a_desc, xmp_desc_t b_desc)
void *	xmp_malloc (xmp_desc_t d,...)
void	xmp_free (xmp_desc_t d)
void	xmp_exit (int status)
void	xmp_array_lbound_global (xmp_desc_t d, int dim, int *global_i)
void	xmp_array_ubound_global (xmp_desc_t d, int dim, int *global_i)
void	xmp_atomic_define (int, int)
void	xmp_atomic_ref (int *, int)

Macro Definition Documentation

_XMP_USERAPI

#define _XMP_USERAPI

XMP_BLOCK

#define XMP_BLOCK   2101

XMP_CYCLIC

#define XMP_CYCLIC   2102

XMP_DESC_ARRAY

#define XMP_DESC_ARRAY   2202

XMP_DESC_NODES

#define XMP_DESC_NODES   2200

XMP_DESC_TEMPLATE

#define XMP_DESC_TEMPLATE   2201

XMP_ENTIRE_NODES

#define XMP_ENTIRE_NODES   2000

XMP_EQUIVALENCE_NODES

#define XMP_EQUIVALENCE_NODES   2003

XMP_EXECUTING_NODES

#define XMP_EXECUTING_NODES   2001

XMP_FAILURE

#define XMP_FAILURE   -2000

XMP_GBLOCK

#define XMP_GBLOCK   2103

XMP_NOT_DISTRIBUTED

#define XMP_NOT_DISTRIBUTED   2100

XMP_PRIMARY_NODES

#define XMP_PRIMARY_NODES   2002

XMP_UNDEFINED

#define XMP_UNDEFINED   -2001

Typedef Documentation

xmp_desc_t

typedef void* xmp_desc_t

Function Documentation

xmp_align_axis()

int xmp_align_axis	(	xmp_desc_t	d,
		int	dim,
		int *	axis
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *axis = a->info[dim-1].align_template_index + 1;
  return 0;
}

Here is the caller graph for this function:

xmp_align_format()

int xmp_align_format	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].align_manner;
}

Here is the caller graph for this function:

xmp_align_offset()

int xmp_align_offset	(	xmp_desc_t	d,
		int	dim,
		int *	offset
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *offset = a->info[dim-1].align_subscript;
  return 0;
}

xmp_align_replicated()

int xmp_align_replicated	(	xmp_desc_t	d,
		int	dim,
		int *	replicated
	)

{
  int andims, nndims, axis, counter=0; 
  xmp_desc_t dt, dn;
 
  xmp_align_template(d, &dt);
  xmp_dist_nodes(dt, &dn);
  xmp_array_ndims(d, &andims);
  xmp_nodes_ndims(dn, &nndims);
 
  for(int i=0; i<andims; i++){
    xmp_align_axis(d, i+1, &axis);
    if (axis <= 0){
      counter = counter +1;
    }
  }
 
  if (counter != nndims){
    *replicated=1;
    for(int i=0; i<andims; i++){
      xmp_align_axis(d, i+1, &axis);
      if (dim == axis){
        *replicated=0;
        break;
      }
    }
  }else{
    *replicated=0;
  }
 
  return 0;
}

Here is the call graph for this function:

xmp_align_size()

int xmp_align_size	(	xmp_desc_t	d,
		int	dim
	)

{
  int format, ival=0, idim;
  xmp_desc_t dt;
  _XMP_array_t *a = (_XMP_array_t *)d;
 
  format = xmp_align_format(d,dim);
  xmp_align_axis(d,dim,&idim);
  xmp_align_template(d,&dt);
 
  _XMP_template_t *t = (_XMP_template_t *)dt;
 
  if (format == _XMP_N_ALIGN_BLOCK){
    ival = t->chunk[idim-1].par_chunk_width;
  }else if (format == _XMP_N_ALIGN_CYCLIC){
    ival = t->chunk[idim-1].par_width;
  }else if (format == _XMP_N_ALIGN_BLOCK_CYCLIC){
    ival = t->chunk[idim-1].par_width;
  }else if (format == _XMP_N_ALIGN_DUPLICATION){
    ival = t->chunk[idim-1].par_chunk_width;
  }else if (format == _XMP_N_ALIGN_NOT_ALIGNED){
    ival = a->info[dim-1].par_size;
  }else
    ival = -1;
 
  return ival;
}

Here is the call graph for this function:

xmp_align_template()

int xmp_align_template	(	xmp_desc_t	d,
		xmp_desc_t *	dt
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *dt = (xmp_desc_t)(a->align_template);
  return 0;
}

Here is the caller graph for this function:

xmp_all_node_num()

int xmp_all_node_num

(

void

)

{
  return _XMP_world_rank + 1;
}

xmp_all_num_nodes()

int xmp_all_num_nodes

(

void

)

{
  return _XMP_world_size;
}

xmp_array_gcglbound()

int xmp_array_gcglbound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].ser_lower;
}

xmp_array_gcgubound()

int xmp_array_gcgubound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].ser_upper;
}

xmp_array_gcllbound()

int xmp_array_gcllbound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].par_lower;
}

xmp_array_gclubound()

int xmp_array_gclubound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].par_upper;
}

xmp_array_gsize()

int xmp_array_gsize	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].ser_size;
}

xmp_array_gtol()

int xmp_array_gtol	(	xmp_desc_t	d,
		int	dim,
		int	g_idx,
		int *	lidx
	)

{
  int rank;
  _XMP_align_local_idx((long long int)g_idx, l_idx, d, dim-1, &rank);
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmp_array_laddr()

int xmp_array_laddr	(	xmp_desc_t	d,
		void **	laddr
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *(void **)laddr = (void *)a->array_addr_p;
  return 0;
}

xmp_array_lbound()

int xmp_array_lbound	(	xmp_desc_t	d,
		int	dim,
		int *	lbound
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *lbound = a->info[dim-1].ser_lower;
  return 0;
}

xmp_array_lbound_global()

void xmp_array_lbound_global	(	xmp_desc_t	d,
		int	dim,
		int *	global_i
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *global_i = a->info[dim-1].par_lower;
}

xmp_array_lcllbound()

int xmp_array_lcllbound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].local_lower;
}

xmp_array_lclubound()

int xmp_array_lclubound	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->info[dim-1].local_upper;
}

xmp_array_lead_dim()

int xmp_array_lead_dim	(	xmp_desc_t	d,
		int	size[]
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
 
  int ndims;
  xmp_array_ndims(d, &ndims);
  for(int i=0;i<ndims;i++)
    size[i] = (int)a->info[i].dim_acc;
 
  return 0;
}

Here is the call graph for this function:

xmp_array_lshadow()

int xmp_array_lshadow	(	xmp_desc_t	d,
		int	dim,
		int *	lshadow
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *lshadow = a->info[dim-1].shadow_size_lo;
  return 0;
}

xmp_array_lsize()

int xmp_array_lsize	(	xmp_desc_t	d,
		int	dim,
		int *	lsize
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  //  *lsize = a->info[dim-1].par_size;
  *lsize = a->info[dim-1].alloc_size;
  return 0;
}

xmp_array_ndims()

int xmp_array_ndims	(	xmp_desc_t	d,
		int *	ndims
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *ndims = a->dim;
  return 0;
}

Here is the caller graph for this function:

xmp_array_owner()

int xmp_array_owner	(	xmp_desc_t	d,
		int	ndims,
		int	index[],
		int	dim
	)

xmp_array_type_size()

size_t xmp_array_type_size

(

xmp_desc_t

d

)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  return a->type_size;
}

Here is the caller graph for this function:

xmp_array_ubound()

int xmp_array_ubound	(	xmp_desc_t	d,
		int	dim,
		int *	ubound
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *ubound = a->info[dim-1].ser_upper;
  return 0;
}

xmp_array_ubound_global()

void xmp_array_ubound_global	(	xmp_desc_t	d,
		int	dim,
		int *	global_i
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *global_i = a->info[dim-1].par_upper;
}

xmp_array_ushadow()

int xmp_array_ushadow	(	xmp_desc_t	d,
		int	dim,
		int *	ushadow
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  *ushadow = a->info[dim-1].shadow_size_hi;
  return 0;
}

xmp_atomic_define()

void xmp_atomic_define	(	int	,
		int
	)

                                {
}

xmp_atomic_ref()

void xmp_atomic_ref	(	int *	,
		int
	)

xmp_barrier()

void xmp_barrier

(

void

)

{
  _XMP_barrier_EXEC();
}

Here is the call graph for this function:

xmp_desc_kind()

int xmp_desc_kind	(	xmp_desc_t	d,
		int *	kind
	)

{
  *kind = *(int*)d;
  return 0;
}

xmp_dist_axis()

int xmp_dist_axis	(	xmp_desc_t	d,
		int	dim,
		int *	axis
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *axis = t->chunk[dim-1].onto_nodes_index + 1;
  return 0;
}

Here is the caller graph for this function:

xmp_dist_blocksize()

int xmp_dist_blocksize	(	xmp_desc_t	d,
		int	dim,
		int *	blocksize
	)

{
  int format;
  _XMP_template_t *t = (_XMP_template_t *)d;
 
  xmp_dist_format(d,dim,&format);
 
  if (format == XMP_BLOCK){
    *blocksize = t->chunk[dim-1].par_chunk_width;
  }else if (format == XMP_CYCLIC){
    *blocksize = t->chunk[dim-1].par_width;
  }else if (format == XMP_NOT_DISTRIBUTED){
    *blocksize = t->chunk[dim-1].par_chunk_width;
  }else{
    *blocksize = -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmp_dist_format()

int xmp_dist_format	(	xmp_desc_t	d,
		int	dim,
		int *	format
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
 
  *format = t->chunk[dim-1].dist_manner;
  if (*format == _XMP_N_DIST_BLOCK){
    *format = XMP_BLOCK;
  }else if (*format == _XMP_N_DIST_CYCLIC){
    *format = XMP_CYCLIC;
  }else if (*format == _XMP_N_DIST_BLOCK_CYCLIC){
    *format = XMP_CYCLIC;
  }else{
    *format = XMP_NOT_DISTRIBUTED;
  }
 
  return 0;
}

Here is the caller graph for this function:

xmp_dist_gblockmap()

int xmp_dist_gblockmap	(	xmp_desc_t	d,
		int	dim,
		int *	map
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  _XMP_template_chunk_t *chunk = &(t->chunk[dim-1]);
 
  int axis, size;
  xmp_desc_t dn;
  xmp_dist_nodes(d, &dn);
  xmp_dist_axis(d, dim, &axis);
  xmp_nodes_size(dn, axis, &size);
 
  for (int i=0; i<size-1; i++){
    map[i] = chunk->mapping_array[i+1]-chunk->mapping_array[i];
  }
  if (size > 1){
    map[size-1] = t->info[dim-1].ser_size - map[size-2];
  }else if (size == 1){
    map[0] =  t->info[dim-1].ser_size;
  }else{
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

xmp_dist_nodes()

int xmp_dist_nodes	(	xmp_desc_t	d,
		xmp_desc_t *	dn
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *dn = (xmp_desc_t)(t->onto_nodes);
  return 0;
}

Here is the caller graph for this function:

xmp_dist_stride()

int xmp_dist_stride	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  return t->chunk[dim-1].par_stride;
}

xmp_exit()

void xmp_exit

(

int

status

)

                         {
  _XMP_finalize(true);
  exit(status);
}

Here is the call graph for this function:

xmp_finalize()

void xmp_finalize

(

)

{
  _XMP_finalize(false);
}

Here is the call graph for this function:

xmp_finalize_mpi()

void xmp_finalize_mpi

(

void

)

{}

xmp_free()

void xmp_free

(

xmp_desc_t

d

)

                           {
  if (((_XMP_array_t *)d)->is_allocated)
    _XMP_dealloc_array((_XMP_array_t *)d);
}

Here is the call graph for this function:

xmp_get_mpi_comm()

MPI_Comm xmp_get_mpi_comm

(

void

)

{
  MPI_Comm *comm;
  comm = _XMP_get_execution_nodes()->comm;
  return *comm;
}

xmp_init()

void xmp_init

(

MPI_Comm

comm

)

{
  _XMP_init(1, NULL, comm);
}

xmp_init_mpi()

void xmp_init_mpi	(	int *	argc,
		char ***	argv
	)

{}

xmp_malloc()

void* xmp_malloc	(	xmp_desc_t	d,
			...
	)

{
  _XMP_array_t *a = (_XMP_array_t *)d;
  _XMP_ASSERT(a->dim == 1);
  _XMP_template_t *t = a->align_template;
  if (!t->is_fixed) _XMP_fatal("target template is not fixed");
  a->is_allocated = t->is_owner;
  int is_star[_XMP_N_MAX_DIM] = { 0 };
  unsigned long long *acc[_XMP_N_MAX_DIM] = { NULL };
 
  va_list args;
  va_start(args, d);
  for (int i = 0; i < a->dim; i++){
    int size = va_arg(args, int);
    _XMP_array_info_t *ai = &(a->info[i]);
    int tdim      = ai->align_template_index;
    ai->ser_upper = size - 1;
    ai->ser_size  = size;
    acc[i]        = ai->acc;
    
    if (tdim == _XMP_N_NO_ALIGN_TEMPLATE){
      _XMP_align_array_NOT_ALIGNED(a, i);
    }
    else {
      _XMP_template_info_t *info = &(t->info[tdim]);
      is_star[tdim] = 1;
 
      /* Now, normalize align_subscript and size */
      size += (ai->align_subscript - info->ser_lower);
      ai->align_subscript = info->ser_lower;
 
      switch (t->chunk[tdim].dist_manner){
      case _XMP_N_DIST_DUPLICATION:
        _XMP_align_array_DUPLICATION(a, i, tdim, ai->align_subscript);
        break;
      case _XMP_N_DIST_BLOCK:
        _XMP_align_array_BLOCK(a, i, tdim, ai->align_subscript, ai->temp0);
        break;
      case _XMP_N_DIST_CYCLIC:
        _XMP_align_array_CYCLIC(a, i, tdim, ai->align_subscript, ai->temp0);
        break;
      case _XMP_N_DIST_BLOCK_CYCLIC:
        _XMP_align_array_BLOCK_CYCLIC(a, i, tdim, ai->align_subscript, ai->temp0);
        break;
      case _XMP_N_DIST_GBLOCK:
        _XMP_align_array_GBLOCK(a, i, tdim, ai->align_subscript, ai->temp0);
        break;
      default:
        _XMP_fatal("unknown distribution manner");
        return NULL;
      }
      _XMP_init_shadow_dim(a, i, ai->shadow_type, ai->shadow_size_lo, ai->shadow_size_hi);
    }
  }
 
  va_end(args);
 
  _XMP_init_array_comm2(a, is_star);
  _XMP_init_array_nodes(a);
 
  void *array_addr;
  _XMP_alloc_array2(&array_addr, a, 1, acc);
 
  return array_addr;
}

Here is the call graph for this function:

xmp_node_num()

int xmp_node_num

(

void

)

{
  return _XMP_get_execution_nodes()->comm_rank + 1;
}

Here is the call graph for this function:

xmp_nodes_comm()

int xmp_nodes_comm	(	xmp_desc_t	d,
		void **	comm
	)

{
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
  *(void **)comm = (void *)n->comm;
  return 0;
}

xmp_nodes_equiv()

int xmp_nodes_equiv	(	xmp_desc_t	d,
		xmp_desc_t *	dn,
		int	lb[],
		int	ub[],
		int	st[]
	)

                                                                               {
 
  int i, ndims;
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
 
  *dn = (xmp_desc_t)(n->inherit_nodes);
  if (*dn != NULL){
    xmp_nodes_ndims(*dn, &ndims);
 
    for (i=0; i<ndims; i++){
      lb[i]= n ->inherit_info[i].lower+1;
      ub[i]= n ->inherit_info[i].upper+1;
      st[i]= n ->inherit_info[i].stride;
    }
    return 0;
 
  }else{
    return -1;
  }
}

Here is the call graph for this function:

xmp_nodes_index()

int xmp_nodes_index	(	xmp_desc_t	d,
		int	dim,
		int *	index
	)

{
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
  *index = n->info[dim-1].rank + 1;
  return 0;
}

xmp_nodes_ndims()

int xmp_nodes_ndims	(	xmp_desc_t	d,
		int *	ndims
	)

{
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
  *ndims = n->dim;
  return 0;
}

Here is the caller graph for this function:

xmp_nodes_rank()

int xmp_nodes_rank	(	xmp_desc_t	d,
		int *	rank
	)

{
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
  *rank = n->comm_rank + 1;
  return 0;
}

xmp_nodes_size()

int xmp_nodes_size	(	xmp_desc_t	d,
		int	dim,
		int *	size
	)

{
  _XMP_nodes_t *n = (_XMP_nodes_t *)d;
  *size = n->info[dim-1].size;
  return 0;
}

Here is the caller graph for this function:

xmp_num_images()

int xmp_num_images

(

void

)

{
  return _XMP_get_execution_nodes()->comm_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmp_num_nodes()

int xmp_num_nodes

(

void

)

{
  return _XMP_get_execution_nodes()->comm_size;
}

Here is the call graph for this function:

xmp_sched_template_index()

void xmp_sched_template_index	(	int *	local_start_index,
		int *	local_end_index,
		const int	global_start_index,
		const int	global_end_index,
		const int	step,
		const xmp_desc_t	template,
		const int	template_dim
	)

{
  int tmp;
  _XMP_template_chunk_t *chunk = &(((_XMP_template_t*)template)->chunk[template_dim]);
 
  switch(chunk->dist_manner){
  case _XMP_N_DIST_BLOCK:
    _XMP_sched_loop_template_BLOCK(global_start_index, global_end_index, step, 
                                   local_start_index, local_end_index, &tmp, template, template_dim);
    break;
  case _XMP_N_DIST_CYCLIC:
    _XMP_sched_loop_template_CYCLIC(global_start_index, global_end_index, step, 
                                    local_start_index, local_end_index, &tmp, template, template_dim);
    break;
  case _XMP_N_DIST_BLOCK_CYCLIC: 
    _XMP_sched_loop_template_BLOCK_CYCLIC(global_start_index, global_end_index, step, 
                                          local_start_index, local_end_index, &tmp, template, template_dim);
    break;
  default:
    _XMP_fatal("does not support distribution in xmp_sched_template_index()");
    break;
  }
}

Here is the call graph for this function:

xmp_sort_down()

void xmp_sort_down	(	xmp_desc_t	a_desc,
		xmp_desc_t	b_desc
	)

xmp_sort_up()

void xmp_sort_up	(	xmp_desc_t	a_desc,
		xmp_desc_t	b_desc
	)

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	(	const 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
}

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
}

xmp_template_fixed()

int xmp_template_fixed	(	xmp_desc_t	d,
		int *	fixed
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *fixed = t->is_fixed;
  return 0;
}

xmp_template_gsize()

int xmp_template_gsize	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  return t->info[dim-1].ser_size;
}

xmp_template_lbound()

int xmp_template_lbound	(	xmp_desc_t	d,
		int	dim,
		int *	lbound
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *lbound = t->info[dim-1].ser_lower;
  return 0;
}

xmp_template_lsize()

int xmp_template_lsize	(	xmp_desc_t	d,
		int	dim
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  return t->chunk[dim-1].par_chunk_width;
}

xmp_template_ndims()

int xmp_template_ndims	(	xmp_desc_t	d,
		int *	ndims
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *ndims = t->dim;
  return 0;
}

xmp_template_ubound()

int xmp_template_ubound	(	xmp_desc_t	d,
		int	dim,
		int *	ubound
	)

{
  _XMP_template_t *t = (_XMP_template_t *)d;
  *ubound = t->info[dim-1].ser_upper;
  return 0;
 
}

xmp_wtick()

double xmp_wtick

(

void

)

{
  return MPI_Wtick();
}

xmp_wtime()

double xmp_wtime

(

void

)

{
  return MPI_Wtime();
}

xmpc_all_node_num()

int xmpc_all_node_num

(

void

)

{
  return _XMP_world_rank;
}

xmpc_node_num()

int xmpc_node_num

(

void

)

{
  return _XMP_get_execution_nodes()->comm_rank;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmpc_this_image()

int xmpc_this_image

(

void

)

{
  return _XMP_get_execution_nodes()->comm_rank;
}

Here is the call graph for this function: