xmp_gmove.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "xmp.h"
#include "mpi.h"
#include "xmp_internal.h"
#include "xmp_math_function.h"

Include dependency graph for xmp_gmove.c:

Macros
#define	MPI_PORTABLE_PLATFORM_H
#define	_XMP_SM_GTOL_BLOCK(_i, _m, _w)   (((_i) - (_m)) % (_w))
#define	_XMP_SM_GTOL_CYCLIC(_i, _m, _P)   (((_i) - (_m)) / (_P))
#define	_XMP_SM_GTOL_BLOCK_CYCLIC(_b, _i, _m, _P)   (((((_i) - (_m)) / (((_P) * (_b)))) * (_b)) + (((_i) - (_m)) % (_b)))
#define	XMP_DBG   0
#define	DBG_RANK   3
#define	XMP_DBG_OWNER_REGION   0

Functions
void *	_XMP_get_array_addr (_XMP_array_t *a, int *gidx)
void	_XMP_gtol_array_ref_triplet (_XMP_array_t *array, int dim_index, int *lower, int *upper, int *stride)
void	_XMP_calc_gmove_rank_array_SCALAR (_XMP_array_t *array, int *ref_index, int *rank_array)
int	_XMP_calc_gmove_array_owner_linear_rank_SCALAR (_XMP_array_t *array, int *ref_index)
int	xmp_calc_gmove_array_owner_linear_rank_scalar_ (_XMP_array_t **a, int *ref_index)
unsigned long long	_XMP_gmove_bcast_ARRAY (void *dst_addr, int dst_dim, int *dst_l, int *dst_u, int *dst_s, unsigned long long *dst_d, void *src_addr, int src_dim, int *src_l, int *src_u, int *src_s, unsigned long long *src_d, int type, size_t type_size, int root_rank)
int	_XMP_check_gmove_array_ref_inclusion_SCALAR (_XMP_array_t *array, int array_index, int ref_index)
void	_XMP_gmove_localcopy_ARRAY (int type, int type_size, void *dst_addr, int dst_dim, int *dst_l, int *dst_u, int *dst_s, unsigned long long *dst_d, void *src_addr, int src_dim, int *src_l, int *src_u, int *src_s, unsigned long long *src_d)
int	_XMP_calc_global_index_HOMECOPY (_XMP_array_t *dst_array, int dst_dim_index, int *dst_l, int *dst_u, int *dst_s, int *src_l, int *src_u, int *src_s)
int	_XMP_calc_global_index_BCAST (int dst_dim, int *dst_l, int *dst_u, int *dst_s, _XMP_array_t *src_array, int *src_array_nodes_ref, int *src_l, int *src_u, int *src_s)
void	_XMP_sendrecv_ARRAY (int type, int type_size, MPI_Datatype *mpi_datatype, _XMP_array_t *dst_array, int *dst_array_nodes_ref, int *dst_lower, int *dst_upper, int *dst_stride, unsigned long long *dst_dim_acc, _XMP_array_t *src_array, int *src_array_nodes_ref, int *src_lower, int *src_upper, int *src_stride, unsigned long long *src_dim_acc)
void	_XMP_gmove_BCAST_GSCALAR (void *dst_addr, _XMP_array_t *array, int ref_index[])
void	_XMP_gmove_SENDRECV_GSCALAR (void *dst_addr, void *src_addr, _XMP_array_t *dst_array, _XMP_array_t *src_array, int dst_ref_index[], int src_ref_index[])
void	_XMP_gmove_calc_unit_size (_XMP_array_t *dst_array, _XMP_array_t *src_array, unsigned long long *alltoall_unit_size, unsigned long long *dst_pack_unit_size, unsigned long long *src_pack_unit_size, unsigned long long *dst_ser_size, unsigned long long *src_ser_size, int dst_block_dim, int src_block_dim)
void	_XMP_align_local_idx (long long int global_idx, int *local_idx, _XMP_array_t *array, int array_axis, int *rank)
void	_XMP_gmove_array_array_common (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int *dst_l, int *dst_u, int *dst_s, unsigned long long *dst_d, int *src_l, int *src_u, int *src_s, unsigned long long *src_d, int mode)
unsigned long long	_XMP_gtol_calc_offset (_XMP_array_t *a, int g_idx[])
void	_XMP_copy_scalar_array (char *scalar, _XMP_array_t *a, _XMP_comm_set_t *comm_set[])
void	_XMP_gmove_INOUT_SCALAR (_XMP_array_t *dst_array, void *scalar,...)
void	_XMP_gmove_scalar_garray (void *scalar, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)
void	_XMP_gmove_garray_scalar (_XMP_gmv_desc_t *gmv_desc_leftp, void *scalar, int mode)
void	_XMP_gmove_garray_garray (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)
void	_XMP_gmove_garray_larray (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)
void	_XMP_gmove_larray_garray (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)

Variables
void(*	_XMP_pack_comm_set )(void *sendbuf, int sendbuf_size, _XMP_array_t *a, _XMP_comm_set_t *comm_set[][_XMP_N_MAX_DIM])
void(*	_XMP_unpack_comm_set )(void *recvbuf, int recvbuf_size, _XMP_array_t *a, _XMP_comm_set_t *comm_set[][_XMP_N_MAX_DIM])
_XMP_nodes_t *	gmv_nodes
int	n_gmv_nodes
int(*	_alloc_size )[_XMP_N_MAX_DIM]
int	_dim_alloc_size

Macro Definition Documentation

_XMP_SM_GTOL_BLOCK

#define _XMP_SM_GTOL_BLOCK	(		_i,
			_m,
			_w
	)		(((_i) - (_m)) % (_w))

_XMP_SM_GTOL_BLOCK_CYCLIC

#define _XMP_SM_GTOL_BLOCK_CYCLIC	(		_b,
			_i,
			_m,
			_P
	)		(((((_i) - (_m)) / (((_P) * (_b)))) * (_b)) + (((_i) - (_m)) % (_b)))

_XMP_SM_GTOL_CYCLIC

#define _XMP_SM_GTOL_CYCLIC	(		_i,
			_m,
			_P
	)		(((_i) - (_m)) / (_P))

DBG_RANK

#define DBG_RANK   3

MPI_PORTABLE_PLATFORM_H

#define MPI_PORTABLE_PLATFORM_H

XMP_DBG

#define XMP_DBG   0

XMP_DBG_OWNER_REGION

#define XMP_DBG_OWNER_REGION   0

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_global_index_BCAST()

int _XMP_calc_global_index_BCAST	(	int	dst_dim,
		int *	dst_l,
		int *	dst_u,
		int *	dst_s,
		_XMP_array_t *	src_array,
		int *	src_array_nodes_ref,
		int *	src_l,
		int *	src_u,
		int *	src_s
	)

                                                                                                                        {
  _XMP_template_t *template = src_array->align_template;
 
  int dst_dim_index = 0;
  int array_dim = src_array->dim;
  for (int i = 0; i < array_dim; i++) {
    if (_XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]) == 1) {
      continue;
    }
 
    int template_index = src_array->info[i].align_template_index;
    if (template_index == _XMP_N_NO_ALIGN_TEMPLATE) {
      do {
        if (_XMP_M_COUNT_TRIPLETi(dst_l[dst_dim_index], dst_u[dst_dim_index], dst_s[dst_dim_index]) != 1) {
          dst_dim_index++;
          break;
        } else if (dst_dim_index < dst_dim) {
          dst_dim_index++;
        } else {
          _XMP_fatal("wrong assign statement for gmove");
        }
      } while (1);
    } else {
      int onto_nodes_index = template->chunk[template_index].onto_nodes_index;
      _XMP_ASSERT(onto_nodes_index != _XMP_N_NO_ONTO_NODES);
 
      int array_nodes_index = _XMP_calc_nodes_index_from_inherit_nodes_index(src_array->array_nodes, onto_nodes_index);
      int rank = src_array_nodes_ref[array_nodes_index];
 
      // calc template info
      int template_lower, template_upper, template_stride;
      if (!_XMP_calc_template_par_triplet(template, template_index, rank, &template_lower, &template_upper, &template_stride)) {
        return _XMP_N_INT_FALSE;
      }
 
      do {
        if (_XMP_M_COUNT_TRIPLETi(dst_l[dst_dim_index], dst_u[dst_dim_index], dst_s[dst_dim_index]) != 1) {
          if (_XMP_sched_gmove_triplet(template_lower, template_upper, template_stride,
                                       src_array, i,
                                       &(src_l[i]), &(src_u[i]), &(src_s[i]),
                                       &(dst_l[dst_dim_index]), &(dst_u[dst_dim_index]), &(dst_s[dst_dim_index]))) {
            dst_dim_index++;
            break;
          } else {
            return _XMP_N_INT_FALSE;
          }
        } else if (dst_dim_index < dst_dim) {
          dst_dim_index++;
        } else {
          _XMP_fatal("wrong assign statement for gmove");
        }
      } while (1);
    }
  }
 
  return _XMP_N_INT_TRUE;
}

Here is the call graph for this function:

_XMP_calc_global_index_HOMECOPY()

int _XMP_calc_global_index_HOMECOPY	(	_XMP_array_t *	dst_array,
		int	dst_dim_index,
		int *	dst_l,
		int *	dst_u,
		int *	dst_s,
		int *	src_l,
		int *	src_u,
		int *	src_s
	)

                                                                        {
  int align_template_index = dst_array->info[dst_dim_index].align_template_index;
  if (align_template_index != _XMP_N_NO_ALIGN_TEMPLATE) {
    _XMP_template_chunk_t *tc = &((dst_array->align_template)->chunk[align_template_index]);
    return _XMP_sched_gmove_triplet(tc->par_lower, tc->par_upper, tc->par_stride,
                                    dst_array, dst_dim_index,
                                    dst_l, dst_u, dst_s,
                                    src_l, src_u, src_s);
  } else {
    return _XMP_N_INT_TRUE;
  }
}

Here is the caller graph for this function:

_XMP_calc_gmove_array_owner_linear_rank_SCALAR()

int _XMP_calc_gmove_array_owner_linear_rank_SCALAR	(	_XMP_array_t *	array,
		int *	ref_index
	)

                                                                                        {
  _XMP_nodes_t *array_nodes = array->array_nodes;
  int array_nodes_dim = array_nodes->dim;
  int rank_array[array_nodes_dim];
 
  _XMP_calc_gmove_rank_array_SCALAR(array, ref_index, rank_array);
 
  return _XMP_calc_linear_rank_on_target_nodes(array_nodes, rank_array, _XMP_get_execution_nodes());
}

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_array_t *	array,
		int *	ref_index,
		int *	rank_array
	)

                                                                                             {
  _XMP_template_t *template = array->align_template;
 
  int array_dim = array->dim;
  for (int i = 0; i < array_dim; i++) {
    _XMP_array_info_t *ai = &(array->info[i]);
    int template_index = ai->align_template_index;
     if (template_index != _XMP_N_NO_ALIGN_TEMPLATE) {
      _XMP_template_chunk_t *chunk = &(template->chunk[ai->align_template_index]);
      int onto_nodes_index = chunk->onto_nodes_index;
      _XMP_ASSERT(array_nodes_index != _XMP_N_NO_ONTO_NODES);
      if (onto_nodes_index == -1) continue;
      int array_nodes_index = _XMP_calc_nodes_index_from_inherit_nodes_index(array->array_nodes, onto_nodes_index);
      rank_array[array_nodes_index] = _XMP_calc_template_owner_SCALAR(template, template_index,
                                                                      ref_index[i] + ai->align_subscript);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_check_gmove_array_ref_inclusion_SCALAR()

int _XMP_check_gmove_array_ref_inclusion_SCALAR	(	_XMP_array_t *	array,
		int	array_index,
		int	ref_index
	)

                                                                                                     {
  _XMP_ASSERT(!(array->align_template)->is_owner);
 
  _XMP_array_info_t *ai = &(array->info[array_index]);
  if (ai->align_manner == _XMP_N_ALIGN_NOT_ALIGNED) {
    return _XMP_N_INT_TRUE;
  } else {
    int template_ref_index = ref_index + ai->align_subscript;
    return _XMP_check_template_ref_inclusion(template_ref_index, template_ref_index, 1,
                                             array->align_template, ai->align_template_index);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_copy_scalar_array()

void _XMP_copy_scalar_array	(	char *	scalar,
		_XMP_array_t *	a,
		_XMP_comm_set_t *	comm_set[]
	)

                                                                                       {
 
  int ndims = a->dim;
 
  char *dst = (char *)a->array_addr_p;
 
  _XMP_comm_set_t *c[ndims];
 
  int i[_XMP_N_MAX_DIM];
 
  switch (ndims){
 
  case 1:
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    break;
 
  case 2:
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    break;
 
  case 3:
    for (c[2] = comm_set[2]; c[2]; c[2] = c[2]->next){
      for (i[2] = c[2]->l; i[2] <= c[2]->u; i[2]++){
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    }}
    break;
 
  case 4:
    for (c[3] = comm_set[3]; c[3]; c[3] = c[3]->next){
      for (i[3] = c[3]->l; i[3] <= c[3]->u; i[3]++){
    for (c[2] = comm_set[2]; c[2]; c[2] = c[2]->next){
      for (i[2] = c[2]->l; i[2] <= c[2]->u; i[2]++){
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    }}
    }}
    break;
 
  case 5:
    for (c[4] = comm_set[4]; c[4]; c[4] = c[4]->next){
      for (i[4] = c[4]->l; i[4] <= c[4]->u; i[4]++){
    for (c[3] = comm_set[3]; c[3]; c[3] = c[3]->next){
      for (i[3] = c[3]->l; i[3] <= c[3]->u; i[3]++){
    for (c[2] = comm_set[2]; c[2]; c[2] = c[2]->next){
      for (i[2] = c[2]->l; i[2] <= c[2]->u; i[2]++){
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    }}
    }}
    }}
    break;
 
  case 6:
    for (c[5] = comm_set[5]; c[5]; c[5] = c[5]->next){
      for (i[5] = c[5]->l; i[5] <= c[5]->u; i[5]++){
    for (c[4] = comm_set[4]; c[4]; c[4] = c[4]->next){
      for (i[4] = c[4]->l; i[4] <= c[4]->u; i[4]++){
    for (c[3] = comm_set[3]; c[3]; c[3] = c[3]->next){
      for (i[3] = c[3]->l; i[3] <= c[3]->u; i[3]++){
    for (c[2] = comm_set[2]; c[2]; c[2] = c[2]->next){
      for (i[2] = c[2]->l; i[2] <= c[2]->u; i[2]++){
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    }}
    }}
    }}
    }}
    break;
 
  case 7:
    for (c[6] = comm_set[6]; c[6]; c[6] = c[6]->next){
      for (i[6] = c[6]->l; i[6] <= c[6]->u; i[6]++){
    for (c[5] = comm_set[5]; c[5]; c[5] = c[5]->next){
      for (i[5] = c[5]->l; i[5] <= c[5]->u; i[5]++){
    for (c[4] = comm_set[4]; c[4]; c[4] = c[4]->next){
      for (i[4] = c[4]->l; i[4] <= c[4]->u; i[4]++){
    for (c[3] = comm_set[3]; c[3]; c[3] = c[3]->next){
      for (i[3] = c[3]->l; i[3] <= c[3]->u; i[3]++){
    for (c[2] = comm_set[2]; c[2]; c[2] = c[2]->next){
      for (i[2] = c[2]->l; i[2] <= c[2]->u; i[2]++){
    for (c[1] = comm_set[1]; c[1]; c[1] = c[1]->next){
      for (i[1] = c[1]->l; i[1] <= c[1]->u; i[1]++){
    for (c[0] = comm_set[0]; c[0]; c[0] = c[0]->next){
      for (i[0] = c[0]->l; i[0] <= c[0]->u; i[0]++){
        memcpy(dst + _XMP_gtol_calc_offset(a, i), scalar, a->type_size);
    }}
    }}
    }}
    }}
    }}
    }}
    }}
    break;
 
  default:
    _XMP_fatal("wrong array dimension");
  }
 
}

Here is the call graph for this function:

_XMP_get_array_addr()

void* _XMP_get_array_addr	(	_XMP_array_t *	a,
		int *	gidx
	)

{
  int ndims = a->dim;
  void *ret = a->array_addr_p;
 
  _XMP_ASSERT(a->is_allocated);
 
  for (int i = 0; i < ndims; i++){
 
    _XMP_array_info_t *ai = &(a->info[i]);
    _XMP_template_info_t *ti = &(a->align_template->info[ai->align_template_index]);
    _XMP_template_chunk_t *tc = &(a->align_template->chunk[ai->align_template_index]);
    int lidx = 0;
    int offset;
    int glb, t_lb, np, w;
    int l_shadow;
    size_t type_size = a->type_size;
 
    switch (ai->align_manner){
 
      case _XMP_N_ALIGN_NOT_ALIGNED:
        lidx = gidx[i] - ai->ser_lower;
        break;
 
      case _XMP_N_ALIGN_DUPLICATION:
        lidx = gidx[i] - ai->ser_lower;
        break;
 
      case _XMP_N_ALIGN_BLOCK:
        // par_lower is the index of the lower bound of the local section.
        glb = ai->par_lower;
        l_shadow = ai->shadow_size_lo;
        lidx = gidx[i] - glb + l_shadow;
        break;
 
      case _XMP_N_ALIGN_CYCLIC:
        // assumed that even a cyclic array is distributed equally
        offset = ai->align_subscript;
        t_lb = ti->ser_lower;
        np = ai->par_stride;
        lidx = (gidx[i] + offset - t_lb) / np;
        break;
 
      case _XMP_N_ALIGN_BLOCK_CYCLIC:
        // assumed that even a cyclic array is distributed equally
        offset = ai->align_subscript;
        t_lb = ti->ser_lower;
        np = ai->par_stride;
        w = tc->par_stride;
        lidx = w * ((gidx[i] + offset - t_lb) / (np * w))
             + ((gidx[i] + offset - t_lb) % w);
        break;
 
      default:
        _XMP_fatal("_XMP_get_array_addr: unknown align_manner");
    }
 
    //xmpf_dbg_printf("a->array_addr_p = %p\n", a->array_addr_p);
    //xmpf_dbg_printf("ret = %p, lidx = %d, ai->dim_acc = %d\n", ret, lidx, ai->dim_acc);
    ret = (char *)ret + lidx * ai->dim_acc * type_size;
  }
 
  return ret;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gmove_array_array_common()

void _XMP_gmove_array_array_common	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int *	dst_l,
		int *	dst_u,
		int *	dst_s,
		unsigned long long *	dst_d,
		int *	src_l,
		int *	src_u,
		int *	src_s,
		unsigned long long *	src_d,
		int	mode
	)

                                            {
  // NOTE: asynchronous gmove aloways done by _XMP_gmove_1to1
  if (!xmp_is_async() && gmv_desc_leftp->is_global && gmv_desc_rightp->is_global && mode == _XMP_N_GMOVE_NORMAL){
    if (_XMP_gmove_garray_garray_opt(gmv_desc_leftp, gmv_desc_rightp,
                                     dst_l, dst_u, dst_s, dst_d,
                                     src_l, src_u, src_s, src_d)) return;
    // fall through
  }
 
  _XMP_gmove_1to1(gmv_desc_leftp, gmv_desc_rightp, mode);
 
  return;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gmove_bcast_ARRAY()

unsigned long long _XMP_gmove_bcast_ARRAY	(	void *	dst_addr,
		int	dst_dim,
		int *	dst_l,
		int *	dst_u,
		int *	dst_s,
		unsigned long long *	dst_d,
		void *	src_addr,
		int	src_dim,
		int *	src_l,
		int *	src_u,
		int *	src_s,
		unsigned long long *	src_d,
		int	type,
		size_t	type_size,
		int	root_rank
	)

                                                                                     {
  unsigned long long dst_buffer_elmts = 1;
  for (int i = 0; i < dst_dim; i++) {
    dst_buffer_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
  }
 
  void *buffer = _XMP_alloc(dst_buffer_elmts * type_size);
 
  _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
  _XMP_ASSERT(exec_nodes->is_member);
 
  if (root_rank == (exec_nodes->comm_rank)) {
    unsigned long long src_buffer_elmts = 1;
    for (int i = 0; i < src_dim; i++) {
      src_buffer_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
    }
 
    if (dst_buffer_elmts != src_buffer_elmts) {
      _XMP_fatal("wrong assign statement for gmove");
    } else {
      (*_xmp_pack_array)(buffer, src_addr, type, type_size, src_dim, src_l, src_u, src_s, src_d);
    }
  }
 
  _XMP_gmove_bcast(buffer, type_size, dst_buffer_elmts, root_rank);
 
  (*_xmp_unpack_array)(dst_addr, buffer, type, type_size, dst_dim, dst_l, dst_u, dst_s, dst_d);
  _XMP_free(buffer);
 
  return dst_buffer_elmts;
}

Here is the call graph for this function:

_XMP_gmove_BCAST_GSCALAR()

void _XMP_gmove_BCAST_GSCALAR	(	void *	dst_addr,
		_XMP_array_t *	array,
		int	ref_index[]
	)

                                                                                   {
 
  _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
  _XMP_ASSERT(exec_nodes->is_member);
 
  void *src_addr = NULL;
  int type_size = array->type_size;
 
  if(_XMP_IS_SINGLE) {
    src_addr = _XMP_get_array_addr(array, ref_index);
    memcpy(dst_addr, src_addr, type_size);
    return;
  }
 
  int root_rank = _XMP_calc_gmove_array_owner_linear_rank_SCALAR(array, ref_index);
 
  if (root_rank == exec_nodes->comm_rank){
    // I am the root.
    src_addr = _XMP_get_array_addr(array, ref_index);
    memcpy(dst_addr, src_addr, type_size);
  }
 
  _XMP_gmove_bcast(dst_addr, type_size, 1, root_rank);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gmove_calc_unit_size()

void _XMP_gmove_calc_unit_size	(	_XMP_array_t *	dst_array,
		_XMP_array_t *	src_array,
		unsigned long long *	alltoall_unit_size,
		unsigned long long *	dst_pack_unit_size,
		unsigned long long *	src_pack_unit_size,
		unsigned long long *	dst_ser_size,
		unsigned long long *	src_ser_size,
		int	dst_block_dim,
		int	src_block_dim
	)

                                                                    {
 
  int dst_dim=dst_array->dim, src_dim=src_array->dim;
  int dst_chunk_size[_XMP_N_MAX_DIM], src_chunk_size[_XMP_N_MAX_DIM];
 
  *alltoall_unit_size=1;
  *dst_pack_unit_size=1;
  *src_pack_unit_size=1;
  *dst_ser_size=1;
  *src_ser_size=1;
 
  if ((_XMPF_running == 1) && (_XMPC_running == 0)){
    for(int i=0; i<dst_dim; i++){
      if(i==dst_block_dim){
        dst_chunk_size[dst_block_dim]=dst_array->info[dst_block_dim].par_size;
      }else if(i==src_block_dim){
        dst_chunk_size[src_block_dim]=src_array->info[src_block_dim].par_size;
      }else{
        dst_chunk_size[i]=dst_array->info[i].ser_size;
      }
    }
    for(int i=0; i<src_dim; i++){
      if(i==dst_block_dim){
        src_chunk_size[i]=dst_array->info[i].par_size;
      }else if(i==src_block_dim){
        src_chunk_size[i]=src_array->info[i].par_size;
      }else{
        src_chunk_size[i]=src_array->info[i].ser_size;
      }
      *alltoall_unit_size *= src_chunk_size[i];
    }
    for(int i=0; i<dst_block_dim+1; i++){
      *src_pack_unit_size *= src_chunk_size[i];
      *src_ser_size *= src_array->info[i].par_size;
    }
    for(int i=0; i<src_block_dim+1; i++){
      *dst_pack_unit_size *= dst_chunk_size[i];
      *dst_ser_size *= dst_array->info[i].par_size;
    }
  }
 
  if ((_XMPF_running == 0) && (_XMPC_running == 1)){
    for(int i=dst_dim-1; i> -1; i--){
      if(i==dst_block_dim){
        dst_chunk_size[i]=dst_array->info[i].par_size;
      }else if(i==src_block_dim){
        dst_chunk_size[i]=src_array->info[i].par_size;
      }else{
        dst_chunk_size[i]=dst_array->info[i].ser_size;
      }
    }
    for(int i=src_dim-1; i>-1; i--){
      if(i==dst_block_dim){
        src_chunk_size[i]=dst_array->info[i].par_size;
      }else if(i==src_block_dim){
        src_chunk_size[i]=src_array->info[i].par_size;
      }else{
        src_chunk_size[i]=src_array->info[i].ser_size;
      }
      *alltoall_unit_size *= src_chunk_size[i];
    }
    for(int i=src_array->dim-1; i>dst_block_dim-1; i--){
      *src_pack_unit_size *= src_chunk_size[i];
      *src_ser_size *= src_array->info[i].par_size;
    }
    for(int i=src_array->dim-1; i>src_block_dim-1; i--){
      *dst_pack_unit_size *= dst_chunk_size[i];
      *dst_ser_size *= dst_array->info[i].par_size;
    }
  }
 
}

_XMP_gmove_garray_garray()

void _XMP_gmove_garray_garray	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int	mode
	)

{
  _XMP_array_t *dst_array = gmv_desc_leftp->a_desc;
  _XMP_array_t *src_array = gmv_desc_rightp->a_desc;
 
  _XMP_ASSERT(src_array->type == type);
  _XMP_ASSERT(src_array->type_size == dst_array->type_size);
 
  //unsigned long long gmove_total_elmts = 0;
 
  // get dst info
  unsigned long long dst_total_elmts = 1;
  int dst_dim = dst_array->dim;
  int dst_l[dst_dim], dst_u[dst_dim], dst_s[dst_dim];
  unsigned long long dst_d[dst_dim];
  int dst_scalar_flag = 1;
  for (int i = 0; i < dst_dim; i++) {
    dst_l[i] = gmv_desc_leftp->lb[i];
    dst_u[i] = gmv_desc_leftp->ub[i];
    dst_s[i] = gmv_desc_leftp->st[i];
    dst_d[i] = dst_array->info[i].dim_acc;
    _XMP_normalize_array_section(gmv_desc_leftp, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
    if (dst_s[i] != 0) dst_total_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
    dst_scalar_flag &= (dst_s[i] == 0);
  }
 
  // get src info
  unsigned long long src_total_elmts = 1;
  int src_dim = src_array->dim;
  int src_l[src_dim], src_u[src_dim], src_s[src_dim];
  unsigned long long src_d[src_dim];
  int src_scalar_flag = 1;
  for (int i = 0; i < src_dim; i++) {
    src_l[i] = gmv_desc_rightp->lb[i];
    src_u[i] = gmv_desc_rightp->ub[i];
    src_s[i] = gmv_desc_rightp->st[i];
    src_d[i] = src_array->info[i].dim_acc;
    _XMP_normalize_array_section(gmv_desc_rightp, i, &(src_l[i]), &(src_u[i]), &(src_s[i]));
    if (src_s[i] != 0) src_total_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
    src_scalar_flag &= (src_s[i] == 0);
  }
 
  if (dst_total_elmts != src_total_elmts && !src_scalar_flag){
    _XMP_fatal("wrong assign statement for gmove");
  }
  else {
    //gmove_total_elmts = dst_total_elmts;
  }
 
  if (mode == _XMP_N_GMOVE_NORMAL){
 
    if (dst_scalar_flag && src_scalar_flag){
      void *dst_addr = (char *)dst_array->array_addr_p + _XMP_gtol_calc_offset(dst_array, dst_l);
      void *src_addr = (char *)src_array->array_addr_p + _XMP_gtol_calc_offset(src_array, src_l);
      _XMP_gmove_SENDRECV_GSCALAR(dst_addr, src_addr,
                                  dst_array, src_array,
                                  dst_l, src_l);
      return;
    }
    else if (!dst_scalar_flag && src_scalar_flag){
      char *tmp = _XMP_alloc(src_array->type_size);
      //char *src_addr = (char *)src_array->array_addr_p + _XMP_gtol_calc_offset(src_array, src_l);
      //_XMP_gmove_BCAST_GSCALAR(tmp, src_addr, src_array, src_l);
      _XMP_gmove_BCAST_GSCALAR(tmp, src_array, src_l);
      _XMP_gmove_gsection_scalar(dst_array, dst_l, dst_u, dst_s, tmp);
      _XMP_free(tmp);
      return;
    }
  }
 
  _XMP_gmove_array_array_common(gmv_desc_leftp, gmv_desc_rightp,
                                dst_l, dst_u, dst_s, dst_d,
                                src_l, src_u, src_s, src_d,
                                mode);
}

Here is the call graph for this function:

_XMP_gmove_garray_larray()

void _XMP_gmove_garray_larray	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int	mode
	)

{
  _XMP_array_t *dst_array = gmv_desc_leftp->a_desc;
 
  int type = dst_array->type;
  size_t type_size = dst_array->type_size;
 
  if (!dst_array->is_allocated && mode != _XMP_N_GMOVE_OUT) return;
 
  // get dst info
  unsigned long long dst_total_elmts = 1;
  void *dst_addr = dst_array->array_addr_p;
  int dst_dim = dst_array->dim;
  int dst_l[dst_dim], dst_u[dst_dim], dst_s[dst_dim];
  unsigned long long dst_d[dst_dim];
  int dst_scalar_flag = 1;
  for (int i = 0; i < dst_dim; i++) {
    dst_l[i] = gmv_desc_leftp->lb[i];
    dst_u[i] = gmv_desc_leftp->ub[i];
    dst_s[i] = gmv_desc_leftp->st[i];
    dst_d[i] = dst_array->info[i].dim_acc;
    _XMP_normalize_array_section(gmv_desc_leftp, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
    if (dst_s[i] != 0) dst_total_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
    dst_scalar_flag &= (dst_s[i] == 0);
  }
 
  // get src info
  unsigned long long src_total_elmts = 1;
  void *src_addr = gmv_desc_rightp->local_data;
  int src_dim = gmv_desc_rightp->ndims;
  int src_l[src_dim], src_u[src_dim], src_s[src_dim];
  unsigned long long src_d[src_dim];
  int src_scalar_flag = 1;
  for (int i = 0; i < src_dim; i++) {
    src_l[i] = gmv_desc_rightp->lb[i];
    src_u[i] = gmv_desc_rightp->ub[i];
    src_s[i] = gmv_desc_rightp->st[i];
    if (i == 0) src_d[i] = 1;
    else src_d[i] = src_d[i-1] * (gmv_desc_rightp->a_ub[i] - gmv_desc_rightp->a_lb[i] + 1);
    _XMP_normalize_array_section(gmv_desc_rightp, i, &(src_l[i]), &(src_u[i]), &(src_s[i]));
    if (src_s[i] != 0) src_total_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
    src_scalar_flag &= (src_s[i] == 0);
  }
 
  if (dst_total_elmts != src_total_elmts && !src_scalar_flag){
    _XMP_fatal("wrong assign statement for gmove");
  }
 
  char *scalar = (char *)src_addr;
  if (src_scalar_flag){
    for (int i = 0; i < src_dim; i++){
      scalar += ((src_l[i] - gmv_desc_rightp->a_lb[i]) * src_d[i] * type_size);
    }
  }
 
  if (mode == _XMP_N_GMOVE_OUT){
    if (src_scalar_flag){
#ifdef _XMP_MPI3_ONESIDED
      _XMP_gmove_inout_scalar(scalar, gmv_desc_leftp, _XMP_N_COARRAY_PUT);
#else
      _XMP_fatal("Not supported gmove in/out on non-MPI3 environments");
#endif
    }
    else {
      _XMP_gmove_array_array_common(gmv_desc_leftp, gmv_desc_rightp,
                                    dst_l, dst_u, dst_s, dst_d,
                                    src_l, src_u, src_s, src_d,
                                    mode);
    }
    return;
  }
 
  if (dst_scalar_flag && src_scalar_flag){
    _XMP_gmove_garray_scalar(gmv_desc_leftp, scalar, mode);
    return;
  }
 
  if (_XMP_IS_SINGLE) {
    for (int i = 0; i < dst_dim; i++) {
      _XMP_gtol_array_ref_triplet(dst_array, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
    }
 
    _XMP_gmove_localcopy_ARRAY(type, type_size,
                               dst_addr, dst_dim, dst_l, dst_u, dst_s, dst_d,
                               src_addr, src_dim, src_l, src_u, src_s, src_d);
    return;
  }
 
  for (int i = 0; i < src_dim; i++){
    src_l[i] -= gmv_desc_rightp->a_lb[i];
    src_u[i] -= gmv_desc_rightp->a_lb[i];
  }
 
  // calc index ref
  int src_dim_index = 0;
  unsigned long long dst_buffer_elmts = 1;
  unsigned long long src_buffer_elmts = 1;
  for (int i = 0; i < dst_dim; i++) {
    int dst_elmts = _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
    if (dst_elmts == 1) {
      if(!_XMP_check_gmove_array_ref_inclusion_SCALAR(dst_array, i, dst_l[i])) {
        return;
      }
    } else {
      dst_buffer_elmts *= dst_elmts;
 
      int src_elmts;
      do {
        src_elmts = _XMP_M_COUNT_TRIPLETi(src_l[src_dim_index], src_u[src_dim_index], src_s[src_dim_index]);
        if (src_elmts != 1) {
          break;
        } else if (src_dim_index < src_dim) {
          src_dim_index++;
        } else {
          _XMP_fatal("wrong assign statement for gmove");
        }
      } while (1);
 
      if (_XMP_calc_global_index_HOMECOPY(dst_array, i,
                                          &(dst_l[i]), &(dst_u[i]), &(dst_s[i]),
                                          &(src_l[src_dim_index]), &(src_u[src_dim_index]), &(src_s[src_dim_index]))) {
        src_buffer_elmts *= src_elmts;
        src_dim_index++;
      } else {
        return;
      }
    }
 
    _XMP_gtol_array_ref_triplet(dst_array, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
  }
 
  for (int i = src_dim_index; i < src_dim; i++) {
    src_buffer_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
  }
 
  // alloc buffer
  if (dst_buffer_elmts != src_buffer_elmts) {
    _XMP_fatal("wrong assign statement for gmove");
  }
 
  void *buffer = _XMP_alloc(dst_buffer_elmts * type_size);
  (*_xmp_pack_array)(buffer, src_addr, type, type_size, src_dim, src_l, src_u, src_s, src_d);
  (*_xmp_unpack_array)(dst_addr, buffer, type, type_size, dst_dim, dst_l, dst_u, dst_s, dst_d);
  _XMP_free(buffer);
}

Here is the call graph for this function:

_XMP_gmove_garray_scalar()

void _XMP_gmove_garray_scalar	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		void *	scalar,
		int	mode
	)

{
  if (mode == _XMP_N_GMOVE_NORMAL){
    _XMP_array_t *array = gmv_desc_leftp->a_desc;
    int type_size = array->type_size;
    void *dst_addr = NULL;
    _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
 
    int ndims = gmv_desc_leftp->ndims;
    int lidx[ndims];
 
    for (int i=0;i<ndims;i++)
      lidx[i] = gmv_desc_leftp->lb[i];
 
    int owner_rank = _XMP_calc_gmove_array_owner_linear_rank_SCALAR(array, lidx);
 
    if (owner_rank == exec_nodes->comm_rank){      // I am the owner.
      dst_addr = _XMP_get_array_addr(array, lidx);
      memcpy(dst_addr, scalar, type_size);
    }
  }
  else if (mode == _XMP_N_GMOVE_OUT){
#ifdef _XMP_MPI3_ONESIDED
    _XMP_gmove_inout_scalar(scalar, gmv_desc_leftp, _XMP_N_COARRAY_PUT);
#else
    _XMP_fatal("Not supported gmove in/out on non-MPI3 environments");
#endif
  }
  else {
    _XMP_fatal("_XMPF_gmove_garray_scalar: wrong gmove mode");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gmove_INOUT_SCALAR()

void _XMP_gmove_INOUT_SCALAR	(	_XMP_array_t *	dst_array,
		void *	scalar,
			...
	)

                                                                        {
 
  _XMP_gmv_desc_t gmv_desc_leftp;
 
  va_list args;
  va_start(args, scalar);
 
  // get dst info
  //unsigned long long dst_total_elmts = 1;
  int dst_dim = dst_array->dim;
  int dst_l[dst_dim], dst_u[dst_dim], dst_s[dst_dim];
  //unsigned long long dst_d[dst_dim];
  for (int i = 0; i < dst_dim; i++) {
    dst_l[i] = va_arg(args, int);
    int size = va_arg(args, int);
    dst_s[i] = va_arg(args, int);
    dst_u[i] = dst_l[i] + (size - 1) * dst_s[i];
    //dst_d[i] = va_arg(args, unsigned long long);
    va_arg(args, unsigned long long); // skip the argument
    _XMP_normalize_array_section(&gmv_desc_leftp, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
    //if (dst_s[i] != 0) dst_total_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
  }
 
  //int mode = va_arg(args, int);
 
  va_end(args);
 
  _XMP_ASSERT(mode != _XMP_N_GMOVE_NORMAL);
 
#ifdef _XMP_MPI3_ONESIDED
  _XMP_gmv_desc_t gmv_desc;
  int kind[_XMP_N_MAX_DIM];
  for (int i = 0; i < dst_dim; i++){
    kind[i] = (dst_s[i] == 0) ? XMP_N_GMOVE_INDEX : XMP_N_GMOVE_RANGE;
  }
 
  gmv_desc.is_global = true;
  gmv_desc.ndims = dst_dim;
 
  gmv_desc.a_desc = dst_array;
 
  gmv_desc.local_data = NULL;
  gmv_desc.a_lb = NULL;
  gmv_desc.a_ub = NULL;
 
  gmv_desc.kind = kind;
  gmv_desc.lb = dst_l;
  gmv_desc.ub = dst_u;
  gmv_desc.st = dst_s;
 
  _XMP_gmove_inout_scalar(scalar, &gmv_desc, _XMP_N_COARRAY_PUT);
#else
  _XMP_fatal("Not supported gmove in/out on non-MPI3 environments");
#endif
 
}

Here is the call graph for this function:

_XMP_gmove_larray_garray()

void _XMP_gmove_larray_garray	(	_XMP_gmv_desc_t *	gmv_desc_leftp,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int	mode
	)

{
  _XMP_array_t *src_array = gmv_desc_rightp->a_desc;
  size_t type_size = src_array->type_size;
 
  // get dst info
  unsigned long long dst_total_elmts = 1;
  int dst_dim = gmv_desc_leftp->ndims;
  int dst_l[dst_dim], dst_u[dst_dim], dst_s[dst_dim];
  unsigned long long dst_d[dst_dim];
  int dst_scalar_flag = 1;
  for(int i=0;i<dst_dim;i++){
    dst_l[i] = gmv_desc_leftp->lb[i];
    dst_u[i] = gmv_desc_leftp->ub[i];
    dst_s[i] = gmv_desc_leftp->st[i];
    dst_d[i] = (i == 0)? 1 : dst_d[i-1]*(gmv_desc_leftp->a_ub[i] - gmv_desc_leftp->a_lb[i]+1);
    _XMP_normalize_array_section(gmv_desc_leftp, i, &(dst_l[i]), &(dst_u[i]), &(dst_s[i]));
    if (dst_s[i] != 0)
      dst_total_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
    dst_scalar_flag &= (dst_s[i] == 0);
  }
 
  // get src info
  unsigned long long src_total_elmts = 1;
  int src_dim = src_array->dim;
  int src_l[src_dim], src_u[src_dim], src_s[src_dim];
  unsigned long long src_d[src_dim];
  int src_scalar_flag = 1;
  for(int i=0;i<src_dim;i++) {
    src_l[i] = gmv_desc_rightp->lb[i];
    src_u[i] = gmv_desc_rightp->ub[i];
    src_s[i] = gmv_desc_rightp->st[i];
    src_d[i] = src_array->info[i].dim_acc;
    _XMP_normalize_array_section(gmv_desc_rightp, i, &(src_l[i]), &(src_u[i]), &(src_s[i]));
    if (src_s[i] != 0) src_total_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
    src_scalar_flag &= (src_s[i] == 0);
  }
 
  if(dst_total_elmts != src_total_elmts && !src_scalar_flag){
    _XMP_fatal("wrong assign statement for gmove");
  }
 
  if (mode == _XMP_N_GMOVE_NORMAL){
    if (dst_scalar_flag && src_scalar_flag){
      char *dst_addr = (char *)gmv_desc_leftp->local_data;
      for (int i = 0; i < dst_dim; i++)
        dst_addr += ((dst_l[i] - gmv_desc_leftp->a_lb[i]) * dst_d[i]) * type_size;
      _XMP_gmove_BCAST_GSCALAR(dst_addr, src_array, src_l);
      return;
    }
    else if (!dst_scalar_flag && src_scalar_flag){
      char *tmp = _XMP_alloc(src_array->type_size);
      _XMP_gmove_BCAST_GSCALAR(tmp, src_array, src_l);
      char *dst_addr = (char *)gmv_desc_leftp->local_data;
 
      // to 0-based
      for (int i = 0; i < dst_dim; i++) {
        dst_l[i] -= gmv_desc_leftp->a_lb[i];
        dst_u[i] -= gmv_desc_leftp->a_lb[i];
      }
 
      _XMP_gmove_lsection_scalar(dst_addr, dst_dim, dst_l, dst_u, dst_s, dst_d, tmp, type_size);
      _XMP_free(tmp);
      return;
    }
    else {
      //gmove_total_elmts = dst_total_elmts;
    }
  }
 
  _XMP_gmove_array_array_common(gmv_desc_leftp, gmv_desc_rightp,
                                dst_l, dst_u, dst_s, dst_d,
                                src_l, src_u, src_s, src_d,
                                mode);
}

Here is the call graph for this function:

_XMP_gmove_localcopy_ARRAY()

void _XMP_gmove_localcopy_ARRAY	(	int	type,
		int	type_size,
		void *	dst_addr,
		int	dst_dim,
		int *	dst_l,
		int *	dst_u,
		int *	dst_s,
		unsigned long long *	dst_d,
		void *	src_addr,
		int	src_dim,
		int *	src_l,
		int *	src_u,
		int *	src_s,
		unsigned long long *	src_d
	)

                                                                                                      {
  unsigned long long dst_buffer_elmts = 1;
  for (int i = 0; i < dst_dim; i++) {
    dst_buffer_elmts *= _XMP_M_COUNT_TRIPLETi(dst_l[i], dst_u[i], dst_s[i]);
  }
 
  unsigned long long src_buffer_elmts = 1;
  for (int i = 0; i < src_dim; i++) {
    src_buffer_elmts *= _XMP_M_COUNT_TRIPLETi(src_l[i], src_u[i], src_s[i]);
  }
 
  if (dst_buffer_elmts != src_buffer_elmts) {
    _XMP_fatal("wrong assign statement for gmove");
  }
 
  void *buffer = _XMP_alloc(dst_buffer_elmts * type_size);
  (*_xmp_pack_array)(buffer, src_addr, type, type_size, src_dim, src_l, src_u, src_s, src_d);
  (*_xmp_unpack_array)(dst_addr, buffer, type, type_size, dst_dim, dst_l, dst_u, dst_s, dst_d);
  _XMP_free(buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gmove_scalar_garray()

void _XMP_gmove_scalar_garray	(	void *	scalar,
		_XMP_gmv_desc_t *	gmv_desc_rightp,
		int	mode
	)

{
  if (mode == _XMP_N_GMOVE_NORMAL){
    _XMP_array_t *array = gmv_desc_rightp->a_desc;
    int ndims = gmv_desc_rightp->ndims;
    int ridx[ndims];
 
    for (int i=0;i<ndims;i++)
      ridx[i] = gmv_desc_rightp->lb[i];
 
    _XMP_gmove_BCAST_GSCALAR(scalar, array, ridx);
  }
  else if (mode == _XMP_N_GMOVE_IN){
#ifdef _XMP_MPI3_ONESIDED
    _XMP_gmove_inout_scalar(scalar, gmv_desc_rightp, _XMP_N_COARRAY_GET);
#else
    _XMP_fatal("Not supported gmove in/out on non-MPI3 environments");
#endif
  }
  else {
    _XMP_fatal("_XMPF_gmove_scalar_garray: wrong gmove mode");
  }
}

Here is the call graph for this function:

_XMP_gmove_SENDRECV_GSCALAR()

void _XMP_gmove_SENDRECV_GSCALAR	(	void *	dst_addr,
		void *	src_addr,
		_XMP_array_t *	dst_array,
		_XMP_array_t *	src_array,
		int	dst_ref_index[],
		int	src_ref_index[]
	)

                                                                           {
  _XMP_ASSERT(dst_array->type_size == src_array->type_size);
  size_t type_size = dst_array->type_size;
 
  if(_XMP_IS_SINGLE) {
    memcpy(dst_addr, src_addr, type_size);
    return;
  }
 
  _XMP_nodes_ref_t *dst_ref = _XMP_create_gmove_nodes_ref_SCALAR(dst_array, dst_ref_index);
  _XMP_nodes_ref_t *src_ref = _XMP_create_gmove_nodes_ref_SCALAR(src_array, src_ref_index);
 
  _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
  _XMP_ASSERT(exec_nodes->is_member);
 
  int exec_rank = exec_nodes->comm_rank;
  MPI_Comm *exec_comm = exec_nodes->comm;
 
  // calc dst_ranks
  int dst_shrink_nodes_size = dst_ref->shrink_nodes_size;
  int dst_ranks[dst_shrink_nodes_size];
  if (dst_shrink_nodes_size == 1) {
    dst_ranks[0] = _XMP_calc_linear_rank(dst_ref->nodes, dst_ref->ref);
  } else {
    _XMP_translate_nodes_rank_array_to_ranks(dst_ref->nodes, dst_ranks, dst_ref->ref, dst_shrink_nodes_size);
  }
 
  // calc src_ranks
  int src_shrink_nodes_size = src_ref->shrink_nodes_size;
  int src_ranks[src_shrink_nodes_size];
  if (src_shrink_nodes_size == 1) {
    src_ranks[0] = _XMP_calc_linear_rank(src_ref->nodes, src_ref->ref);
  } else {
    _XMP_translate_nodes_rank_array_to_ranks(src_ref->nodes, src_ranks, src_ref->ref, src_shrink_nodes_size);
  }
 
  int wait_recv = _XMP_N_INT_FALSE;
  MPI_Request gmove_request;
  for (int i = 0; i < dst_shrink_nodes_size; i++) {
    if (dst_ranks[i] == exec_rank) {
      wait_recv = _XMP_N_INT_TRUE;
 
      int src_rank;
      if ((dst_shrink_nodes_size == src_shrink_nodes_size) ||
          (dst_shrink_nodes_size <  src_shrink_nodes_size)) {
        src_rank = src_ranks[i];
      } else {
        src_rank = src_ranks[i % src_shrink_nodes_size];
      }
 
      MPI_Irecv(dst_addr, type_size, MPI_BYTE, src_rank, _XMP_N_MPI_TAG_GMOVE, *exec_comm, &gmove_request);
    }
  }
 
  for (int i = 0; i < src_shrink_nodes_size; i++) {
    if (src_ranks[i] == exec_rank) {
      if ((dst_shrink_nodes_size == src_shrink_nodes_size) ||
          (dst_shrink_nodes_size <  src_shrink_nodes_size)) {
        if (i < dst_shrink_nodes_size) {
          MPI_Send(src_addr, type_size, MPI_BYTE, dst_ranks[i], _XMP_N_MPI_TAG_GMOVE, *exec_comm);
        }
      } else {
        int request_size = _XMP_M_COUNT_TRIPLETi(i, dst_shrink_nodes_size, src_shrink_nodes_size);
        MPI_Request *requests = _XMP_alloc(sizeof(MPI_Request) * request_size);
 
        int request_count = 0;
        for (int j = i; j < dst_shrink_nodes_size; j += src_shrink_nodes_size) {
          MPI_Isend(src_addr, type_size, MPI_BYTE, dst_ranks[j], _XMP_N_MPI_TAG_GMOVE, *exec_comm, requests + request_count);
          request_count++;
        }
 
        MPI_Waitall(request_size, requests, MPI_STATUSES_IGNORE);
        _XMP_free(requests);
      }
    }
  }
 
  if (wait_recv) {
    MPI_Wait(&gmove_request, MPI_STATUS_IGNORE);
  }
 
  _XMP_free(dst_ref);
  _XMP_free(src_ref);
}

Here is the caller graph for this function:

_XMP_gtol_array_ref_triplet()

void _XMP_gtol_array_ref_triplet	(	_XMP_array_t *	array,
		int	dim_index,
		int *	lower,
		int *	upper,
		int *	stride
	)

                                                                                     {
  _XMP_array_info_t *array_info = &(array->info[dim_index]);
  if (array_info->shadow_type == _XMP_N_SHADOW_FULL) {
    return;
  }
 
  _XMP_template_t *align_template = array->align_template;
 
  int align_template_index = array_info->align_template_index;
  if (align_template_index != _XMP_N_NO_ALIGN_TEMPLATE) {
    int align_subscript = array_info->align_subscript;
 
    int t_lower = *lower - align_subscript,
        t_upper = *upper - align_subscript,
        t_stride = *stride;
 
    _XMP_template_info_t *ti = &(align_template->info[align_template_index]);
    int template_ser_lower = ti->ser_lower;
 
    _XMP_template_chunk_t *tc = &(align_template->chunk[align_template_index]);
    int template_par_width = tc->par_width;
    int template_par_nodes_size = (tc->onto_nodes_info)->size;
    int template_par_chunk_width = tc->par_chunk_width;
 
    switch (tc->dist_manner) {
      case _XMP_N_DIST_DUPLICATION:
        // do nothing
        break;
      case _XMP_N_DIST_BLOCK:
        {
          t_lower = _XMP_SM_GTOL_BLOCK(t_lower, template_ser_lower, template_par_chunk_width);
          t_upper = _XMP_SM_GTOL_BLOCK(t_upper, template_ser_lower, template_par_chunk_width);
          // t_stride does not change
        } break;
      case _XMP_N_DIST_CYCLIC:
        {
          t_lower = _XMP_SM_GTOL_CYCLIC(t_lower, template_ser_lower, template_par_nodes_size);
          t_upper = _XMP_SM_GTOL_CYCLIC(t_upper, template_ser_lower, template_par_nodes_size);
          t_stride = t_stride / template_par_nodes_size;
        } break;
      case _XMP_N_DIST_BLOCK_CYCLIC:
        {
          t_lower = _XMP_SM_GTOL_BLOCK_CYCLIC(template_par_width, t_lower, template_ser_lower, template_par_nodes_size);
          t_upper = _XMP_SM_GTOL_BLOCK_CYCLIC(template_par_width, t_upper, template_ser_lower, template_par_nodes_size);
          // t_stride does not change (in block)
        } break;
      default:
        _XMP_fatal("wrong distribute manner for normal shadow");
    }
 
    *lower = t_lower + align_subscript;
    *upper = t_upper + align_subscript;
    *stride = t_stride;
  }
 
  _XMP_ASSERT(array_info->shadow_type != _XMP_N_SHADOW_FULL);
  switch (array_info->shadow_type) {
    case _XMP_N_SHADOW_NONE:
      // do nothing
      break;
    case _XMP_N_SHADOW_NORMAL:
      switch (array_info->align_manner) {
        case _XMP_N_ALIGN_NOT_ALIGNED:
        case _XMP_N_ALIGN_DUPLICATION:
        case _XMP_N_ALIGN_BLOCK:
          {
            int shadow_size_lo = array_info->shadow_size_lo;
            *lower += shadow_size_lo;
            *upper += shadow_size_lo;
          } break;
        case _XMP_N_ALIGN_CYCLIC:
          // FIXME not supported now
        case _XMP_N_ALIGN_BLOCK_CYCLIC:
          // FIXME not supported now
        default:
          _XMP_fatal("gmove does not support shadow region for cyclic or block-cyclic distribution");
      } break;
    default:
      _XMP_fatal("unknown shadow type");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_gtol_calc_offset()

unsigned long long _XMP_gtol_calc_offset	(	_XMP_array_t *	a,
		int	g_idx[]
	)

{
  int ndims = a->dim;
  int l_idx[ndims];
  for(int i=0;i<ndims;i++)
    xmp_array_gtol(a, i+1, g_idx[i], &l_idx[i]);
 
  //xmp_dbg_printf("g0 = %d, g1 = %d, l0 = %d, l1 = %d\n", g_idx[0], g_idx[1], l_idx[0], l_idx[1]);
 
  unsigned long long offset = 0;
 
  for (int i = 0; i < a->dim; i++){
    offset += (l_idx[i] * a->info[i].dim_acc * a->type_size);
    //xmp_dbg_printf("(%d) acc = %llu, type_size = %d\n", i, a->info[i].dim_acc, a->type_size);
  }
 
  return offset;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_sendrecv_ARRAY()

void _XMP_sendrecv_ARRAY	(	int	type,
		int	type_size,
		MPI_Datatype *	mpi_datatype,
		_XMP_array_t *	dst_array,
		int *	dst_array_nodes_ref,
		int *	dst_lower,
		int *	dst_upper,
		int *	dst_stride,
		unsigned long long *	dst_dim_acc,
		_XMP_array_t *	src_array,
		int *	src_array_nodes_ref,
		int *	src_lower,
		int *	src_upper,
		int *	src_stride,
		unsigned long long *	src_dim_acc
	)

                                                                                                           {
  _XMP_nodes_t *dst_array_nodes = dst_array->array_nodes;
  _XMP_nodes_t *src_array_nodes = src_array->array_nodes;
  void *dst_addr = dst_array->array_addr_p;
  void *src_addr = src_array->array_addr_p;
  int dst_dim = dst_array->dim;
  int src_dim = src_array->dim;
 
  _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
  _XMP_ASSERT(exec_nodes->is_member);
 
  int exec_rank = exec_nodes->comm_rank;
  MPI_Comm *exec_comm = exec_nodes->comm;
 
  // calc dst_ranks
  _XMP_nodes_ref_t *dst_ref = _XMP_create_nodes_ref_for_target_nodes(dst_array_nodes, dst_array_nodes_ref, exec_nodes);
  int dst_shrink_nodes_size = dst_ref->shrink_nodes_size;
  int dst_ranks[dst_shrink_nodes_size];
  if (dst_shrink_nodes_size == 1) {
    dst_ranks[0] = _XMP_calc_linear_rank(dst_ref->nodes, dst_ref->ref);
  } else {
    _XMP_translate_nodes_rank_array_to_ranks(dst_ref->nodes, dst_ranks, dst_ref->ref, dst_shrink_nodes_size);
  }
 
  unsigned long long total_elmts = 1;
  for (int i = 0; i < dst_dim; i++) {
    total_elmts *= _XMP_M_COUNT_TRIPLETi(dst_lower[i], dst_upper[i], dst_stride[i]);
  }
 
  // calc src_ranks
  _XMP_nodes_ref_t *src_ref = _XMP_create_nodes_ref_for_target_nodes(src_array_nodes, src_array_nodes_ref, exec_nodes);
  int src_shrink_nodes_size = src_ref->shrink_nodes_size;
  int src_ranks[src_shrink_nodes_size];
  if (src_shrink_nodes_size == 1) {
    src_ranks[0] = _XMP_calc_linear_rank(src_ref->nodes, src_ref->ref);
  } else {
    _XMP_translate_nodes_rank_array_to_ranks(src_ref->nodes, src_ranks, src_ref->ref, src_shrink_nodes_size);
  }
 
  unsigned long long src_total_elmts = 1;
  for (int i = 0; i < src_dim; i++) {
    src_total_elmts *= _XMP_M_COUNT_TRIPLETi(src_lower[i], src_upper[i], src_stride[i]);
  }
 
  if (total_elmts != src_total_elmts) {
    _XMP_fatal("wrong assign statement for gmove");
  }
 
  // recv phase
  void *recv_buffer = NULL;
  void *recv_alloc = NULL;
  int wait_recv = _XMP_N_INT_FALSE;
  MPI_Request gmove_request;
  for (int i = 0; i < dst_shrink_nodes_size; i++) {
    if (dst_ranks[i] == exec_rank) {
      wait_recv = _XMP_N_INT_TRUE;
 
      int src_rank;
      if ((dst_shrink_nodes_size == src_shrink_nodes_size) ||
          (dst_shrink_nodes_size <  src_shrink_nodes_size)) {
        src_rank = src_ranks[i];
      } else {
        src_rank = src_ranks[i % src_shrink_nodes_size];
      }
 
      for (int i = 0; i < dst_dim; i++) {
        _XMP_gtol_array_ref_triplet(dst_array, i, &(dst_lower[i]), &(dst_upper[i]), &(dst_stride[i]));
      }
      if(dst_dim == 1 && dst_stride[0] == 1){
        recv_buffer = (char*)dst_addr + type_size * dst_lower[0];
      }else{
        recv_alloc = _XMP_alloc(total_elmts * type_size);
        recv_buffer = recv_alloc;
      }
      MPI_Irecv(recv_buffer, total_elmts, *mpi_datatype, src_rank, _XMP_N_MPI_TAG_GMOVE, *exec_comm, &gmove_request);
      //      fprintf(stderr, "DEBUG: Proc(%d), Irecv(src=%d, total_elmnt=%llu)\n", exec_rank, src_rank, total_elmts);
    }
  }
 
  // send phase
  for (int i = 0; i < src_shrink_nodes_size; i++) {
    if (src_ranks[i] == exec_rank) {
      void *send_buffer = NULL;
      void *send_alloc = NULL;
      for (int j = 0; j < src_dim; j++) {
        _XMP_gtol_array_ref_triplet(src_array, j, &(src_lower[j]), &(src_upper[j]), &(src_stride[j]));
      }
      if(src_dim == 1 && src_stride[0] == 1){
        send_buffer = (char*)src_addr + type_size * src_lower[0];
      }else{
        send_alloc = _XMP_alloc(total_elmts * type_size);
        send_buffer = send_alloc;
        (*_xmp_pack_array)(send_buffer, src_addr, type, type_size, src_dim, src_lower, src_upper, src_stride, src_dim_acc);
      }
      if ((dst_shrink_nodes_size == src_shrink_nodes_size) ||
          (dst_shrink_nodes_size <  src_shrink_nodes_size)) {
        if (i < dst_shrink_nodes_size) {
          MPI_Send(send_buffer, total_elmts, *mpi_datatype, dst_ranks[i], _XMP_N_MPI_TAG_GMOVE, *exec_comm);
          //      fprintf(stderr, "DEBUG: Proc(%d), Send(dst=%d, total_elmnt=%llu)\n", exec_rank, dst_ranks[i], total_elmts);
        }
      } else {
        int request_size = _XMP_M_COUNT_TRIPLETi(i, dst_shrink_nodes_size - 1, src_shrink_nodes_size);
        MPI_Request *requests = _XMP_alloc(sizeof(MPI_Request) * request_size);
 
        int request_count = 0;
        for (int j = i; j < dst_shrink_nodes_size; j += src_shrink_nodes_size) {
          MPI_Isend(send_buffer, total_elmts, *mpi_datatype, dst_ranks[j], _XMP_N_MPI_TAG_GMOVE, *exec_comm,
                    requests + request_count);
          //      fprintf(stderr, "DEBUG: Proc(%d), Isend(dst=%d, total_elmnt=%llu)\n", exec_rank, dst_ranks[j], total_elmts);
          request_count++;
        }
 
        MPI_Waitall(request_size, requests, MPI_STATUSES_IGNORE);
        _XMP_free(requests);
      }
 
      _XMP_free(send_alloc);
    }
  }
 
  // wait recv phase
  if (wait_recv) {
    MPI_Wait(&gmove_request, MPI_STATUS_IGNORE);
    if(! (dst_dim == 1 && dst_stride[0] == 1)){
      (*_xmp_unpack_array)(dst_addr, recv_buffer, type, type_size, dst_dim, dst_lower, dst_upper, dst_stride, dst_dim_acc);
    }
    _XMP_free(recv_alloc);
  }
 
  _XMP_finalize_nodes_ref(dst_ref);
  _XMP_finalize_nodes_ref(src_ref);
}

Here is the call graph for this function:

xmp_calc_gmove_array_owner_linear_rank_scalar_()

int xmp_calc_gmove_array_owner_linear_rank_scalar_	(	_XMP_array_t **	a,
		int *	ref_index
	)

                                                                                     {
  _XMP_array_t *array = *a;
  _XMP_nodes_t *array_nodes = array->array_nodes;
  int array_nodes_dim = array_nodes->dim;
  int rank_array[array_nodes_dim];
 
  _XMP_calc_gmove_rank_array_SCALAR(array, ref_index, rank_array);
 
  return _XMP_calc_linear_rank_on_target_nodes(array_nodes, rank_array, _XMP_get_execution_nodes());
}

Here is the call graph for this function:

Variable Documentation

_alloc_size

int(* _alloc_size)[_XMP_N_MAX_DIM]

_dim_alloc_size

int _dim_alloc_size

_XMP_pack_comm_set

void(* _XMP_pack_comm_set) (void *sendbuf, int sendbuf_size, _XMP_array_t *a, _XMP_comm_set_t *comm_set[][_XMP_N_MAX_DIM])

_XMP_unpack_comm_set

void(* _XMP_unpack_comm_set) (void *recvbuf, int recvbuf_size, _XMP_array_t *a, _XMP_comm_set_t *comm_set[][_XMP_N_MAX_DIM])

gmv_nodes

_XMP_nodes_t* gmv_nodes

n_gmv_nodes

int n_gmv_nodes