xmp_gmove_acc.c File Reference

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

Include dependency graph for xmp_gmove_acc.c:

Data Structures
struct	_XACC_sendrecv_comm_type
struct	_XACC_gmv_comm_type

Macros
#define	_XACC_NUM_COMM_CACHES   4
#define	_XACC_MAX_NUM_SENDRECVS   4

Typedefs
typedef struct _XACC_sendrecv_comm_type	_XACC_sendrecv_comm_t
typedef struct _XACC_gmv_comm_type	_XACC_gmv_comm_t

Functions
void	xmpc_gmv_g_alloc_acc (_XMP_gmv_desc_t **gmv_desc, _XMP_array_t *ap, void *dev_addr)
void	xmpc_gmv_l_alloc_acc (_XMP_gmv_desc_t **gmv_desc, void *local_data, int n)
void	_XMP_gmove_array_array_common_acc (_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)
void	_XMP_gmove_garray_garray_acc (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)
void	xmpc_gmv_do_acc (_XMP_gmv_desc_t *gmv_desc_leftp, _XMP_gmv_desc_t *gmv_desc_rightp, int mode)

Macro Definition Documentation

_XACC_MAX_NUM_SENDRECVS

#define _XACC_MAX_NUM_SENDRECVS   4

_XACC_NUM_COMM_CACHES

#define _XACC_NUM_COMM_CACHES   4

Typedef Documentation

_XACC_gmv_comm_t

typedef struct _XACC_gmv_comm_type _XACC_gmv_comm_t

_XACC_sendrecv_comm_t

typedef struct _XACC_sendrecv_comm_type _XACC_sendrecv_comm_t

Function Documentation

_XMP_gmove_array_array_common_acc()

void _XMP_gmove_array_array_common_acc	(	_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 always 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_acc_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);
  _XMP_fatal("_XMP_gmove_1to1 for acc is not implemented");
 
  return;
 
}

Here is the call graph for this function:

_XMP_gmove_garray_garray_acc()

void _XMP_gmove_garray_garray_acc	(	_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);
 
  _XACC_gmv_comm_t *gmv_comm = find_gmv_comm(gmv_desc_leftp, gmv_desc_rightp);
  if(gmv_comm != NULL){
    //do cached comm
    exec_gmv_comm(gmv_comm);
    return;
  }
 
  g_current_comm.num_recvs = 0;
  g_current_comm.num_sends = 0;
 
  //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);
      _XMP_fatal("_XMP_gmove_SENDRECV_GSCALAR() for acc is not implemented");
      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);
//      _XMP_gmove_gsection_scalar(dst_array, dst_l, dst_u, dst_s, tmp);
//      _XMP_free(tmp);
      _XMP_fatal("_XMP_gmove_BCAST_GSCALAR() and _XMP_gmove_gsection_scalar() for acc is not implemented");
      return;
    }
  }
 
  _XMP_gmove_array_array_common_acc(gmv_desc_leftp, gmv_desc_rightp,
                                    dst_l, dst_u, dst_s, dst_d,
                                    src_l, src_u, src_s, src_d,
                                    mode);
 
//cache comm
  if(g_current_comm.num_recvs <= _XACC_MAX_NUM_SENDRECVS && g_current_comm.num_sends <= _XACC_MAX_NUM_SENDRECVS){
//    printf("cache comm\n");
    gmv_comm = (_XACC_gmv_comm_t*)malloc(sizeof(_XACC_gmv_comm_t));
    gmv_comm->desc_left = alloc_gmv_desc(gmv_desc_leftp);
    gmv_comm->desc_right = alloc_gmv_desc(gmv_desc_rightp);
    gmv_comm->num_recvs = g_current_comm.num_recvs;
    gmv_comm->num_sends = g_current_comm.num_sends;
 
    for(int i = 0; i < g_current_comm.num_recvs; i++){
      gmv_comm->recvs[i] = g_current_comm.recvs[i];
    }
    for(int i = 0; i < g_current_comm.num_sends; i++){
      gmv_comm->sends[i] = g_current_comm.sends[i];
    }
    cache_comm(gmv_comm);
  }
}

Here is the caller graph for this function:

xmpc_gmv_do_acc()

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

{
  if (gmv_desc_leftp->is_global && gmv_desc_rightp->is_global){
    _XMP_gmove_garray_garray_acc(gmv_desc_leftp, gmv_desc_rightp, mode);
  }
  else {
    _XMP_fatal("gmv_do_acc: currently both sides must be global.");
  }
}

Here is the call graph for this function:

xmpc_gmv_g_alloc_acc()

void xmpc_gmv_g_alloc_acc	(	_XMP_gmv_desc_t **	gmv_desc,
		_XMP_array_t *	ap,
		void *	dev_addr
	)

{
  _XMP_gmv_desc_t *gp;
  int n = ap->dim;
 
  gp = (_XMP_gmv_desc_t *)_XMP_alloc(sizeof(_XMP_gmv_desc_t));
 
  gp->kind = (int *)_XMP_alloc(sizeof(int) * n);
  gp->lb = (int *)_XMP_alloc(sizeof(int) * n);
  gp->ub = (int *)_XMP_alloc(sizeof(int) * n);
  gp->st = (int *)_XMP_alloc(sizeof(int) * n);
  
  if (!gp || !gp->kind || !gp->lb || !gp->st)
    _XMP_fatal("gmv_g_alloc: cannot alloc memory");
 
  gp->is_global = true;
  gp->ndims = n;
  gp->a_desc = ap;
 
  gp->local_data = NULL;
  gp->a_lb = NULL;
  gp->a_ub = NULL;
 
  gp->a_dev = dev_addr;
 
  *gmv_desc = gp;
}

Here is the call graph for this function:

xmpc_gmv_l_alloc_acc()

void xmpc_gmv_l_alloc_acc	(	_XMP_gmv_desc_t **	gmv_desc,
		void *	local_data,
		int	n
	)

{
  _XMP_gmv_desc_t *gp;
 
  gp = (_XMP_gmv_desc_t *)_XMP_alloc(sizeof(_XMP_gmv_desc_t));
 
  gp->kind = (int *)_XMP_alloc(sizeof(int) * n);
  gp->lb = (int *)_XMP_alloc(sizeof(int) * n);
  gp->ub = (int *)_XMP_alloc(sizeof(int) * n);
  gp->st = (int *)_XMP_alloc(sizeof(int) * n);
  gp->a_lb = (int *)_XMP_alloc(sizeof(int) * n);
  gp->a_ub = (int *)_XMP_alloc(sizeof(int) * n);
 
  gp->is_global = false;
  gp->ndims = n;
  gp->a_desc = NULL;
 
  gp->local_data = NULL;
 
  gp->a_dev = local_data;
 
  *gmv_desc = gp;
}

Here is the call graph for this function: