xmp_intrinsic.c File Reference

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

Include dependency graph for xmp_intrinsic.c:

Macros
#define	MPI_PORTABLE_PLATFORM_H

Functions
void	_XMP_align_local_idx (long long int global_idx, int *local_idx, _XMP_array_t *array, int array_axis, int *rank)
int	check_template (_XMP_template_t *dst_t, _XMP_template_t *src_t)
void	xmp_transpose (void *dst_p, void *src_p, int opt)
void	xmpf_transpose (void *dst_p, void *src_p, int opt)
void	xmp_matmul (void *x_p, void *a_p, void *b_p)
void	xmpf_matmul (void *x_p, void *a_p, void *b_p)
void	xmp_gather (void *x_d, void *a_d,...)
void	xmpf_gather (void *x_p, void *a_p, _XMP_array_t **idx_array)
void	xmp_scatter (void *x_d, void *a_d,...)
void	xmpf_scatter (void *x_p, void *a_p, _XMP_array_t **idx_array)
void	xmp_pack (void *v_p, void *a_p, void *m_p)
void	xmp_pack_mask (void *v_p, void *a_p, void *m_p)
void	xmp_pack_nomask (void *v_p, void *a_p)
void	xmpf_pack (void *v_p, void *a_p, void *m_p)
void	xmpf_pack_mask (void *v_p, void *a_p, void *m_p)
void	xmpf_pack_nomask (void *v_p, void *a_p)
void	xmp_unpack (void *a_p, void *v_p, void *m_p)
void	xmp_unpack_mask (void *a_p, void *v_p, void *m_p)
void	xmp_unpack_nomask (void *a_p, void *v_p)
void	xmpf_unpack (void *a_p, void *v_p, void *m_p)
void	xmpf_unpack_mask (void *a_p, void *v_p, void *m_p)
void	xmpf_unpack_nomask (void *a_p, void *v_p)
void	_XMP_atomic_define_0 (void *dst_desc, size_t dst_offset, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_1 (void *dst_desc, size_t dst_offset, int image0, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_2 (void *dst_desc, size_t dst_offset, int image0, int image1, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_3 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_4 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_5 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_6 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int image5, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_define_7 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int image5, int image6, int value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_0 (void *dst_desc, size_t dst_offset, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_1 (void *dst_desc, size_t dst_offset, int image, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_2 (void *dst_desc, size_t dst_offset, int image0, int image1, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_3 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_4 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_5 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_6 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int image5, int *value, void *src_desc, size_t src_offset, size_t elmt_size)
void	_XMP_atomic_ref_7 (void *dst_desc, size_t dst_offset, int image0, int image1, int image2, int image3, int image4, int image5, int image6, int *value, void *src_desc, size_t src_offset, size_t elmt_size)

Macro Definition Documentation

MPI_PORTABLE_PLATFORM_H

#define MPI_PORTABLE_PLATFORM_H

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");
  }
 
}

_XMP_atomic_define_0()

void _XMP_atomic_define_0	(	void *	dst_desc,
		size_t	dst_offset,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
#endif
 
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(_XMP_world_rank, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(_XMP_world_rank, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(_XMP_world_rank, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(_XMP_world_rank, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_1()

void _XMP_atomic_define_1	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image0, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image0, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image0, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image0, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_2()

void _XMP_atomic_define_2	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0 + c->distance_of_image_elmts[1] * image1;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_3()

void _XMP_atomic_define_3	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_4()

void _XMP_atomic_define_4	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0 
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_5()

void _XMP_atomic_define_5	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_6()

void _XMP_atomic_define_6	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int	image5,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0 
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4
    + c->distance_of_image_elmts[5] * image5;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_define_7()

void _XMP_atomic_define_7	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int	image5,
		int	image6,
		int	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4
    + c->distance_of_image_elmts[5] * image5
    + c->distance_of_image_elmts[6] * image6;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_define(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_define(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_define(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_0()

void _XMP_atomic_ref_0	(	void *	dst_desc,
		size_t	dst_offset,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
#endif
  
  // Memo: This function requires a polling operation
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(_XMP_world_rank, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(_XMP_world_rank, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(_XMP_world_rank, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(_XMP_world_rank, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_1()

void _XMP_atomic_ref_1	(	void *	dst_desc,
		size_t	dst_offset,
		int	image,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_2()

void _XMP_atomic_ref_2	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_3()

void _XMP_atomic_ref_3	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_4()

void _XMP_atomic_ref_4	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0 
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_5()

void _XMP_atomic_ref_5	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_6()

void _XMP_atomic_ref_6	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int	image5,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0 
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4
    + c->distance_of_image_elmts[5] * image5;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

_XMP_atomic_ref_7()

void _XMP_atomic_ref_7	(	void *	dst_desc,
		size_t	dst_offset,
		int	image0,
		int	image1,
		int	image2,
		int	image3,
		int	image4,
		int	image5,
		int	image6,
		int *	value,
		void *	src_desc,
		size_t	src_offset,
		size_t	elmt_size
	)

{
#if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
  _XMP_coarray_t* c = (_XMP_coarray_t*)dst_desc;
  int image = c->distance_of_image_elmts[0] * image0
    + c->distance_of_image_elmts[1] * image1
    + c->distance_of_image_elmts[2] * image2
    + c->distance_of_image_elmts[3] * image3
    + c->distance_of_image_elmts[4] * image4
    + c->distance_of_image_elmts[5] * image5
    + c->distance_of_image_elmts[6] * image6;
#endif
  
#ifdef _XMP_GASNET
  _XMP_gasnet_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_FJRDMA
  _XMP_fjrdma_atomic_ref(image, c, dst_offset, value, src_desc, src_offset, elmt_size);
#elif _XMP_UTOFU
  _XMP_utofu_atomic_ref(image, c, dst_offset, value, elmt_size);
#elif _XMP_MPI3_ONESIDED
  _XMP_mpi_atomic_ref(image, c, dst_offset, value, elmt_size);
#endif
}

Here is the call graph for this function:

check_template()

int check_template	(	_XMP_template_t *	dst_t,
		_XMP_template_t *	src_t
	)

{
   int i, j;
   
   if(dst_t == src_t) return 1;
 
   if(dst_t->dim != src_t->dim ||
      dst_t->onto_nodes != src_t->onto_nodes ||
      !dst_t->is_fixed || !src_t->is_fixed) return 0;
   
   for(i=0; i<dst_t->dim; i++){
      if(dst_t->chunk[i].par_lower != src_t->chunk[i].par_lower ||
         dst_t->chunk[i].par_upper != src_t->chunk[i].par_upper ||
         dst_t->chunk[i].par_width != src_t->chunk[i].par_width ||
         dst_t->chunk[i].par_stride != src_t->chunk[i].par_stride ||
         dst_t->chunk[i].par_chunk_width != src_t->chunk[i].par_chunk_width ||
         dst_t->chunk[i].dist_manner != src_t->chunk[i].dist_manner ||
         dst_t->chunk[i].onto_nodes_index != src_t->chunk[i].onto_nodes_index) return 0;
      if(dst_t->chunk[i].dist_manner == _XMP_N_DIST_GBLOCK){
         for(j=0; j<=dst_t->onto_nodes->info[dst_t->chunk[i].onto_nodes_index].size; j++){
            if(dst_t->chunk[i].mapping_array[j] != src_t->chunk[i].mapping_array[j]) return 0;
         }
      }
   }
   
   return 1;
}

Here is the caller graph for this function:

xmp_gather()

void xmp_gather	(	void *	x_d,
		void *	a_d,
			...
	)

{
  int          i;
  va_list      valst;
  _XMP_array_t *idx_p;
  _XMP_array_t **idx_array;
  _XMP_array_t *a_p = (_XMP_array_t *)a_d;
 
  idx_array = (_XMP_array_t **)_XMP_alloc(sizeof(_XMP_array_t *)*a_p->dim);
 
  va_start( valst, a_d );
  for(i=0;i<a_p->dim;i++){
     idx_p = va_arg( valst , _XMP_array_t* );
     idx_array[i] = idx_p;
  }
  va_end(valst);
 
  xmp_gather_kernel(x_d, a_d, idx_array);
 
  _XMP_free(idx_array);
}

Here is the call graph for this function:

xmp_matmul()

void xmp_matmul	(	void *	x_p,
		void *	a_p,
		void *	b_p
	)

{
   _XMP_array_t *x_d;
   _XMP_array_t *a_d;
   _XMP_array_t *b_d;
   int same_nodes;
   int same_align;
   int duplicate;
   int dist_dim=0;
   int i;
   
   x_d = (_XMP_array_t*)x_p;
   a_d = (_XMP_array_t*)a_p;
   b_d = (_XMP_array_t*)b_p;
 
   
   /* error check */
   if(x_d->dim != 2 || a_d->dim != 2 || b_d->dim != 2){
      _XMP_fatal("xmp_matmul: argument dimension is not 2");
      return;
   }
   if(x_d->type != a_d->type || x_d->type != b_d->type){
      _XMP_fatal("xmp_matmul: argument type is not match");
      return;
   }
   if(!x_d->align_template->is_distributed ||
      !a_d->align_template->is_distributed ||
      !b_d->align_template->is_distributed){
      _XMP_fatal("xmp_matmul: argument is not distributed");
      return;
   }
 
   /* same nodes? */
   same_nodes = 1;
   if(_XMP_get_execution_nodes()->comm_size != x_d->align_template->onto_nodes->comm_size) same_nodes = 0;
   if(_XMP_get_execution_nodes()->comm_size != a_d->align_template->onto_nodes->comm_size) same_nodes = 0;
   if(_XMP_get_execution_nodes()->comm_size != b_d->align_template->onto_nodes->comm_size) same_nodes = 0;
 
   /* duplicate? */
   duplicate = 0;
   for(i=0; i<x_d->dim; i++){
      if(x_d->info[i].align_template_index >= 0){
         duplicate++;
      }
   }
   if(duplicate >= x_d->align_template->onto_nodes->dim) duplicate = 0;
 
   /* distribute & align check */
   same_align = 0;
   if(same_nodes){
      for(i=0; i<x_d->dim; i++){
         if(x_d->info[i].align_manner == _XMP_N_ALIGN_BLOCK ||
            x_d->info[i].align_manner == _XMP_N_ALIGN_GBLOCK){
            if(x_d->info[i].align_manner == a_d->info[i].align_manner &&
               x_d->info[i].align_manner == b_d->info[i].align_manner &&
               x_d->info[i].align_subscript == 0 &&
               a_d->info[i].align_subscript == 0 &&
               b_d->info[i].align_subscript == 0 &&
               x_d->info[i].ser_size == x_d->align_template->info[x_d->info[i].align_template_index].ser_size &&
               a_d->info[i].ser_size == a_d->align_template->info[a_d->info[i].align_template_index].ser_size &&
               b_d->info[i].ser_size == b_d->align_template->info[b_d->info[i].align_template_index].ser_size){
               same_align++;
               dist_dim = i;
            } else {
               same_align = 0;
               break;
            }
         }
      }
   }
 
   /* GBLOCK mapping check */
   if(same_align == 1 && x_d->info[dist_dim].align_manner == _XMP_N_ALIGN_GBLOCK){
      _XMP_template_chunk_t *x_chunk = &(x_d->align_template->chunk[x_d->info[dist_dim].align_template_index]);
      if(dist_dim == 0){
         _XMP_template_chunk_t *a_chunk = &(a_d->align_template->chunk[a_d->info[dist_dim].align_template_index]);
         for(i=0; i<x_d->align_template->onto_nodes->comm_size; i++){
            if(x_chunk->mapping_array[i] != a_chunk->mapping_array[i]){
               same_align = 0;
               break;
            }
         }
      } else {
         _XMP_template_chunk_t *b_chunk = &(b_d->align_template->chunk[b_d->info[dist_dim].align_template_index]);
         for(i=0; i<x_d->align_template->onto_nodes->comm_size; i++){
            if(x_chunk->mapping_array[i] != b_chunk->mapping_array[i]){
               same_align = 0;
               break;
            }
         }
      }
   } else if(same_align == 2){
      if(x_d->info[0].align_manner == _XMP_N_ALIGN_GBLOCK){
         _XMP_template_chunk_t *x_chunk = &(x_d->align_template->chunk[x_d->info[0].align_template_index]);
         _XMP_template_chunk_t *a_chunk = &(a_d->align_template->chunk[a_d->info[0].align_template_index]);
         for(i=0; i<x_d->align_template->onto_nodes->comm_size; i++){
            if(x_chunk->mapping_array[i] != a_chunk->mapping_array[i]){
               same_align = 0;
               break;
            }
         }
      }
      if(x_d->info[1].align_manner == _XMP_N_ALIGN_GBLOCK){
         _XMP_template_chunk_t *x_chunk = &(x_d->align_template->chunk[x_d->info[1].align_template_index]);
         _XMP_template_chunk_t *b_chunk = &(b_d->align_template->chunk[b_d->info[1].align_template_index]);
         for(i=0; i<x_d->align_template->onto_nodes->comm_size; i++){
            if(x_chunk->mapping_array[i] != b_chunk->mapping_array[i]){
               same_align = 0;
               break;
            }
         }
      }
   }
   
   /*  */
   if(same_nodes && !duplicate && same_align == 1){
      xmp_matmul_allgather(x_d, a_d, b_d, dist_dim);
   } else if(xmpf_running && same_nodes && !duplicate && same_align == 2){
      xmp_matmul_blockf(x_d, a_d, b_d);
   } else if(!xmpf_running && same_nodes && !duplicate && same_align == 2){
      xmp_matmul_blockc(x_d, a_d, b_d);
   } else {
      xmp_matmul_no_opt(x_d, a_d, b_d);
   }
}

Here is the call graph for this function:

xmp_pack()

void xmp_pack	(	void *	v_p,
		void *	a_p,
		void *	m_p
	)

{
   _XMP_array_t *v_d;
   _XMP_array_t *a_d;
   _XMP_array_t *m_d;
   //int *mp;
   int i;
   MPI_Comm *comm;
   int /*myrank,*/size;
   MPI_Request *com_req1;
   int *offset;
   int *lindx;
   int *lindx2;
   int wkcount;
   int masknum;
   int localnum_a;
   int *maskflag;
   int *pickindx;
   int icounter;
   int vcount;
   int packnum;
   int packflag;
   void (*xmp_pack_recv_info)(_XMP_array_t *, _XMP_array_t *, int, int *,
                              int *, int *, int *, int *, int, void *);
   void (*xmp_pack_send_info)(_XMP_array_t *, _XMP_array_t *, int, int *,
                              int *, int *, void *);
   /* packing */
 
   /* pack-unpack list */
   struct Listindx {
      int indx;
      struct Listindx *next;
   };
 
   /* pack-unpack list */
   struct Listinfo {
      int num;
      struct Listindx *head;
      struct Listindx *tail;
   };
 
   struct Listinfo *listinfo1;
   struct Listinfo *listinfo2;
 
   struct Listindx *p;
   MPI_Status istatus;
   char *buf;
   char *buf2;
   int dtoffset;
   int dsize;
   int comcount;
   int j;
 
   xmp_pack_recv_info = xmp_pack_unpack_array_v;
   xmp_pack_send_info = xmp_pack_unpack_array_a;
 
   v_d = (_XMP_array_t*)v_p;
   a_d = (_XMP_array_t*)a_p;
   if(m_p==NULL){
      m_d = NULL;
   }else{
      m_d = (_XMP_array_t*)m_p;
   }
 
   /* error check */
   if(v_d->dim != 1){
      _XMP_fatal("xmp_pack: 1st argument dimension is not 1");
      return;
   }
 
   if(m_p!=NULL){
     if(a_d->dim != m_d->dim){
        _XMP_fatal("xmp_pack: 2nd and 3rd argument dimension is not match");
        return;
     }
   }
 
   if(v_d->type != a_d->type){
      _XMP_fatal("xmp_pack: 1st and 2nd argument type is not match");
      return;
   }
 
   if(!v_d->align_template->is_distributed ||
      !a_d->align_template->is_distributed){
      _XMP_fatal("xmp_pack: argument is not distributed");
      if(m_p!=NULL){
         if(!m_d->align_template->is_distributed){
           _XMP_fatal("xmp_pack: argument is not distributed");
         }
      }
      return;
   }
/*
   mp=NULL;
   if(m_d != NULL){
      mp=m_d->array_addr_p;
   }
*/
   comm = _XMP_get_execution_nodes()->comm;
//   myrank=_XMP_get_execution_nodes()->comm_rank;
   size  =_XMP_get_execution_nodes()->comm_size;
 
   offset = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
   lindx = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
   lindx2 = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
 
   /* packing */
   listinfo1 = (struct Listinfo*)_XMP_alloc(sizeof(struct Listinfo)*size);
   listinfo2 = (struct Listinfo*)_XMP_alloc(sizeof(struct Listinfo)*size);
   for(i=0;i<size;i++){
      listinfo1[i].num = 0;
      listinfo1[i].head = NULL;
      listinfo1[i].tail = NULL;
      listinfo2[i].num = 0;
      listinfo2[i].head = NULL;
      listinfo2[i].tail = NULL;
   }
 
   for(i=0; i<a_d->dim; i++){
      offset[i] = 0 - a_d->info[i].ser_lower;
   }
 
   /* gen maskXXX */
   masknum=1;
   localnum_a=1;
   for(i=0; i<a_d->dim; i++){
      masknum  *= (a_d->info[i].ser_upper - a_d->info[i].ser_lower + 1);
      localnum_a *= (a_d->info[i].local_upper - a_d->info[i].local_lower + 1);
   }
   maskflag = (int*)_XMP_alloc(masknum*sizeof(int));
   pickindx = (int*)_XMP_alloc(masknum*sizeof(int));
 
   com_req1 = (MPI_Request*)_XMP_alloc(size*sizeof(MPI_Request));
 
   /* init maksXXX */
   for(i=0;i<masknum;i++){
     maskflag[i]=0;
     pickindx[i]=v_d->info[0].ser_lower - 1;
   }
   for(i=0;i<size;i++){
     com_req1[i] = MPI_REQUEST_NULL;
   }
 
   wkcount=0;
 
   if(m_d != NULL){
      if(xmpf_running){
         xmp_pack_unpack_dim(m_d, m_d->dim, offset, &wkcount, maskflag, lindx2);
      }else{
         xmp_pack_unpack_dim(m_d, -1, offset, &wkcount, maskflag, lindx2);
      }
   }
 
   /* gather(reduce) all mask */
   if(m_d != NULL){
      MPI_Allreduce(MPI_IN_PLACE, maskflag, masknum, MPI_INT, MPI_SUM, *comm);
   }else{
      for(i=0;i<masknum;i++){
        maskflag[i] = 1;
      }
      wkcount = masknum;
   }
 
   icounter=v_d->info[0].ser_lower;
   packnum=0;
   for(i=0;i<masknum;i++){
      if(maskflag[i]==1){
         pickindx[i]=icounter++;
         packnum++;
      }
   }
 
   packflag = 1;
   wkcount=0;
   vcount=0;
 
   /* pack data recv info */
   if(xmpf_running){
      xmp_pack_recv_info(a_d, v_d, a_d->dim, offset, &wkcount, lindx2, pickindx, 
                    &vcount, packflag,(void *)listinfo2);
   }else{
      xmp_pack_recv_info(a_d, v_d, -1, offset, &wkcount, lindx2, pickindx, 
                    &vcount, packflag,(void *)listinfo2);
   }
 
   /* pack data send info*/
   wkcount=0;
 
   if(xmpf_running){
      xmp_pack_send_info(a_d, v_d, a_d->dim, offset, lindx2, pickindx, 
                    (void *)listinfo1);
   }else{
      xmp_pack_send_info(a_d, v_d, -1, offset, lindx2, pickindx,
                    (void *)listinfo1);
   }
 
   /* send packing data */
   dsize=0;
   for(i=0;i<size;i++){
      if(listinfo1[i].num > 0){
         p = listinfo1[i].head;
         for(j=0;j<listinfo1[i].num;j++){
           dsize++;
         }
      }
   }
 
   buf = (char*)_XMP_alloc(a_d->type_size*dsize);
 
   comcount=0;
   dtoffset=0;
   for(i=0;i<size;i++){
      if(listinfo1[i].num > 0){
         p = listinfo1[i].head;
         for(j=0;j<listinfo1[i].num;j++){
            memcpy(buf+j*a_d->type_size+dtoffset,
                   (char *)a_d->array_addr_p+p->indx*a_d->type_size,
                   a_d->type_size);
            p = p->next;
         }
         MPI_Isend(buf+dtoffset, a_d->type_size*listinfo1[i].num, MPI_BYTE,
                   i, 99, *comm, &com_req1[comcount]);
         dtoffset += listinfo1[i].num*a_d->type_size;
         comcount++;
      }
   }
 
   /* recv packing data */
   for(i=0;i<size;i++){
      if(listinfo2[i].num > 0){
         buf2 = (char*)_XMP_alloc(v_d->type_size*listinfo2[i].num);
 
         MPI_Recv(buf2, v_d->type_size*listinfo2[i].num, MPI_BYTE, i, 99, *comm, &istatus);
 
         p = listinfo2[i].head;
         for(j=0;j<listinfo2[i].num;j++){
 
            memcpy((char *)v_d->array_addr_p+p->indx*v_d->type_size,
                   buf2+j*v_d->type_size,
                   v_d->type_size);
            p = p->next;
         }
         _XMP_free(buf2);
      }
   }
 
   if(comcount > 0){
      MPI_Waitall(comcount, com_req1, MPI_STATUSES_IGNORE);
   }
   _XMP_free(buf);
 
   /* duplicate */
   duplicate_copy(v_d);
 
   _XMP_free(maskflag);
   _XMP_free(pickindx);
   _XMP_free(com_req1);
   _XMP_free(offset);
   _XMP_free(lindx);
   _XMP_free(lindx2);
   _XMP_free(listinfo1);
   _XMP_free(listinfo2);
 
   return;
}

Here is the caller graph for this function:

xmp_pack_mask()

void xmp_pack_mask	(	void *	v_p,
		void *	a_p,
		void *	m_p
	)

{
    xmp_pack(v_p, a_p, m_p);
}

Here is the call graph for this function:

xmp_pack_nomask()

void xmp_pack_nomask	(	void *	v_p,
		void *	a_p
	)

{
    xmp_pack(v_p, a_p, NULL);
}

Here is the call graph for this function:

xmp_scatter()

void xmp_scatter	(	void *	x_d,
		void *	a_d,
			...
	)

{
  int          i;
  va_list      valst;
  _XMP_array_t *idx_p;
  _XMP_array_t **idx_array;
  _XMP_array_t *x_p = (_XMP_array_t *)x_d;
  _XMP_array_t *a_p = (_XMP_array_t *)a_d;
 
  idx_array = (_XMP_array_t **)_XMP_alloc(sizeof(_XMP_array_t *)*a_p->dim);
 
  va_start( valst, a_d );
  for(i=0;i<x_p->dim;i++){
     idx_p = va_arg( valst , _XMP_array_t* );
     idx_array[i] = idx_p;
  }
  va_end(valst);
 
  xmp_scatter_kernel(x_d, a_d, idx_array);
 
  _XMP_free(idx_array);
}

Here is the call graph for this function:

xmp_transpose()

void xmp_transpose	(	void *	dst_p,
		void *	src_p,
		int	opt
	)

{
   _XMP_array_t *dst_d;
   _XMP_array_t *src_d;
   int same_nodes;
   int same_template;
   int same_align;
   int dist_num;
   int dist_dim;
   int regular;
   int duplicate;
   int dst_alloc_size[2];
   int src_alloc_size[2];
   int i, j, k;
 
   dst_d = (_XMP_array_t*)dst_p;
   src_d = (_XMP_array_t*)src_p;
 
   /* error check */
   if(dst_d->dim != 2 || src_d->dim != 2){
      _XMP_fatal("xmp_transpose: argument dimension is not 2");
      return;
   }
   if(dst_d->type != src_d->type){
      _XMP_fatal("xmp_transpose: argument type is not match");
      return;
   }
   if(!dst_d->align_template->is_distributed || !src_d->align_template->is_distributed){
      _XMP_fatal("xmp_transpose: argument is not distributed");
      return;
   }
 
   /* allocate check */
   if(dst_d->is_allocated){
      dst_alloc_size[0] = dst_d->info[0].alloc_size;
      dst_alloc_size[1] = dst_d->info[1].alloc_size;
   } else {
      dst_alloc_size[0] = 0;
      dst_alloc_size[1] = 0;
   }
   if(src_d->is_allocated){
      src_alloc_size[0] = src_d->info[0].alloc_size;
      src_alloc_size[1] = src_d->info[1].alloc_size;
   } else {
      src_alloc_size[0] = 0;
      src_alloc_size[1] = 0;
   }
 
   /* same nodes? */
   same_nodes=1;
   if(_XMP_get_execution_nodes()->comm_size != dst_d->align_template->onto_nodes->comm_size) same_nodes = 0;
   if(_XMP_get_execution_nodes()->comm_size != src_d->align_template->onto_nodes->comm_size) same_nodes = 0;
 
   /* duplicate? */
   duplicate = 0;
   for(i=0; i<dst_d->dim; i++){
      if(dst_d->info[i].align_template_index >= 0){
         duplicate++;
      }
   }
   if(duplicate >= dst_d->align_template->onto_nodes->dim) duplicate = 0;
      
 
   /* same template? */
   same_template = check_template(dst_d->align_template, src_d->align_template);
 
   /* same align? */
   same_align = 1;
   if(dst_d->info[0].align_template_index != src_d->info[0].align_template_index) same_align = 0;
   if(dst_d->info[1].align_template_index != src_d->info[1].align_template_index) same_align = 0;
 
   /* distribute num & regular */
   dist_num = 0;
   dist_dim = -1;
   regular = 0;
   for(i=0; i<src_d->dim; i++){
      j = src_d->info[i].align_template_index;
      if(j >= 0){
         switch(src_d->align_template->chunk[j].dist_manner){
         case _XMP_N_DIST_BLOCK:
            if(same_align && src_d->info[i].align_manner == dst_d->info[i].align_manner){
               if(dist_num == 0 &&
                  src_d->info[i].ser_size == src_d->align_template->info[j].ser_size &&
                  src_d->info[i].ser_size%_XMP_get_execution_nodes()->comm_size == 0 &&
                  dst_d->info[i].ser_size == dst_d->align_template->info[j].ser_size &&
                  dst_d->info[i].ser_size%_XMP_get_execution_nodes()->comm_size == 0) {
                  regular = 1;
               } else {
                  regular = 0;
               }
            }
            dist_num++;
            dist_dim = i;
            break;
         case _XMP_N_DIST_CYCLIC:
         case _XMP_N_DIST_BLOCK_CYCLIC:
            dist_num++;
            dist_dim = i;
            break;
         case _XMP_N_DIST_GBLOCK:
            if(same_align && src_d->info[i].align_manner == dst_d->info[i].align_manner){
               _XMP_template_chunk_t *src_c = &(src_d->align_template->chunk[src_d->info[i].align_template_index]);
               _XMP_template_chunk_t *dst_c = &(dst_d->align_template->chunk[dst_d->info[i].align_template_index]);
               unsigned long long w;
               if(dist_num == 0 &&
                  src_d->info[i].ser_size == src_d->align_template->info[j].ser_size &&
                  dst_d->info[i].ser_size == dst_d->align_template->info[j].ser_size){
                  regular = 1;
 
                  w=src_c->mapping_array[1]-src_c->mapping_array[0];
                  for(k=1; k<=src_c->onto_nodes_info->size; k++){
                     if((src_c->mapping_array[k]-src_c->mapping_array[k-1]) != w) regular = 0;
                  }
                  w=dst_c->mapping_array[1]-dst_c->mapping_array[0];
                  for(k=1; k<=dst_c->onto_nodes_info->size; k++){
                     if((dst_c->mapping_array[k]-dst_c->mapping_array[k-1]) != w) regular = 0;
                  }
               }
            }
            dist_num++;
            dist_dim = i;
            break;
         default:
            break;
         }
      }
   }
   /* regular? */
   if(src_d->info[0].align_subscript != 0 || src_d->info[1].align_subscript != 0 ||
      dst_d->info[0].align_subscript != 0 || dst_d->info[1].align_subscript != 0 ) regular = 0;
   
#ifdef DEBUG
   for(i=0; i<_XMP_get_execution_nodes()->comm_size; i++){
      if(i == _XMP_get_execution_nodes()->comm_rank){
         printf("rank%d: nodes %d: template %d: align %d: regular %d\n",
                i, same_nodes, same_template, same_align, regular);
         fflush(stdout);
      }
      fflush(stdout);
      MPI_Barrier(*(MPI_Comm*)(_XMP_get_execution_nodes()->comm));
   }
#endif
 
   /*============================================================================================*/
   /* same_node && same_template && !same_align && dist_num==1 : no MPI communication            */
   /* same_node && same_align && regular && dist_num==1 : use collective MPI communication       */
   /* other: pack/unpack + send/recv                                                             */
   /*============================================================================================*/
   if(same_nodes && same_template && !same_align && dist_num == 1 &&
      dst_d->info[0].align_subscript == src_d->info[1].align_subscript &&
      dst_d->info[1].align_subscript == src_d->info[0].align_subscript){
      /* no MPI communication transpose */
      int di, dj;
      char *dst_array_p = (char*)dst_d->array_addr_p;
      char *src_array_p = (char*)src_d->array_addr_p;
      
#ifdef DEBUG
      show_all(src_d);
      show_all(dst_d);
#endif
      if(xmpf_running){                 /* Fortran */
         if(dst_d->is_allocated && src_d->is_allocated){
            for(j=src_d->info[1].local_lower; j<=src_d->info[1].local_upper; j++){
               di = j-src_d->info[1].local_lower+dst_d->info[0].local_lower;
               for(i=src_d->info[0].local_lower; i<=src_d->info[0].local_upper; i++){
                  dj = i-src_d->info[0].local_lower+dst_d->info[1].local_lower;
                  memcpy(dst_array_p+(dj*dst_alloc_size[0]+di)*dst_d->type_size,
                         src_array_p+(j*src_alloc_size[0]+i)*src_d->type_size,
                         src_d->type_size);
               }
            }
         }
      } else {                           /* C */
         if(dst_d->is_allocated && src_d->is_allocated){
            for(i=src_d->info[0].local_lower; i<=src_d->info[0].local_upper; i++){
               dj = i-src_d->info[0].local_lower+dst_d->info[1].local_lower;
               for(j=src_d->info[1].local_lower; j<=src_d->info[1].local_upper; j++){
                  di = j-src_d->info[1].local_lower+dst_d->info[0].local_lower;
                  memcpy(dst_array_p+(di*dst_alloc_size[1]+dj)*dst_d->type_size,
                         src_array_p+(i*src_alloc_size[1]+j)*src_d->type_size,
                         src_d->type_size);
               }
            }
         }
      }
#ifdef DEBUG
      show_array(src_d, NULL);
      show_array(dst_d, NULL);
#endif
 
   } 
   else if(xmpf_running && same_nodes && same_align && regular && !duplicate &&
             dist_num == 1 && dist_dim == 1 && dst_d->info[dist_dim].align_manner == _XMP_N_ALIGN_BLOCK &&
             dst_d->info[dist_dim].shadow_size_lo == 0 && dst_d->info[dist_dim].shadow_size_hi == 0 &&
             src_d->info[dist_dim].shadow_size_lo == 0 && src_d->info[dist_dim].shadow_size_hi == 0){
      /* original xmp_transpose (Fortran) */
      /* start_collection("xmp_transpose_original"); */
      xmp_transpose_original(dst_d, src_d, opt);
      /* stop_collection("xmp_transpose_original"); */
      
   } 
   else if(same_nodes && same_align && regular && !duplicate && dist_num == 1){
      /* collective MPI communication transpose */
      /* start_collection("xmp_transpose_alltoall"); */
      xmp_transpose_alltoall(dst_d, src_d, opt, dist_dim);
      /* stop_collection("xmp_transpose_alltoall"); */
 
   /* } else if(same_nodes && same_align && !duplicate && dist_num == 1){ */
      /* TODO: not support (block size is not even) */
   /*    /\* collective MPI communication transpose *\/ */
   /*    xmp_transpose_alltoallv(dst_d, src_d, opt, dist_dim); */
      
   } 
   else {
      /* pack/unpack + sendrecv */
      xmp_transpose_no_opt(dst_d, src_d, opt);
   }
}

Here is the call graph for this function:

xmp_unpack()

void xmp_unpack	(	void *	a_p,
		void *	v_p,
		void *	m_p
	)

{
   _XMP_array_t *v_d;
   _XMP_array_t *a_d;
   _XMP_array_t *m_d;
//   int *mp;
   int i;
   MPI_Comm *comm;
   int /*myrank,*/size;
   MPI_Request *com_req2;
   int *offset;
   int *lindx;
   int *lindx2;
   int wkcount;
   int masknum;
   int localnum_v;
   int *maskflag;
   int *pickindx;
   int icounter;
   int vcount;
   int packnum;
   int packflag;
   void (*xmp_unpack_send_info)(_XMP_array_t *, _XMP_array_t *, int, int *,
                                int *, int *, int *, int *, int, void *);
   void (*xmp_unpack_recv_info)(_XMP_array_t *, _XMP_array_t *, int, int *,
                                int *, int *, void *);
   /* packing */
   /* pack-unpack list */
   struct Listindx {
      int indx;
      struct Listindx *next;
   };
   /* pack-unpack list */
   struct Listinfo {
      int num;
      struct Listindx *head;
      struct Listindx *tail;
   };
   struct Listinfo *listinfo1;
   struct Listinfo *listinfo2;
   struct Listindx *p;
   MPI_Status istatus;
   char *buf;
   char *buf2;
   int dtoffset;
   int dsize;
   int comcount;
   int j;
 
   xmp_unpack_send_info = xmp_pack_unpack_array_v;
   xmp_unpack_recv_info = xmp_pack_unpack_array_a;
 
   a_d = (_XMP_array_t*)a_p;
   v_d = (_XMP_array_t*)v_p;
   if(m_p==NULL){
      m_d = NULL;
   }else{
      m_d = (_XMP_array_t*)m_p;
   }
 
   /* error check */
   if(v_d->dim != 1){
      _XMP_fatal("xmp_unpack: 2st argument dimension is not 1");
      return;
   }
 
   if(m_p!=NULL){
     if(a_d->dim != m_d->dim){
        _XMP_fatal("xmp_unpack: 1nd and 3rd argument dimension is not match");
        return;
     }
   }
 
   if(a_d->type != v_d->type){
      _XMP_fatal("xmp_unpack: 1st and 2nd argument type is not match");
      return;
   }
 
   if(!v_d->align_template->is_distributed ||
      !a_d->align_template->is_distributed){
      _XMP_fatal("xmp_unpack: argument is not distributed");
      if(m_p!=NULL){
         if(!m_d->align_template->is_distributed){
           _XMP_fatal("xmp_unpack: argument is not distributed");
         }
      }
      return;
   }
/*
   mp=NULL;
   if(m_d != NULL){
      mp=m_d->array_addr_p;
   }*/
 
   comm = _XMP_get_execution_nodes()->comm;
   //myrank=_XMP_get_execution_nodes()->comm_rank;
   size  =_XMP_get_execution_nodes()->comm_size;
 
   offset = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
   lindx = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
   lindx2 = (int*)_XMP_alloc((a_d->dim)*sizeof(int));
 
   /* packing */
   listinfo1 = (struct Listinfo*)_XMP_alloc(sizeof(struct Listinfo)*size);
   listinfo2 = (struct Listinfo*)_XMP_alloc(sizeof(struct Listinfo)*size);
   for(i=0;i<size;i++){
      listinfo1[i].num = 0;
      listinfo1[i].head = NULL;
      listinfo1[i].tail = NULL;
      listinfo2[i].num = 0;
      listinfo2[i].head = NULL;
      listinfo2[i].tail = NULL;
   }
 
   for(i=0; i<a_d->dim; i++){
      offset[i] = 0 - a_d->info[i].ser_lower;
   }
 
   /* gen maskXXX */
   masknum=1;
   localnum_v=1;
   for(i=0; i<a_d->dim; i++){
      masknum  *= (a_d->info[i].ser_upper - a_d->info[i].ser_lower + 1);
   }
   for(i=0; i<v_d->dim; i++){
      localnum_v *= (v_d->info[i].local_upper - v_d->info[i].local_lower + 1);
   }
   maskflag = (int*)_XMP_alloc(masknum*sizeof(int));
   pickindx = (int*)_XMP_alloc(masknum*sizeof(int));
 
   com_req2 = (MPI_Request*)_XMP_alloc(size*sizeof(MPI_Request));
 
   /* init maksXXX */
   for(i=0;i<masknum;i++){
     maskflag[i]=0;
     pickindx[i]=v_d->info[0].ser_lower - 1;
   }
   for(i=0;i<size;i++){
     com_req2[i] = MPI_REQUEST_NULL;
   }
 
   wkcount=0;
 
   if(m_d != NULL){
      if(xmpf_running){
         xmp_pack_unpack_dim(m_d, m_d->dim, offset, &wkcount, maskflag, lindx2);
      }else{
         xmp_pack_unpack_dim(m_d, -1, offset, &wkcount, maskflag, lindx2);
      }
   }
 
   /* gather(reduce) all mask */
   if(m_d != NULL){
      MPI_Allreduce(MPI_IN_PLACE, maskflag, masknum, MPI_INT, MPI_SUM, *comm);
   }else{
      for(i=0;i<masknum;i++){
        maskflag[i] = 1;
      }
      wkcount = masknum;
   }
 
   icounter=v_d->info[0].ser_lower;
   packnum=0;
   for(i=0;i<masknum;i++){
      if(maskflag[i]==1){
         pickindx[i]=icounter++;
         packnum++;
      }
   }
 
   packflag = 0;
   wkcount=0;
   vcount=0;
 
   /* unpack data send info */
   if(xmpf_running){
      xmp_unpack_send_info(a_d, v_d, a_d->dim, offset, &wkcount, lindx2, pickindx,
                      &vcount, packflag, listinfo2);
   }else{
      xmp_unpack_send_info(a_d, v_d, -1, offset, &wkcount, lindx2, pickindx,
                      &vcount, packflag, listinfo2);
   }
 
   /* unpack data recv info */
   wkcount=0;
 
   if(xmpf_running){
      xmp_unpack_recv_info(a_d, v_d, a_d->dim, offset, lindx2, pickindx,
                      listinfo1);
   }else{
      xmp_unpack_recv_info(a_d, v_d, -1, offset, lindx2, pickindx,
                      listinfo1);
   }
 
  /* send packing data */
   dsize=0;
   for(i=0;i<size;i++){
      if(listinfo2[i].num > 0){
         p = listinfo2[i].head;
         for(j=0;j<listinfo2[i].num;j++){
           dsize++;
         }
      }
   }
 
   buf = (char*)_XMP_alloc(v_d->type_size*dsize);
 
   comcount=0;
   dtoffset=0;
   for(i=0;i<size;i++){
      if(listinfo2[i].num > 0){
         p = listinfo2[i].head;
         for(j=0;j<listinfo2[i].num;j++){
            memcpy(buf+j*v_d->type_size+dtoffset,
                   (char *)v_d->array_addr_p+p->indx*v_d->type_size,
                   v_d->type_size);
            p = p->next;
         }
         MPI_Isend(buf+dtoffset, v_d->type_size*listinfo2[i].num, MPI_BYTE,
                   i, 99, *comm, &com_req2[comcount]);
         dtoffset += listinfo2[i].num*v_d->type_size;
         comcount++;
      }
   }
 
   /* recv packing data */
   for(i=0;i<size;i++){
      if(listinfo1[i].num > 0){
         buf2 = (char*)_XMP_alloc(a_d->type_size*listinfo1[i].num);
 
         MPI_Recv(buf2, a_d->type_size*listinfo1[i].num, MPI_BYTE, i, 99, *comm, &istatus);
 
         p = listinfo1[i].head;
         for(j=0;j<listinfo1[i].num;j++){
            memcpy((char *)a_d->array_addr_p+p->indx*a_d->type_size,
                   buf2+j*a_d->type_size,
                   a_d->type_size);
            p = p->next;
         }
         _XMP_free(buf2);
      }
   }
 
   if(comcount > 0){
      MPI_Waitall(comcount, com_req2, MPI_STATUSES_IGNORE);
   }
   _XMP_free(buf);
 
   /* duplicate */
   duplicate_copy(a_d);
 
   _XMP_free(maskflag);
   _XMP_free(pickindx);
   _XMP_free(com_req2);
   _XMP_free(offset);
   _XMP_free(lindx);
   _XMP_free(lindx2);
   _XMP_free(listinfo1);
   _XMP_free(listinfo2);
 
   return;
}

Here is the caller graph for this function:

xmp_unpack_mask()

void xmp_unpack_mask	(	void *	a_p,
		void *	v_p,
		void *	m_p
	)

{
   xmp_unpack(v_p, a_p, m_p);
}

Here is the call graph for this function:

xmp_unpack_nomask()

void xmp_unpack_nomask	(	void *	a_p,
		void *	v_p
	)

{
   xmp_unpack(a_p, v_p, NULL);
}

Here is the call graph for this function:

xmpf_gather()

void xmpf_gather	(	void *	x_p,
		void *	a_p,
		_XMP_array_t **	idx_array
	)

{
   xmpf_running = 1;
   xmp_gather_kernel(x_p, a_p, idx_array);
   xmpf_running = 0;
}

xmpf_matmul()

void xmpf_matmul	(	void *	x_p,
		void *	a_p,
		void *	b_p
	)

{
   xmpf_running = 1;
   xmp_matmul(x_p, a_p, b_p);
   xmpf_running = 0;
}

xmpf_pack()

void xmpf_pack	(	void *	v_p,
		void *	a_p,
		void *	m_p
	)

{
   xmpf_running = 1;
   xmp_pack(v_p, a_p, m_p);
   xmpf_running = 0;
}

xmpf_pack_mask()

void xmpf_pack_mask	(	void *	v_p,
		void *	a_p,
		void *	m_p
	)

{
   xmpf_running = 1;
   xmp_pack(v_p, a_p, m_p);
   xmpf_running = 0;
}

xmpf_pack_nomask()

void xmpf_pack_nomask	(	void *	v_p,
		void *	a_p
	)

{
   xmpf_running = 1;
   xmp_pack(v_p, a_p, NULL);
   xmpf_running = 0;
}

xmpf_scatter()

void xmpf_scatter	(	void *	x_p,
		void *	a_p,
		_XMP_array_t **	idx_array
	)

{
   xmpf_running = 1;
   xmp_scatter_kernel(x_p, a_p, idx_array);
   xmpf_running = 0;
}

xmpf_transpose()

void xmpf_transpose	(	void *	dst_p,
		void *	src_p,
		int	opt
	)

{
   xmpf_running = 1;
   xmp_transpose(dst_p, src_p, opt);
   xmpf_running = 0;
}

xmpf_unpack()

void xmpf_unpack	(	void *	a_p,
		void *	v_p,
		void *	m_p
	)

{
   xmpf_running = 1;
   xmp_unpack(a_p, v_p, m_p);
   xmpf_running = 0;
}

xmpf_unpack_mask()

void xmpf_unpack_mask	(	void *	a_p,
		void *	v_p,
		void *	m_p
	)

{
   xmpf_running = 1;
   xmp_unpack(a_p, v_p, m_p);
   xmpf_running = 0;
}

xmpf_unpack_nomask()

void xmpf_unpack_nomask	(	void *	a_p,
		void *	v_p
	)

{
   xmpf_running = 1;
   xmp_unpack(a_p, v_p, NULL);
   xmpf_running = 0;
}