xmp_reduce_shadow.c File Reference

#include "xmp_internal.h"

Include dependency graph for xmp_reduce_shadow.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)
void	_XMP_reflect_pack_dim (_XMP_array_t *a, int i, int *lwidth, int *uwidth, int *is_periodic, int shadow_comm_type)
void	_XMP_sum_vector (int type, char *restrict dst, char *restrict src, int count, int blocklength, long stride)
int	_XMP_get_owner_pos (_XMP_array_t *a, int dim, int index)
void	_XMP_set_reduce_shadow__ (_XMP_array_t *a, int dim, int lwidth, int uwidth, int is_periodic)
void	_XMP_reduce_shadow__ (_XMP_array_t *a)
void	_XMP_reduce_shadow_wait (_XMP_array_t *a)
void	_XMP_reduce_shadow_sum (_XMP_array_t *a)

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

void _XMP_reduce_shadow__

(

_XMP_array_t *

a

)

{
 
  _XMP_async_comm_t *async = NULL;
  MPI_Request *reqs = NULL;
  int nreqs = 0;
 
  if (xmp_is_async()){
    async = _XMP_get_current_async();
    reqs = &async->reqs[async->nreqs];
  }
  
  //_XMP_RETURN_IF_SINGLE;
  if (!a->is_allocated){
    _xmp_set_reduce_shadow_flag = 0;
    return;
  }
 
  if (!_xmp_set_reduce_shadow_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;
    }
  }
 
  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 *shadow_sched = ai->reflect_sched;
 
      if (_xmp_lwidth[i] || _xmp_uwidth[i]){
 
        _XMP_ASSERT(shadow_sched);
 
        if (!shadow_sched->reduce_is_initialized ||
            _xmp_lwidth[i] != shadow_sched->lo_width ||
            _xmp_uwidth[i] != shadow_sched->hi_width ||
            _xmp_is_periodic[i] != shadow_sched->is_periodic){
 
          _XMP_reflect_pcopy_sched_dim(a, i, _xmp_lwidth[i], _xmp_uwidth[i], _xmp_is_periodic[i], _XMP_COMM_REDUCE_SHADOW);
 
          shadow_sched->reduce_is_initialized = 1;
          shadow_sched->lo_width = _xmp_lwidth[i];
          shadow_sched->hi_width = _xmp_uwidth[i];
          shadow_sched->is_periodic = _xmp_is_periodic[i];
 
        }
        
        _XMP_reflect_pack_dim(a, i, _xmp_lwidth, _xmp_uwidth, _xmp_is_periodic, _XMP_COMM_REDUCE_SHADOW);
 
        if (shadow_sched->req_reduce[0] != MPI_REQUEST_NULL) // if req[0] isn't null, any others shouldn't be null.
          MPI_Startall(4, shadow_sched->req_reduce);
 
        if (xmp_is_async()){
          if (async->nreqs + nreqs + 4 > _XMP_MAX_ASYNC_REQS){
            _XMP_fatal("too many arrays in an asynchronous reflect/reduce_shadow");
          }
          memcpy(&reqs[nreqs], shadow_sched->req_reduce, 4 * sizeof(MPI_Request));
          nreqs += 4;
        }
 
      }
 
    }
    else { /* _XMP_N_SHADOW_FULL */
      // not supported yet
      //_XMP_reduce_shadow_shadow_FULL(a->array_addr_p, a, i);
    }
    
  }
 
  if (!xmp_is_async()){
    _XMP_reduce_shadow_wait(a);
    _XMP_reduce_shadow_sum(a);
  }
  else {
    async->a = a;
    async->nreqs += nreqs;
    async->type = _XMP_COMM_REDUCE_SHADOW;
  }
  
  _xmp_set_reduce_shadow_flag = 0;
  for (int i = 0; i < a->dim; i++){
    _xmp_lwidth[i] = 0;
    _xmp_uwidth[i] = 0;
    _xmp_is_periodic[i] = 0;
  }
 
}

Here is the call graph for this function:

_XMP_reduce_shadow_sum()

void _XMP_reduce_shadow_sum

(

_XMP_array_t *

a

)

