xmp_lib.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include "xmp_internal.h"
#include "xmp.h"
#include <stddef.h>

Include dependency graph for xmp_lib.c:

Functions
void	_XMP_align_local_idx (long long int global_idx, int *local_idx, _XMP_array_t *array, int array_axis, int *rank)
void	_XMP_init_shadow_dim (_XMP_array_t *array, int i, int type, int lo, int hi)
MPI_Comm	xmp_get_mpi_comm (void)
void	xmp_init_mpi (int *argc, char ***argv)
void	xmp_finalize_mpi (void)
void	xmp_init_py (MPI_Fint comm)
void	xmp_init (MPI_Comm comm)
void	xmp_finalize ()
int	xmp_desc_kind (xmp_desc_t d, int *kind)
int	xmp_num_nodes (void)
int	xmp_num_images (void)
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_ushadow (xmp_desc_t d, int dim, int *ushadow)
int	xmp_array_lshadow (xmp_desc_t d, int dim, int *lshadow)
int	xmp_array_owner (xmp_desc_t d, int ndims, int index[ndims], 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 *l_idx)
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_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_calc_gmove_rank_array_SCALAR (xmp_desc_t array, int *ref_index, int *rank_array)
int	xmp_array_owner_rank (xmp_desc_t d, int *ref_index, int *owners)

Function Documentation

_XMP_align_local_idx()

void _XMP_align_local_idx	(	long long int	global_idx,
		int *	local_idx,
		_XMP_array_t *	array,
		int	array_axis,
		int *	rank
	)

{
  _XMP_template_t *template = array->align_template;
  int template_index = array->info[array_axis].align_template_index;
  _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
  _XMP_nodes_info_t *n_info = chunk->onto_nodes_info;
  long long base = array->info[array_axis].ser_lower;
  long long tbase = template->info[template_index].ser_lower;
  int offset = array->info[array_axis].align_subscript + (base - tbase);
  int irank, idiv, imod;
 
  switch(array->info[array_axis].align_manner){
  case _XMP_N_ALIGN_DUPLICATION:
    {
      *rank=0;
      *local_idx = global_idx + offset - base;
    }
    break;
  case _XMP_N_ALIGN_BLOCK:
    {
      *rank = (global_idx + offset - base) / chunk->par_chunk_width;
      *local_idx = (global_idx + offset - base ) - *rank * chunk->par_chunk_width + array->info[array_axis].shadow_size_lo;
      idiv = offset / (chunk->par_chunk_width);
      if (*rank == idiv){
        *local_idx = *local_idx - offset%(chunk->par_chunk_width);
      }
    }
    break;
  case _XMP_N_ALIGN_CYCLIC:
    {
      idiv = offset/n_info->size;
      imod = offset%n_info->size;
      *rank = (global_idx + offset - base) % n_info->size;
      *local_idx = (global_idx + offset - base) / n_info->size;
      if (imod > *rank){
        *local_idx = *local_idx - (idiv + 1);
      } else {
        *local_idx = *local_idx - idiv;
      }
    }
    break;
  case _XMP_N_ALIGN_BLOCK_CYCLIC:
    {
      int w = chunk->par_width;
      idiv = (offset/w)/n_info->size;
      int imod1 = (offset/w)%n_info->size;
      int imod2 = offset%w;
      int off = global_idx + offset - base;
      *local_idx = (off / (n_info->size*w)) * w + off%w;
 
      *rank=(off/w)% (n_info->size);
      if (imod1 > 0){
        if (imod1 == *rank ){
          *local_idx = *local_idx - idiv*w-imod2;
        }else if (imod1 > *rank){
          *local_idx = *local_idx - (idiv+1)*w;
        }
      }else if (imod1 == 0){
        if (imod1 == *rank ){
          *local_idx = *local_idx - idiv*w -imod2;
        }else{
          *local_idx = *local_idx - idiv*w;
        }
      }
    }
    break;
  case _XMP_N_ALIGN_GBLOCK:
    {
      irank=-1;
      idiv=0;
      for(int i=1;i<(n_info->size+1);i++){
        if(global_idx + offset < chunk->mapping_array[i]+ (base - tbase)){
          *rank = i - 1;
          break;
        }
      }
      *local_idx = global_idx + offset - chunk->mapping_array[*rank]- (base - tbase) + array->info[array_axis].shadow_size_lo;
      for(int i=1;i<n_info->size+1;i++){
        if(offset < chunk->mapping_array[i]+(base-tbase)){
          irank = i - 1;
          idiv = offset - (chunk->mapping_array[i-1] + (base - tbase) - base);
          break;
        }
      }
      if (*rank == irank){
        *local_idx = *local_idx - idiv;
      }
    }
    break;
  case _XMP_N_ALIGN_NOT_ALIGNED:
    {
      *rank=0;
      *local_idx=global_idx - base;
    }
    break;
  default:
    _XMP_fatal("_XMP_: unknown chunk dist_manner");
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_calc_gmove_rank_array_SCALAR()

void _XMP_calc_gmove_rank_array_SCALAR	(	xmp_desc_t	array,
		int *	ref_index,
		int *	rank_array
	)

Here is the caller graph for this function:

_XMP_init_shadow_dim()

void _XMP_init_shadow_dim	(	_XMP_array_t *	array,
		int	i,
		int	type,
		int	lo,
		int	hi
	)

                                                                               {
 
  _XMP_array_info_t *ai = &(array->info[i]);
 
  switch (type) {
  case _XMP_N_SHADOW_NONE:
    ai->shadow_type = _XMP_N_SHADOW_NONE;
    break;
  case _XMP_N_SHADOW_NORMAL:
    {
      _XMP_ASSERT(ai->align_manner == _XMP_N_ALIGN_BLOCK);
 
      if (lo < 0) {
        _XMP_fatal("<shadow-width> should be a nonnegative integer");
      }
 
      if (hi < 0) {
        _XMP_fatal("<shadow-width> should be a nonnegative integer");
      }
 
      if ((lo == 0) && (hi == 0)) {
        ai->shadow_type = _XMP_N_SHADOW_NONE;
      }
      else {
        ai->shadow_type = _XMP_N_SHADOW_NORMAL;
        ai->shadow_size_lo = lo;
        ai->shadow_size_hi = hi;
 
        if (array->is_allocated) {
          ai->local_lower += lo;
          ai->local_upper += lo;
          // ai->local_stride is not changed
          ai->alloc_size += lo + hi;
 
          *(ai->temp0) -= lo;
          ai->temp0_v -= lo;
        }
 
        if (!ai->reflect_sched){
          _XMP_reflect_sched_t *sched = _XMP_alloc(sizeof(_XMP_reflect_sched_t));
          _XMP_init_reflect_sched(sched);
        /*   sched->is_periodic = -1; /\* not used yet *\/ */
        /*   sched->datatype_lo = MPI_DATATYPE_NULL; */
        /*   sched->datatype_hi = MPI_DATATYPE_NULL; */
        /*   for (int j = 0; j < 4; j++){ */
        /*     sched->req[j] = MPI_REQUEST_NULL; */
        /*     sched->req_reduce[j] = MPI_REQUEST_NULL; */
        /*   } */
        /*   sched->lo_send_buf = NULL; */
        /*   sched->lo_recv_buf = NULL; */
        /*   sched->hi_send_buf = NULL; */
        /*   sched->hi_recv_buf = NULL; */
          ai->reflect_sched = sched;
        }
        ai->reflect_acc_sched = NULL;
 
        _XMP_create_shadow_comm(array, i);
      }
 
      break;
    }
  case _XMP_N_SHADOW_FULL:
    {
      ai->shadow_type = _XMP_N_SHADOW_FULL;
 
      if (array->is_allocated) {
        ai->shadow_size_lo = ai->par_lower - ai->ser_lower;
        ai->shadow_size_hi = ai->ser_upper - ai->par_upper;
 
        ai->local_lower = ai->par_lower;
        ai->local_upper = ai->par_upper;
        ai->local_stride = ai->par_stride;
        ai->alloc_size = ai->ser_size;
      }
 
      _XMP_create_shadow_comm(array, i);
      break;
    }
  default:
    _XMP_fatal("unknown shadow type");
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
  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[ndims],
		int	dim
	)

{
  int idim, ival, idistnum, t_dist_size, format;
  xmp_desc_t dt, dn;
  _XMP_array_t *a = (_XMP_array_t *)d;
 
  xmp_align_template(d, &dt);
  xmp_dist_nodes(dt, &dn);
  _XMP_nodes_t *n = (_XMP_nodes_t *)dn;
 
  xmp_dist_blocksize(dt,dim,&t_dist_size);
  idistnum=a->info[dim-1].align_subscript/t_dist_size;
 
  format = xmp_align_format(d,dim);
  xmp_align_axis(d,dim,&idim);
 
  if (format == _XMP_N_ALIGN_BLOCK){
    ival = index[idim-1]/t_dist_size+idistnum +1;
  }else if (format == _XMP_N_ALIGN_CYCLIC){
    ival = (index[idim-1]/t_dist_size+idistnum)%(n->info[idim-1].size)+1;
  }else if (format == _XMP_N_ALIGN_BLOCK_CYCLIC){
    ival = (index[idim-1]/t_dist_size+idistnum)%(n->info[idim-1].size)+1;
  }else
    ival = -1;
 
  return ival;
}

Here is the call graph for this function:

xmp_array_owner_rank()

int xmp_array_owner_rank	(	xmp_desc_t	d,
		int *	ref_index,
		int *	owners
	)

                                                                   {
 
  int num = 0;
  
  _XMP_array_t *array = (_XMP_array_t *)d;
  _XMP_nodes_t *nodes = array->align_template->onto_nodes;
  int nodes_dim = nodes->dim;
  int rank_array[_XMP_N_MAX_DIM];
  int lb[_XMP_N_MAX_DIM] = {0}, ub[_XMP_N_MAX_DIM];;
 
  for (int i = 0; i < nodes_dim; i++) rank_array[i] = -1;
  for (int i = 0; i < _XMP_N_MAX_DIM; i++) ub[i] = 1;
 
  _XMP_calc_gmove_rank_array_SCALAR(array, ref_index, rank_array);
 
  for (int i = 0; i < nodes_dim; i++){
    //    printf("%d : %d\n", i, rank_array[i]);
    if (rank_array[i] == -1){
      //lb[i] = 0;
      ub[i] = nodes->info[i].size;
    }
    else {
      lb[i] = rank_array[i];
      ub[i] = rank_array[i] + 1;
    }
  }
 
  //printf("(%d, %d) => %d %d %d %d\n", ref_index[0], ref_index[1], lb[0], ub[0], lb[1], ub[1]);
  
  for (rank_array[0] = lb[0]; rank_array[0] < ub[0]; rank_array[0]++)
  for (rank_array[1] = lb[1]; rank_array[1] < ub[1]; rank_array[1]++)
  for (rank_array[2] = lb[2]; rank_array[2] < ub[2]; rank_array[2]++)
  for (rank_array[3] = lb[3]; rank_array[3] < ub[3]; rank_array[3]++)
  for (rank_array[4] = lb[4]; rank_array[4] < ub[4]; rank_array[4]++)
  for (rank_array[5] = lb[5]; rank_array[5] < ub[5]; rank_array[5]++)
  for (rank_array[6] = lb[6]; rank_array[6] < ub[6]; rank_array[6]++)
    owners[num++] = _XMP_calc_linear_rank_on_target_nodes(nodes, rank_array, _XMP_get_execution_nodes());
 
  return num;
}

Here is the call graph for this function:

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

void xmp_init_py

(

MPI_Fint

comm

)

                                {
  _XMP_init(1, NULL, MPI_Comm_f2c(comm));
}

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