xmp_reflect.c File Reference

#include "xmp_internal.h"
#include <string.h>
#include <stdio.h>
#include <math.h>

Include dependency graph for xmp_reflect.c:

Functions
void	_XMP_reflect_pcopy_sched_dim (_XMP_array_t *adesc, int target_dim, int lwidth, int uwidth, int is_periodic, int shadow_comm_type)
int	_XMP_get_owner_pos (_XMP_array_t *a, int dim, int index)
void	_XMP_reflect_pack_dim (_XMP_array_t *a, int i, int *lwidth, int *uwidth, int *is_periodic, int shadow_comm_type)
void	_XMP_reflect_async_cardinal (_XMP_array_t *a, int async_id)
void	_XMP_reflect_async_ordinal (_XMP_array_t *a, int async_id)
void	xmp_dbg_printf (char *fmt,...)
void	_XMP_set_reflect__ (_XMP_array_t *a, int dim, int lwidth, int uwidth, int is_periodic)
void	_XMP_reflect__ (_XMP_array_t *a)
void	_XMP_reflect_async__ (_XMP_array_t *a, int async_id)

Variables
int	_xmp_reflect_pack_flag

Function Documentation

_XMP_get_owner_pos()

int _XMP_get_owner_pos	(	_XMP_array_t *	a,
		int	dim,
		int	index
	)

                                                           {
 
  int align_offset = a->info[dim].align_subscript;
 
  int tdim = a->info[dim].align_template_index;
  int tlb = a->align_template->info[tdim].ser_lower;
  int chunk = a->align_template->chunk[tdim].par_chunk_width;
 
  int pos;
  switch (a->info[dim].align_manner){
 
  case _XMP_N_ALIGN_BLOCK:
    pos = (index + align_offset - tlb) / chunk;
    return pos;
 
  case _XMP_N_ALIGN_GBLOCK:
    {
      int tpos = index + align_offset; // tlb is not subtracted because the mapping_array is 1-origin.
      long long *m = a->align_template->chunk[tdim].mapping_array;
      int np = a->align_template->chunk[tdim].onto_nodes_info->size;
      for (int i = 0; i < np; i++){
        if (m[i] <= tpos && tpos < m[i+1]){
          return i;
        }
      }
    }
  }
 
  _XMP_fatal("cannot calculate position");
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_reflect__()

void _XMP_reflect__

(

_XMP_array_t *

a

)

{
 
  int is_ordinal = 1;
 
  //_XMP_RETURN_IF_SINGLE;
  if (!a->is_allocated){
    _xmp_set_reflect_flag = 0;
    return;
  }
 
  if (!_xmp_set_reflect_flag){
    for (int i = 0; i < a->dim; i++){
      _XMP_array_info_t *ai = &(a->info[i]);
      _xmp_lwidth[i] = ai->shadow_size_lo;
      _xmp_uwidth[i] = ai->shadow_size_hi;
      _xmp_is_periodic[i] = 0;
    }
  }
 
  _XMP_TSTART(t0);
  for (int i = 0; i < a->dim; i++){
 
    _XMP_array_info_t *ai = &(a->info[i]);
 
    if (ai->shadow_type == _XMP_N_SHADOW_NONE){
      continue;
    }
    else if (ai->shadow_type == _XMP_N_SHADOW_NORMAL){
 
      _XMP_reflect_sched_t *reflect = ai->reflect_sched;
 
      if (_xmp_lwidth[i] || _xmp_uwidth[i]){
 
        _XMP_ASSERT(reflect);
 
        /* if (!reflect->reflect_is_initialized || */
        /*     _xmp_lwidth[i] != reflect->lo_width || */
        /*     _xmp_uwidth[i] != reflect->hi_width || */
        /*     _xmp_is_periodic[i] != reflect->is_periodic){ */
 
        /*   reflect->lo_width = _xmp_lwidth[i]; */
        /*   reflect->hi_width = _xmp_uwidth[i]; */
        /*   reflect->is_periodic = _xmp_is_periodic[i]; */
 
        /*   if (_xmp_reflect_pack_flag){ */
        /*     _XMP_reflect_pcopy_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i], 0); */
        /*   } */
        /*   else { */
        /*     _XMP_reflect_normal_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i]); */
        /*   } */
 
        /*   reflect->reflect_is_initialized = 1; */
        /* } */
 
        if (!reflect->reflect_is_initialized ||
            _xmp_lwidth[i] != reflect->lo_width ||
            _xmp_uwidth[i] != reflect->hi_width ||
            _xmp_is_periodic[i] != reflect->is_periodic){
 
          if (_xmp_reflect_pack_flag){
            _XMP_reflect_pcopy_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i], _XMP_COMM_REFLECT);
          }
          else {
            _XMP_reflect_normal_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i]);
          }
 
          reflect->reflect_is_initialized = 1;
          reflect->lo_width = _xmp_lwidth[i];
          reflect->hi_width = _xmp_uwidth[i];
          reflect->is_periodic = _xmp_is_periodic[i];
        }
 
        if (_xmp_reflect_pack_flag && reflect->req[0] != MPI_REQUEST_NULL){
          _XMP_TSTART(t0);
          _XMP_reflect_pack_dim(a, i, _xmp_lwidth, _xmp_uwidth, _xmp_is_periodic, _XMP_COMM_REFLECT);
          _XMP_TEND(xmptiming_.t_copy, t0);
        }
 
        _XMP_TSTART(t0);
        if (reflect->req[0] != MPI_REQUEST_NULL) // if req[0] isn't null, any others shouldn't be null.
          MPI_Startall(4, reflect->req);
        _XMP_TEND2(xmptiming_.t_comm, xmptiming_.tdim_comm[i], t0);
 
        if (is_ordinal){
          _XMP_TSTART(t0);
          MPI_Waitall(4, reflect->req, MPI_STATUSES_IGNORE);
          _XMP_TEND2(xmptiming_.t_wait, xmptiming_.tdim_wait[i], t0);
          if (_xmp_reflect_pack_flag && reflect->req[0] != MPI_REQUEST_NULL){
            _XMP_TSTART(t0);
            _XMP_reflect_unpack_dim(a, i, _xmp_lwidth, _xmp_uwidth, _xmp_is_periodic);
            _XMP_TEND(xmptiming_.t_copy, t0);
          }
        }
 
      }
 
    }
    else { /* _XMP_N_SHADOW_FULL */
      _XMP_reflect_shadow_FULL(a->array_addr_p, a, i);
    }
    
  }
  _XMP_TEND(xmptiming_.t_sched, t0);
 
  //  t0 = MPI_Wtime();
  if (!is_ordinal)
    _XMP_reflect_wait(a, _xmp_lwidth, _xmp_uwidth, _xmp_is_periodic);
  //  t_wait = t_wait + (MPI_Wtime() - t0);
 
  _xmp_set_reflect_flag = 0;
  for (int i = 0; i < a->dim; i++){
    _xmp_lwidth[i] = 0;
    _xmp_uwidth[i] = 0;
    _xmp_is_periodic[i] = 0;
  }
 
}

_XMP_reflect_async__()

void _XMP_reflect_async__	(	_XMP_array_t *	a,
		int	async_id
	)

                                                        {
 
  int is_ordinal = 1;
 
  //_XMP_RETURN_IF_SINGLE;
  if (!a->is_allocated){
    _xmp_set_reflect_flag = 0;
    return;
  }
 
  if (!_xmp_set_reflect_flag){
    for (int i = 0; i < a->dim; i++){
      _XMP_array_info_t *ai = &(a->info[i]);
      if (ai->shadow_type == _XMP_N_SHADOW_FULL){
        _XMP_fatal("asynchronous reflect for full shadow not supported.");
      }
      _xmp_lwidth[i] = ai->shadow_size_lo;
      _xmp_uwidth[i] = ai->shadow_size_hi;
      _xmp_is_periodic[i] = 0;
    }
  }
 
  int reflect_ndims = 0;
  for (int i = 0; i < a->dim; i++){
    if (_xmp_lwidth[i] || _xmp_uwidth[i]){
      reflect_ndims++;
    }
  }
 
  if (reflect_ndims == 0){
    return;
  }
  else if (reflect_ndims == 1 || !is_ordinal){
    _XMP_reflect_async_cardinal(a, async_id);
  }
  else {
    _XMP_reflect_async_ordinal(a, async_id);
  }
 
  _xmp_set_reflect_flag = 0;
  for (int i = 0; i < a->dim; i++){
    _xmp_lwidth[i] = 0;
    _xmp_uwidth[i] = 0;
    _xmp_is_periodic[i] = 0;
  }
 
}

_XMP_reflect_async_cardinal()

void _XMP_reflect_async_cardinal	(	_XMP_array_t *	a,
		int	async_id
	)

{
 
  _XMP_async_comm_t *async = _XMP_get_current_async();
  MPI_Request *reqs = &async->reqs[async->nreqs];
  int nreqs = 0;
 
  _XMP_TSTART(t0);
  for (int i = 0; i < a->dim; i++){
 
    _XMP_array_info_t *ai = &(a->info[i]);
 
    if (ai->shadow_type == _XMP_N_SHADOW_NONE){
      continue;
    }
    else if (ai->shadow_type == _XMP_N_SHADOW_NORMAL){
 
      _XMP_reflect_sched_t *reflect = ai->reflect_sched;
 
      if (_xmp_lwidth[i] || _xmp_uwidth[i]){
 
        _XMP_ASSERT(reflect);
 
        if (reflect->is_periodic == -1 /* not set yet */ ||
            _xmp_lwidth[i] != reflect->lo_width ||
            _xmp_uwidth[i] != reflect->hi_width ||
            _xmp_is_periodic[i] != reflect->is_periodic){
 
          reflect->lo_width = _xmp_lwidth[i];
          reflect->hi_width = _xmp_uwidth[i];
          reflect->is_periodic = _xmp_is_periodic[i];
 
          _XMP_reflect_normal_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i]);
 
        }
 
        if (async->nreqs + nreqs + 4 > _XMP_MAX_ASYNC_REQS){
          _XMP_fatal("too many arrays in an asynchronous reflect");
        }
        memcpy(&reqs[nreqs], reflect->req, 4 * sizeof(MPI_Request));
        nreqs += 4;
 
        _XMP_TSTART(t0);
        if (reflect->req[0] != MPI_REQUEST_NULL) // if req[0] isn't null, any others shouldn't be null.
          MPI_Startall(4, reflect->req);
        _XMP_TEND2(xmptiming_.t_comm, xmptiming_.tdim_comm[i], t0);
 
      }
 
    }
    else { /* _XMP_N_SHADOW_FULL */
      _XMP_reflect_shadow_FULL(a->array_addr_p, a, i);
    }
    
  }
  _XMP_TEND(xmptiming_.t_sched, t0);
 
  async->nreqs += nreqs;
 
}

Here is the call graph for this function:

_XMP_reflect_async_ordinal()

void _XMP_reflect_async_ordinal	(	_XMP_array_t *	a,
		int	async_id
	)

                                                              {
 
  int n = a->dim;
  _XMP_async_reflect_t *async_reflect;
 
  _Bool reusable_sched = false;
 
  if (!a->async_reflect){
    int max_nreqs = (pow(3, n) - 1) * 2;
    async_reflect = (_XMP_async_reflect_t *)_XMP_alloc(sizeof(_XMP_async_reflect_t));
    async_reflect->datatype = (MPI_Datatype *)_XMP_alloc(sizeof(MPI_Datatype) * max_nreqs);
    async_reflect->reqs = (MPI_Request *)_XMP_alloc(sizeof(MPI_Request) * max_nreqs);
    for (int i = 0; i < max_nreqs; i++){
      async_reflect->datatype[i] = MPI_DATATYPE_NULL;
      async_reflect->reqs[i] = MPI_REQUEST_NULL;
    }
    async_reflect->nreqs = 0;
    a->async_reflect = async_reflect;
  }
  else {
    reusable_sched = true;
    async_reflect = a->async_reflect;
    for (int i = 0; i < n; i++){
      if (async_reflect->lwidth[i] != _xmp_lwidth[i] ||
          async_reflect->uwidth[i] != _xmp_uwidth[i] ||
          async_reflect->is_periodic[i] != _xmp_is_periodic[i]){
        reusable_sched = false;
        break;
      }
    }
  }
 
  if (!reusable_sched){
 
    int lb[_XMP_N_MAX_DIM] = { 0 };
    int ub[_XMP_N_MAX_DIM] = { 0 };
 
    for (int i = 0; i < n; i++){
      async_reflect->lwidth[i] = _xmp_lwidth[i];
      async_reflect->uwidth[i] = _xmp_uwidth[i];
      async_reflect->is_periodic[i] = _xmp_is_periodic[i];
 
      if (_xmp_lwidth[i] > 0) lb[i] = -1;
      if (_xmp_uwidth[i] > 0) ub[i] = 1;
    }
 
    for (int i = 0; i < async_reflect->nreqs; i++){
      if (async_reflect->datatype[i] != MPI_DATATYPE_NULL)
        MPI_Type_free(&async_reflect->datatype[i]);
      if (async_reflect->reqs[i] != MPI_REQUEST_NULL)
        MPI_Request_free(&async_reflect->reqs[i]);
    }
    async_reflect->nreqs = 0;
 
    int ishadow[_XMP_N_MAX_DIM];
    for (ishadow[0] = lb[0]; ishadow[0] <= ub[0]; ishadow[0]++){
    for (ishadow[1] = lb[1]; ishadow[1] <= ub[1]; ishadow[1]++){
    for (ishadow[2] = lb[2]; ishadow[2] <= ub[2]; ishadow[2]++){
    for (ishadow[3] = lb[3]; ishadow[3] <= ub[3]; ishadow[3]++){
    for (ishadow[4] = lb[4]; ishadow[4] <= ub[4]; ishadow[4]++){
    for (ishadow[5] = lb[5]; ishadow[5] <= ub[5]; ishadow[5]++){
    for (ishadow[6] = lb[6]; ishadow[6] <= ub[6]; ishadow[6]++){
 
      // When ishadow > 0, upper shadow is to be updated, and vice versa.
 
      int nnzero = 0;
      for (int i = 0; i < n; i++){
        if (ishadow[i] != 0) nnzero++;
      }
      if (nnzero == 0) continue;
 
      _XMP_reflect_sched_dir(a, ishadow, _xmp_lwidth, _xmp_uwidth, _xmp_is_periodic);
 
    }}}}}}}
 
  }
 
  _XMP_async_comm_t *async = _XMP_get_current_async();
  MPI_Request *reqs = &async->reqs[async->nreqs];
 
  // copy to async
  if (async->nreqs + async_reflect->nreqs > _XMP_MAX_ASYNC_REQS){
    _XMP_fatal("too many arrays in an asynchronous reflect");
  }
  memcpy(reqs, async_reflect->reqs, async_reflect->nreqs * sizeof(MPI_Request));
 
  async->nreqs += async_reflect->nreqs;
 
  _XMP_TSTART(t0);
  MPI_Startall(async_reflect->nreqs, reqs);
  _XMP_TEND(xmptiming_.t_start, t0);
 
}

Here is the call graph for this function:

_XMP_reflect_pack_dim()

void _XMP_reflect_pack_dim	(	_XMP_array_t *	a,
		int	i,
		int *	lwidth,
		int *	uwidth,
		int *	is_periodic,
		int	shadow_comm_type
	)

{
 
  char *pack_dst_lo, *pack_src_lo; int dst_lo;
  char *pack_dst_hi, *pack_src_hi; int dst_hi;
  
  if (shadow_comm_type == _XMP_COMM_REFLECT){
    if (a->order == MPI_ORDER_FORTRAN){ /* for XMP/F */
      if (i == a->dim - 1) return;
    }
    else if (a->order == MPI_ORDER_C){ /* for XMP/C */
      if (i == 0) return;
    }
    else {
      _XMP_fatal("cannot determin the base language.");
    }
  }
 
  _XMP_array_info_t *ai = &(a->info[i]);
  _XMP_reflect_sched_t *reflect = ai->reflect_sched;
 
  if (shadow_comm_type == _XMP_COMM_REDUCE_SHADOW){
    pack_dst_lo = (char *)reflect->lo_recv_buf;
    pack_src_lo = (char *)reflect->lo_recv_array;
    dst_lo = reflect->lo_rank;
    pack_dst_hi = (char *)reflect->hi_recv_buf;
    pack_src_hi = (char *)reflect->hi_recv_array;
    dst_hi = reflect->hi_rank;
  }
  else {
    pack_dst_lo = (char *)reflect->lo_send_buf;
    pack_src_lo = (char *)reflect->lo_send_array;
    dst_lo = reflect->hi_rank;
    pack_dst_hi = (char *)reflect->hi_send_buf;
    pack_src_hi = (char *)reflect->hi_send_array;
    dst_hi = reflect->lo_rank;
  }
 
  
  if (ai->shadow_type == _XMP_N_SHADOW_NORMAL){
 
    // for lower reflect
    if (lwidth[i] && dst_lo != MPI_PROC_NULL){
      _XMP_pack_vector(pack_dst_lo, pack_src_lo,
                       reflect->count, lwidth[i] * reflect->blocklength,
                       reflect->stride);
    }
 
    // for upper reflect
    if (uwidth[i] && dst_hi != MPI_PROC_NULL){
      _XMP_pack_vector(pack_dst_hi, pack_src_hi,
                       reflect->count, uwidth[i] * reflect->blocklength,
                       reflect->stride);
    }
 
  }
 
}

Here is the call graph for this function:

_XMP_reflect_pcopy_sched_dim()