{
  int type_size = a->type_size;
 
  for (int i = 0; i < a->dim; i++){
 
    _XMP_array_info_t *ai = &(a->info[i]);
    _XMP_reflect_sched_t *shadow_sched = ai->reflect_sched;
 
    if (!shadow_sched) continue;
 
    int lwidth = shadow_sched->lo_width;
    int uwidth = shadow_sched->hi_width;
    int is_periodic = shadow_sched->is_periodic;
 
    if (ai->shadow_type == _XMP_N_SHADOW_NORMAL){
 
      int target_dim = ai->align_template_index;
      int my_pos = a->align_template->chunk[target_dim].onto_nodes_info->rank;
      int lb_pos = _XMP_get_owner_pos(a, i, ai->ser_lower);
      int ub_pos = _XMP_get_owner_pos(a, i, ai->ser_upper);
 
      // for lower reduce_shadow
      if (lwidth && (is_periodic || my_pos != ub_pos)){
        _XMP_sum_vector(a->type,
                        (char *)shadow_sched->lo_send_array,
                        (char *)shadow_sched->lo_send_buf,
                        shadow_sched->count, lwidth * shadow_sched->blocklength / type_size,
                        shadow_sched->stride / type_size);
      }
 
      // for upper reduce_shadow
      if (uwidth && (is_periodic || my_pos != lb_pos)){
        _XMP_sum_vector(a->type,
                        (char *)shadow_sched->hi_send_array,
                        (char *)shadow_sched->hi_send_buf,
                        shadow_sched->count, uwidth * shadow_sched->blocklength / type_size,
                        shadow_sched->stride / type_size);
      }
 
    }
 
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

_XMP_reduce_shadow_wait()

void _XMP_reduce_shadow_wait

(

_XMP_array_t *

a

)

{
  for (int i = 0; i < a->dim; i++){
 
    _XMP_array_info_t *ai = &(a->info[i]);
    _XMP_reflect_sched_t *shadow_sched = ai->reflect_sched;
 
    if (!shadow_sched) continue;
 
    int lwidth = shadow_sched->lo_width;
    int uwidth = shadow_sched->hi_width;
    
    if (!lwidth && !uwidth) continue;
 
    if (ai->shadow_type == _XMP_N_SHADOW_NORMAL){
      MPI_Waitall(4, shadow_sched->req_reduce, MPI_STATUSES_IGNORE);
    }
    else if (ai->shadow_type == _XMP_N_SHADOW_FULL){
      ;
    }
 
  }
 
}

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

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

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

_XMP_sum_vector()

void _XMP_sum_vector	(	int	type,
		char *restrict	dst,
		char *restrict	src,
		int	count,
		int	blocklength,
		long	stride
	)

                                                             {
 
  if (_xmp_omp_num_procs > 1 && count > 8 * _xmp_omp_num_procs){
 
    switch (type){
 
    case _XMP_N_TYPE_SHORT:
#pragma omp parallel for
      _XMP_SUM_VECTOR(short);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_SHORT:
#pragma omp parallel for
      _XMP_SUM_VECTOR(unsigned short);
      break;
 
    case _XMP_N_TYPE_INT:
#pragma omp parallel for
      _XMP_SUM_VECTOR(int);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_INT:
#pragma omp parallel for
      _XMP_SUM_VECTOR(unsigned int);
      break;
 
    case _XMP_N_TYPE_LONG:
#pragma omp parallel for
      _XMP_SUM_VECTOR(long);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_LONG:
#pragma omp parallel for
      _XMP_SUM_VECTOR(unsigned long);
      break;
 
    case _XMP_N_TYPE_LONGLONG:
#pragma omp parallel for
      _XMP_SUM_VECTOR(long long);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_LONGLONG:
#pragma omp parallel for
      _XMP_SUM_VECTOR(unsigned long long);
      break;
 
    case _XMP_N_TYPE_FLOAT:
#pragma omp parallel for
      _XMP_SUM_VECTOR(float);
      break;
 
    case _XMP_N_TYPE_DOUBLE:
#pragma omp parallel for
      _XMP_SUM_VECTOR(double);
      break;
      
    case _XMP_N_TYPE_LONG_DOUBLE:
#pragma omp parallel for
      _XMP_SUM_VECTOR(long double);
      break;
        
#ifdef __STD_IEC_559_COMPLEX__
 
    case _XMP_N_TYPE_FLOAT_IMAGINARY:
#pragma omp parallel for
      _XMP_SUM_VECTOR(float imaginary);
      break;
 
    case _XMP_N_TYPE_FLOAT_COMPLEX:
#pragma omp parallel for
      _XMP_SUM_VECTOR(float complex);
      break;
 
    case _XMP_N_TYPE_DOUBLE_IMAGINARY:
#pragma omp parallel for
      _XMP_SUM_VECTOR(double imaginary);
      break;
 
    case _XMP_N_TYPE_DOUBLE_COMPLEX:
#pragma omp parallel for
      _XMP_SUM_VECTOR(double complex);
      break;
 
    case _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY:
#pragma omp parallel for
      _XMP_SUM_VECTOR(long double imaginary);
      break;
 
    case _XMP_N_TYPE_LONG_DOUBLE_COMPLEX:
#pragma omp parallel for
      _XMP_SUM_VECTOR(long double complex);
      break;
 
#endif
 
    case _XMP_N_TYPE_BOOL:
    case _XMP_N_TYPE_CHAR:
    case _XMP_N_TYPE_UNSIGNED_CHAR:
    case _XMP_N_TYPE_NONBASIC:
    default:
      _XMP_fatal("_XMP_sum_vector: array arguments must be of a numerical type");
      break;
    }
    
  }
  else {
 
    switch (type){
 
    case _XMP_N_TYPE_SHORT:
      _XMP_SUM_VECTOR(short);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_SHORT:
      _XMP_SUM_VECTOR(unsigned short);
      break;
 
    case _XMP_N_TYPE_INT:
      _XMP_SUM_VECTOR(int);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_INT:
      _XMP_SUM_VECTOR(unsigned int);
      break;
 
    case _XMP_N_TYPE_LONG:
      _XMP_SUM_VECTOR(long);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_LONG:
      _XMP_SUM_VECTOR(unsigned long);
      break;
 
    case _XMP_N_TYPE_LONGLONG:
      _XMP_SUM_VECTOR(long long);
      break;
 
    case _XMP_N_TYPE_UNSIGNED_LONGLONG:
      _XMP_SUM_VECTOR(unsigned long long);
      break;
 
    case _XMP_N_TYPE_FLOAT:
      _XMP_SUM_VECTOR(float);
      break;
 
    case _XMP_N_TYPE_DOUBLE:
      _XMP_SUM_VECTOR(double);
      break;
      
    case _XMP_N_TYPE_LONG_DOUBLE:
      _XMP_SUM_VECTOR(long double);
      break;
        
#ifdef __STD_IEC_559_COMPLEX__
 
    case _XMP_N_TYPE_FLOAT_IMAGINARY:
      _XMP_SUM_VECTOR(float imaginary);
      break;
 
    case _XMP_N_TYPE_FLOAT_COMPLEX:
      _XMP_SUM_VECTOR(float complex);
      break;
 
    case _XMP_N_TYPE_DOUBLE_IMAGINARY:
      _XMP_SUM_VECTOR(double imaginary);
      break;
 
    case _XMP_N_TYPE_DOUBLE_COMPLEX:
      _XMP_SUM_VECTOR(double complex);
      break;
 
    case _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY:
      _XMP_SUM_VECTOR(long double imaginary);
      break;
 
    case _XMP_N_TYPE_LONG_DOUBLE_COMPLEX:
      _XMP_SUM_VECTOR(long double complex);
      break;
 
#endif
 
    case _XMP_N_TYPE_BOOL:
    case _XMP_N_TYPE_CHAR:
    case _XMP_N_TYPE_UNSIGNED_CHAR:
    case _XMP_N_TYPE_NONBASIC:
    default:
      _XMP_fatal("_XMP_sum_vector: array arguments must be of a numerical type");
      break;
    }
 
  }
 
}

Here is the call graph for this function:

Here is the caller graph for this function: