#include <mpi.h>
#include <stdio.h>
#include <stddef.h>
#include <stdarg.h>
#include <stdint.h>
#include <string.h>
#include "xmp_data_struct.h"

Include dependency graph for xmp_internal.h:

Go to the source code of this file.

Data Structures
struct	_XMP_coarray_list_type

Macros
#define	_XMP_INTERNAL

#define	MIN(a, b) ( (a)<(b) ? (a) : (b) )

#define	MAX(a, b) ( (a)>(b) ? (a) : (b) )

#define	_XMP_ASSERT(_flag)

#define	_XMP_RETURN_IF_SINGLE

#define	_XMP_RETURN_IF_AFTER_FINALIZATION

#define	_XMP_IS_SINGLE (_XMP_world_size == 1)

#define	_XMP_TSTART(t0)

#define	_XMP_TEND(t, t0)

#define	_XMP_TEND2(t, tt, t0)

#define	XACC_DEBUG(...) do{}while(0)

Typedefs
typedef struct _XMP_coarray_list_type	_XMP_coarray_list_t

Functions
int	xmp_get_ruuning ()

void	_XMP_calc_array_dim_elmts (_XMP_array_t *array, int array_index)

void	_XMP_init_array_desc (_XMP_array_t *array, _XMP_template_t template, int dim, int type, size_t type_size,...)

void	_XMP_init_array_desc_NOT_ALIGNED (_XMP_array_t *adesc, _XMP_template_t template, int ndims, int type, size_t type_size, unsigned long long dim_acc, void ap)

void	_XMP_finalize_array_desc (_XMP_array_t *array)

void	_XMP_align_array_NOT_ALIGNED (_XMP_array_t *array, int array_index)

void	_XMP_align_array_DUPLICATION (_XMP_array_t *array, int array_index, int template_index, long long align_subscript)

void	_XMP_align_array_BLOCK (_XMP_array_t array, int array_index, int template_index, long long align_subscript, int temp0)

void	_XMP_align_array_CYCLIC (_XMP_array_t array, int array_index, int template_index, long long align_subscript, int temp0)

void	_XMP_align_array_BLOCK_CYCLIC (_XMP_array_t array, int array_index, int template_index, long long align_subscript, int temp0)

void	_XMP_align_array_GBLOCK (_XMP_array_t array, int array_index, int template_index, long long align_subscript, int temp0)

void	_XMP_init_array_nodes (_XMP_array_t *array)

void	_XMP_init_array_comm (_XMP_array_t *array,...)

void	_XMP_init_array_comm2 (_XMP_array_t *array, int args[])

void	_XMP_alloc_array (void *array_addr, _XMP_array_t array_desc, int is_coarray,...)

void	_XMP_alloc_array2 (void *array_addr, _XMP_array_t array_desc, int is_coarray, unsigned long long *acc[])

void	_XMP_dealloc_array (_XMP_array_t *array_desc)

void	_XMP_normalize_array_section (_XMP_gmv_desc_t gmv_desc, int idim, int lower, int upper, int stride)

void	_XMPC_pack_array (void buffer, void src, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)

void	_XMPC_unpack_array (void dst, void buffer, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)

_XMP_async_comm_t *	_XMP_get_current_async ()

void	_XMP_initialize_async_comm_tab ()

void	_XMP_nodes_dealloc_after_wait_async (_XMP_nodes_t *n)

void	xmpc_end_async (int)

void	_XMP_barrier_NODES_ENTIRE (_XMP_nodes_t *nodes)

void	_XMP_barrier_EXEC (void)

void	_XMP_bcast_NODES_ENTIRE_OMITTED (_XMP_nodes_t bcast_nodes, void addr, int count, size_t datatype_size)

void	_XMP_bcast_NODES_ENTIRE_NODES (_XMP_nodes_t bcast_nodes, void addr, int count, size_t datatype_size, _XMP_nodes_t *from_nodes,...)

void	_XMP_bcast_NODES_ENTIRE_NODES_V (_XMP_nodes_t bcast_nodes, void addr, int count, size_t datatype_size, _XMP_nodes_t *from_nodes, va_list args)

void	_XMP_initialize_onesided_functions ()

void	_XMP_finalize_onesided_functions ()

void	_XMP_build_sync_images_table ()
	Build table for sync images. More...

void	_XMP_sync_images_EXEC (int *status)

void	_XMP_build_coarray_queue ()
	Build queue for coarray. More...

void	_XMP_coarray_lastly_deallocate ()
	Deallocate memory space and an object of the last coarray. More...

void	_XMP_mpi_coarray_deallocate (_XMP_coarray_t *, bool is_acc)

size_t	_XMP_calc_copy_chunk (const int, const _XMP_array_section_t *)

int	_XMP_get_dim_of_allelmts (const int, const _XMP_array_section_t *)

void	_XMP_local_put (_XMP_coarray_t , const void , const int, const int, const int, const int, const _XMP_array_section_t , const _XMP_array_section_t , const size_t, const size_t)

void	_XMP_local_get (void , const _XMP_coarray_t , const int, const int, const int, const int, const _XMP_array_section_t , const _XMP_array_section_t , const size_t, const size_t)

void	_XMP_L2G (int local_idx, long long int global_idx, _XMP_template_t template, int template_index)

void	_XMP_G2L (long long int global_idx, int local_idx, _XMP_template_t template, int template_index)

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

void	xmpf_matmul (void x_p, void a_p, void *b_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	xmpf_pack (void v_p, void a_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	xmpf_unpack (void a_p, void v_p, void *m_p)

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

int	_XMP_calc_gmove_array_owner_linear_rank_SCALAR (_XMP_array_t array, int ref_index)

void	_XMP_gmove_bcast_SCALAR (void dst_addr, void src_addr, size_t type_size, int root_rank)

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

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

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

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

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

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

void	_XMP_gmove_inout_scalar (void scalar, _XMP_gmv_desc_t gmv_desc, int rdma_type)

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

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

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

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

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

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

int	_XMP_sched_loop_template_width_1 (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int *par_step, int template_lower, int template_upper, int template_stride)

int	_XMP_sched_loop_template_width_N (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int *par_step, int template_lower, int template_upper, int template_stride, int width, int template_ser_lower, int template_ser_upper)

void	_XMP_sched_loop_template_DUPLICATION (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int par_step, _XMP_template_t template, int template_index)

void	_XMP_sched_loop_template_BLOCK (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int par_step, _XMP_template_t template, int template_index)

void	_XMP_sched_loop_template_CYCLIC (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int par_step, _XMP_template_t template, int template_index)

void	_XMP_sched_loop_template_BLOCK_CYCLIC (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int par_step, _XMP_template_t template, int template_index)

void	_XMP_sched_loop_template_GBLOCK (int ser_init, int ser_cond, int ser_step, int par_init, int par_cond, int par_step, _XMP_template_t template, int template_index)

_XMP_nodes_t *	_XMP_create_temporary_nodes (_XMP_nodes_t *n)

_XMP_nodes_t *	_XMP_init_nodes_struct_GLOBAL (int dim, int *dim_size, int is_static)

_XMP_nodes_t *	_XMP_init_nodes_struct_EXEC (int dim, int *dim_size, int is_static)

_XMP_nodes_t *	_XMP_init_nodes_struct_NODES_NUMBER (int dim, int ref_lower, int ref_upper, int ref_stride, int *dim_size, int is_static)

_XMP_nodes_t *	_XMP_init_nodes_struct_NODES_NAMED (int dim, _XMP_nodes_t ref_nodes, int shrink, int ref_lower, int ref_upper, int ref_stride, int dim_size, int is_static)

void	_XMP_finalize_nodes (_XMP_nodes_t *nodes)

_XMP_nodes_t *	_XMP_create_nodes_by_comm (int is_member, _XMP_comm_t *comm)

void	_XMP_calc_rank_array (_XMP_nodes_t n, int rank_array, int linear_rank)

int	_XMP_calc_linear_rank (_XMP_nodes_t n, int rank_array)

int	_XMP_calc_linear_rank_on_target_nodes (_XMP_nodes_t n, int rank_array, _XMP_nodes_t *target_nodes)

_Bool	_XMP_calc_coord_on_target_nodes2 (_XMP_nodes_t n, int ncoord, _XMP_nodes_t target_n, int target_ncoord)

_Bool	_XMP_calc_coord_on_target_nodes (_XMP_nodes_t n, int ncoord, _XMP_nodes_t target_n, int target_ncoord)

_XMP_nodes_ref_t *	_XMP_init_nodes_ref (_XMP_nodes_t n, int rank_array)

void	_XMP_finalize_nodes_ref (_XMP_nodes_ref_t *nodes_ref)

_XMP_nodes_ref_t *	_XMP_create_nodes_ref_for_target_nodes (_XMP_nodes_t n, int rank_array, _XMP_nodes_t *target_nodes)

void	_XMP_translate_nodes_rank_array_to_ranks (_XMP_nodes_t nodes, int ranks, int *rank_array, int shrink_nodes_size)

int	_XMP_get_next_rank (_XMP_nodes_t nodes, int rank_array)

int	_XMP_calc_nodes_index_from_inherit_nodes_index (_XMP_nodes_t *nodes, int inherit_nodes_index)

void	_XMP_push_nodes (_XMP_nodes_t *nodes)

void	_XMP_pop_nodes (void)

void	_XMP_pop_n_free_nodes (void)

void	_XMP_pop_n_free_nodes_wo_finalize_comm (void)

_XMP_nodes_t *	_XMP_get_execution_nodes (void)

int	_XMP_get_execution_nodes_rank (void)

void	_XMP_push_comm (_XMP_comm_t *comm)

void	_XMP_finalize_comm (_XMP_comm_t *comm)

void	_XMP_pack_vector (char restrict dst, char restrict src, int count, int blocklength, long stride)

void	_XMP_pack_vector2 (char restrict dst, char restrict src, int count, int blocklength, int nnodes, int type_size, int src_block_dim)

void	_XMP_unpack_vector (char restrict dst, char restrict src, int count, int blocklength, long stride)

void	_XMPF_unpack_transpose_vector (char restrict dst, char restrict src, int dst_stride, int src_stride, int type_size, int dst_block_dim)

void	_XMP_check_reflect_type (void)

void	_XMP_reduce_NODES_ENTIRE (_XMP_nodes_t nodes, void addr, int count, int datatype, int op)

void	_XMPF_reduce_FLMM_NODES_ENTIRE (_XMP_nodes_t nodes, void addr, int count, int datatype, int op, int num_locs, void *loc_vars, int loc_types)

void	_XMP_reduce_CLAUSE (void *data_addr, int count, int datatype, int op)

void	xmp_reduce_initialize ()

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_wait_async__ (int async_id)

void	_XMP_reflect_async__ (_XMP_array_t *a, int async_id)

void	_XMP_reduce_shadow_wait (_XMP_array_t *a)

void	_XMP_reduce_shadow_sum (_XMP_array_t *a)

void	_XMP_init (int argc, char **argv, MPI_Comm comm)

void	_XMP_finalize (bool isFinalize)

size_t	_XMP_get_datatype_size (int datatype)

void	print_rsd (_XMP_rsd_t *rsd)

void	print_bsd (_XMP_bsd_t *bsd)

void	print_csd (_XMP_csd_t *csd)

void	print_comm_set (_XMP_comm_set_t *comm_set0)

_XMP_rsd_t *	intersection_rsds (_XMP_rsd_t _rsd1, _XMP_rsd_t _rsd2)

_XMP_csd_t *	intersection_csds (_XMP_csd_t csd1, _XMP_csd_t csd2)

_XMP_csd_t *	alloc_csd (int n)

void	free_csd (_XMP_csd_t *csd)

_XMP_csd_t *	copy_csd (_XMP_csd_t *csd)

int	get_csd_size (_XMP_csd_t *csd)

void	free_comm_set (_XMP_comm_set_t *comm_set)

_XMP_csd_t *	rsd2csd (_XMP_rsd_t *rsd)

_XMP_csd_t *	bsd2csd (_XMP_bsd_t *bsd)

_XMP_comm_set_t *	csd2comm_set (_XMP_csd_t *csd)

void	reduce_csd (_XMP_csd_t *csd[_XMP_N_MAX_DIM], int ndims)

void	_XMP_create_shadow_comm (_XMP_array_t *array, int array_index)

void	_XMP_reflect_shadow_FULL (void array_addr, _XMP_array_t array_desc, int array_index)

void	_XMP_init_reflect_sched (_XMP_reflect_sched_t *sched)

void	_XMP_finalize_reflect_sched (_XMP_reflect_sched_t *sched, _Bool free_buf)

void	_XMP_init_shadow (_XMP_array_t *array,...)

void	_XMP_sort (_XMP_array_t a_desc, _XMP_array_t b_desc, int is_up)

int	xmpc_ltog (int local_idx, _XMP_template_t *template, int template_index, int offset)

_XMP_template_t *	_XMP_create_template_desc (int dim, _Bool is_fixed)

int	_XMP_check_template_ref_inclusion (int ref_lower, int ref_upper, int ref_stride, _XMP_template_t *t, int index)

void	_XMP_init_template_FIXED (_XMP_template_t **template, int dim,...)

_XMP_nodes_t *	_XMP_create_nodes_by_template_ref (_XMP_template_t ref_template, int shrink, long long ref_lower, long long ref_upper, long long *ref_stride)

void	_XMP_calc_template_size (_XMP_template_t *t)

void	_XMP_init_template_chunk (_XMP_template_t template, _XMP_nodes_t nodes)

void	_XMP_finalize_template (_XMP_template_t *template)

int	_XMP_calc_template_owner_SCALAR (_XMP_template_t *ref_template, int dim_index, long long ref_index)

int	_XMP_calc_template_par_triplet (_XMP_template_t template, int template_index, int nodes_rank, int template_lower, int template_upper, int template_stride)

void	_XMP_dist_template_DUPLICATION (_XMP_template_t *template, int template_index)

void	_XMP_dist_template_BLOCK (_XMP_template_t *template, int template_index, int nodes_index)

void	_XMP_dist_template_CYCLIC (_XMP_template_t *template, int template_index, int nodes_index)

void	_XMP_dist_template_BLOCK_CYCLIC (_XMP_template_t *template, int template_index, int nodes_index, unsigned long long width)

void	_XMP_dist_template_GBLOCK (_XMP_template_t template, int template_index, int nodes_index, int mapping_array, int *temp0)

unsigned long long	_XMP_get_on_ref_id (void)

void *	_XMP_alloc (size_t size)

void	_XMP_free (void *p)

void	_XMP_fatal (char *msg)

void	_XMP_fatal_nomsg ()

void	_XMP_unexpected_error (void)

void	_XMP_warning (char *msg)

void	_XMP_init_world (int argc, char **argv)

void	_XMP_finalize_world (bool)

int	_XMP_split_world_by_color (int color)

_Bool	xmp_is_async ()

void	_XMP_threads_init (void)

void	_XMP_threads_finalize (void)

Variables
int	_XMPC_running

int	_XMPF_running

void(*	_xmp_pack_array )(void buffer, void src, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)

void(*	_xmp_unpack_array )(void dst, void buffer, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)

_XMP_coarray_list_t *	_XMP_coarray_list_head

_XMP_coarray_list_t *	_XMP_coarray_list_tail

int	_XMP_world_size

int	_XMP_world_rank

void *	_XMP_world_nodes

Macro Definition Documentation

◆ _XMP_ASSERT

#define _XMP_ASSERT ( _flag )

◆ _XMP_INTERNAL

#define _XMP_INTERNAL

◆ _XMP_IS_SINGLE

#define _XMP_IS_SINGLE (_XMP_world_size == 1)

◆ _XMP_RETURN_IF_AFTER_FINALIZATION

#define _XMP_RETURN_IF_AFTER_FINALIZATION

Value:

  { \
    if (! xmp_get_ruuning()) return; \
  }

◆ _XMP_RETURN_IF_SINGLE

#define _XMP_RETURN_IF_SINGLE

Value:

{ \
  if (_XMP_world_size == 1) { \
    return; \
  } \
}

◆ _XMP_TEND

#define _XMP_TEND	(	t,
		t0
	)

◆ _XMP_TEND2

#define _XMP_TEND2	(	t,
		tt,
		t0
	)

◆ _XMP_TSTART

#define _XMP_TSTART ( t0 )

◆ MAX

#define MAX	(	a,
		b
	)	( (a)>(b) ? (a) : (b) )

◆ MIN

#define MIN	(	a,
		b
	)	( (a)<(b) ? (a) : (b) )

◆ XACC_DEBUG

#define XACC_DEBUG ( ... ) do{}while(0)

Typedef Documentation

◆ _XMP_coarray_list_t

typedef struct _XMP_coarray_list_type _XMP_coarray_list_t

Function Documentation

◆ _XMP_align_array_BLOCK()

void _XMP_align_array_BLOCK	(	_XMP_array_t *	array,
		int	array_index,
		int	template_index,
		long long	align_subscript,
		int *	temp0
	)

 {
   _XMP_template_t *template = array->align_template;
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *ti     = &(template->info[template_index]);
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_array_info_t *ai        = &(array->info[array_index]);
  
   // check range
   long long align_lower = ai->ser_lower + align_subscript;
   long long align_upper = ai->ser_upper + align_subscript;
   if(align_lower < ti->ser_lower || align_upper > ti->ser_upper)
     _XMP_fatal("aligned array is out of template bound");
  
   // set members
   ai->is_regular_chunk = (ti->ser_lower == (ai->ser_lower + align_subscript)) && chunk->is_regular_chunk;
   ai->align_manner     = _XMP_N_ALIGN_BLOCK;
  
   if(template->is_owner){
     long long template_lower = chunk->par_lower;
     long long template_upper = chunk->par_upper;
  
     // set par_lower
     if(align_lower < template_lower){
       ai->par_lower = template_lower - align_subscript;
     }
     else if(template_upper < align_lower){
       array->is_allocated = false;
       goto EXIT_CALC_PARALLEL_MEMBERS;
     }
     else{
       ai->par_lower = ai->ser_lower;
     }
  
     // set par_upper
     if(align_upper < template_lower){
       array->is_allocated = false;
       goto EXIT_CALC_PARALLEL_MEMBERS;
     }
     else if(template_upper < align_upper){
       ai->par_upper = template_upper - align_subscript;
     }
     else{
       ai->par_upper = ai->ser_upper;
     }
  
     ai->par_stride   = 1;
     ai->par_size     = _XMP_M_COUNT_TRIPLETi(ai->par_lower, ai->par_upper, 1);
     ai->local_lower  = 0;  // array lower is always 0 in C
     ai->local_upper  = ai->par_size - 1;
     ai->local_stride = 1;
     ai->alloc_size   = ai->par_size;
     *temp0           = ai->par_lower;
     ai->temp0        = temp0;
     ai->temp0_v      = *temp0;
   }
  
 EXIT_CALC_PARALLEL_MEMBERS:
   ai->align_subscript      = align_subscript;
   ai->align_template_index = template_index;
 }

Here is the call graph for this function:

◆ _XMP_align_array_BLOCK_CYCLIC()

void _XMP_align_array_BLOCK_CYCLIC	(	_XMP_array_t *	array,
		int	array_index,
		int	template_index,
		long long	align_subscript,
		int *	temp0
	)

                                                                           {
   _XMP_template_t *template = array->align_template;
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *ti = &(template->info[template_index]);
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   // check range
   long long align_lower = ai->ser_lower + align_subscript;
   long long align_upper = ai->ser_upper + align_subscript;
   if (((align_lower < ti->ser_lower) || (align_upper > ti->ser_upper))) {
     _XMP_fatal("aligned array is out of template bound");
   }
  
   // set members
   ai->is_regular_chunk = _XMP_N_INT_TRUE;
   ai->align_manner = _XMP_N_ALIGN_BLOCK_CYCLIC;
  
   if (template->is_owner) {
  
     int cycle = chunk->par_stride;
     int rank = chunk->onto_nodes_info->rank;
     int nsize = chunk->onto_nodes_info->size;
  
     //
     // set par_lower
     //
  
 /*     ai->par_lower = chunk->par_lower - ti->ser_lower; */
 /*     ai->par_upper = chunk->par_upper - ti->ser_lower; */
 /*     ai->par_stride = chunk->par_stride; */
 /*     ai->par_size = chunk->par_chunk_width; */
  
     /* //int rank_lb = ((ai->ser_lower + align_subscript - ti->ser_lower) / 2) % nsize; */
     /* int rank_lb = ((ai->ser_lower + align_subscript - ti->ser_lower) / chunk->par_width) % nsize; */
     /* //int mod = _XMP_modi_ll_i(rank - rank_lb, nsize); */
     /* int mod = rank + rank_lb; */
  
     /* int v_lower = ti->ser_lower - align_subscript; */
  
     /* ai->par_lower = MAX(ai->ser_lower, (long long)(mod * chunk->par_width) + v_lower); */
  
     /* //ai->par_lower = mod * chunk->par_width + ai->ser_lower; */
  
     /* xmp_dbg_printf("par_lower = %d, mod = %d, par_width = %d, ser_lower = %d\n", */
     /*             ai->par_lower, mod, chunk->par_width, ai->ser_lower); */
  
     /* // */
     /* // set par_upper and par_size */
     /* // */
  
     /* int dist = (ai->ser_upper - (mod * chunk->par_width + ai->ser_lower)) / cycle; */
     /* int diff = ai->ser_upper - (ai->par_lower + (dist * cycle) + (chunk->par_width - 1)); */
     /* if (diff > 0){ */
     /*   ai->par_upper = ai->par_lower + (dist * cycle) + (chunk->par_width - 1); */
     /*   ai->par_size = (dist + 1) * chunk->par_width; */
     /* } */
     /* else { */
     /*   ai->par_upper = ai->ser_upper; */
     /*   ai->par_size = (dist + 1) * chunk->par_width + diff; */
     /* } */
  
     int rank_dist = (ai->ser_lower + align_subscript - ti->ser_lower) / chunk->par_width;
     int v_lower = ti->ser_lower + chunk->par_width * rank_dist - align_subscript;
     int rank_lb = rank_dist % nsize;
     int mod = _XMP_modi_ll_i(rank - rank_lb, nsize);
     ai->par_lower = MAX(ai->ser_lower, (long long)(mod * chunk->par_width) + v_lower);
  
     /* xmp_dbg_printf("par_lower = %d, mod = %d, par_width = %d, ser_lower = %d\n", */
     /*             ai->par_lower, mod, chunk->par_width, ai->ser_lower); */
  
     //
     // set par_upper and par_size
     //
  
     int dist = (ai->ser_upper - (mod * chunk->par_width + v_lower)) / cycle;
     int diff = ai->ser_upper - (ai->par_lower + (dist * cycle) + (chunk->par_width - 1));
     if (diff > 0){
       ai->par_upper = ai->par_lower + (dist * cycle) + (chunk->par_width - 1);
       ai->par_size = (dist + 1) * chunk->par_width;
     }
     else {
       ai->par_upper = ai->ser_upper;
       ai->par_size = (dist + 1) * chunk->par_width + diff;
     }
  
     ai->par_stride = chunk->par_stride;
  
     //xmpf_dbg_printf("par_lower = %d, par_upper = %d, par_stride = %d, par_size = %d\n",
     //              ai->par_lower, ai->par_upper, ai->par_stride, ai->par_size);
  
     // array lower is always 0 in C
     // FIXME works when only data is divided equally
     ai->local_lower = 0;
     ai->local_upper = ai->par_size - 1;
     ai->local_stride = 1;
     ai->alloc_size = ai->par_size;
  
     // FIXME needs more variables
     *temp0 = ai->par_stride;
     ai->temp0 = temp0;
     ai->temp0_v = *temp0;
   }
  
   ai->align_subscript = align_subscript;
  
   ai->align_template_index = template_index;
 }

Here is the call graph for this function:

◆ _XMP_align_array_CYCLIC()

void _XMP_align_array_CYCLIC	(	_XMP_array_t *	array,
		int	array_index,
		int	template_index,
		long long	align_subscript,
		int *	temp0
	)

 {
   _XMP_template_t *template = array->align_template;
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *ti = &(template->info[template_index]);
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   // check range
   long long align_lower = ai->ser_lower + align_subscript;
   long long align_upper = ai->ser_upper + align_subscript;
   if (((align_lower < ti->ser_lower) || (align_upper > ti->ser_upper))) {
     _XMP_fatal("aligned array is out of template bound");
   }
  
   // set members
   ai->is_regular_chunk = (ti->ser_lower == (ai->ser_lower + align_subscript)) && chunk->is_regular_chunk;
   ai->align_manner = _XMP_N_ALIGN_CYCLIC;
  
   if (template->is_owner) {
     int cycle = chunk->par_stride;
     //int mod = _XMP_modi_ll_i(chunk->par_lower - align_subscript, cycle);
     int rank = chunk->onto_nodes_info->rank;
     int nsize = chunk->onto_nodes_info->size;
     int rank_lb = (ai->ser_lower + align_subscript - ti->ser_lower) % nsize;
     int mod = _XMP_modi_ll_i(rank - rank_lb, nsize);
  
     int dist = (ai->ser_upper - (mod + ai->ser_lower)) / cycle;
  
     //xmpf_dbg_printf("cycle = %d, mod = %d, dist = %d, rank_lb = %d, nsize = %d\n", cycle, mod, dist, rank_lb, nsize);
  
     ai->par_lower = mod + ai->ser_lower;
     ai->par_upper = ai->par_lower + (dist * cycle);
     ai->par_stride = cycle;
     ai->par_size = dist + 1;
  
     // array lower is always 0 in C
     ai->local_lower = 0;
     ai->local_upper = ai->par_size - 1;
     ai->local_stride = 1;
     ai->alloc_size = ai->par_size;
  
     *temp0 = ai->par_stride;
     ai->temp0 = temp0;
     ai->temp0_v = *temp0;
   }
  
   ai->align_subscript = align_subscript;
  
   ai->align_template_index = template_index;
 }

Here is the call graph for this function:

◆ _XMP_align_array_DUPLICATION()

void _XMP_align_array_DUPLICATION	(	_XMP_array_t *	array,
		int	array_index,
		int	template_index,
		long long	align_subscript
	)

                                                              {
   _XMP_template_t *template = array->align_template;
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *ti = &(template->info[template_index]);
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   int lower = ai->ser_lower;
   int upper = ai->ser_upper;
   int size = ai->ser_size;
  
   // check range
   long long align_lower = lower + align_subscript;
   long long align_upper = upper + align_subscript;
   if (((align_lower < ti->ser_lower) || (align_upper > ti->ser_upper))) {
     _XMP_fatal("aligned array is out of template bound");
   }
  
   // set members
   ai->is_regular_chunk = true;
   ai->align_manner = _XMP_N_ALIGN_DUPLICATION;
  
   if (template->is_owner) {
     ai->par_lower = lower;
     ai->par_upper = upper;
     ai->par_stride = 1;
     ai->par_size = size;
  
     ai->local_lower = lower;
     ai->local_upper = upper;
     ai->local_stride = 1;
     ai->alloc_size = size;
   }
  
   ai->align_subscript = align_subscript;
  
   ai->align_template_index = template_index;
 }

Here is the call graph for this function:

◆ _XMP_align_array_GBLOCK()

void _XMP_align_array_GBLOCK	(	_XMP_array_t *	array,
		int	array_index,
		int	template_index,
		long long	align_subscript,
		int *	temp0
	)

                                                                     {
  
   _XMP_template_t *template = array->align_template;
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *ti = &(template->info[template_index]);
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   // check range
   long long align_lower = ai->ser_lower + align_subscript;
   long long align_upper = ai->ser_upper + align_subscript;
   if (((align_lower < ti->ser_lower) || (align_upper > ti->ser_upper))) {
     _XMP_fatal("aligned array is out of template bound");
   }
  
   // set members
   ai->is_regular_chunk = (ti->ser_lower == (ai->ser_lower + align_subscript)) && chunk->is_regular_chunk;
   ai->align_manner = _XMP_N_ALIGN_GBLOCK;
  
   if (template->is_owner) {
     long long template_lower = chunk->par_lower;
     long long template_upper = chunk->par_upper;
  
     // set par_lower
     if (align_lower < template_lower) {
       ai->par_lower = template_lower - align_subscript;
     }
     else if (template_upper < align_lower) {
       array->is_allocated = false;
       goto EXIT_CALC_PARALLEL_MEMBERS;
     }
     else {
       ai->par_lower = ai->ser_lower;
     }
  
     // set par_upper
     if (align_upper < template_lower) {
       array->is_allocated = false;
       goto EXIT_CALC_PARALLEL_MEMBERS;
     }
     else if (template_upper < align_upper) {
       ai->par_upper = template_upper - align_subscript;
     }
     else {
       ai->par_upper = ai->ser_upper;
     }
  
     ai->par_stride = 1;
     ai->par_size = _XMP_M_COUNT_TRIPLETi(ai->par_lower, ai->par_upper, 1);
  
     // array lower is always 0 in C
     ai->local_lower = 0;
     ai->local_upper = ai->par_size - 1;
     ai->local_stride = 1;
     ai->alloc_size = ai->par_size;
  
     *temp0 = ai->par_lower;
     ai->temp0 = temp0;
     ai->temp0_v = *temp0;
   }
  
 EXIT_CALC_PARALLEL_MEMBERS:
  
   ai->align_subscript = align_subscript;
  
   ai->align_template_index = template_index;
 }

Here is the call graph for this function:

◆ _XMP_align_array_NOT_ALIGNED()

void _XMP_align_array_NOT_ALIGNED	(	_XMP_array_t *	array,
		int	array_index
	)

                                                                         {
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   int lower = ai->ser_lower;
   int upper = ai->ser_upper;
   int size = ai->ser_size;
  
   // set members
   ai->is_regular_chunk = true;
   ai->align_manner = _XMP_N_ALIGN_NOT_ALIGNED;
  
   ai->par_lower = lower;
   ai->par_upper = upper;
   ai->par_stride = 1;
   ai->par_size = size;
  
   // must be translated to as 0-origin in XMP/F.
   //ai->local_lower = lower;
   //ai->local_upper = upper;
   ai->local_lower = 0;
   ai->local_upper = upper - lower;
   ai->local_stride = 1;
   ai->alloc_size = size;
  
   ai->align_subscript = 0;
  
   ai->align_template_index = _XMP_N_NO_ALIGN_TEMPLATE;
 }

◆ _XMP_alloc()

void* _XMP_alloc ( size_t size )

 {
   void *addr;
 #ifdef _XMP_FJRDMA
   int error = posix_memalign(&addr, 128, size);
   if(addr == NULL || error != 0)
     _XMP_fatal("cannot allocate memory");
 #else  
   addr = malloc(size);
   if(addr == NULL)
     _XMP_fatal("cannot allocate memory");
 #endif
   
   return addr;
 }

◆ _XMP_alloc_array()

void _XMP_alloc_array	(	void **	array_addr,
		_XMP_array_t *	array_desc,
		int	is_coarray,
			...
	)

 {
   /* if (!array_desc->is_allocated) { */
   /*   *array_addr = NULL; */
   /*   return; */
   /* } */
  
   unsigned long long total_elmts = 1;
   int dim = array_desc->dim;
   
   va_list args;
   va_start(args, is_coarray);
   for(int i=dim-1;i>=0;i--){
     unsigned long long *acc = va_arg(args, unsigned long long *);
     *acc = total_elmts;
  
     array_desc->info[i].dim_acc = total_elmts;
     total_elmts *= array_desc->info[i].alloc_size;
   }
   va_end(args);
  
   for(int i=0;i<dim;i++)
     _XMP_calc_array_dim_elmts(array_desc, i);
  
   *array_addr = _XMP_alloc(total_elmts * (array_desc->type_size));
  
   // set members
   array_desc->array_addr_p = *array_addr;
   array_desc->total_elmts  = total_elmts;
  
   // for gmove in/out
  
 #ifdef _XMP_MPI3_ONESIDED
   if (is_coarray){
     _XMP_coarray_t *c = (_XMP_coarray_t *)_XMP_alloc(sizeof(_XMP_coarray_t));
  
     long asize[dim];
     for (int i = 0; i < dim; i++){
       asize[i] = array_desc->info[i].alloc_size;
     }
  
     _XMP_coarray_malloc_info_n(asize, dim, array_desc->type_size);
  
     //_XMP_nodes_t *ndesc = a->align_template->onto_nodes;
     //_XMP_nodes_t *ndesc = _XMP_get_execution_nodes();
     _XMP_nodes_t *ndesc = _XMP_world_nodes;
     int ndims_node = ndesc->dim;
     int nsize[ndims_node-1];
     for (int i = 0; i < ndims_node-1; i++){
       nsize[i] = ndesc->info[i].size;
     }
     _XMP_coarray_malloc_image_info_n(nsize, ndims_node);
  
     _XMP_coarray_attach(c, *array_addr, array_desc->total_elmts * array_desc->type_size);
  
     array_desc->coarray = c;
   }
 #endif
  
 #ifdef _XMP_TCA
   _XMP_alloc_tca(array_desc);
 #endif
 }

Here is the call graph for this function:

◆ _XMP_alloc_array2()

void _XMP_alloc_array2	(	void **	array_addr,
		_XMP_array_t *	array_desc,
		int	is_coarray,
		unsigned long long *	acc[]
	)

                                                   {
   /* if (!array_desc->is_allocated) { */
   /*   *array_addr = NULL; */
   /*   return; */
   /* } */
  
   unsigned long long total_elmts = 1;
   int dim = array_desc->dim;
  
   for (int i = dim - 1; i >= 0; i--) {
     *acc[i] = total_elmts;
  
     array_desc->info[i].dim_acc = total_elmts;
  
     total_elmts *= array_desc->info[i].alloc_size;
   }
  
   for (int i = 0; i < dim; i++) {
     _XMP_calc_array_dim_elmts(array_desc, i);
   }
  
   *array_addr = _XMP_alloc(total_elmts * (array_desc->type_size));
  
   // set members
   array_desc->array_addr_p = *array_addr;
   array_desc->total_elmts = total_elmts;
  
   // for gmove in/out
  
 #ifdef _XMP_MPI3_ONESIDED
   if (is_coarray){
     _XMP_coarray_t *c = (_XMP_coarray_t *)_XMP_alloc(sizeof(_XMP_coarray_t));
  
     long asize[dim];
     for (int i = 0; i < dim; i++){
       asize[i] = array_desc->info[i].alloc_size;
     }
  
     _XMP_coarray_malloc_info_n(asize, dim, array_desc->type_size);
  
     //_XMP_nodes_t *ndesc = a->align_template->onto_nodes;
     //_XMP_nodes_t *ndesc = _XMP_get_execution_nodes();
     _XMP_nodes_t *ndesc = _XMP_world_nodes;
     int ndims_node = ndesc->dim;
     int nsize[ndims_node-1];
     for (int i = 0; i < ndims_node-1; i++){
       nsize[i] = ndesc->info[i].size;
     }
     _XMP_coarray_malloc_image_info_n(nsize, ndims_node);
  
     _XMP_coarray_attach(c, *array_addr, array_desc->total_elmts * array_desc->type_size);
     
     array_desc->coarray = c;
   }
 #endif
  
 #ifdef _XMP_TCA
   _XMP_alloc_tca(array_desc);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_barrier_EXEC()

void _XMP_barrier_EXEC ( void )

                              {
   _XMP_RETURN_IF_SINGLE;
   _XMP_RETURN_IF_AFTER_FINALIZATION;
  
   MPI_Barrier(*((MPI_Comm *)(_XMP_get_execution_nodes())->comm));
 }

◆ _XMP_barrier_NODES_ENTIRE()

void _XMP_barrier_NODES_ENTIRE ( _XMP_nodes_t * nodes )

                                                     {
   _XMP_RETURN_IF_SINGLE;
  
   if (nodes->is_member) {
     MPI_Barrier(*((MPI_Comm *)nodes->comm));
   }
 }

◆ _XMP_bcast_NODES_ENTIRE_NODES()

void _XMP_bcast_NODES_ENTIRE_NODES	(	_XMP_nodes_t *	bcast_nodes,
		void *	addr,
		int	count,
		size_t	datatype_size,
		_XMP_nodes_t *	from_nodes,
			...
	)

                                                                   {
   va_list args;
   va_start(args, from_nodes);
  
   _XMP_bcast_NODES_ENTIRE_NODES_V(bcast_nodes, addr, count, datatype_size, from_nodes, args);
  
   va_end(args);
 }

Here is the call graph for this function:

◆ _XMP_bcast_NODES_ENTIRE_NODES_V()

void _XMP_bcast_NODES_ENTIRE_NODES_V	(	_XMP_nodes_t *	bcast_nodes,
		void *	addr,
		int	count,
		size_t	datatype_size,
		_XMP_nodes_t *	from_nodes,
		va_list	args
	)

                                                                              {
   _XMP_RETURN_IF_SINGLE;
  
   if (!bcast_nodes->is_member) {
     return;
   }
  
   if (!from_nodes->is_member) {
     _XMP_fatal("broadcast failed, cannot find the source node");
   }
  
   // calc source nodes number
   int root = 0;
   int acc_nodes_size = 1;
   int from_dim = from_nodes->dim;
   int from_lower, from_upper, from_stride;
   _XMP_nodes_inherit_info_t  *inherit_info = bcast_nodes->inherit_info;
  
   if(inherit_info == NULL){
     for (int i = 0; i < from_dim; i++) {
       int size = from_nodes->info[i].size;
       if(inherit_info != NULL){
         if(inherit_info[i].shrink == true)
           continue;
         size = inherit_info[i].upper - inherit_info[i].lower + 1;
         if(size == 0) continue;
       }
       int rank = from_nodes->info[i].rank;
  
       if (va_arg(args, int) == 1) {
         root += (acc_nodes_size * rank);
       }
       else {
         from_lower = va_arg(args, int) - 1;
         from_upper = va_arg(args, int) - 1;
         from_stride = va_arg(args, int);
         
         // check <from-ref>
         if (_XMP_M_COUNT_TRIPLETi(from_lower, from_upper, from_stride) != 1) {
           _XMP_fatal("multiple source nodes indicated in bcast directive");
         }
  
         root += (acc_nodes_size * (from_lower));
       }
       
       acc_nodes_size *= size;
     }
   }
   else{
     int inherit_node_dim = bcast_nodes->inherit_nodes->dim;
  
     for (int i = 0; i < inherit_node_dim; i++) {
  
       if(inherit_info[i].shrink) // skip i
         continue;
  
       int size = inherit_info[i].upper - inherit_info[i].lower + 1;
       
       if(size == 0) {  // skip arguments
         va_arg(args, int);   // is_astrisk 
         va_arg(args, int);   // from_lower
         va_arg(args, int);   // from_upper
         va_arg(args, int);   // from_stride
         continue;
       }
  
       int is_astrisk = va_arg(args, int);
       if (is_astrisk == 1){
         int rank = from_nodes->info[i].rank;
         root += (acc_nodes_size * rank);
       }
       else {
         from_lower = va_arg(args, int) - 1;
         from_upper = va_arg(args, int) - 1;
         va_arg(args, int); // skip from_stride
  
         // check <from-ref> 
         if(from_lower != from_upper)
           _XMP_fatal("multiple source nodes indicated in bcast directive");
  
         root += (acc_nodes_size * (from_lower - inherit_info[i].lower));
       }
       
       acc_nodes_size *= size;
     }
   }
  
 #ifdef _XMP_MPI3
   if(xmp_is_async()){
     _XMP_async_comm_t *async = _XMP_get_current_async();
     MPI_Ibcast(addr, count*datatype_size, MPI_BYTE, root,
                *((MPI_Comm *)bcast_nodes->comm), &async->reqs[async->nreqs]);
     async->nreqs++;
   }
   else
 #endif
   MPI_Bcast(addr, count*datatype_size, MPI_BYTE, root,
             *((MPI_Comm *)bcast_nodes->comm));
  
   /* // setup type */
   /* MPI_Datatype mpi_datatype; */
   /* MPI_Type_contiguous(datatype_size, MPI_BYTE, &mpi_datatype); */
   /* MPI_Type_commit(&mpi_datatype); */
  
   /* // bcast */
   /* MPI_Bcast(addr, count, mpi_datatype, root, *((MPI_Comm *)bcast_nodes->comm)); */
  
   /* MPI_Type_free(&mpi_datatype); */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_bcast_NODES_ENTIRE_OMITTED()

void _XMP_bcast_NODES_ENTIRE_OMITTED	(	_XMP_nodes_t *	bcast_nodes,
		void *	addr,
		int	count,
		size_t	datatype_size
	)

                                                                                                             {
   _XMP_RETURN_IF_SINGLE;
  
   if(!bcast_nodes->is_member) return;
  
 #ifdef _XMP_MPI3
   if(xmp_is_async()){
     _XMP_async_comm_t *async = _XMP_get_current_async();
     MPI_Ibcast(addr, count*datatype_size, MPI_BYTE, _XMP_N_DEFAULT_ROOT_RANK,
                *((MPI_Comm *)bcast_nodes->comm), &async->reqs[async->nreqs]);
     async->nreqs++;
   }
   else
 #endif
     MPI_Bcast(addr, count*datatype_size, MPI_BYTE, _XMP_N_DEFAULT_ROOT_RANK,
               *((MPI_Comm *)bcast_nodes->comm));
 }

Here is the call graph for this function:

◆ _XMP_build_coarray_queue()

void _XMP_build_coarray_queue ( )

Build queue for coarray.

 {
   _coarray_queue.max_size = _XMP_COARRAY_QUEUE_INITIAL_SIZE;
   _coarray_queue.num      = 0;
   _coarray_queue.coarrays = malloc(sizeof(_XMP_coarray_t*) * _coarray_queue.max_size);
 }

Here is the caller graph for this function:

◆ _XMP_build_sync_images_table()

void _XMP_build_sync_images_table ( )

Build table for sync images.

 {
 #ifdef _XMP_GASNET
   _XMP_gasnet_build_sync_images_table();
 #elif _XMP_FJRDMA
   _XMP_fjrdma_build_sync_images_table();
 #elif _XMP_UTOFU
   _XMP_utofu_build_sync_images_table();
 #elif _XMP_MPI3_ONESIDED
   _XMP_mpi_build_sync_images_table();
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_array_dim_elmts()

void _XMP_calc_array_dim_elmts	(	_XMP_array_t *	array,
		int	array_index
	)

                                                                      {
   _XMP_ASSERT(array->is_allocated);
  
   int dim = array->dim;
  
   unsigned long long dim_elmts = 1;
   for (int i = 0; i < dim; i++) {
     if (i != array_index) {
       dim_elmts *= array->info[i].par_size;
     }
   }
  
   array->info[array_index].dim_elmts = dim_elmts;
 }

Here is the caller graph for this function:

◆ _XMP_calc_coord_on_target_nodes()

_Bool _XMP_calc_coord_on_target_nodes	(	_XMP_nodes_t *	n,
		int *	ncoord,
		_XMP_nodes_t *	target_n,
		int *	target_ncoord
	)

 {
   if(_XMP_calc_coord_on_target_nodes2(n, ncoord, target_n, target_ncoord))
     return true;
  
   _XMP_nodes_t *p = n->inherit_nodes;
   if (p){
     int pcoord[_XMP_N_MAX_DIM];
     int rank = _XMP_calc_linear_rank(n, ncoord);
     //_XMP_calc_rank_array(p, pcoord, rank);
      
     _XMP_nodes_inherit_info_t *inherit_info = n->inherit_info;
     int multiplier[_XMP_N_MAX_DIM];
  
     int dim = p->dim;
     multiplier[0] = 1;
     for(int i=1;i<dim;i++)
       multiplier[i] = multiplier[i-1] * inherit_info[i].size;
  
     int j = rank;
     for (int i=dim;i>= 0;i--){
       if(inherit_info[i].shrink){
         pcoord[i] = p->info[i].rank;
       }
       else{
         int rank_dim = j / multiplier[i];
         pcoord[i] = inherit_info[i].stride * rank_dim + inherit_info[i].lower;
         j = j % multiplier[i];
       }
     }
     
     if(_XMP_calc_coord_on_target_nodes(p, pcoord, target_n, target_ncoord))
       return true;
   }
  
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_coord_on_target_nodes2()

_Bool _XMP_calc_coord_on_target_nodes2	(	_XMP_nodes_t *	n,
		int *	ncoord,
		_XMP_nodes_t *	target_n,
		int *	target_ncoord
	)

 {
   if (n == target_n){
     //printf("%d, %d\n", n->dim, target_n->dim);
     memcpy(target_ncoord, ncoord, sizeof(int) * n->dim);
     return true;
   }
   else if (n->attr == _XMP_ENTIRE_NODES && target_n->attr == _XMP_ENTIRE_NODES){
     int rank = _XMP_calc_linear_rank(n, ncoord);
     _XMP_calc_rank_array(target_n, target_ncoord, rank);
     //xmp_dbg_printf("ncoord = %d, target_ncoord = %d\n", ncoord[0], target_ncoord[0]);
     return true;
   }
  
   _XMP_nodes_t *target_p = target_n->inherit_nodes;
   if (target_p){
     int target_pcoord[_XMP_N_MAX_DIM];
     if (_XMP_calc_coord_on_target_nodes2(n, ncoord, target_p, target_pcoord)){
       //int target_prank = _XMP_calc_linear_rank(target_p, target_pcoord);
       /* printf("dim = %d, m0 = %d, m1 = %d\n", */
       /*             target_n->dim, target_n->info[0].multiplier, target_n->info[1].multiplier); */
       //_XMP_calc_rank_array(target_n, target_ncoord, target_prank);
  
       _XMP_nodes_inherit_info_t *inherit_info = target_n->inherit_info;
       int target_rank = 0;
       int multiplier  = 1;
  
       for (int i = 0; i < target_p->dim; i++){
  
         if (inherit_info[i].shrink){
           ;
         }
         else if (target_pcoord[i] < inherit_info[i].lower || target_pcoord[i] > inherit_info[i].upper){
           for (int i = 0; i < target_n->dim; i++){
             target_ncoord[i] = -1;
           }
           return true;
         }
         else {
           int target_rank_dim = (target_pcoord[i] - inherit_info[i].lower) / inherit_info[i].stride;
           target_rank += multiplier * target_rank_dim;
           //multiplier *= inherit_info[i].size;
           multiplier *= _XMP_M_COUNT_TRIPLETi(inherit_info[i].lower, inherit_info[i].upper, inherit_info[i].stride);
         }
       }
  
       _XMP_calc_rank_array(target_n, target_ncoord, target_rank);
  
       return true;
     }
   }
   
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_copy_chunk()

size_t _XMP_calc_copy_chunk	(	const int	copy_chunk_dim,
		const _XMP_array_section_t *	array
	)

 {
   if(copy_chunk_dim == 0)   // All elements are copied
     return array[0].length * array[0].distance;
  
   if(array[copy_chunk_dim-1].stride == 1)
     return array[copy_chunk_dim-1].length * array[copy_chunk_dim-1].distance;
   else
     return array[copy_chunk_dim-1].distance;
 }

Here is the caller graph for this function:

◆ _XMP_calc_global_index_BCAST()

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

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

Here is the call graph for this function:

◆ _XMP_calc_global_index_HOMECOPY()

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

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

Here is the caller graph for this function:

◆ _XMP_calc_gmove_array_owner_linear_rank_SCALAR()

int _XMP_calc_gmove_array_owner_linear_rank_SCALAR	(	_XMP_array_t *	array,
		int *	ref_index
	)

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_linear_rank()

int _XMP_calc_linear_rank	(	_XMP_nodes_t *	n,
		int *	rank_array
	)

 {
   int acc_rank = 0;
   int acc_nodes_size = 1;
   int nodes_dim = n->dim;
   
   for(int i=0;i<nodes_dim;i++){
     acc_rank += (rank_array[i]) * acc_nodes_size;
     acc_nodes_size *= n->info[i].size;
   }
  
   return acc_rank;
 }

Here is the caller graph for this function:

◆ _XMP_calc_linear_rank_on_target_nodes()

int _XMP_calc_linear_rank_on_target_nodes	(	_XMP_nodes_t *	n,
		int *	rank_array,
		_XMP_nodes_t *	target_nodes
	)

 {
   if(_XMP_compare_nodes(n, target_nodes)){
     return _XMP_calc_linear_rank(n, rank_array);
   }
   else{
     _XMP_nodes_t *inherit_nodes = n->inherit_nodes;
     if(inherit_nodes == NULL){
       // FIXME implement
       _XMP_fatal("unsupported case: gmove");
       return _XMP_N_INVALID_RANK; // XXX dummy;
     }
     else{
       int inherit_nodes_dim = inherit_nodes->dim;
       int *new_rank_array = _XMP_alloc(sizeof(int) * inherit_nodes_dim);
       _XMP_nodes_inherit_info_t *inherit_info = n->inherit_info;
  
       int j = 0;
       for(int i=0;i<inherit_nodes_dim;i++){
         if(inherit_info[i].shrink){
           // FIXME how implement ???
           new_rank_array[i] = 0;
         }
         else{
           new_rank_array[i] = ((inherit_info[i].stride) * rank_array[j]) + (inherit_info[i].lower);
           j++;
         }
       }
  
       int ret = _XMP_calc_linear_rank_on_target_nodes(inherit_nodes, new_rank_array, target_nodes);
       _XMP_free(new_rank_array);
       return ret;
     }
   }
 }

Here is the caller graph for this function:

◆ _XMP_calc_nodes_index_from_inherit_nodes_index()

int _XMP_calc_nodes_index_from_inherit_nodes_index	(	_XMP_nodes_t *	nodes,
		int	inherit_nodes_index
	)

 {
   _XMP_nodes_t *inherit_nodes = nodes->inherit_nodes;
   if(inherit_nodes == NULL)
     _XMP_fatal("inherit nodes is NULL");
  
   int nodes_index = 0;
   int inherit_nodes_index_count = 0;
   int inherit_nodes_dim = inherit_nodes->dim;
   for(int i=0;i<inherit_nodes_dim;i++,inherit_nodes_index_count++){
     if(inherit_nodes_index_count == inherit_nodes_index){
       return nodes_index;
     }
     else{
       if(!nodes->inherit_info[i].shrink)
         nodes_index++;
     }
   }
  
   _XMP_fatal("the function does not reach here");
   return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_rank_array()

void _XMP_calc_rank_array	(	_XMP_nodes_t *	n,
		int *	rank_array,
		int	linear_rank
	)

 {
   int j = linear_rank;
   for(int i=n->dim-1;i>=0;i--){
     rank_array[i] = j / n->info[i].multiplier;
     j = j % n->info[i].multiplier;
   }
 }

Here is the caller graph for this function:

◆ _XMP_calc_template_owner_SCALAR()

int _XMP_calc_template_owner_SCALAR	(	_XMP_template_t *	ref_template,
		int	dim_index,
		long long	ref_index
	)

                                                                                                    {
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_info_t *info = &(template->info[dim_index]);
   _XMP_template_chunk_t *chunk = &(template->chunk[dim_index]);
   _XMP_ASSERT(chunk->dist_manner != _XMP_N_DIST_DUPLICATION);
  
   switch (chunk->dist_manner) {
     case _XMP_N_DIST_BLOCK:
       return (ref_index - (info->ser_lower)) / (chunk->par_chunk_width);
     case _XMP_N_DIST_CYCLIC:
       return (ref_index - (info->ser_lower)) % (chunk->par_stride);
     case _XMP_N_DIST_BLOCK_CYCLIC:
       {
         int width = chunk->par_width;
         return ((ref_index - (info->ser_lower)) / width) % ((chunk->par_stride) / width);
       }
     case _XMP_N_DIST_GBLOCK:
       {
         long long *m = chunk->mapping_array;
         int np = chunk->onto_nodes_info->size;
         for (int i = 0; i < np; i++){
           if (m[i] <= ref_index && ref_index < m[i+1]){
             return i;
           }
         }
       }
       return _XMP_N_INVALID_RANK;
     default:
       _XMP_fatal("unknown distribute manner");
       return _XMP_N_INVALID_RANK; // XXX dummy
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_template_par_triplet()

int _XMP_calc_template_par_triplet	(	_XMP_template_t *	template,
		int	template_index,
		int	nodes_rank,
		int *	template_lower,
		int *	template_upper,
		int *	template_stride
	)

                                                                                                    {
   _XMP_ASSERT(template->is_distributed);
  
   int par_lower = 0, par_upper = 0, par_stride = 0;
  
   _XMP_template_info_t *ti = &(template->info[template_index]);
   int ser_lower = ti->ser_lower;
   int ser_upper = ti->ser_upper;
   int ser_size = ti->ser_size;
  
   _XMP_template_chunk_t *tc = &(template->chunk[template_index]);
   int par_width = tc->par_width;
   int par_chunk_width = tc->par_chunk_width;
  
   switch (tc->dist_manner) {
     case _XMP_N_DIST_DUPLICATION:
       {
         par_lower = ser_lower;
         par_upper = ser_upper;
  
         par_stride = 1;
       } break;
     case _XMP_N_DIST_BLOCK:
       {
         par_lower = nodes_rank * par_chunk_width + ser_lower;
         int owner_nodes_size = _XMP_M_CEILi(ser_size, par_chunk_width);
         if (nodes_rank == (owner_nodes_size - 1)) {
           par_upper = ser_upper;
         } else if (nodes_rank >= owner_nodes_size) {
           return _XMP_N_INT_FALSE;
         } else {
           par_upper = par_lower + par_chunk_width - 1;
         }
  
         par_stride = 1;
       } break;
     case _XMP_N_DIST_CYCLIC:
     case _XMP_N_DIST_BLOCK_CYCLIC:
       {
         _XMP_ASSERT(tc->onto_nodes_index != _XMP_N_NO_ONTO_NODES);
         _XMP_nodes_info_t *ni = tc->onto_nodes_info;
  
         int nodes_size = ni->size;
         int template_size = _XMP_M_CEILi(ser_size, par_width);
  
         if (template_size < nodes_size) {
           if (nodes_rank < template_size) {
             int par_index = ser_lower + (nodes_rank * par_width);
  
             par_lower = par_index;
             par_upper = par_index;
           } else {
             return _XMP_N_INT_FALSE;
           }
         } else {
           int div = template_size / nodes_size;
           int mod = template_size % nodes_size;
           int par_size = 0;
           if(mod == 0) {
             par_size = div;
           } else {
             if(nodes_rank >= mod) {
               par_size = div;
             } else {
               par_size = div + 1;
             }
           }
  
           par_lower = ser_lower + (nodes_rank * par_width);
           par_upper = par_lower + (nodes_size * (par_size - 1) * par_width);
         }
  
         par_stride = nodes_size * par_width;
       } break;
     default:
       _XMP_fatal("unknown distribution manner");
   }
  
   // return triplet
   *template_lower = par_lower;
   *template_upper = par_upper;
   *template_stride = par_stride;
  
   return _XMP_N_INT_TRUE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_calc_template_size()

void _XMP_calc_template_size ( _XMP_template_t * t )

 {
   int dim;
   if(t->is_fixed){
     dim = t->dim;
   }
   else{
     dim = t->dim-1;
   }
  
   for(int i=0;i<dim;i++){
     int ser_lower = t->info[i].ser_lower;
     int ser_upper = t->info[i].ser_upper;
  
     if(ser_lower > ser_upper)
       _XMP_fatal("the lower bound of template should be less than or equal to the upper bound");
  
     t->info[i].ser_size = _XMP_M_COUNTi(ser_lower, ser_upper);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_check_gmove_array_ref_inclusion_SCALAR()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_check_reflect_type()

void _XMP_check_reflect_type ( void )

 {
   char *reflect_type = getenv("XMP_REFLECT_TYPE");
   _xmp_omp_num_procs = omp_get_num_procs();
  
   if (reflect_type){
  
     if (strcmp(reflect_type, "REFLECT_NOPACK") == 0){
       _xmp_reflect_pack_flag = 0;
       //xmpf_dbg_printf("REFLECT_NOPACK\n");
       return;
     }
     else if (strcmp(reflect_type, "REFLECT_PACK") == 0){
       _xmp_reflect_pack_flag = 1;
       //xmpf_dbg_printf("REFLECT_PACK\n");
       return;
     }
  
   }
  
   // not specified or a wrong value
   if (_xmp_omp_num_procs > 1){
     _xmp_reflect_pack_flag = 1;
     //xmpf_dbg_printf("not specified and REFLECT_PACK\n");
   }
   else {
     _xmp_reflect_pack_flag = 0;
     //xmpf_dbg_printf("not specified and REFLECT_NOPACK\n");
   }
  
 }

◆ _XMP_check_template_ref_inclusion()

int _XMP_check_template_ref_inclusion	(	int	ref_lower,
		int	ref_upper,
		int	ref_stride,
		_XMP_template_t *	t,
		int	index
	)

                                                                      {
   _XMP_template_info_t *info = &(t->info[index]);
   _XMP_template_chunk_t *chunk = &(t->chunk[index]);
  
   _XMP_validate_template_ref(&ref_lower, &ref_upper, &ref_stride, info->ser_lower, info->ser_upper);
  
   switch (chunk->dist_manner) {
     case _XMP_N_DIST_DUPLICATION:
       return _XMP_N_INT_TRUE;
     case _XMP_N_DIST_BLOCK:
     case _XMP_N_DIST_CYCLIC:
       return _XMP_check_template_ref_inclusion_width_1(ref_lower, ref_upper, ref_stride,
                                                        chunk->par_lower, chunk->par_upper, chunk->par_stride);
     case _XMP_N_DIST_BLOCK_CYCLIC:
       return _XMP_check_template_ref_inclusion_width_N(ref_lower, ref_upper, ref_stride, t, index);
     default:
       _XMP_fatal("unknown distribution manner");
       return _XMP_N_INT_FALSE; // XXX dummy
   }
 }

Here is the caller graph for this function:

◆ _XMP_coarray_lastly_deallocate()

void _XMP_coarray_lastly_deallocate ( )

Deallocate memory space and an object of the last coarray.

 {
 #ifdef _XMP_GASNET
   _XMP_gasnet_coarray_lastly_deallocate();
 #elif _XMP_FJRDMA
   _XMP_fjrdma_coarray_lastly_deallocate();
 #elif _XMP_UTOFU
   // _XMP_utofu_coarray_lastly_deallocate();
 #elif _XMP_MPI3_ONESIDED
   _XMP_mpi_coarray_lastly_deallocate(false);
 #endif
  
   _XMP_coarray_t *_last_coarray_ptr = _pop_coarray_queue();
   _XMP_coarray_deallocate(_last_coarray_ptr);
 }

◆ _XMP_create_nodes_by_comm()

_XMP_nodes_t* _XMP_create_nodes_by_comm	(	int	is_member,
		_XMP_comm_t *	comm
	)

 {
   int size;
   MPI_Comm_size(*((MPI_Comm *)comm), &size);
  
   _XMP_nodes_t *n = _XMP_create_new_nodes(is_member, 1, size, comm);
  
   n->info[0].size = size;
   if(is_member)
     MPI_Comm_rank(*((MPI_Comm *)comm), &(n->info[0].rank));
  
   // calc inherit info
   n->inherit_nodes      = NULL;
   n->inherit_info       = NULL;
   n->info[0].multiplier = 1;
  
   return n;
 }

◆ _XMP_create_nodes_by_template_ref()

_XMP_nodes_t* _XMP_create_nodes_by_template_ref	(	_XMP_template_t *	ref_template,
		int *	shrink,
		long long *	ref_lower,
		long long *	ref_upper,
		long long *	ref_stride
	)

 {
   _XMP_ASSERT(ref_template->is_fixed);
   _XMP_ASSERT(ref_template->is_distributed);
  
   _XMP_nodes_t *onto_nodes = ref_template->onto_nodes;
   int onto_nodes_dim = onto_nodes->dim;
   int onto_nodes_shrink[onto_nodes_dim];
   int onto_nodes_ref_lower[onto_nodes_dim];
   int onto_nodes_ref_upper[onto_nodes_dim];
   int onto_nodes_ref_stride[onto_nodes_dim];
   
   for(int i=0;i<onto_nodes_dim;i++)
     onto_nodes_shrink[i] = 1;
  
   int new_nodes_dim = 0;
   int new_nodes_dim_size[_XMP_N_MAX_DIM];
   int acc_dim_size = 1;
   int ref_template_dim = ref_template->dim;
   
   for(int i=0;i<ref_template_dim;i++){
     if(shrink[i]){
       continue;
     }
  
     _XMP_template_chunk_t *chunk = &(ref_template->chunk[i]);
     int onto_nodes_index = chunk->onto_nodes_index;
     if (onto_nodes_index != _XMP_N_NO_ONTO_NODES) {
       onto_nodes_shrink[onto_nodes_index] = 0;
  
       int size = (chunk->onto_nodes_info)->size;
       // FIXME calc onto_nodes_ref_lower, onto_nodes_ref_upper, onto_nodes_ref_stride
       if (_XMP_M_COUNT_TRIPLETi(ref_lower[i], ref_upper[i], ref_stride[i]) == 1) {
         int j = _XMP_calc_template_owner_SCALAR(ref_template, i, ref_lower[i]) + 1;
         onto_nodes_ref_lower[onto_nodes_index] = j;
         onto_nodes_ref_upper[onto_nodes_index] = j;
         onto_nodes_ref_stride[onto_nodes_index] = 1;
  
         new_nodes_dim_size[new_nodes_dim] = 1;
       } else {
         onto_nodes_ref_lower[onto_nodes_index] = 1;
         onto_nodes_ref_upper[onto_nodes_index] = size;
         onto_nodes_ref_stride[onto_nodes_index] = 1;
         acc_dim_size *= _XMP_M_COUNT_TRIPLETi(1, size, 1);
  
         new_nodes_dim_size[new_nodes_dim] = size;
       }
  
       new_nodes_dim++;
     }
   }
  
   if (new_nodes_dim > 0)
     return _XMP_init_nodes_struct_NODES_NAMED(new_nodes_dim, onto_nodes, onto_nodes_shrink,
                                               onto_nodes_ref_lower, onto_nodes_ref_upper,
                                               onto_nodes_ref_stride, new_nodes_dim_size, _XMP_N_INT_TRUE);
   else return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_create_nodes_ref_for_target_nodes()

_XMP_nodes_ref_t* _XMP_create_nodes_ref_for_target_nodes	(	_XMP_nodes_t *	n,
		int *	rank_array,
		_XMP_nodes_t *	target_nodes
	)

 {
   if(_XMP_compare_nodes(n, target_nodes)){
     return _XMP_init_nodes_ref(n, rank_array);
   }
   else{
     _XMP_nodes_t *inherit_nodes = n->inherit_nodes;
     if(inherit_nodes == NULL){
       // FIXME implement
       _XMP_fatal("unsupported case: gmove");
       return NULL; // XXX dummy;
       // return _XMP_init_nodes_ref(n, rank_array);
     }
     else{
       int inherit_nodes_dim = inherit_nodes->dim;
       int *new_rank_array = _XMP_alloc(sizeof(int) * inherit_nodes_dim);
       _XMP_nodes_inherit_info_t *inherit_info = n->inherit_info;
  
       int j = 0;
       for(int i = 0; i < inherit_nodes_dim; i++){
         if(inherit_info[i].shrink){
           new_rank_array[i] = _XMP_N_UNSPECIFIED_RANK;
         }
         else{
           new_rank_array[i] = ((inherit_info[i].stride) * rank_array[j]) + (inherit_info[i].lower);
           j++;
         }
       }
  
       _XMP_nodes_ref_t *ret = _XMP_create_nodes_ref_for_target_nodes(inherit_nodes, new_rank_array, target_nodes);
       _XMP_free(new_rank_array);
       return ret;
     }
   }
 }

Here is the caller graph for this function:

◆ _XMP_create_shadow_comm()

void _XMP_create_shadow_comm	(	_XMP_array_t *	array,
		int	array_index
	)

                                                                    {
   _XMP_nodes_t *onto_nodes = (array->align_template)->onto_nodes;
   _XMP_array_info_t *ai = &(array->info[array_index]);
  
   _XMP_template_t *align_template = array->align_template;
  
   int color = 1;
   if (onto_nodes->is_member) {
     _XMP_ASSERT(ai->align_manner != _XMP_N_ALIGN_NOT_ALIGNED);
     _XMP_ASSERT(ai->align_manner != _XMP_N_ALIGN_DUPLICATION);
  
     _XMP_template_chunk_t *chunk = &(align_template->chunk[ai->align_template_index]);
     _XMP_ASSERT(chunk->dist_manner != _XMP_N_DIST_DUPLICATION);
  
     int onto_nodes_index = chunk->onto_nodes_index;
  
     int acc_nodes_size = 1;
     int nodes_dim = onto_nodes->dim;
     for (int i = 0; i < nodes_dim; i++) {
       _XMP_nodes_info_t *onto_nodes_info = &(onto_nodes->info[i]);
       int size = onto_nodes_info->size;
       int rank = onto_nodes_info->rank;
  
       if (i != onto_nodes_index) {
         color += (acc_nodes_size * rank);
       }
  
       acc_nodes_size *= size;
     }
  
     if (!array->is_allocated) {
       color = 0;
     }
   } else {
     color = 0;
   }
  
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_split(*((MPI_Comm *)(_XMP_get_execution_nodes())->comm), color, _XMP_world_rank, comm);
  
   // set members
   if (array->is_allocated) {
     ai->is_shadow_comm_member = true;
  
     ai->shadow_comm = comm;
     MPI_Comm_size(*comm, &(ai->shadow_comm_size));
     MPI_Comm_rank(*comm, &(ai->shadow_comm_rank));
   } else {
     _XMP_finalize_comm(comm);
   }
 }

Here is the caller graph for this function:

◆ _XMP_create_template_desc()

_XMP_template_t* _XMP_create_template_desc	(	int	dim,
		_Bool	is_fixed
	)

 {
   // alloc descriptor
   _XMP_template_t *t = _XMP_alloc(sizeof(_XMP_template_t) +
                                   sizeof(_XMP_template_info_t) * (dim - 1));
  
   // calc members
   t->desc_kind      = _XMP_DESC_TEMPLATE;
  
   t->on_ref_id      = _XMP_get_on_ref_id();
   t->is_fixed       = is_fixed;
   t->is_distributed = false;
   t->is_owner       = false;
   t->dim            = dim;
   t->onto_nodes     = NULL;
   t->chunk          = NULL;
  
   return t;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_create_temporary_nodes()

_XMP_nodes_t* _XMP_create_temporary_nodes ( _XMP_nodes_t * n )

 {
   int is_member       = n->is_member;
   int onto_nodes_dim  = n->dim;
   int onto_nodes_size = n->comm_size;
   int dim_size[onto_nodes_dim];
   _XMP_nodes_t *new_node = _XMP_create_new_nodes(is_member, onto_nodes_dim, onto_nodes_size, n->comm);
   _XMP_nodes_inherit_info_t *inherit_info = _XMP_alloc(sizeof(_XMP_nodes_inherit_info_t) * onto_nodes_dim);
  
   for(int i=0;i<onto_nodes_dim;i++){
     inherit_info[i].shrink = _XMP_N_INT_FALSE;
     inherit_info[i].lower  = 1;
     inherit_info[i].upper  = n->info[i].size;
     inherit_info[i].stride = 1;
     dim_size[i]            = n->info[i].size;
   }
  
   new_node->inherit_nodes = new_node;
   new_node->inherit_info  = inherit_info;
  
   _XMP_init_nodes_info(new_node, dim_size, _XMP_N_INT_TRUE);
  
   new_node->info[0].multiplier = 1;
   for(int i=1;i<onto_nodes_dim;i++)
     new_node->info[i].multiplier = new_node->info[i-1].multiplier * dim_size[i-1];
  
   return new_node;
 }

Here is the caller graph for this function:

◆ _XMP_dealloc_array()

void _XMP_dealloc_array ( _XMP_array_t * array_desc )

                                                  {
   _XMP_free(array_desc->array_addr_p);
 }

Here is the call graph for this function:

◆ _XMP_dist_template_BLOCK()

void _XMP_dist_template_BLOCK	(	_XMP_template_t *	template,
		int	template_index,
		int	nodes_index
	)

 {
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_nodes_t *nodes          = template->onto_nodes;
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_template_info_t *ti     = &(template->info[template_index]);
   _XMP_nodes_info_t *ni        = &(nodes->info[nodes_index]);
  
   unsigned long long nodes_size = ni->size;
  
   // calc parallel members
   unsigned long long chunk_width = _XMP_M_CEILi(ti->ser_size, nodes_size);
  
   if(nodes->is_member){
     unsigned long long nodes_rank = ni->rank;
     unsigned long long owner_nodes_size = _XMP_M_CEILi(ti->ser_size, chunk_width);
  
     chunk->par_lower = nodes_rank * chunk_width + ti->ser_lower;
     if(nodes_rank == (owner_nodes_size - 1)){
       chunk->par_upper = ti->ser_upper;
     }
     else if (nodes_rank >= owner_nodes_size){
       template->is_owner = false;
     }
     else{
       chunk->par_upper = chunk->par_lower + chunk_width - 1;
     }
   }
  
   chunk->par_width       = 1;
   chunk->par_stride      = 1;
   chunk->par_chunk_width = chunk_width;
   chunk->dist_manner     = _XMP_N_DIST_BLOCK;
   
   if((ti->ser_size % nodes_size) == 0){
     chunk->is_regular_chunk = true;
   }
   else{
     chunk->is_regular_chunk = false;
   }
  
   chunk->onto_nodes_index = nodes_index;
   chunk->onto_nodes_info  = ni;
 }

◆ _XMP_dist_template_BLOCK_CYCLIC()

void _XMP_dist_template_BLOCK_CYCLIC	(	_XMP_template_t *	template,
		int	template_index,
		int	nodes_index,
		unsigned long long	width
	)

 {
   _XMP_dist_template_CYCLIC_WIDTH(template, template_index, nodes_index, width);
 }

◆ _XMP_dist_template_CYCLIC()

void _XMP_dist_template_CYCLIC	(	_XMP_template_t *	template,
		int	template_index,
		int	nodes_index
	)

 {
   _XMP_dist_template_CYCLIC_WIDTH(template, template_index, nodes_index, 1);
 }

◆ _XMP_dist_template_DUPLICATION()

void _XMP_dist_template_DUPLICATION	(	_XMP_template_t *	template,
		int	template_index
	)

                                                                                    {
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_template_info_t *ti = &(template->info[template_index]);
  
   chunk->par_lower = ti->ser_lower;
   chunk->par_upper = ti->ser_upper;
   chunk->par_width = 1;
  
   chunk->par_stride = 1;
   chunk->par_chunk_width = ti->ser_size;
   chunk->dist_manner = _XMP_N_DIST_DUPLICATION;
   chunk->is_regular_chunk = true;
  
   chunk->onto_nodes_index = _XMP_N_NO_ONTO_NODES;
   chunk->onto_nodes_info = NULL;
 }

◆ _XMP_dist_template_GBLOCK()

void _XMP_dist_template_GBLOCK	(	_XMP_template_t *	template,
		int	template_index,
		int	nodes_index,
		int *	mapping_array,
		int *	temp0
	)

                                                                {
  
   _XMP_ASSERT(template->is_fixed);
   _XMP_ASSERT(template->is_distributed);
  
   _XMP_nodes_t *nodes = template->onto_nodes;
  
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_template_info_t *ti = &(template->info[template_index]);
   _XMP_nodes_info_t *ni = &(nodes->info[nodes_index]);
  
   if (mapping_array){
  
     long long *rsum_array = _XMP_alloc(sizeof(long long) * (ni->size + 1));
     rsum_array[0] = ti->ser_lower;
     for (int i = 1; i <= ni->size; i++){
       rsum_array[i] = rsum_array[i-1] + (long long)mapping_array[i-1];
     }
     chunk->mapping_array = rsum_array;
  
     if (ti->ser_upper >= rsum_array[ni->size])
       _XMP_fatal("The size of the template exceeds the sum of the mapping array.");
  
     if (ti->ser_upper + 1 < rsum_array[ni->size]) 
       _XMP_warning("The sum of the mapping array exceeds the size of the template.");
  
     template->is_owner = false;
     if (nodes->is_member && rsum_array[ni->rank + 1] != rsum_array[ni->rank]) {
       chunk->par_lower = rsum_array[ni->rank];
       if (chunk->par_lower <= ti->ser_upper){
         chunk->par_upper = min(ti->ser_upper, rsum_array[ni->rank + 1] - 1);
         template->is_owner = true;
       }
     }
  
     chunk->par_width = 1;
     chunk->par_stride = 1;
     chunk->par_chunk_width = chunk->par_upper - chunk->par_lower + 1;
   }
   else {
     template->is_fixed = false;
   }
  
   chunk->dist_manner = _XMP_N_DIST_GBLOCK;
   chunk->is_regular_chunk = false;
  
   chunk->onto_nodes_index = nodes_index;
   chunk->onto_nodes_info = ni;
  
   *temp0 = chunk->par_lower;
 }

Here is the call graph for this function:

◆ _XMP_fatal()

void _XMP_fatal ( char * msg )

 {
   fprintf(stderr, "[RANK:%d] XcalableMP runtime error: %s\n", _XMP_world_rank, msg);
   MPI_Abort(MPI_COMM_WORLD, 1);
 }

◆ _XMP_fatal_nomsg()

void _XMP_fatal_nomsg ( )

 {
   MPI_Abort(MPI_COMM_WORLD, 1);
 }

Here is the caller graph for this function:

◆ _XMP_finalize()

void _XMP_finalize ( bool isFinalize )

 {
   if (_XMP_runtime_working) {
     xmpc_traverse_finalize();
     
 #if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_TCA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
     _XMP_finalize_onesided_functions();
 #endif
     _XMP_finalize_world(isFinalize);
     _XMP_runtime_working = _XMP_N_INT_FALSE;
   }
 }

Here is the caller graph for this function:

◆ _XMP_finalize_array_desc()

void _XMP_finalize_array_desc ( _XMP_array_t * array )

 {
   int dim = array->dim;
  
   for(int i=0;i<dim;i++){
     _XMP_array_info_t *ai = &(array->info[i]);
  
     if(ai->is_shadow_comm_member)
       _XMP_finalize_comm(ai->shadow_comm);
  
     _Bool free_buf = (_XMPF_running && i != dim -1) || (_XMPC_running && i != 0);
  
     _XMP_reflect_sched_t *reflect_sched;
     if((reflect_sched = ai->reflect_sched)){
       _XMP_finalize_reflect_sched(reflect_sched, free_buf);
       _XMP_free(reflect_sched);
     }
  
 #ifdef _XMP_XACC
     _XMP_reflect_sched_t *reflect_acc_sched;
     if((reflect_acc_sched = ai->reflect_acc_sched)){
       _XMP_finalize_reflect_sched_acc(reflect_acc_sched, free_buf);
       _XMP_free(reflect_acc_sched);
     }
 #endif
   }
  
   _XMP_async_reflect_t *async_reflect = array->async_reflect;
   if(async_reflect){
     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]);
     }
     _XMP_free(async_reflect->datatype);
     _XMP_free(async_reflect->reqs);
     _XMP_free(async_reflect);
   }
  
 /*   for (int i = 0; i < array->num_reqs; i++){ */
 /*     if (array->mpi_req_shadow[i] != MPI_REQUEST_NULL){ */
 /*       MPI_Request_free(&array->mpi_req_shadow[i]); */
 /*     } */
 /*   } */
 /*   _XMP_free(array->mpi_req_shadow); */
  
   if(array->is_align_comm_member)
     _XMP_finalize_comm(array->align_comm);
  
   if(array->is_shrunk_template)
     if(array->array_nodes)
       _XMP_finalize_nodes(array->array_nodes);
  
 #ifdef _XMP_MPI3_ONESIDED
   if (array->coarray){
     _XMP_coarray_detach(array->coarray);
     _XMP_free(array->coarray);
   }
 #endif
  
   _XMP_free(array);
 }

Here is the call graph for this function:

◆ _XMP_finalize_comm()

void _XMP_finalize_comm ( _XMP_comm_t * comm )

 {
   MPI_Comm_free(comm);
   _XMP_free(comm);
 }

◆ _XMP_finalize_nodes()

void _XMP_finalize_nodes ( _XMP_nodes_t * nodes )

 {
   if(!nodes->use_subcomm)
     _XMP_finalize_comm(nodes->comm);
  
   if(nodes->subcomm != NULL){
     int dim       = nodes->dim;
     int num_comms = 1<<dim;
     for(int i=0;i<num_comms;i++){
       MPI_Comm *comm = (MPI_Comm *)nodes->subcomm;
       MPI_Comm_free(&comm[i]);
     }
     free(nodes->subcomm);
   }
   
   _XMP_free(nodes->inherit_info);
   _XMP_free(nodes);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_finalize_nodes_ref()

void _XMP_finalize_nodes_ref ( _XMP_nodes_ref_t * nodes_ref )

 {
   _XMP_free(nodes_ref->ref);
   _XMP_free(nodes_ref);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_finalize_onesided_functions()

void _XMP_finalize_onesided_functions ( )

 {
 #ifdef _XMP_GASNET
   _XMP_gasnet_finalize();
 #elif _XMP_FJRDMA
   if(_XMP_world_size > _XMP_ONESIDED_MAX_PROCS) return;
   else _XMP_fjrdma_finalize();
 #elif _XMP_UTOFU
   _XMP_utofu_finalize();
 #elif _XMP_MPI3_ONESIDED
   _XMP_mpi_onesided_finalize();
 #endif
  
 #ifdef _XMP_TCA
   _XMP_tca_finalize();
 #endif
 }

Here is the call graph for this function:

◆ _XMP_finalize_reflect_sched()

void _XMP_finalize_reflect_sched	(	_XMP_reflect_sched_t *	sched,
		_Bool	free_buf
	)

                                                                              {
  
   if (sched->datatype_lo != MPI_DATATYPE_NULL)
     MPI_Type_free(&sched->datatype_lo);
   if (sched->datatype_hi != MPI_DATATYPE_NULL)
     MPI_Type_free(&sched->datatype_hi);
  
   for (int j = 0; j < 4; j++){
     if (sched->req[j] != MPI_REQUEST_NULL){
       MPI_Request_free(&sched->req[j]);
     }
     if (sched->req_reduce[j] != MPI_REQUEST_NULL){
       MPI_Request_free(&sched->req_reduce[j]);
     }
   }
  
   if (free_buf){
     _XMP_free(sched->lo_send_buf);
     _XMP_free(sched->lo_recv_buf);
     _XMP_free(sched->hi_send_buf);
     _XMP_free(sched->hi_recv_buf);
   }
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_finalize_template()

void _XMP_finalize_template ( _XMP_template_t * template )

                                                        {
   if (template->is_distributed) {
     for (int i = 0; i < template->dim; i++){
       _XMP_template_chunk_t *chunk = &(template->chunk[i]);
       if (chunk->dist_manner == _XMP_N_DIST_GBLOCK){
         _XMP_free(chunk->mapping_array);
       }
     }
     _XMP_free(template->chunk);
   }
  
   _XMP_free(template);
 }

Here is the call graph for this function:

◆ _XMP_finalize_world()

void _XMP_finalize_world ( bool isFinalize )

                                           {
   MPI_Barrier(MPI_COMM_WORLD);
  
   int flag = 0;
   MPI_Finalized(&flag);
   if (!flag) {
     _XMP_nodes_t *n =  _XMP_get_execution_nodes();
     _XMP_finalize_nodes(n);
     if(isFinalize)
       MPI_Finalize();
   }
 }

Here is the call graph for this function:

◆ _XMP_free()

void _XMP_free ( void * p )

 {
   free(p);
 }

◆ _XMP_G2L()

void _XMP_G2L	(	long long int	global_idx,
		int *	local_idx,
		_XMP_template_t *	template,
		int	template_index
	)

 {
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_nodes_info_t *n_info = chunk->onto_nodes_info;
   long long base = template->info[template_index].ser_lower;
  
   // NOTE: local_idx is 0-origin.
  
   switch(chunk->dist_manner){
   case _XMP_N_DIST_DUPLICATION:
     //*local_idx = global_idx - base;
     *local_idx = global_idx;
     break;
   case _XMP_N_DIST_BLOCK:
     *local_idx = (global_idx - base) - n_info->rank * chunk->par_chunk_width;
     break;
   case _XMP_N_DIST_CYCLIC:
     *local_idx = (global_idx - base) / n_info->size;
     break;
   case _XMP_N_DIST_BLOCK_CYCLIC:
     {
       int off = global_idx - base;
       int w = chunk->par_width;
       *local_idx = (off / (n_info->size*w)) * w + off%w;
     }
     break;
   case _XMP_N_DIST_GBLOCK:
     *local_idx = global_idx - chunk->mapping_array[n_info->rank];
     break;
   default:
     _XMP_fatal("_XMP_: unknown chunk dist_manner");
   }
 }

Here is the call graph for this function:

◆ _XMP_get_current_async()

_XMP_async_comm_t* _XMP_get_current_async ( )

 {
   return _tmp_async;
 }

Here is the caller graph for this function:

◆ _XMP_get_datatype_size()

size_t _XMP_get_datatype_size ( int datatype )

 {
   size_t size;
  
   // size of each type is obtained from config.h.
   // Note: need to fix when building a cross compiler.
   switch (datatype){
  
   case _XMP_N_TYPE_BOOL:
     size = _XMPF_running ? SIZEOF_UNSIGNED_INT : SIZEOF__BOOL;
     break;
  
   case _XMP_N_TYPE_CHAR:
   case _XMP_N_TYPE_UNSIGNED_CHAR:
     size = SIZEOF_UNSIGNED_CHAR; break;
  
   case _XMP_N_TYPE_SHORT:
   case _XMP_N_TYPE_UNSIGNED_SHORT:
     size = SIZEOF_UNSIGNED_SHORT; break;
  
   case _XMP_N_TYPE_INT:
   case _XMP_N_TYPE_UNSIGNED_INT:
     size = SIZEOF_UNSIGNED_INT; break;
  
   case _XMP_N_TYPE_LONG:
   case _XMP_N_TYPE_UNSIGNED_LONG:
     size = SIZEOF_UNSIGNED_LONG; break;
  
   case _XMP_N_TYPE_LONGLONG:
   case _XMP_N_TYPE_UNSIGNED_LONGLONG:
     size = SIZEOF_UNSIGNED_LONG_LONG; break;
  
   case _XMP_N_TYPE_FLOAT:
 #ifdef __STD_IEC_559_COMPLEX__
   case _XMP_N_TYPE_FLOAT_IMAGINARY:
 #endif
     size = SIZEOF_FLOAT; break;
  
   case _XMP_N_TYPE_DOUBLE:
 #ifdef __STD_IEC_559_COMPLEX__
   case _XMP_N_TYPE_DOUBLE_IMAGINARY:
 #endif
     size = SIZEOF_DOUBLE; break;
  
   case _XMP_N_TYPE_LONG_DOUBLE:
 #ifdef __STD_IEC_559_COMPLEX__
   case _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY:
 #endif
     size = SIZEOF_LONG_DOUBLE; break;
  
   case _XMP_N_TYPE_FLOAT_COMPLEX:
     size = SIZEOF_FLOAT * 2; break;
  
   case _XMP_N_TYPE_DOUBLE_COMPLEX:
     size = SIZEOF_DOUBLE * 2; break;
  
   case _XMP_N_TYPE_LONG_DOUBLE_COMPLEX:
     size = SIZEOF_LONG_DOUBLE * 2; break;
  
   case _XMP_N_TYPE_NONBASIC: // should be fixed for structures.
   default:
     size = 0; break;
   }
  
   return size;
 }

◆ _XMP_get_dim_of_allelmts()

int _XMP_get_dim_of_allelmts	(	const int	dims,
		const _XMP_array_section_t *	array_info
	)

 {
   int val = dims;
  
   for(int i=dims-1;i>=0;i--){
     if(array_info[i].start == 0 && array_info[i].length == array_info[i].elmts)
       val--;
     else
       return val;
   }
   
   return val;
 }

Here is the caller graph for this function:

◆ _XMP_get_execution_nodes()

_XMP_nodes_t* _XMP_get_execution_nodes ( void )

 {
   return _XMP_nodes_stack_top->nodes;
 }

Here is the caller graph for this function:

◆ _XMP_get_execution_nodes_rank()

int _XMP_get_execution_nodes_rank ( void )

 {
   return _XMP_get_execution_nodes()->comm_rank;
 }

◆ _XMP_get_next_rank()

int _XMP_get_next_rank	(	_XMP_nodes_t *	nodes,
		int *	rank_array
	)

 {
   int i, dim = nodes->dim;
   for(i=0;i<dim;i++){
     int size = nodes->info[i].size;
     (rank_array[i])++;
     if(rank_array[i] == size)
       rank_array[i] = 0;
     else
       break;
   }
  
   if(i == dim)
     return _XMP_N_INT_FALSE;
   else
    return _XMP_N_INT_TRUE;
 }

◆ _XMP_get_on_ref_id()

unsigned long long _XMP_get_on_ref_id ( void )

 {
   if(_XMP_on_ref_id_count == ULLONG_MAX)
     _XMP_fatal("cannot create a new nodes/template: too many");
  
   return _XMP_on_ref_id_count++;
 }

Here is the caller graph for this function:

◆ _XMP_gmove_array_array_common()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_gmove_bcast_ARRAY()

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

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

Here is the call graph for this function:

◆ _XMP_gmove_bcast_SCALAR()

void _XMP_gmove_bcast_SCALAR	(	void *	dst_addr,
		void *	src_addr,
		size_t	type_size,
		int	root_rank
	)

◆ _XMP_gmove_garray_garray()

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

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

Here is the call graph for this function:

◆ _XMP_gmove_garray_larray()

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

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

Here is the call graph for this function:

◆ _XMP_gmove_garray_scalar()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_gmove_inout_scalar()

void _XMP_gmove_inout_scalar	(	void *	scalar,
		_XMP_gmv_desc_t *	gmv_desc,
		int	rdma_type
	)

Here is the caller graph for this function:

◆ _XMP_gmove_larray_garray()

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

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

Here is the call graph for this function:

◆ _XMP_gmove_localcopy_ARRAY()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_gmove_scalar_garray()

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

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

Here is the call graph for this function:

◆ _XMP_gtol_array_ref_triplet()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_gtol_calc_offset()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_init()

void _XMP_init	(	int	argc,
		char **	argv,
		MPI_Comm	comm
	)

 {
   if (!_XMP_runtime_working) {
     int flag = 0;
     MPI_Initialized(&flag);
  
     if(!flag)
       MPI_Init(&argc, &argv);
     MPI_Comm_rank(MPI_COMM_WORLD, &_XMP_world_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &_XMP_world_size);
  
     //    int result = 0;
     //    MPI_Comm_compare(MPI_COMM_WORLD, comm, &result);
     //    if(result != MPI_IDENT)
     //      _XMP_fatal("Now implementation does not support subcommunicator");
     
 #ifdef _XMP_XACC
     _XACC_init();
 #endif
  
 #ifdef _XMP_TCA
     _XMP_init_tca();
 #endif
  
 #if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_TCA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
     _XMP_initialize_onesided_functions();
 #endif
 #ifdef _XMP_MPI3
     _XMP_initialize_async_comm_tab();
 #endif
     xmp_reduce_initialize();
   }
  
  
   _XMP_init_world(NULL, NULL);
   _XMP_check_reflect_type();
   
   if (!_XMP_runtime_working) {
     xmpc_traverse_init();
   }
   _XMP_runtime_working = _XMP_N_INT_TRUE;
 }

Here is the caller graph for this function:

◆ _XMP_init_array_comm()

void _XMP_init_array_comm	(	_XMP_array_t *	array,
			...
	)

 {
   _XMP_template_t *align_template = array->align_template;
   _XMP_ASSERT(align_template->is_distributed);
   _XMP_nodes_t *onto_nodes = align_template->onto_nodes;
  
   int color = 1;
   if(onto_nodes->is_member){
     int acc_nodes_size = 1;
     int template_dim   = align_template->dim;
  
     va_list args;
     va_start(args, array);
     for(int i=0;i<template_dim;i++){
       _XMP_template_chunk_t *chunk = &(align_template->chunk[i]);
  
       int size, rank;
       if(chunk->dist_manner == _XMP_N_DIST_DUPLICATION){
         size = 1;
         rank = 0;
       }
       else{
         _XMP_nodes_info_t *onto_nodes_info = chunk->onto_nodes_info;
         size = onto_nodes_info->size;
         rank = onto_nodes_info->rank;
       }
  
       if(va_arg(args, int) == 1)
         color += (acc_nodes_size * rank);
  
       acc_nodes_size *= size;
     }
     va_end(args);
   }
   else {
     color = 0;
   }
  
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_split(*((MPI_Comm *)(_XMP_get_execution_nodes())->comm), color, _XMP_world_rank, comm);
  
   // set members
   array->is_align_comm_member = true;
   array->align_comm           = comm;
   MPI_Comm_size(*comm, &(array->align_comm_size));
   MPI_Comm_rank(*comm, &(array->align_comm_rank));
 }

◆ _XMP_init_array_comm2()

void _XMP_init_array_comm2	(	_XMP_array_t *	array,
		int	args[]
	)

                                                             {
   _XMP_template_t *align_template = array->align_template;
   _XMP_ASSERT(align_template->is_distributed);
  
   _XMP_nodes_t *onto_nodes = align_template->onto_nodes;
  
   int color = 1;
   if (onto_nodes->is_member) {
     int acc_nodes_size = 1;
     int template_dim = align_template->dim;
  
     for (int i = 0; i < template_dim; i++) {
       _XMP_template_chunk_t *chunk = &(align_template->chunk[i]);
  
       int size, rank;
       if (chunk->dist_manner == _XMP_N_DIST_DUPLICATION) {
         size = 1;
         rank = 0;
       } else {
         _XMP_nodes_info_t *onto_nodes_info = chunk->onto_nodes_info;
         size = onto_nodes_info->size;
         rank = onto_nodes_info->rank;
       }
  
       if (args[i] == 1) {
         color += (acc_nodes_size * rank);
       }
  
       acc_nodes_size *= size;
     }
   } else {
     color = 0;
   }
  
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_split(*((MPI_Comm *)(_XMP_get_execution_nodes())->comm), color, _XMP_world_rank, comm);
  
   // set members
   array->is_align_comm_member = true;
  
   array->align_comm = comm;
   MPI_Comm_size(*comm, &(array->align_comm_size));
   MPI_Comm_rank(*comm, &(array->align_comm_rank));
 }

Here is the caller graph for this function:

◆ _XMP_init_array_desc()

void _XMP_init_array_desc	(	_XMP_array_t **	array,
		_XMP_template_t *	template,
		int	dim,
		int	type,
		size_t	type_size,
			...
	)

 {
   _XMP_array_t *a = _XMP_alloc(sizeof(_XMP_array_t) + sizeof(_XMP_array_info_t) * (dim - 1));
  
   a->desc_kind            = _XMP_DESC_ARRAY;
   
   a->is_allocated         = template->is_owner;
   a->is_align_comm_member = false;
   a->dim                  = dim;
   a->type                 = type;
   a->type_size            = type_size;
   
   size_t dummy;
   if (type != _XMP_N_TYPE_NONBASIC)
     _XMP_setup_reduce_type(&a->mpi_type, &dummy, type);
   else {
     a->mpi_type = MPI_BYTE;
   }
   
   a->order           = MPI_ORDER_C;
   a->array_addr_p    = NULL;
   a->total_elmts     = 0;
   a->async_reflect   = NULL;
   a->align_comm      = NULL;
   a->align_comm_size = 1;
   a->align_comm_rank = _XMP_N_INVALID_RANK;
  
 #ifdef _XMP_MPI3_ONESIDED
   a->coarray = NULL;
 #endif
  
   //a->num_reqs = -1;
  
   //if (!template->is_fixed) _XMP_fatal("target template is not fixed");
   a->align_template = template;
  
   va_list args;
   va_start(args, type_size);
   for (int i=0;i<dim;i++){
     int size = va_arg(args, int);
     _XMP_ASSERT(size > 0);
     
     _XMP_array_info_t *ai = &(a->info[i]);
     ai->is_shadow_comm_member = false;
  
     // array lower is always 0 in C
     ai->ser_lower = 0;
     ai->ser_upper = size - 1;
     ai->ser_size = size;
  
     ai->par_lower = 0;
     ai->par_upper = 0;
     ai->par_stride = 0;
     ai->par_size = 0;
     ai->local_lower = 0;
     ai->local_upper = 0;
     ai->local_stride = 0;
     ai->alloc_size = 0;
  
     ai->shadow_type = _XMP_N_SHADOW_NONE;
     ai->shadow_size_lo  = 0;
     ai->shadow_size_hi  = 0;
  
     ai->reflect_sched = NULL;
     ai->reflect_acc_sched = NULL;
  
     ai->shadow_comm = NULL;
     ai->shadow_comm_size = 1;
     ai->shadow_comm_rank = _XMP_N_INVALID_RANK;
  
     ai->align_template_index = -1;
   }
   va_end(args);
  
   *array = a;
 }

Here is the call graph for this function:

◆ _XMP_init_array_desc_NOT_ALIGNED()

void _XMP_init_array_desc_NOT_ALIGNED	(	_XMP_array_t **	adesc,
		_XMP_template_t *	template,
		int	ndims,
		int	type,
		size_t	type_size,
		unsigned long long *	dim_acc,
		void *	ap
	)

                                                                                                         {
  
   _XMP_array_t *a = _XMP_alloc(sizeof(_XMP_array_t) + sizeof(_XMP_array_info_t) * (ndims - 1));
  
   a->desc_kind    = _XMP_DESC_ARRAY;
  
   a->is_allocated = template->is_owner;
   a->is_align_comm_member = false;
   a->dim = ndims;
   a->type = type;
   a->type_size = type_size;
   size_t dummy;
   _XMP_setup_reduce_type(&a->mpi_type, &dummy, type);
   a->order = MPI_ORDER_C;
   a->array_addr_p = ap;
  
   a->total_elmts = -1; // local (non-aligned) data
  
   a->async_reflect = NULL;
  
   a->align_comm = NULL;
   a->align_comm_size = 1;
   a->align_comm_rank = _XMP_N_INVALID_RANK;
  
 #ifdef _XMP_MPI3_ONESIDED
   a->coarray = NULL;
 #endif
  
   a->is_shrunk_template = false;
  
   a->align_template = template;
  
   for (int i = 0; i < ndims; i++) {
  
     _XMP_array_info_t *ai = &(a->info[i]);
  
     ai->is_shadow_comm_member = false;
     ai->is_regular_chunk = true;
     ai->align_manner = _XMP_N_ALIGN_NOT_ALIGNED;
  
     ai->ser_lower = 0;
     /* ai->ser_upper = 0; */
     /* ai->ser_size = 0; */
  
     /* ai->par_lower = 0 */
     /* ai->par_upper = 0 */
     /* ai->par_stride = 0; */
     /* ai->par_size = 0; */
  
     /* ai->local_lower = 0; */
     /* ai->local_upper = 0; */
     /* ai->local_stride = 0; */
     /* ai->alloc_size = 0; */
  
     ai->dim_acc = dim_acc[i];
     //ai->dim_elmts = 0;
  
     ai->align_subscript = 0;
  
     ai->shadow_type = _XMP_N_SHADOW_NONE;
     //ai->shadow_size_lo  = 0;
     //ai->shadow_size_hi  = 0;
  
     ai->reflect_sched = NULL;
     ai->reflect_acc_sched = NULL;
     ai->shadow_comm = NULL;
     ai->shadow_comm_size = 1;
     ai->shadow_comm_rank = _XMP_N_INVALID_RANK;
  
     ai->align_template_index = _XMP_N_NO_ALIGN_TEMPLATE;
  
   }
   *adesc = a;
 }

Here is the call graph for this function:

◆ _XMP_init_array_nodes()

void _XMP_init_array_nodes ( _XMP_array_t * array )

 {
   _XMP_template_t *align_template = array->align_template;
   
   int template_dim = align_template->dim;
   int align_template_shrink[template_dim];
   int align_template_num = 0;
   long long align_template_lower[template_dim], align_template_upper[template_dim],
             align_template_stride[template_dim];
   
   for(int i=0;i<template_dim;i++)
     align_template_shrink[i] = 1;
  
   int array_dim = array->dim;
   for(int i=0;i<array_dim;i++){
     _XMP_array_info_t *info = &(array->info[i]);
     int align_template_index = info->align_template_index;
     if(align_template_index != _XMP_N_NO_ALIGN_TEMPLATE){
       align_template_shrink[align_template_index] = 0;
       align_template_num++;
       align_template_lower[align_template_index]  = info->ser_lower + info->align_subscript;
       align_template_upper[align_template_index]  = info->ser_upper + info->align_subscript;
       align_template_stride[align_template_index] = 1;
     }
   }
  
   if(template_dim == align_template_num){
     array->is_shrunk_template = false;
   }
   else if (template_dim > align_template_num){
     array->is_shrunk_template = true;
   }
  
   if (array->is_shrunk_template){
     array->array_nodes =
       _XMP_create_nodes_by_template_ref(align_template, align_template_shrink, align_template_lower,
                                         align_template_upper, align_template_stride);
   }else{
     array->array_nodes =_XMP_create_temporary_nodes(align_template->onto_nodes);
   }
 }

Here is the call graph for this function:

◆ _XMP_init_nodes_ref()

_XMP_nodes_ref_t* _XMP_init_nodes_ref	(	_XMP_nodes_t *	n,
		int *	rank_array
	)

 {
   _XMP_nodes_ref_t *nodes_ref = _XMP_alloc(sizeof(_XMP_nodes_ref_t));
   int dim = n->dim;
   int *new_rank_array = _XMP_alloc(sizeof(int) * dim);
  
   int shrink_nodes_size = 1;
   for(int i=0;i<dim;i++){
     new_rank_array[i] = rank_array[i];
     if(new_rank_array[i] == _XMP_N_UNSPECIFIED_RANK){
       shrink_nodes_size *= (n->info[i].size);
     }
   }
  
   nodes_ref->nodes = n;
   nodes_ref->ref = new_rank_array;
   nodes_ref->shrink_nodes_size = shrink_nodes_size;
  
   return nodes_ref;
 }

Here is the call graph for this function:

◆ _XMP_init_nodes_struct_EXEC()

_XMP_nodes_t* _XMP_init_nodes_struct_EXEC	(	int	dim,
		int *	dim_size,
		int	is_static
	)

 {
   _XMP_nodes_t *exec_nodes = _XMP_get_execution_nodes();
   int size = exec_nodes->comm_size;
  
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_dup(*((MPI_Comm *)exec_nodes->comm), comm);
  
   _XMP_nodes_t *n = _XMP_create_new_nodes(_XMP_N_INT_TRUE, dim, size, (_XMP_comm_t *)comm);
  
   // calc inherit info
   _XMP_nodes_t *inherit_nodes = _XMP_get_execution_nodes();
   n->inherit_nodes = inherit_nodes;
   n->inherit_info  = _XMP_calc_inherit_info(inherit_nodes);
   n->attr          = _XMP_EXECUTING_NODES;
  
   // calc info
   _XMP_init_nodes_info(n, dim_size, is_static);
  
   n->info[0].multiplier = 1;
   for(int i=1;i<dim;i++)
     n->info[i].multiplier = n->info[i-1].multiplier * dim_size[i-1];
   
   return n;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_init_nodes_struct_GLOBAL()

_XMP_nodes_t* _XMP_init_nodes_struct_GLOBAL	(	int	dim,
		int *	dim_size,
		int	is_static
	)

 {
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_dup(MPI_COMM_WORLD, comm);
  
   _XMP_nodes_t *n = _XMP_create_new_nodes(_XMP_N_INT_TRUE, dim, _XMP_world_size, (_XMP_comm_t *)comm);
  
   // calc inherit info
   n->inherit_nodes = NULL;
   n->inherit_info  = NULL;
   n->attr          = _XMP_ENTIRE_NODES;
  
   // set dim_size if XMP_NODE_SIZEn is set.
   if(!is_static){
     is_static = _XMP_N_INT_TRUE;
     for(int i=0;i<dim;i++){
       if(dim_size[i] == -1){
         char name[20];
         sprintf(name, "XMP_NODE_SIZE%d", i);
         char *size = getenv(name);
  
         if(!size){
           if(i == dim - 1){
             is_static = _XMP_N_INT_FALSE;
             break;
           }
           else _XMP_fatal("XMP_NODE_SIZE not specified although '*' is in the dimension of a node array\n");
         }
         else{
           dim_size[i] = atoi(size);
           if(dim_size[i] <= 0 || dim_size[i] > _XMP_world_size)
             _XMP_fatal("Wrong value in XMP_NODE_SIZE\n");
         }
       }
     }
   }
  
   _XMP_init_nodes_info(n, dim_size, is_static);
  
   n->info[0].multiplier = 1;
   for(int i=1;i<dim;i++)
     n->info[i].multiplier = n->info[i-1].multiplier * dim_size[i-1];
  
   n->subcomm = create_subcomm(n);
   
   return n;
 }

Here is the caller graph for this function:

◆ _XMP_init_nodes_struct_NODES_NAMED()

_XMP_nodes_t* _XMP_init_nodes_struct_NODES_NAMED	(	int	dim,
		_XMP_nodes_t *	ref_nodes,
		int *	shrink,
		int *	ref_lower,
		int *	ref_upper,
		int *	ref_stride,
		int *	dim_size,
		int	is_static
	)

 {
   int ref_dim       = ref_nodes->dim;
   int is_ref_member = ref_nodes->is_member;
   int color         = 1;
   int is_member     = _XMP_N_INT_TRUE;
   
   if(is_ref_member){
     int acc_nodes_size = 1;
     for(int i=0;i<ref_dim;i++){
       int size = ref_nodes->info[i].size;
       int rank = ref_nodes->info[i].rank;
  
       if(shrink[i]){
         color += (acc_nodes_size * rank);
       }
       else{
         _XMP_validate_nodes_ref(&ref_lower[i], &ref_upper[i], &ref_stride[i], size);
         is_member = is_member && _XMP_check_nodes_ref_inclusion(ref_lower[i], ref_upper[i], ref_stride[i], size, rank);
       }
  
       acc_nodes_size *= size;
     }
  
     if(!is_member){
       color = 0;
     }
   }
   else{
     is_member = _XMP_N_INT_FALSE;
     color = 0;
   }
  
   int comm_size = 1;
   for(int i=0;i<ref_dim;i++)
     if(!shrink[i])
       comm_size *= _XMP_M_COUNT_TRIPLETi(ref_lower[i], ref_upper[i], ref_stride[i]);
  
   MPI_Comm *comm;
   int use_subcomm;  
   if(check_subcomm(ref_nodes, ref_lower, ref_upper, ref_stride, shrink)){
     use_subcomm = _XMP_N_INT_TRUE;
     comm        = (MPI_Comm *)get_subcomm(ref_nodes, ref_lower, ref_upper, ref_stride, shrink);
     //    MPI_Comm_dup(*(MPI_Comm *)get_subcomm(ref_nodes, ref_lower, ref_upper, ref_stride, shrink), comm);
   }
   else if(comm_size == 1){
     use_subcomm = _XMP_N_INT_FALSE;
     comm        = _XMP_alloc(sizeof(MPI_Comm));
     MPI_Comm_dup(MPI_COMM_SELF, comm);
   }
   else{
     use_subcomm = _XMP_N_INT_FALSE;
     comm        = _XMP_alloc(sizeof(MPI_Comm));
     MPI_Comm_split(*((MPI_Comm *)ref_nodes->comm), color, _XMP_world_rank, comm);
   }
  
   _XMP_nodes_t *n = _XMP_create_new_nodes(is_member, dim, comm_size, (_XMP_comm_t *)comm);
  
   // calc inherit info
   n->inherit_nodes = ref_nodes;
   n->inherit_info  = _XMP_calc_inherit_info_by_ref(ref_nodes, shrink, ref_lower, ref_upper, ref_stride);
   n->attr          = _XMP_EQUIVALENCE_NODES;
   n->use_subcomm   = use_subcomm;
  
   // calc info
   _XMP_init_nodes_info(n, dim_size, is_static);
  
   n->info[0].multiplier = 1;
   for(int i=1;i<dim;i++)
     n->info[i].multiplier = n->info[i-1].multiplier * dim_size[i-1];
  
   return n;
 }

Here is the caller graph for this function:

◆ _XMP_init_nodes_struct_NODES_NUMBER()

_XMP_nodes_t* _XMP_init_nodes_struct_NODES_NUMBER	(	int	dim,
		int	ref_lower,
		int	ref_upper,
		int	ref_stride,
		int *	dim_size,
		int	is_static
	)

 {
   _XMP_validate_nodes_ref(&ref_lower, &ref_upper, &ref_stride, _XMP_world_size);
   int is_member = _XMP_check_nodes_ref_inclusion(ref_lower, ref_upper, ref_stride, _XMP_world_size, _XMP_world_rank);
  
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_split(*((MPI_Comm *)(_XMP_get_execution_nodes())->comm), is_member, _XMP_world_rank, comm);
  
   _XMP_nodes_t *n = _XMP_create_new_nodes(is_member, dim, _XMP_M_COUNT_TRIPLETi(ref_lower, ref_upper, ref_stride),
                                           (_XMP_comm_t *)comm);
  
   // calc inherit info
   int shrink[1] = {_XMP_N_INT_FALSE};
   int l[1] = {ref_lower};
   int u[1] = {ref_upper};
   int s[1] = {ref_stride};
   n->inherit_nodes = _XMP_world_nodes;
   n->inherit_info = _XMP_calc_inherit_info_by_ref(_XMP_world_nodes, shrink, l, u, s);
   n->attr = _XMP_ENTIRE_NODES;
  
   // calc info
   _XMP_init_nodes_info(n, dim_size, is_static);
  
   n->info[0].multiplier = 1;
   for(int i=1;i<dim;i++)
     n->info[i].multiplier = n->info[i-1].multiplier * dim_size[i-1];
  
   n->subcomm = create_subcomm(n);
   
   return n;
 }

Here is the caller graph for this function:

◆ _XMP_init_reflect_sched()

void _XMP_init_reflect_sched ( _XMP_reflect_sched_t * sched )

                                                          {
   //sched->is_periodic = -1; /* not used yet */
   sched->reflect_is_initialized = 0;
   sched->reduce_is_initialized = 0;
   sched->prev_pcopy_sched_type = 0;
   sched->datatype_lo = MPI_DATATYPE_NULL;
   sched->datatype_hi = MPI_DATATYPE_NULL;
   for (int j = 0; j < 4; j++){
     sched->req[j] = MPI_REQUEST_NULL;
     sched->req_reduce[j] = MPI_REQUEST_NULL;
   }
   sched->lo_send_buf = NULL;
   sched->lo_recv_buf = NULL;
   sched->hi_send_buf = NULL;
   sched->hi_recv_buf = NULL;
 }

Here is the caller graph for this function:

◆ _XMP_init_shadow()

void _XMP_init_shadow	(	_XMP_array_t *	array,
			...
	)

                                                 {
   int dim = array->dim;
   va_list args;
   va_start(args, array);
   for (int i = 0; i < dim; i++) {
     _XMP_array_info_t *ai = &(array->info[i]);
  
     int type = va_arg(args, int);
     switch (type) {
       case _XMP_N_SHADOW_NONE:
         ai->shadow_type = _XMP_N_SHADOW_NONE;
         break;
       case _XMP_N_SHADOW_NORMAL:
         {
           _XMP_ASSERT(ai->align_manner == _XMP_N_ALIGN_BLOCK);
  
           int lo = va_arg(args, int);
           if (lo < 0) {
             _XMP_fatal("<shadow-width> should be a nonnegative integer");
           }
  
           int hi = va_arg(args, int);
           if (hi < 0) {
             _XMP_fatal("<shadow-width> should be a nonnegative integer");
           }
  
           if ((lo == 0) && (hi == 0)) {
             ai->shadow_type = _XMP_N_SHADOW_NONE;
           }
           else {
             ai->shadow_type = _XMP_N_SHADOW_NORMAL;
             ai->shadow_size_lo = lo;
             ai->shadow_size_hi = hi;
  
             if (array->is_allocated) {
               ai->local_lower += lo;
               ai->local_upper += lo;
            // ai->local_stride is not changed
               ai->alloc_size += lo + hi;
  
               *(ai->temp0) -= lo;
               ai->temp0_v -= lo;
             }
  
             if (!ai->reflect_sched){
               _XMP_reflect_sched_t *sched = _XMP_alloc(sizeof(_XMP_reflect_sched_t));
               _XMP_init_reflect_sched(sched);
               ai->reflect_sched = sched;
             }
 #ifdef _XMP_XACC
             if (!ai->reflect_acc_sched){
               _XMP_reflect_sched_t *sched = _XMP_alloc(sizeof(_XMP_reflect_sched_t));
               _XMP_init_reflect_sched_acc(sched);
               ai->reflect_acc_sched = sched;
             }
 #endif
  
             _XMP_create_shadow_comm(array, i);
           }
  
           break;
         }
       case _XMP_N_SHADOW_FULL:
         {
           ai->shadow_type = _XMP_N_SHADOW_FULL;
  
           if (array->is_allocated) {
             ai->shadow_size_lo = ai->par_lower - ai->ser_lower;
             ai->shadow_size_hi = ai->ser_upper - ai->par_upper;
  
             ai->local_lower = ai->par_lower - ai->ser_lower;
             ai->local_upper = ai->par_upper - ai->ser_lower;
             ai->local_stride = ai->par_stride;
             ai->alloc_size = ai->ser_size;
           }
  
           _XMP_create_shadow_comm(array, i);
           break;
         }
       default:
         _XMP_fatal("unknown shadow type");
     }
   }
 }

Here is the call graph for this function:

◆ _XMP_init_template_chunk()

void _XMP_init_template_chunk	(	_XMP_template_t *	template,
		_XMP_nodes_t *	nodes
	)

 {
   template->is_distributed = true;
   template->is_owner       = nodes->is_member;
   template->onto_nodes     = nodes;
   template->chunk          = _XMP_alloc(sizeof(_XMP_template_chunk_t) * (template->dim));
 }

Here is the call graph for this function:

◆ _XMP_init_template_FIXED()

void _XMP_init_template_FIXED	(	_XMP_template_t **	template,
		int	dim,
			...
	)

 {
   // alloc descriptor
   _XMP_template_t *t = _XMP_create_template_desc(dim, true);
  
   // calc info
   va_list args;
   va_start(args, dim);
   for(int i=0;i<dim;i++){
     t->info[i].ser_lower = va_arg(args, long long);
     t->info[i].ser_upper = va_arg(args, long long);
   }
   va_end(args);
  
   _XMP_calc_template_size(t);
  
   *template = t;
 }

Here is the call graph for this function:

◆ _XMP_init_world()

void _XMP_init_world	(	int *	argc,
		char ***	argv
	)

                                               {
   int flag = 0;
   MPI_Initialized(&flag);
   if (!flag) MPI_Init(argc, argv);
   
   MPI_Comm *comm = _XMP_alloc(sizeof(MPI_Comm));
   MPI_Comm_dup(MPI_COMM_WORLD, comm);
   _XMP_nodes_t *n = _XMP_create_nodes_by_comm(_XMP_N_INT_TRUE, comm);
   n->attr = _XMP_ENTIRE_NODES;
   _XMP_world_size = n->comm_size;
   _XMP_world_rank = n->comm_rank;
   _XMP_world_nodes = n;
   _XMP_push_nodes(n);
  
   MPI_Barrier(MPI_COMM_WORLD);
 }

◆ _XMP_initialize_async_comm_tab()

void _XMP_initialize_async_comm_tab ( )

 {
   for(int i=0;i<_XMP_ASYNC_COMM_SIZE;i++){
     _XMP_async_comm_tab[i].nreqs   = 0;
     _XMP_async_comm_tab[i].nnodes  = 0;
     _XMP_async_comm_tab[i].is_used = false;
     _XMP_async_comm_tab[i].type    = _XMP_COMM_NONE;
     _XMP_async_comm_tab[i].node    = NULL;
     _XMP_async_comm_tab[i].reqs    = NULL;
     _XMP_async_comm_tab[i].gmove   = NULL;
     _XMP_async_comm_tab[i].a       = NULL;
     _XMP_async_comm_tab[i].next    = NULL;
   }
 }

◆ _XMP_initialize_onesided_functions()

void _XMP_initialize_onesided_functions ( )

 {
 #ifdef _XMP_FJRDMA
   if(_XMP_world_size > _XMP_ONESIDED_MAX_PROCS){
     if(_XMP_world_rank == 0)
       fprintf(stderr, "Warning : Onesided operations cannot be not used in %d processes (up to %d processes)\n", 
               _XMP_world_size, _XMP_ONESIDED_MAX_PROCS);
  
     return;
   }
 #endif
  
 #ifdef _XMP_GASNET
   size_t _xmp_heap_size, _xmp_stride_size;
   _xmp_heap_size   = _get_size("XMP_ONESIDED_HEAP_SIZE");
   _xmp_stride_size = _get_size("XMP_ONESIDED_STRIDE_SIZE");
   _xmp_heap_size  += _xmp_stride_size;
   _XMP_gasnet_initialize(_xmp_heap_size, _xmp_stride_size);
   _XMP_gasnet_intrinsic_initialize();
 #elif _XMP_FJRDMA
   _XMP_fjrdma_initialize();
 #elif _XMP_UTOFU
   _XMP_utofu_initialize();
 #elif _XMP_MPI3_ONESIDED
   size_t _xmp_heap_size;
   _xmp_heap_size   = _get_size("XMP_ONESIDED_HEAP_SIZE");
   _XMP_mpi_onesided_initialize(_xmp_heap_size);
 #endif
  
 #ifdef _XMP_TCA
   _XMP_tca_initialize();
 #endif
  
 #if defined(_XMP_GASNET) || defined(_XMP_FJRDMA) || defined(_XMP_TCA) || defined(_XMP_MPI3_ONESIDED) || defined(_XMP_UTOFU)
   _XMP_build_sync_images_table();
   _XMP_build_coarray_queue();
   _XMP_post_wait_initialize();
 #endif
  
   /* Temporary  */
   if(getenv("XMP_PUT_NB") != NULL){
     _XMP_flag_put_nb = true;  // defalt false
     if(_XMP_world_rank == 0)
       printf("*** _XMP_coarray_contiguous_put() is Non-Blocking ***\n");
   }
  
   if(getenv("XMP_GET_NB") != NULL){
     _XMP_flag_get_nb = true;  // defalt false
     if(_XMP_world_rank == 0)
       printf("*** _XMP_coarray_contiguous_get() is Non-Blocking ***\n");
   }
  
 #if defined(_XMP_FJRDMA)
   if(getenv("XMP_PUT_NB_RR") != NULL){
     _XMP_flag_put_nb    = true;  // defalt false
     _XMP_flag_put_nb_rr = true;  // defalt false
     if(_XMP_world_rank == 0)
       printf("*** _XMP_coarray_contiguous_put() is Non-Blocking and Round-Robin ***\n");
   }
  
   if(getenv("XMP_PUT_NB_RR_I") != NULL){
     _XMP_flag_put_nb      = true;  // defalt false
     _XMP_flag_put_nb_rr   = true;  // defalt false
     _XMP_flag_put_nb_rr_i = true;  // defalt false
     if(_XMP_world_rank == 0)
       printf("*** _XMP_coarray_contiguous_put() is Non-Blocking, Round-Robin and Immediately ***\n");
   }
 #endif
   /* End Temporary */
 }

Here is the call graph for this function:

◆ _XMP_L2G()

void _XMP_L2G	(	int	local_idx,
		long long int *	global_idx,
		_XMP_template_t *	template,
		int	template_index
	)

 {
   if(! template->is_owner){
     return;
   }
  
   _XMP_template_chunk_t *chunk = &(template->chunk[template_index]);
   _XMP_nodes_info_t *n_info = chunk->onto_nodes_info;
   long long base = template->info[template_index].ser_lower;
  
   switch(chunk->dist_manner){
   case _XMP_N_DIST_DUPLICATION:
     //*global_idx = base + local_idx ;
     *global_idx = local_idx ;
     break;
   case _XMP_N_DIST_BLOCK:
     *global_idx = base + n_info->rank * chunk->par_chunk_width + local_idx;
     //xmpf_dbg_printf("%d -> %d, base = %d, rank = %d, chunk = %d\n", local_idx, *global_idx, base, n_info->rank, chunk->par_chunk_width);
     break;
   case _XMP_N_DIST_CYCLIC:
     *global_idx = base + n_info->rank + n_info->size * local_idx;
     break;
   case _XMP_N_DIST_BLOCK_CYCLIC:
     {
       int w = chunk->par_width;
       *global_idx = base + n_info->rank * w
                   + (local_idx/w) * w * n_info->size + local_idx%w;
     }
     break;
   case _XMP_N_DIST_GBLOCK:
     *global_idx = local_idx + chunk->mapping_array[n_info->rank];
     break;
   default:
     _XMP_fatal("_XMP_: unknown chunk dist_manner");
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_local_get()

void _XMP_local_get	(	void *	dst,
		const _XMP_coarray_t *	src_desc,
		const int	dst_contiguous,
		const int	src_contiguous,
		const int	dst_dims,
		const int	src_dims,
		const _XMP_array_section_t *	dst_info,
		const _XMP_array_section_t *	src_info,
		const	size_t,
		const	size_t
	)

 {
   size_t dst_offset = _XMP_get_offset(dst_info, dst_dims);
   size_t src_offset = _XMP_get_offset(src_info, src_dims);
   size_t elmt_size  = src_desc->elmt_size;
  
   if(dst_contiguous && src_contiguous)
     _XMP_local_contiguous_copy((char *)dst+dst_offset, (char *)src_desc->real_addr+src_offset, 
                                dst_elmts, src_elmts, elmt_size);
   else
     _local_NON_contiguous_copy((char *)dst+dst_offset, (char *)src_desc->real_addr+src_offset,
                                dst_dims, src_dims, dst_info, src_info, dst_elmts, src_elmts, elmt_size);
 }

Here is the call graph for this function:

◆ _XMP_local_put()

void _XMP_local_put	(	_XMP_coarray_t *	dst_desc,
		const void *	src,
		const int	dst_contiguous,
		const int	src_contiguous,
		const int	dst_dims,
		const int	src_dims,
		const _XMP_array_section_t *	dst_info,
		const _XMP_array_section_t *	src_info,
		const	size_t,
		const	size_t
	)

 {
   size_t dst_offset = _XMP_get_offset(dst_info, dst_dims);
   size_t src_offset = _XMP_get_offset(src_info, src_dims);
   size_t elmt_size  = dst_desc->elmt_size;
  
   if(dst_contiguous && src_contiguous)
     _XMP_local_contiguous_copy((char *)dst_desc->real_addr+dst_offset, (char *)src+src_offset,
                                dst_elmts, src_elmts, elmt_size);
   else
     _local_NON_contiguous_copy((char *)dst_desc->real_addr+dst_offset, (char *)src+src_offset,
                                dst_dims, src_dims, dst_info, src_info, dst_elmts, src_elmts, elmt_size);
 }

Here is the call graph for this function:

◆ _XMP_mpi_coarray_deallocate()

void _XMP_mpi_coarray_deallocate	(	_XMP_coarray_t *	c,
		bool	is_acc
	)

 {
   if(_XMP_flag_multi_win){
     MPI_Win_unlock_all(c->win);
     _XMP_barrier_EXEC();
     _XMP_mpi_onesided_dealloc_win(&(c->win), (void **)&(c->real_addr), is_acc);
   }
 }

Here is the call graph for this function:

◆ _XMP_nodes_dealloc_after_wait_async()

void _XMP_nodes_dealloc_after_wait_async ( _XMP_nodes_t * n )

 {
   if(_tmp_async->nnodes >= _XMP_MAX_ASYNC_NODES) // Fix me
     _XMP_fatal("Too many nodes");
  
   if(_tmp_async->nnodes == 0)
     _tmp_async->node = _XMP_alloc(sizeof(_XMP_nodes_t*) * _XMP_MAX_ASYNC_NODES);
   
   _tmp_async->node[_tmp_async->nnodes] = n;
   _tmp_async->nnodes++;
 }

Here is the caller graph for this function:

◆ _XMP_normalize_array_section()

void _XMP_normalize_array_section	(	_XMP_gmv_desc_t *	gmv_desc,
		int	idim,
		int *	lower,
		int *	upper,
		int *	stride
	)

                                                                                                             {
   // setup temporary variables
  
   //_XMPC_array_t *array = gmv_desc->a_desc;
   int l, u;
   int s = *(stride);
   if (s > 0) {
     l = *lower;
     u = *upper;
   }
   else if (s < 0) {
     l = *upper;
     u = *lower;
   }
   else { // s == 0 (scalar), do nothing
     return;
    /*  if (*lower==0 && *upper==0){ */
    /*    if (gmv_desc->is_global == true){ */
    /*       l = array->info[idim].ser_lower; */
    /*       u = array->info[idim].ser_upper; */
    /*       s = 1; */
    /*    }else{ */
    /*       l = gmv_desc->a_lb[idim]; */
    /*       u = gmv_desc->a_ub[idim]; */
    /*       s = 1; */
    /*    } */
    /*  }else{ */
    /*    l = *lower; */
    /*    u = *lower; */
    /*    s = 1; */
    /*  } */
    /* // _XMP_fatal("the stride of <array-section> is 0"); */
    /* // l = 0; u = 0; // XXX dummy */
   }
  
   // normalize values
   if (s > 0) {
     u = u - ((u - l) % s);
   }
   else {
     s = -s;
     l = l + ((u - l) % s);
   }
   *lower = l;
   *upper = u;
   *stride = s;
 }

◆ _XMP_pack_vector()

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

                                                               {
   long i;
   if (_xmp_omp_num_procs > 1 && count > 8 * _xmp_omp_num_procs){
 #pragma omp parallel for private(i)
     for (i = 0; i < count; i++){
       memcpy(dst + i * blocklength, src + i * stride, blocklength);
     }
   }
   else {
     for (i = 0; i < count; i++){
       memcpy(dst + i * blocklength, src + i * stride, blocklength);
     }
   }
  
 }

Here is the caller graph for this function:

◆ _XMP_pack_vector2()

void _XMP_pack_vector2	(	char *restrict	dst,
		char *restrict	src,
		int	count,
		int	blocklength,
		int	nnodes,
		int	type_size,
		int	src_block_dim
	)

                                                                     {
   long j,k;
   if (src_block_dim == 1){
 #pragma omp parallel for private(j,k)
     for (j = 0; j < count; j++){
       for (k = 0; k < nnodes; k++){
         memcpy(dst + ((k * count +j ) * blocklength ) * type_size,
                src + ((k + j * nnodes) * blocklength ) * type_size,
                blocklength * type_size);
       }
     }
   }
 }

◆ _XMP_pop_n_free_nodes()

void _XMP_pop_n_free_nodes ( void )

 {
   _XMP_nodes_dish_t *freed_dish = _XMP_nodes_stack_top;
   _XMP_nodes_stack_top = freed_dish->prev;
   _XMP_finalize_nodes(freed_dish->nodes);
   _XMP_free(freed_dish);
 }

◆ _XMP_pop_n_free_nodes_wo_finalize_comm()

void _XMP_pop_n_free_nodes_wo_finalize_comm ( void )

 {
   _XMP_nodes_dish_t *freed_dish = _XMP_nodes_stack_top;
   _XMP_nodes_stack_top          = freed_dish->prev;
   _XMP_free(freed_dish->nodes);
   _XMP_free(freed_dish);
 }

◆ _XMP_pop_nodes()

void _XMP_pop_nodes ( void )

 {
   _XMP_nodes_dish_t *freed_dish = _XMP_nodes_stack_top;
   _XMP_nodes_stack_top          = freed_dish->prev;
   _XMP_free(freed_dish);
 }

◆ _XMP_push_comm()

void _XMP_push_comm ( _XMP_comm_t * comm )

 {
   _XMP_push_nodes(_XMP_create_nodes_by_comm(_XMP_N_INT_TRUE, comm));
 }

◆ _XMP_push_nodes()

void _XMP_push_nodes ( _XMP_nodes_t * nodes )

 {
   _XMP_nodes_dish_t *new_dish = _XMP_alloc(sizeof(_XMP_nodes_dish_t));
   new_dish->nodes             = nodes;
   new_dish->prev              = _XMP_nodes_stack_top;
   _XMP_nodes_stack_top        = new_dish;
 }

Here is the call graph for this function:

◆ _XMP_reduce_CLAUSE()

void _XMP_reduce_CLAUSE	(	void *	data_addr,
		int	count,
		int	datatype,
		int	op
	)

                                                                           {
   _XMP_RETURN_IF_SINGLE;
     
   // setup information
   MPI_Datatype mpi_datatype = MPI_INT; // dummy
   size_t datatype_size; // not used in this function
   MPI_Op mpi_op = MPI_SUM; // dummy
   _XMP_setup_reduce_type(&mpi_datatype, &datatype_size, datatype);
   _XMP_setup_reduce_op(&mpi_op, op);
  
   // reduce
   MPI_Allreduce(MPI_IN_PLACE, data_addr, count, mpi_datatype, mpi_op, *((MPI_Comm *)(_XMP_get_execution_nodes())->comm));
 }

◆ _XMP_reduce_NODES_ENTIRE()

void _XMP_reduce_NODES_ENTIRE	(	_XMP_nodes_t *	nodes,
		void *	addr,
		int	count,
		int	datatype,
		int	op
	)

                                                                                                 {
   if (count == 0) {
     return; // FIXME not good implementation
   }
  
   if (!nodes->is_member) {
     return;
   }
  
   // setup information
   MPI_Datatype mpi_datatype = MPI_INT; //dummy
   size_t datatype_size;
   MPI_Op mpi_op = MPI_SUM; // dummy
   _XMP_setup_reduce_type(&mpi_datatype, &datatype_size, datatype);
   _XMP_setup_reduce_op(&mpi_op, op);
  
 #ifdef _XMP_MPI3
   if(xmp_is_async()){
     _XMP_async_comm_t *async = _XMP_get_current_async();
     MPI_Iallreduce(MPI_IN_PLACE, addr, count, mpi_datatype, mpi_op, *((MPI_Comm *)nodes->comm),
                    &async->reqs[async->nreqs]);
     async->nreqs++;
   }
   else
 #endif
     MPI_Allreduce(MPI_IN_PLACE, addr, count, mpi_datatype, mpi_op, *((MPI_Comm *)nodes->comm));
 }

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

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

void _XMP_reflect_shadow_FULL	(	void *	array_addr,
		_XMP_array_t *	array_desc,
		int	array_index
	)

                                                                                            {
   _XMP_RETURN_IF_SINGLE;
  
   if (!array_desc->is_allocated) {
     return;
   }
  
   _XMP_array_info_t *ai = &(array_desc->info[array_index]);
   if ((ai->shadow_comm_size) == 1) {
     return;
   }
  
   int array_dim = array_desc->dim;
  
   // using allgather/allgatherv in special cases
   if ((array_dim == 1) && (ai->align_manner == _XMP_N_ALIGN_BLOCK) && (ai->is_regular_chunk)) {
     _XMP_reflect_shadow_FULL_ALLGATHER(array_addr, array_desc, array_index);
   }
   else {
     _XMP_reflect_shadow_FULL_BCAST(array_addr, array_desc, array_index);
   }
 }

◆ _XMP_sched_loop_template_BLOCK()

void _XMP_sched_loop_template_BLOCK	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		_XMP_template_t *	template,
		int	template_index
	)

                                                                                    {
   _XMP_ASSERT(template->is_distributed);
  
   if (!template->is_owner) {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
     return;
   }
  
   _XMP_template_info_t *template_info = &(template->info[template_index]);
   int template_ser_lower = template_info->ser_lower;
  
   _XMP_template_chunk_t *template_chunk = &(template->chunk[template_index]);
   int template_lower = template_chunk->par_lower;
   int template_upper = template_chunk->par_upper;
   int template_stride = template_chunk->par_stride;
   int chunk_width = template_chunk->par_chunk_width;
  
   int reverse_iter = _XMP_N_INT_FALSE;
   _XMP_SM_NORM_SCHED_PARAMS(ser_init, ser_cond, ser_step, reverse_iter)
  
   // calc par_init, par_cond, par_step
   if (_XMP_sched_loop_template_width_1(ser_init, ser_cond, ser_step, par_init, par_cond, par_step,
                                        template_lower, template_upper, template_stride)) {
     *par_init = _XMP_SM_GTOL_BLOCK(*par_init, template_ser_lower, chunk_width);
     *par_cond = _XMP_SM_GTOL_BLOCK(*par_cond, template_ser_lower, chunk_width);
     *par_step = ser_step;
  
     // finalize iter
     _XMP_SM_FINALIZE_ITER(par_init, par_cond, par_step, reverse_iter);
   } else {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
   }
  
   /* // */
   /* // for EXPAND/MARGIN */
   /* // */
   
   /* if (expand_type == _XMP_LOOP_NONE){ */
   /*   return; */
   /* } */
   /* else if (expand_type == _XMP_LOOP_EXPAND){ */
  
   /*   if ((*par_init) <= (*par_cond)){ // iterates at least once */
   /*     (*par_init) -= lwidth; */
   /*     (*par_cond) += uwidth; */
   /*   } */
  
   /* } */
   /* else if (expand_type == _XMP_LOOP_MARGIN){ */
  
   /*   if ((*par_init) <= (*par_cond)){ // iterates at least once */
  
   /*     if (lwidth > 0){ */
   /*    (*par_init) -= lwidth; */
   /*    (*par_cond) = (*par_init) + lwidth; */
   /*     } */
   /*     else if (lwidth < 0){ */
   /*    (*par_cond) = (*par_init) - lwidth; */
   /*    // (*par_init) */
   /*     } */
   /*     else if (uwidth > 0){ */
   /*    (*par_cond) += uwidth; */
   /*    (*par_init) = (*par_cond) - uwidth; */
   /*     } */
   /*     else if (uwidth < 0){ */
   /*    (*par_init) = (*par_cond) + uwidth; */
   /*    // (*par_cond) */
   /*     } */
  
   /*   } */
  
   /* } */
  
   /* if (unbound_flag == 0){ */
  
   /*   long long int ser_init2; */
   /*   _XMP_L2G(*par_init, &ser_init2, template, template_index); */
   /*   if (ser_init2 < ser_init){ */
   /*     (*par_init) += lwidth; */
   /*   } */
  
   /*   long long int ser_cond2; */
   /*   _XMP_L2G(*par_cond-1, &ser_cond2, template, template_index); */
   /*   // because (*par_cond) is (upper_bound + 1). */
   /*   if (ser_cond2 > ser_cond){ */
   /*     (*par_cond) -= uwidth; */
   /*   } */
   /* } */
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_BLOCK_CYCLIC()

void _XMP_sched_loop_template_BLOCK_CYCLIC	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		_XMP_template_t *	template,
		int	template_index
	)

                                                                                           {
   _XMP_ASSERT(template->is_distributed);
  
   if (!template->is_owner) {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
     return;
   }
  
   _XMP_template_info_t *template_info = &(template->info[template_index]);
   int template_ser_lower = template_info->ser_lower;
   int template_ser_upper = template_info->ser_upper;
  
   _XMP_template_chunk_t *template_chunk = &(template->chunk[template_index]);
   int nodes_size = (template_chunk->onto_nodes_info)->size;
   int template_lower = template_chunk->par_lower;
   int template_upper = template_chunk->par_upper;
   int template_stride = template_chunk->par_stride;
   int width = template_chunk->par_width;
  
   int reverse_iter = _XMP_N_INT_FALSE;
   _XMP_SM_NORM_SCHED_PARAMS(ser_init, ser_cond, ser_step, reverse_iter)
  
   // calc par_init, par_cond, par_step
   if (_XMP_sched_loop_template_width_N(ser_init, ser_cond, ser_step, par_init, par_cond, par_step,
                                        template_lower, template_upper, template_stride,
                                        width, template_ser_lower, template_ser_upper)) {
     *par_init = _XMP_SM_GTOL_BLOCK_CYCLIC(width, *par_init, template_ser_lower, nodes_size);
     *par_cond = _XMP_SM_GTOL_BLOCK_CYCLIC(width, *par_cond, template_ser_lower, nodes_size);
     *par_step = 1;
  
     // finalize iter
     _XMP_SM_FINALIZE_ITER(par_init, par_cond, par_step, reverse_iter);
   } else {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_CYCLIC()

void _XMP_sched_loop_template_CYCLIC	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		_XMP_template_t *	template,
		int	template_index
	)

                                                                                     {
   _XMP_ASSERT(template->is_distributed);
  
   if (!template->is_owner) {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
     return;
   }
  
   _XMP_template_info_t *template_info = &(template->info[template_index]);
   int template_ser_lower = template_info->ser_lower;
  
   _XMP_template_chunk_t *template_chunk = &(template->chunk[template_index]);
   int nodes_size = (template_chunk->onto_nodes_info)->size;
   int template_lower = template_chunk->par_lower;
   int template_upper = template_chunk->par_upper;
   int template_stride = template_chunk->par_stride;
  
   int reverse_iter = _XMP_N_INT_FALSE;
   _XMP_SM_NORM_SCHED_PARAMS(ser_init, ser_cond, ser_step, reverse_iter)
  
   // calc par_init, par_cond, par_step
   if (_XMP_sched_loop_template_width_1(ser_init, ser_cond, ser_step, par_init, par_cond, par_step,
                                        template_lower, template_upper, template_stride)) {
     *par_init = _XMP_SM_GTOL_CYCLIC(*par_init, template_ser_lower, nodes_size);
     *par_cond = _XMP_SM_GTOL_CYCLIC(*par_cond, template_ser_lower, nodes_size);
     *par_step = 1;
  
     // finalize iter
     _XMP_SM_FINALIZE_ITER(par_init, par_cond, par_step, reverse_iter);
   } else {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_DUPLICATION()

void _XMP_sched_loop_template_DUPLICATION	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		_XMP_template_t *	template,
		int	template_index
	)

                                                                                          {
   _XMP_ASSERT(template->is_distributed); // FIXME too strict?
  
   if (!template->is_owner) {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
     return;
   }
  
   _XMP_template_chunk_t *template_chunk = &(template->chunk[template_index]);
   int template_lower = template_chunk->par_lower;
   int template_upper = template_chunk->par_upper;
   int template_stride = template_chunk->par_stride;
  
   int reverse_iter = _XMP_N_INT_FALSE;
   _XMP_SM_NORM_SCHED_PARAMS(ser_init, ser_cond, ser_step, reverse_iter)
  
   // calc par_init, par_cond, par_step
   if (_XMP_sched_loop_template_width_1(ser_init, ser_cond, ser_step, par_init, par_cond, par_step,
                                        template_lower, template_upper, template_stride)) {
     // finalize iter
     _XMP_SM_FINALIZE_ITER(par_init, par_cond, par_step, reverse_iter);
   } else {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_GBLOCK()

void _XMP_sched_loop_template_GBLOCK	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		_XMP_template_t *	template,
		int	template_index
	)

                                                                                     {
  
   _XMP_ASSERT(template->is_distributed);
  
   if (!template->is_owner) {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
     return;
   }
  
   _XMP_template_chunk_t *template_chunk = &(template->chunk[template_index]);
   int rank = template_chunk->onto_nodes_info->rank;
   int template_lower = template_chunk->par_lower;
   int template_upper = template_chunk->par_upper;
   int template_stride = template_chunk->par_stride;
   long long *mapping_array = template_chunk->mapping_array;
  
   int reverse_iter = _XMP_N_INT_FALSE;
   _XMP_SM_NORM_SCHED_PARAMS(ser_init, ser_cond, ser_step, reverse_iter)
  
   // calc par_init, par_cond, par_step
   if (_XMP_sched_loop_template_width_1(ser_init, ser_cond, ser_step, par_init, par_cond, par_step,
                                        template_lower, template_upper, template_stride)) {
  
     *par_init = _XMP_SM_GTOL_GBLOCK(*par_init, mapping_array[rank]);
     *par_cond = _XMP_SM_GTOL_GBLOCK(*par_cond, mapping_array[rank]);
     *par_step = ser_step;
  
     // finalize iter
     _XMP_SM_FINALIZE_ITER(par_init, par_cond, par_step, reverse_iter);
   } else {
     *par_init = 0;
     *par_cond = 0;
     *par_step = 1;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_width_1()

int _XMP_sched_loop_template_width_1	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		int	template_lower,
		int	template_upper,
		int	template_stride
	)

                                                                                                   {
   int x, x_max = _XMP_floori((template_upper - template_lower), template_stride);
   if (ser_step == 1) {
     // calc par_init
     x = _XMP_ceili((ser_init - template_lower), template_stride);
     if (x < 0) {
       *par_init = template_lower;
     } else if (x > x_max) {
       return _XMP_N_INT_FALSE;
     } else {
       *par_init = (x * template_stride) + template_lower;
     }
  
     // calc par_cond
     x = _XMP_floori((ser_cond - template_lower), template_stride);
     if (x < 0) {
       return _XMP_N_INT_FALSE;
     } else if (x > x_max) {
       *par_cond = template_upper;
     } else {
       *par_cond = (x * template_stride) + template_lower;
     }
  
     // calc par_step
     *par_step = template_stride;
   } else {
     if ((template_upper < ser_init) || (ser_cond < template_lower)) {
       return _XMP_N_INT_FALSE;
     }
  
     // calc par_init
     for (int i = template_lower; i <= template_upper; i += template_stride) {
       if (i < ser_init) {
         continue;
       } else if (((i - ser_init) % ser_step) == 0) {
         *par_init = i;
         goto calc_par_cond;
       }
     }
     return _XMP_N_INT_FALSE;
  
 calc_par_cond:
     // calc par_cond
     for (int i = template_upper; i >= template_lower; i -= template_stride) {
       if (i > ser_cond) {
         continue;
       } else if (((i - ser_init) % ser_step) == 0) {
         *par_cond = i;
         goto calc_par_step;
       }
     }
     return _XMP_N_INT_FALSE;
  
 calc_par_step:
     // calc par_step
     *par_step = _XMP_lcm(ser_step, template_stride);
   }
  
   return _XMP_N_INT_TRUE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_sched_loop_template_width_N()

int _XMP_sched_loop_template_width_N	(	int	ser_init,
		int	ser_cond,
		int	ser_step,
		int *	par_init,
		int *	par_cond,
		int *	par_step,
		int	template_lower,
		int	template_upper,
		int	template_stride,
		int	width,
		int	template_ser_lower,
		int	template_ser_upper
	)

                                                                                                 {
   int si = ((ser_init - template_ser_lower) / width) + template_ser_lower;
   int sc = ((ser_cond - template_ser_lower) / width) + template_ser_lower;
   int tl = ((template_lower - template_ser_lower) / width) + template_ser_lower;
   int tu = ((template_upper - template_ser_lower) / width) + template_ser_lower;
   int ts = template_stride / width;
  
   /* FIXME HOW IMPLEMENT??? */
   if (ser_step != 1) {
     _XMP_fatal("loop step is not 1, -1: unsupported case");
   }
  
   if (_XMP_sched_loop_template_width_1(si, sc, 1, par_init, par_cond, par_step, tl, tu, ts)) {
     // init par_init
     int par_init_temp = ((*par_init - template_ser_lower) * width) + template_ser_lower;
     if (par_init_temp < ser_init) {
       *par_init = ser_init;
     } else {
       *par_init = par_init_temp;
     }
  
     // init par_cond
     int par_cond_temp = ((*par_cond - template_ser_lower) * width) + template_ser_lower + width - 1;
     if (par_cond_temp > template_ser_upper) {
       par_cond_temp = template_ser_upper;
     }
  
     if (par_cond_temp > ser_cond) {
       *par_cond = ser_cond;
     } else {
       *par_cond = par_cond_temp;
     }
  
     // init par_step
     // FIXME how implement???
  
     return _XMP_N_INT_TRUE;
   } else {
     return _XMP_N_INT_FALSE;
   }
 }

Here is the call graph for this function:

Here is the caller 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_sort()

void _XMP_sort	(	_XMP_array_t *	a_desc,
		_XMP_array_t *	b_desc,
		int	is_up
	)

                                                                      {
  
   void *a_adr = a_desc->array_addr_p;
   int a_lshadow = a_desc->info[0].shadow_size_lo;
  
   int a_size = a_desc->info[0].ser_size;
   int a_ndims = a_desc->dim;
   int a_type = a_desc->type;
  
   int b_size = b_desc->info[0].ser_size;
   int b_ndims = b_desc->dim;
   int b_type = b_desc->type;
  
   if (a_size != b_size) _XMP_fatal("xmp_sort: different size for array arguments");
   if (a_ndims != 1 || b_ndims != 1) _XMP_fatal("xmp_sort: array arguments must be one-dimensional");
   if (a_type != b_type) _XMP_fatal("xmp_sort: different type for array arguments");
  
   int lsize = a_desc->info[0].par_size;
  
   comm = a_desc->array_nodes->comm;
   me = a_desc->array_nodes->comm_rank;
   nprocs = a_desc->array_nodes->comm_size;
  
   set_funcs(a_desc, is_up);
   datasize = a_desc->type_size;
  
   do_sort((char *)a_adr + a_lshadow * datasize, lsize, b_desc);
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_split_world_by_color()

int _XMP_split_world_by_color ( int color )

                                          {
   int new_comm_rank;
   MPI_Comm new_comm;
   MPI_Comm_split(MPI_COMM_WORLD, color, _XMP_world_rank, &new_comm);
   MPI_Comm_rank(new_comm, &new_comm_rank);
   MPI_Comm_free(&new_comm);
  
   return new_comm_rank;
 }

◆ _XMP_sync_images_EXEC()

void _XMP_sync_images_EXEC ( int * status )

 {
   _XMP_mpi_sync_memory();
   _XMP_barrier_EXEC();
 }

Here is the call graph for this function:

◆ _XMP_threads_finalize()

void _XMP_threads_finalize ( void )

                                  {
   return;
 }

◆ _XMP_threads_init()

void _XMP_threads_init ( void )

                              {
   return;
 }

◆ _XMP_translate_nodes_rank_array_to_ranks()

void _XMP_translate_nodes_rank_array_to_ranks	(	_XMP_nodes_t *	nodes,
		int *	ranks,
		int *	rank_array,
		int	shrink_nodes_size
	)

 {
   int calc_flag = _XMP_N_INT_TRUE;
   int nodes_dim = nodes->dim;
   
   for(int i=0;i<nodes_dim;i++){
     if(rank_array[i] == _XMP_N_UNSPECIFIED_RANK){
       calc_flag = _XMP_N_INT_FALSE;
       int nodes_size = nodes->info[i].size;
       int new_shrink_nodes_size = shrink_nodes_size / nodes_size;
       for(int j=0;j<nodes_size;j++){
         rank_array[i] = j;
         _XMP_translate_nodes_rank_array_to_ranks(nodes, ranks + (j * new_shrink_nodes_size), rank_array, new_shrink_nodes_size);
       }
     }
   }
  
   if(calc_flag)
     *ranks = _XMP_calc_linear_rank(nodes, rank_array);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _XMP_unexpected_error()

void _XMP_unexpected_error ( void )

 {
   _XMP_fatal("unexpected error in runtime");
 }

◆ _XMP_unpack_vector()

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

                                                                 {
   long i;
   if (_xmp_omp_num_procs > 1 && count > 8 * _xmp_omp_num_procs){
 #pragma omp parallel for private(i)
     for (i = 0; i < count; i++){
       memcpy(dst + i * stride, src + i * blocklength, blocklength);
     }
   }
   else {
     for (i = 0; i < count; i++){
       memcpy(dst + i * stride, src + i * blocklength, blocklength);
     }
   }
  
 }

◆ _XMP_wait_async__()

void _XMP_wait_async__ ( int async_id )

 {
   _XMP_async_comm_t *async;
  
   if(!(async = _XMP_get_async(async_id))) return;
  
   int nreqs         = async->nreqs;
   MPI_Request *reqs = async->reqs;
  
 #if defined(_KCOMPUTER) && defined(K_RDMA_REFLECT)
   // For RDMA reflects, async->nreqs > 0 and async->reqs == NULL.
   if(nreqs && !reqs){
     _XMP_wait_async_rdma(async);
     return;
   }
 #endif
  
   _XMP_async_gmove_t *gmove = async->gmove;
  
   if (async->type == _XMP_COMM_REDUCE_SHADOW){
     MPI_Waitall(nreqs, reqs, MPI_STATUSES_IGNORE);
     _XMP_reduce_shadow_sum(async->a);
   }
   else if (!gmove || gmove->mode == _XMP_N_GMOVE_NORMAL){
     _XMP_TSTART(t0);
     MPI_Waitall(nreqs, reqs, MPI_STATUSES_IGNORE);
     _XMP_TEND(xmptiming_.t_wait, t0);
   }
  
   //
   // for asynchronous gmove
   //
  
   if (gmove){
     if (gmove->mode == _XMP_N_GMOVE_NORMAL) _XMP_finalize_async_gmove(gmove);
 #ifdef _XMP_MPI3_ONESIDED
     else {
       int status;
       // NOTE: the send_buf field is used for an improper purpose.
       _XMP_sync_images_COMM((MPI_Comm *)gmove->sendbuf, &status);
     }
 #endif
   }
  
 }

◆ _XMP_warning()

void _XMP_warning ( char * msg )

                             {
   fprintf(stderr, "[RANK:%d] XcalableMP runtime warning: %s\n", _XMP_world_rank, msg);
 }

Here is the caller graph for this function:

◆ _XMPC_pack_array()

void _XMPC_pack_array	(	void *	buffer,
		void *	src,
		int	array_type,
		size_t	array_type_size,
		int	array_dim,
		int *	l,
		int *	u,
		int *	s,
		unsigned long long *	d
	)

                                                                                    {
   if (array_type >= _XMP_N_TYPE_FLOAT_COMPLEX && array_type <= _XMP_N_TYPE_NONBASIC) {
     /*_XMP_N_TYPE_FLOAT_COMPLEX || _XMP_N_TYPE_DOUBLE_COMPLEX ||
       _XMP_N_TYPE_LONG_DOUBLE_COMPLEX ||
       _XMP_N_TYPE_NONBASIC */
     _XMPC_pack_array_GENERAL(buffer, src, array_type_size, array_dim, l, u, s, d);
 #ifdef __STD_IEC_559_COMPLEX__
   } else if (array_type >= _XMP_N_TYPE_FLOAT_IMAGINARY && array_type <= _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY) {
     /* _XMP_N_TYPE_FLOAT_IMAGINARY || _XMP_N_TYPE_DOUBLE_IMAGINARY ||
        _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY */
     _XMPC_pack_array_GENERAL(buffer, src, array_type_size, array_dim, l, u, s, d);
 #endif
   } else {
     _XMPC_pack_array_BASIC(buffer, src, array_type, array_dim, l, u, s, d);
   }
 }

Here is the call graph for this function:

◆ _XMPC_unpack_array()

void _XMPC_unpack_array	(	void *	dst,
		void *	buffer,
		int	array_type,
		size_t	array_type_size,
		int	array_dim,
		int *	l,
		int *	u,
		int *	s,
		unsigned long long *	d
	)

                                                                                      {
   if (array_type >= _XMP_N_TYPE_FLOAT_COMPLEX && array_type <= _XMP_N_TYPE_NONBASIC) {
     /*_XMP_N_TYPE_FLOAT_COMPLEX || _XMP_N_TYPE_DOUBLE_COMPLEX ||
       _XMP_N_TYPE_LONG_DOUBLE_COMPLEX ||
       _XMP_N_TYPE_NONBASIC */
     _XMPC_unpack_array_GENERAL(dst, buffer, array_type_size, array_dim, l, u, s, d);
 #ifdef __STD_IEC_559_COMPLEX__
   } else if (array_type >= _XMP_N_TYPE_FLOAT_IMAGINARY && array_type <= _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY) {
     /* _XMP_N_TYPE_FLOAT_IMAGINARY || _XMP_N_TYPE_DOUBLE_IMAGINARY ||
        _XMP_N_TYPE_LONG_DOUBLE_IMAGINARY */
     _XMPC_unpack_array_GENERAL(dst, buffer, array_type_size, array_dim, l, u, s, d);
 #endif
   } else {
     _XMPC_unpack_array_BASIC(dst, buffer, array_type, array_dim, l, u, s, d);
   }
 }

Here is the call graph for this function:

◆ _XMPF_reduce_FLMM_NODES_ENTIRE()

void _XMPF_reduce_FLMM_NODES_ENTIRE	(	_XMP_nodes_t *	nodes,
		void *	addr,
		int	count,
		int	datatype,
		int	op,
		int	num_locs,
		void **	loc_vars,
		int *	loc_types
	)

                                                                                    {
  
   if (count == 0) {
     return; // FIXME not good implementation
   }
  
   if (!nodes->is_member) {
     return;
   }
  
   // setup information
   MPI_Datatype mpi_datatype;
   size_t datatype_size;
   MPI_Op mpi_op;
   _XMP_setup_reduce_type(&mpi_datatype, &datatype_size, datatype);
   _XMP_setup_reduce_op(&mpi_op, op);
  
   // reduce <reduction-variable>
   size_t n = datatype_size * count;
   void *temp_buffer = _XMP_alloc(n);
   memcpy(temp_buffer, addr, n);
  
   MPI_Allreduce(temp_buffer, addr, count, mpi_datatype, mpi_op, *((MPI_Comm *)nodes->comm));
  
   // compare results
   n = sizeof(int) * count;
   int *cmp_buffer = _XMP_alloc(n);
   _XMP_compare_reduce_results(cmp_buffer, temp_buffer, addr, count, datatype);
  
   // reduce <location-variable>
   for (int i = 0; i < num_locs; i++) {
     void *loc = loc_vars[i];
     int loc_datatype = loc_types[i];
  
     _XMP_setup_reduce_type(&mpi_datatype, &datatype_size, loc_datatype);
     _XMP_setup_reduce_FLMM_op(&mpi_op, op);
     _XMP_init_localtion_variables(loc, count, loc_datatype, cmp_buffer, op);
  
     n = datatype_size * count;
     void *loc_temp = _XMP_alloc(n);
     memcpy(loc_temp, loc, n);
  
     MPI_Allreduce(loc_temp, loc, count, mpi_datatype, mpi_op, *((MPI_Comm *)nodes->comm));
  
     _XMP_free(loc_temp);
   }
  
   _XMP_free(temp_buffer);
   _XMP_free(cmp_buffer);
 }

Here is the call graph for this function:

◆ _XMPF_unpack_transpose_vector()

void _XMPF_unpack_transpose_vector	(	char *restrict	dst,
		char *restrict	src,
		int	dst_stride,
		int	src_stride,
		int	type_size,
		int	dst_block_dim
	)

                                                                     {
   long i,j;
   if (dst_block_dim == 1){
     if (type_size == 16){
       long ii,jj,imin,jmin,nblk=16;
       double _Complex *dst0 = (double _Complex *)dst;
       double _Complex *src0 = (double _Complex *)src;
       for (jj = 0; jj < src_stride; jj+=nblk){
         jmin=((jj+nblk) < src_stride)? (jj+nblk):src_stride;
 #pragma omp parallel for private(i,j,ii,imin)
         for (ii = 0; ii < dst_stride; ii+=nblk){
           imin=((ii+nblk) < dst_stride)? (ii+nblk):dst_stride;
           for (j = jj; j < jmin; j++){
             for (i = ii; i < imin; i++){
               dst0[j * dst_stride + i] = src0[i * src_stride + j];
             }
           }
         }
       }
     }
     else {
       for (j = 0; j < src_stride; j++){
         for (i = 0; i < dst_stride; i++){
           memcpy(dst + (j * dst_stride + i) * type_size,
                  src + (i * src_stride + j) * type_size, type_size);
         }
       }
     }
   }
 }

◆ alloc_csd()

_XMP_csd_t* alloc_csd ( int n )

                             {
   _XMP_csd_t *csd = (_XMP_csd_t *)_XMP_alloc(sizeof(_XMP_csd_t));
   csd->l = (int *)_XMP_alloc(sizeof(int) * n);
   csd->u = (int *)_XMP_alloc(sizeof(int) * n);
   csd->n = n;
   return csd;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bsd2csd()

_XMP_csd_t* bsd2csd ( _XMP_bsd_t * bsd )

                                     {
  
   if (!bsd) return NULL;
  
   _XMP_csd_t *csd = alloc_csd(bsd->b);
   csd->n = bsd->b;
  
   for (int i = 0; i < bsd->b; i++){
     csd->l[i] = bsd->l + i;
     int t = (bsd->u - csd->l[i]) / bsd->c;
     csd->u[i] = csd->l[i] + bsd->c * t;
   }
  
   csd->s = bsd->c;
  
   return csd;
  
 }

Here is the call graph for this function:

◆ copy_csd()

_XMP_csd_t* copy_csd ( _XMP_csd_t * csd )

                                      {
   _XMP_csd_t *new_csd = alloc_csd(csd->n);
   for (int i = 0; i < csd->n; i++){
     new_csd->l[i] = csd->l[i];
     new_csd->u[i] = csd->u[i];
   }
   new_csd->s = csd->s;
   return new_csd;
 }

Here is the call graph for this function:

◆ csd2comm_set()

_XMP_comm_set_t* csd2comm_set ( _XMP_csd_t * csd )

                                               {
  
   if (!csd || csd->n == 0) return NULL;
  
   _XMP_comm_set_t *comm_set0 = (_XMP_comm_set_t *)_XMP_alloc(sizeof(_XMP_comm_set_t));
  
   _XMP_comm_set_t *comm_set = comm_set0;
   comm_set->l = csd->l[0];
   comm_set->u = csd->l[0];
   comm_set->next = NULL;
  
   for (int j = 0; csd->l[0] + j <= csd->u[0]; j+= csd->s){
  
     for (int i = 0; i < csd->n; i++){
  
       int l = csd->l[i] + j;
  
       if (l > csd->u[i]) continue;
  
       if (l == comm_set->u + 1){
         comm_set->u = l;
       }
       else if (l <= comm_set->u){
         continue;
       }
       else {
         comm_set->next = (_XMP_comm_set_t *)malloc(sizeof(_XMP_comm_set_t));
         comm_set = comm_set->next;
         comm_set->l = l;
         comm_set->u = l;
         comm_set->next = NULL;
       }
     }
  
   }
  
   return comm_set0;
  
 }

Here is the call graph for this function:

◆ free_comm_set()

void free_comm_set ( _XMP_comm_set_t * comm_set )

                                              {
  
   while (comm_set){
     _XMP_comm_set_t *next = comm_set->next;
     _XMP_free(comm_set);
     comm_set = next;
   }
  
 }

Here is the call graph for this function:

◆ free_csd()

void free_csd ( _XMP_csd_t * csd )

                               {
   if (csd){
     _XMP_free(csd->l);
     _XMP_free(csd->u);
     _XMP_free(csd);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_csd_size()

int get_csd_size ( _XMP_csd_t * csd )

                                  {
   int size = 0;
   for (int i = 0; i < csd->n; i++){
     size += _XMP_M_COUNT_TRIPLETi(csd->l[i], csd->u[i], csd->s);
   }
   return size;
 }

◆ intersection_csds()

_XMP_csd_t* intersection_csds	(	_XMP_csd_t *	csd1,
		_XMP_csd_t *	csd2
	)

                                                                  {
  
   if (!csd1 || !csd2) return NULL;
  
   _XMP_csd_t *csd0 = alloc_csd(MAX(csd1->n, csd2->n));
  
   int k = 0;
  
   csd0->n = 0;
  
   for (int i = 0; i < csd1->n; i++){
     for (int j = 0; j < csd2->n; j++){
  
       _XMP_rsd_t *tmp = NULL;
       _XMP_rsd_t rsd1 = { csd1->l[i], csd1->u[i], csd1->s };
       _XMP_rsd_t rsd2 = { csd2->l[j], csd2->u[j], csd2->s };
  
       tmp = intersection_rsds(&rsd1, &rsd2);
  
       if (tmp){
  
         csd0->l[k] = tmp->l;
         csd0->u[k] = tmp->u;
  
         // bubble sort
         int p = k;
         while (csd0->l[p-1] > tmp->l && p > 0){
           int s;
           s = csd0->l[p-1]; csd0->l[p-1] = csd0->l[p]; csd0->l[p] = s;
           s = csd0->u[p-1]; csd0->u[p-1] = csd0->u[p]; csd0->u[p] = s;
           p--;
         }
  
         csd0->n++;
         csd0->s = tmp->s;
         k++;
  
         _XMP_free(tmp);
       }
  
     }
   }
  
   return csd0;
  
 }

Here is the call graph for this function:

◆ intersection_rsds()

_XMP_rsd_t* intersection_rsds	(	_XMP_rsd_t *	_rsd1,
		_XMP_rsd_t *	_rsd2
	)

                                                                    {
  
   _XMP_rsd_t *rsd1, *rsd2;
  
   if (!_rsd1 || !_rsd2) return NULL;
  
   if (_rsd1->l <= _rsd2->l){
     rsd1 = _rsd1;
     rsd2 = _rsd2;
   }
   else {
     rsd1 = _rsd2;
     rsd2 = _rsd1;
   }
  
   if (rsd2->l <= rsd1->u){
     int min_u = MIN(rsd1->u, rsd2->u);
     for (int i = rsd2->l; i <= min_u; i += rsd2->s){
       if ((i - rsd1->l) % rsd1->s == 0){
         _XMP_rsd_t *rsd0 = (_XMP_rsd_t *)_XMP_alloc(sizeof(_XMP_rsd_t));
         rsd0->l = i;
         rsd0->s = _XMP_lcm(rsd1->s, rsd2->s);
         int t = (min_u - rsd0->l) / rsd0->s;
         rsd0->u = rsd0->l + rsd0->s * t;
         return rsd0;
       }
     }
   }
  
   return NULL;
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_bsd()

void print_bsd ( _XMP_bsd_t * bsd )

                                {
   if (!bsd){
     printf("()\n");
   }
   else {
     printf("(%d : %d : %d : %d)\n", bsd->l, bsd->u, bsd->b, bsd->c);
   }
 }

◆ print_comm_set()

void print_comm_set ( _XMP_comm_set_t * comm_set0 )

                                                {
  
   if (!comm_set0){
     printf("()\n");
     return;
   }
  
   _XMP_comm_set_t *comm_set = comm_set0;
  
   printf("(%d : %d)", comm_set->l, comm_set->u);
  
   while ((comm_set = comm_set->next)){
     printf(", (%d : %d)", comm_set->l, comm_set->u);
   }
  
   printf("\n");
  
 }

◆ print_csd()

void print_csd ( _XMP_csd_t * csd )

                                {
  
   if (!csd || csd->n == 0){
     printf("()\n");
     return;
   }
  
   printf("(");
  
   printf("(%d", csd->l[0]);
   for (int i = 1; i < csd->n; i++){
     printf(", %d", csd->l[i]);
   }
   printf(")");
  
   printf(" : ");
  
   printf("(%d", csd->u[0]);
   for (int i = 1; i < csd->n; i++){
     printf(", %d", csd->u[i]);
   }
   printf(")");
  
   printf(" : ");
  
   printf("%d)\n", csd->s);
  
 }

◆ print_rsd()

void print_rsd ( _XMP_rsd_t * rsd )

                                {
  
   if (!rsd){
     printf("()\n");
     return;
   }
  
   if (rsd->s){
     printf("(%d : %d : %d)\n", rsd->l, rsd->u, rsd->s);
   }
   else {
     printf("()\n");
   }
 }

◆ reduce_csd()

void reduce_csd	(	_XMP_csd_t *	csd[_XMP_N_MAX_DIM],
		int	ndims
	)

                                                            {
  
   for (int i = 0; i < ndims; i++){
     if (!csd[i] || csd[i]->n == 0){
       for (int j = 0; j < ndims; j++){
         free_csd(csd[j]);
         csd[j] = NULL;
       }
       return;
     }
   }      
  
 }

Here is the call graph for this function:

◆ rsd2csd()

_XMP_csd_t* rsd2csd ( _XMP_rsd_t * rsd )

                                     {
   if (!rsd) return NULL;
   _XMP_csd_t *csd = alloc_csd(1);
   csd->l[0] = rsd->l;
   csd->u[0] = rsd->u;
   csd->n = 1;
   csd->s = rsd->s;
   return csd;
 }

Here is the call graph for this function:

◆ xmp_get_ruuning()

int xmp_get_ruuning ( )

 {
   return _XMP_runtime_working;
 }

◆ xmp_is_async()

_Bool xmp_is_async ( )

 {
   return _xmp_is_async;
 }

Here is the caller graph for this function:

◆ xmp_reduce_initialize()

void xmp_reduce_initialize ( )

 {
   MPI_Op_create(_reduce_maxloc, 1, &_xmp_maxloc);
   MPI_Op_create(_reduce_minloc, 1, &_xmp_minloc);
 }

◆ xmpc_end_async()

void xmpc_end_async ( int async_id )

 {
   int hash_id = async_id % _XMP_ASYNC_COMM_SIZE;
   _XMP_async_comm_t *async = &_XMP_async_comm_tab[hash_id];
   
   if(!async->is_used) return;
  
   // The case no comm. registered for async_id 0 and xmpc_end_async called for
   // async_id == 0, may occur and is inconsistent.
   // But, actually, the code below works without problems in such a case, even if
   // no hash_id == 0.
   if(async->async_id == async_id){
     if(async->next == NULL){
       initialize_async(async);
     }
     else{
       _XMP_async_comm_t *next = async->next;
       initialize_async(async);
       async->async_id = next->async_id;
       async->nreqs    = next->nreqs;
       async->nnodes   = next->nnodes;
       async->is_used  = next->is_used;
       async->type     = next->type;
       async->node     = next->node;
       async->gmove    = next->gmove;
       async->reqs     = next->reqs;
       async->a        = next->a;
       async->next     = next->next;
       _XMP_free(next);
     }
     return;
   }
   else{
     _XMP_async_comm_t *prev = async;
     while((async = prev->next)){
       if(async->async_id == async_id){
         prev->next = async->next;
         initialize_async(async);
         _XMP_free(async);
         return;
       }
       prev = async;
     }
   }
 }

◆ xmpc_ltog()

int xmpc_ltog	(	int	local_idx,
		_XMP_template_t *	template,
		int	template_index,
		int	offset
	)

 {
   /*long long*/ int global_index = 0;
   _XMP_template_chunk_t *chunk   = &(template->chunk[dim]);
   _XMP_nodes_info_t *n_info      = chunk->onto_nodes_info;
   long long base                 = template->info[dim].ser_lower;
  
   switch(chunk->dist_manner){
   case _XMP_N_DIST_DUPLICATION:
     global_index = local_idx;
     break;
   case _XMP_N_DIST_BLOCK:
     global_index = base + n_info->rank * chunk->par_chunk_width + local_idx;
     break;
   case _XMP_N_DIST_CYCLIC:
     global_index = base + n_info->rank + n_info->size * local_idx;
     break;
   case _XMP_N_DIST_BLOCK_CYCLIC:
     {
       int w = chunk->par_width;
       global_index =  base + n_info->rank * w
                   + (local_idx/w) * w * n_info->size + local_idx%w;
     }
     break;
   case _XMP_N_DIST_GBLOCK:
     global_index = local_idx + chunk->mapping_array[n_info->rank];
   default:
     _XMP_fatal("_XMP_: unknown chunk dist_manner");
   }
  
   return global_index - offset;
     
 }

Here is the call graph for this function:

◆ 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_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;
 }

Variable Documentation

◆ _XMP_coarray_list_head

_XMP_coarray_list_t* _XMP_coarray_list_head

extern

◆ _XMP_coarray_list_tail

_XMP_coarray_list_t* _XMP_coarray_list_tail

extern

◆ _xmp_pack_array

void(* _xmp_pack_array) (void buffer, void src, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)	(	void *	buffer,
		void *	src,
		int	array_type,
		size_t	array_type_size,
		int	array_dim,
		int *	l,
		int *	u,
		int *	s,
		unsigned long long *	d
	)

extern

◆ _xmp_unpack_array

void(* _xmp_unpack_array) (void dst, void buffer, int array_type, size_t array_type_size, int array_dim, int l, int u, int s, unsigned long long d)	(	void *	dst,
		void *	buffer,
		int	array_type,
		size_t	array_type_size,
		int	array_dim,
		int *	l,
		int *	u,
		int *	s,
		unsigned long long *	d
	)

extern

◆ _XMP_world_nodes

void* _XMP_world_nodes

extern

◆ _XMP_world_rank

int _XMP_world_rank

extern

◆ _XMP_world_size

int _XMP_world_size

extern

◆ _XMPC_running

int _XMPC_running

extern

◆ _XMPF_running

int _XMPF_running

extern

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _XMP_ASSERT

◆ _XMP_INTERNAL

◆ _XMP_IS_SINGLE

◆ _XMP_RETURN_IF_AFTER_FINALIZATION

◆ _XMP_RETURN_IF_SINGLE

◆ _XMP_TEND

◆ _XMP_TEND2

◆ _XMP_TSTART

◆ MAX

◆ MIN

◆ XACC_DEBUG

Typedef Documentation

◆ _XMP_coarray_list_t

Function Documentation

◆ _XMP_align_array_BLOCK()

◆ _XMP_align_array_BLOCK_CYCLIC()

◆ _XMP_align_array_CYCLIC()

◆ _XMP_align_array_DUPLICATION()

◆ _XMP_align_array_GBLOCK()

◆ _XMP_align_array_NOT_ALIGNED()

◆ _XMP_alloc()

◆ _XMP_alloc_array()

◆ _XMP_alloc_array2()

◆ _XMP_barrier_EXEC()

◆ _XMP_barrier_NODES_ENTIRE()

◆ _XMP_bcast_NODES_ENTIRE_NODES()

◆ _XMP_bcast_NODES_ENTIRE_NODES_V()

◆ _XMP_bcast_NODES_ENTIRE_OMITTED()

◆ _XMP_build_coarray_queue()

◆ _XMP_build_sync_images_table()

◆ _XMP_calc_array_dim_elmts()

◆ _XMP_calc_coord_on_target_nodes()

◆ _XMP_calc_coord_on_target_nodes2()

◆ _XMP_calc_copy_chunk()

◆ _XMP_calc_global_index_BCAST()

◆ _XMP_calc_global_index_HOMECOPY()

◆ _XMP_calc_gmove_array_owner_linear_rank_SCALAR()

◆ _XMP_calc_linear_rank()

◆ _XMP_calc_linear_rank_on_target_nodes()

◆ _XMP_calc_nodes_index_from_inherit_nodes_index()

◆ _XMP_calc_rank_array()

◆ _XMP_calc_template_owner_SCALAR()

◆ _XMP_calc_template_par_triplet()

◆ _XMP_calc_template_size()

◆ _XMP_check_gmove_array_ref_inclusion_SCALAR()

◆ _XMP_check_reflect_type()

◆ _XMP_check_template_ref_inclusion()

◆ _XMP_coarray_lastly_deallocate()

◆ _XMP_create_nodes_by_comm()

◆ _XMP_create_nodes_by_template_ref()

◆ _XMP_create_nodes_ref_for_target_nodes()

◆ _XMP_create_shadow_comm()

◆ _XMP_create_template_desc()

◆ _XMP_create_temporary_nodes()

◆ _XMP_dealloc_array()

◆ _XMP_dist_template_BLOCK()

◆ _XMP_dist_template_BLOCK_CYCLIC()

◆ _XMP_dist_template_CYCLIC()

◆ _XMP_dist_template_DUPLICATION()

◆ _XMP_dist_template_GBLOCK()

◆ _XMP_fatal()

◆ _XMP_fatal_nomsg()

◆ _XMP_finalize()

◆ _XMP_finalize_array_desc()

◆ _XMP_finalize_comm()

◆ _XMP_finalize_nodes()

◆ _XMP_finalize_nodes_ref()

◆ _XMP_finalize_onesided_functions()

◆ _XMP_finalize_reflect_sched()

◆ _XMP_finalize_template()

◆ _XMP_finalize_world()

◆ _XMP_free()

◆ _XMP_G2L()

◆ _XMP_get_current_async()