void _XMP_reflect_pcopy_sched_dim	(	_XMP_array_t *	adesc,
		int	target_dim,
		int	lwidth,
		int	uwidth,
		int	is_periodic,
		int	shadow_comm_type
	)

                                                                                                {
 
  if (lwidth == 0 && uwidth == 0) return;
 
  _XMP_array_info_t *ai = &(adesc->info[target_dim]);
  _XMP_array_info_t *ainfo = adesc->info;
  _XMP_ASSERT(ai->align_manner == _XMP_N_ALIGN_BLOCK);
  _XMP_ASSERT(ai->is_shadow_comm_member);
 
  if (lwidth > ai->shadow_size_lo || uwidth > ai->shadow_size_hi){
    _XMP_fatal("reflect width is larger than shadow width.");
  }
 
  _XMP_reflect_sched_t *reflect = ai->reflect_sched;
 
  int target_tdim = ai->align_template_index;
  _XMP_nodes_info_t *ni = adesc->align_template->chunk[target_tdim].onto_nodes_info;
 
  if (ni->size == 1 && !is_periodic) return;
 
  int ndims = adesc->dim;
 
  // 0-origin
  int my_pos = ni->rank;
  int lb_pos = _XMP_get_owner_pos(adesc, target_dim, ai->ser_lower);
  int ub_pos = _XMP_get_owner_pos(adesc, target_dim, ai->ser_upper);
 
  int lo_pos = (my_pos == lb_pos) ? ub_pos : my_pos - 1;
  int hi_pos = (my_pos == ub_pos) ? lb_pos : my_pos + 1;
 
  MPI_Comm *comm = adesc->align_template->onto_nodes->comm;
  int my_rank = adesc->align_template->onto_nodes->comm_rank;
 
  int lo_rank = my_rank + (lo_pos - my_pos) * ni->multiplier;
  int hi_rank = my_rank + (hi_pos - my_pos) * ni->multiplier;
 
  int count = 0, blocklength = 0;
  long long stride = 0;
 
  int type_size = adesc->type_size;
  void *array_addr = adesc->array_addr_p;
 
  void *lo_send_array = NULL, *lo_recv_array = NULL;
  void *hi_send_array = NULL, *hi_recv_array = NULL;
 
  void *lo_send_buf = NULL;
  void *lo_recv_buf = NULL;
  void *hi_send_buf = NULL;
  void *hi_recv_buf = NULL;
 
  int lo_buf_size = 0;
  int hi_buf_size = 0;
 
  if (reflect->prev_pcopy_sched_type &&
      lwidth == reflect->lo_width &&
      uwidth == reflect->hi_width &&
      is_periodic == reflect->is_periodic){
    if ((adesc->order == MPI_ORDER_FORTRAN && target_dim != ndims - 1) ||
        (adesc->order == MPI_ORDER_C && target_dim != 0)){
      goto init_comm;
    }
    else if (reflect->prev_pcopy_sched_type != shadow_comm_type){
      count = reflect->count;
      blocklength = reflect->blocklength;
      stride = reflect->stride;
      goto alloc_buf;
    }
  }
  
  //
  // setup data_type
  //
 
  if (adesc->order == MPI_ORDER_FORTRAN){ /* for XMP/F */
 
    count = 1;
    blocklength = type_size;
    stride = ainfo[0].alloc_size * type_size;
 
    for (int i = ndims - 2; i >= target_dim; i--){
      count *= ainfo[i+1].alloc_size;
    }
 
    for (int i = 1; i <= target_dim; i++){
      blocklength *= ainfo[i-1].alloc_size;
      stride *= ainfo[i].alloc_size;
    }
 
  }
  else if (adesc->order == MPI_ORDER_C){ /* for XMP/C */
 
    count = 1;
    blocklength = type_size;
    stride = ainfo[ndims-1].alloc_size * type_size;
 
    for (int i = 1; i <= target_dim; i++){
      count *= ainfo[i-1].alloc_size;
    }
 
    for (int i = ndims - 2; i >= target_dim; i--){
      blocklength *= ainfo[i+1].alloc_size;
      stride *= ainfo[i].alloc_size;
    }
 
  }
  else {
    _XMP_fatal("cannot determin the base language.");
  }
 
  //
  // calculate base address
  //
 
 alloc_buf:
  
  // for lower reflect
 
  if (lwidth){
 
    lo_send_array = array_addr;
    lo_recv_array = array_addr;
 
    for (int i = 0; i < ndims; i++) {
 
      int lb_send, lb_recv;
      unsigned long long dim_acc;
 
      if (i == target_dim) {
        lb_send = ainfo[i].local_upper - lwidth + 1;
        lb_recv = ainfo[i].shadow_size_lo - lwidth;;
      }
      else {
        // Note: including shadow area
        lb_send = 0;
        lb_recv = 0;
      }
 
      dim_acc = ainfo[i].dim_acc;
 
      lo_send_array = (void *)((char *)lo_send_array + lb_send * dim_acc * type_size);
      lo_recv_array = (void *)((char *)lo_recv_array + lb_recv * dim_acc * type_size);
 
    }
 
  }
 
  // for upper reflect
 
  if (uwidth){
 
    hi_send_array = array_addr;
    hi_recv_array = array_addr;
 
    for (int i = 0; i < ndims; i++) {
 
      int lb_send, lb_recv;
      unsigned long long dim_acc;
 
      if (i == target_dim) {
        lb_send = ainfo[i].local_lower;
        lb_recv = ainfo[i].local_upper + 1;
      }
      else {
        // Note: including shadow area
        lb_send = 0;
        lb_recv = 0;
      }
 
      dim_acc = ainfo[i].dim_acc;
 
      hi_send_array = (void *)((char *)hi_send_array + lb_send * dim_acc * type_size);
      hi_recv_array = (void *)((char *)hi_recv_array + lb_recv * dim_acc * type_size);
 
    }
 
  }
 
  //
  // Allocate buffers
  //
 
  if (reflect->prev_pcopy_sched_type == _XMP_COMM_REFLECT &&
      ((adesc->order == MPI_ORDER_FORTRAN && target_dim == ndims - 1) ||
       (adesc->order == MPI_ORDER_C && target_dim == 0))){
    ;
  }
  else {
    _XMP_free(reflect->lo_send_buf);
    _XMP_free(reflect->lo_recv_buf);
    _XMP_free(reflect->hi_send_buf);
    _XMP_free(reflect->hi_recv_buf);
  }
 
  // for lower reflect
 
  if (lwidth){
 
    lo_buf_size = lwidth * blocklength * count;
 
    if (shadow_comm_type == _XMP_COMM_REFLECT &&
        ((adesc->order == MPI_ORDER_FORTRAN && target_dim == ndims - 1) ||
         (adesc->order == MPI_ORDER_C && target_dim == 0))){
      lo_send_buf = lo_send_array;
      lo_recv_buf = lo_recv_array;
    }
    else {
      _XMP_TSTART(t0);
      lo_send_buf = _XMP_alloc(lo_buf_size);
      lo_recv_buf = _XMP_alloc(lo_buf_size);
      _XMP_TEND2(xmptiming_.t_mem, xmptiming_.tdim_mem[target_dim], t0);
    }
 
  }
 
  // for upper reflect
 
  if (uwidth){
 
    hi_buf_size = uwidth * blocklength * count;
 
    if (shadow_comm_type == _XMP_COMM_REFLECT &&
        ((adesc->order == MPI_ORDER_FORTRAN && target_dim == ndims - 1) ||
         (adesc->order == MPI_ORDER_C && target_dim == 0))){
      hi_send_buf = hi_send_array;
      hi_recv_buf = hi_recv_array;
    }
    else {
      _XMP_TSTART(t0);
      hi_send_buf = _XMP_alloc(hi_buf_size);
      hi_recv_buf = _XMP_alloc(hi_buf_size);
      _XMP_TEND2(xmptiming_.t_mem, xmptiming_.tdim_mem[target_dim], t0);
    }
 
  }
 
  //
  // cache schedule
  //
 
  reflect->count = count;
  reflect->blocklength = blocklength;
  reflect->stride = stride;
 
  reflect->lo_send_array = lo_send_array;
  reflect->lo_recv_array = lo_recv_array;
  reflect->hi_send_array = hi_send_array;
  reflect->hi_recv_array = hi_recv_array;
 
  reflect->lo_send_buf = lo_send_buf;
  reflect->lo_recv_buf = lo_recv_buf;
  reflect->hi_send_buf = hi_send_buf;
  reflect->hi_recv_buf = hi_recv_buf;
 
  //
  // initialize communication
  //
 
  int src, dst;
 
 init_comm:
  
  if (!is_periodic && my_pos == lb_pos){ // no periodic
    lo_rank = MPI_PROC_NULL;
  }
 
  if (!is_periodic && my_pos == ub_pos){ // no periodic
    hi_rank = MPI_PROC_NULL;
  }
 
  lo_buf_size = lwidth * reflect->blocklength * reflect->count;
  hi_buf_size = uwidth * reflect->blocklength * reflect->count;
 
  // for lower shadow
 
  if (lwidth){
    src = lo_rank;
    dst = hi_rank;
  }
  else {
    src = MPI_PROC_NULL;
    dst = MPI_PROC_NULL;
  }
 
  if (shadow_comm_type == _XMP_COMM_REDUCE_SHADOW){
    if (reflect->req_reduce[0] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req_reduce[0]);
    }
        
    if (reflect->req_reduce[1] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req_reduce[1]);
    }
 
    MPI_Send_init(reflect->lo_recv_buf, lo_buf_size, MPI_BYTE, src,
                  _XMP_N_MPI_TAG_REFLECT_LO, *comm, &reflect->req_reduce[0]);
    MPI_Recv_init(reflect->lo_send_buf, lo_buf_size, MPI_BYTE, dst,
                  _XMP_N_MPI_TAG_REFLECT_LO, *comm, &reflect->req_reduce[1]);
  }
  else {
    if (reflect->req[0] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req[0]);
    }
        
    if (reflect->req[1] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req[1]);
    }
 
    MPI_Recv_init(reflect->lo_recv_buf, lo_buf_size, MPI_BYTE, src,
                  _XMP_N_MPI_TAG_REFLECT_LO, *comm, &reflect->req[0]);
    MPI_Send_init(reflect->lo_send_buf, lo_buf_size, MPI_BYTE, dst,
                  _XMP_N_MPI_TAG_REFLECT_LO, *comm, &reflect->req[1]);
  }
  
  // for upper shadow
 
  if (uwidth){
    src = hi_rank;
    dst = lo_rank;
  }
  else {
    src = MPI_PROC_NULL;
    dst = MPI_PROC_NULL;
  }
 
  if (shadow_comm_type == _XMP_COMM_REDUCE_SHADOW){
    if (reflect->req_reduce[2] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req_reduce[2]);
    }
        
    if (reflect->req_reduce[3] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req_reduce[3]);
    }
 
    MPI_Send_init(reflect->hi_recv_buf, hi_buf_size, MPI_BYTE, src,
                  _XMP_N_MPI_TAG_REFLECT_HI, *comm, &reflect->req_reduce[2]);
    MPI_Recv_init(reflect->hi_send_buf, hi_buf_size, MPI_BYTE, dst,
                  _XMP_N_MPI_TAG_REFLECT_HI, *comm, &reflect->req_reduce[3]);
  }
  else {
    if (reflect->req[2] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req[2]);
    }
        
    if (reflect->req[3] != MPI_REQUEST_NULL){
      MPI_Request_free(&reflect->req[3]);
    }
 
    MPI_Recv_init(reflect->hi_recv_buf, hi_buf_size, MPI_BYTE, src,
                  _XMP_N_MPI_TAG_REFLECT_HI, *comm, &reflect->req[2]);
    MPI_Send_init(reflect->hi_send_buf, hi_buf_size, MPI_BYTE, dst,
                  _XMP_N_MPI_TAG_REFLECT_HI, *comm, &reflect->req[3]);
  }
  
  reflect->prev_pcopy_sched_type = shadow_comm_type;
  
  reflect->lo_rank = lo_rank;
  reflect->hi_rank = hi_rank;
 
}

Here is the call graph for this function:

_XMP_set_reflect__()

void _XMP_set_reflect__	(	_XMP_array_t *	a,
		int	dim,
		int	lwidth,
		int	uwidth,
		int	is_periodic
	)

{
  _xmp_set_reflect_flag = 1;
  _xmp_lwidth[dim] = lwidth;
  _xmp_uwidth[dim] = uwidth;
  _xmp_is_periodic[dim] = is_periodic;
}

xmp_dbg_printf()

void xmp_dbg_printf	(	char *	fmt,
			...
	)

{
  char buf[512];
  va_list args;
 
  va_start(args,fmt);
  vsprintf(buf,fmt,args);
  va_end(args);
 
  printf("[%d] %s",_XMP_world_rank, buf);
  fflush(stdout);
}

Variable Documentation

_xmp_reflect_pack_flag

int _xmp_reflect_pack_flag