libxmp/libxmpf in Omni Compiler  1.3.4
xmp_coarray_mpi.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include "xmp_internal.h"
#include <signal.h>
#include <string.h>
Include dependency graph for xmp_coarray_mpi.c:

Data Structures

struct  _shift_queue_t
 

Macros

#define _SYNCIMAGE_SENDRECV
 
#define _is_put_blocking   (! _XMP_flag_put_nb)
 
#define _is_put_local_blocking   (! _XMP_flag_put_nb)
 
#define _is_get_blocking   (! _XMP_flag_get_nb)
 

Functions

MPI_Win _XMP_mpi_coarray_get_window (const _XMP_coarray_t *desc, bool is_acc)
 
char * _XMP_mpi_coarray_get_remote_addr (const _XMP_coarray_t *desc, const int target_rank, const bool is_acc)
 
char * _XMP_mpi_coarray_get_local_addr (const _XMP_coarray_t *desc, const bool is_acc)
 
void _XMP_mpi_build_shift_queue (bool is_acc)
 Set initial value to the shift queue. More...
 
void _XMP_mpi_destroy_shift_queue (bool is_acc)
 Destroy shift queue. More...
 
void _XMP_mpi_coarray_lastly_deallocate (bool is_acc)
 Deallocate memory region when calling _XMP_coarray_lastly_deallocate() More...
 
void _XMP_mpi_coarray_deallocate (_XMP_coarray_t *c, bool is_acc)
 
void _XMP_mpi_coarray_malloc (_XMP_coarray_t *coarray_desc, void **addr, const size_t coarray_size, bool is_acc)
 
void _XMP_mpi_contiguous_put (const int org_target_rank, const _XMP_coarray_t *dst_desc, const _XMP_coarray_t *src_desc, const size_t dst_offset, const size_t src_offset, const size_t dst_elmts, const size_t src_elmts, const size_t elmt_size, const bool is_dst_on_acc, const bool is_src_on_acc)
 
void _XMP_mpi_contiguous_get (const int org_target_rank, const _XMP_coarray_t *dst_desc, const _XMP_coarray_t *src_desc, const size_t dst_offset, const size_t src_offset, const size_t dst_elmts, const size_t src_elmts, const size_t elmt_size, const bool is_dst_on_acc, const bool is_src_on_acc)
 
void _XMP_mpi_put (const int dst_contiguous, const int src_contiguous, const int org_target_rank, const int dst_dims, const int src_dims, const _XMP_array_section_t *dst_info, const _XMP_array_section_t *src_info, const _XMP_coarray_t *dst_desc, const void *src, const int dst_elmts, const int src_elmts, const int is_dst_on_acc)
 
void _XMP_mpi_get (const int src_contiguous, const int dst_contiguous, const int org_target_rank, const int src_dims, const int dst_dims, const _XMP_array_section_t *src_info, const _XMP_array_section_t *dst_info, const _XMP_coarray_t *src_desc, void *dst, const int src_elmts, const int dst_elmts, const int is_src_on_acc)
 
void _XMP_mpi_sync_memory ()
 Execute sync_memory. More...
 
void _XMP_mpi_sync_all ()
 Execute sync_all. More...
 
void _XMP_mpi_coarray_attach (_XMP_coarray_t *coarray_desc, void *addr, const size_t coarray_size, const bool is_acc)
 
void _XMP_mpi_coarray_detach (_XMP_coarray_t *coarray_desc, const bool is_acc)
 
void _XMP_mpi_build_sync_images_table ()
 Build table and Initialize for sync images. More...
 
void _XMP_mpi_sync_images (const int num, const int *image_set, int *status)
 Execute sync images. More...
 
void _XMP_sync_images_EXEC (int *status)
 
void _XMP_sync_images_COMM (MPI_Comm *comm, int *status)
 
void _XMP_mpi_coarray_regmem (_XMP_coarray_t *coarray_desc, void *real_addr, const size_t coarray_size, bool is_acc)
 
void _XMP_mpi_coarray_deregmem (_XMP_coarray_t *c)
 

Variables

int _XMP_flag_put_nb
 These variables are temporral. More...
 
int _XMP_flag_get_nb
 
int _XMP_flag_multi_win
 

Macro Definition Documentation

◆ _is_get_blocking

#define _is_get_blocking   (! _XMP_flag_get_nb)

◆ _is_put_blocking

#define _is_put_blocking   (! _XMP_flag_put_nb)

◆ _is_put_local_blocking

#define _is_put_local_blocking   (! _XMP_flag_put_nb)

◆ _SYNCIMAGE_SENDRECV

#define _SYNCIMAGE_SENDRECV

Function Documentation

◆ _XMP_mpi_build_shift_queue()

void _XMP_mpi_build_shift_queue ( bool  is_acc)

Set initial value to the shift queue.

154 {
155  struct _shift_queue_t *shift_queue = is_acc? &_shift_queue_acc : &_shift_queue;
156 
157  shift_queue->max_size = _XMP_MPI_ONESIDED_COARRAY_SHIFT_QUEUE_INITIAL_SIZE;
158  shift_queue->num = 0;
159  shift_queue->shifts = malloc(sizeof(size_t) * shift_queue->max_size);
160  shift_queue->total_shift = 0;
161 }
Here is the caller graph for this function:

◆ _XMP_mpi_build_sync_images_table()

void _XMP_mpi_build_sync_images_table ( )

Build table and Initialize for sync images.

952 {
953  size_t table_size = sizeof(unsigned int) * _XMP_world_size;
954 #ifdef _SYNCIMAGE_SENDRECV
955  _sync_images_table = _XMP_alloc(table_size);
956 #else
957  struct _shift_queue_t *shift_queue = &_shift_queue;
958  _sync_images_table = (unsigned int*)(_xmp_mpi_onesided_buf + shift_queue->total_shift);
959  _sync_images_table_disp = (unsigned int*)(shift_queue->total_shift);
960 
961  size_t shift;
962  if(table_size % _XMP_MPI_ALIGNMENT == 0)
963  shift = table_size;
964  else{
965  shift = ((table_size / _XMP_MPI_ALIGNMENT) + 1) * _XMP_MPI_ALIGNMENT;
966  }
967  _push_shift_queue(shift_queue, shift);
968 #endif
969 
970  for(int i=0;i<_XMP_world_size;i++)
971  _sync_images_table[i] = 0;
972 
973  MPI_Barrier(MPI_COMM_WORLD);
974 }
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_attach()

void _XMP_mpi_coarray_attach ( _XMP_coarray_t coarray_desc,
void *  addr,
const size_t  coarray_size,
const bool  is_acc 
)
865 {
866  MPI_Win win = MPI_WIN_NULL;
867  char **each_addr = NULL; // head address of a local array on each node
868 
870  int comm_size = nodes->comm_size;
871  MPI_Comm comm = *(MPI_Comm *)nodes->comm;
872 
873  XACC_DEBUG("attach addr=%p, size=%zd, is_acc=%d", addr, coarray_size, is_acc);
874 
876  _XMP_mpi_onesided_create_win(&win, addr, coarray_size, comm);
877  MPI_Win_lock_all(MPI_MODE_NOCHECK, win);
878  }else{
880 #ifdef _XMP_XACC
881  if(is_acc){
883  }
884 #endif
885  MPI_Win_attach(win, addr, coarray_size);
886 
887  each_addr = (char**)_XMP_alloc(sizeof(char *) * comm_size);
888 
889  MPI_Allgather(&addr, sizeof(char *), MPI_BYTE,
890  each_addr, sizeof(char *), MPI_BYTE,
891  comm); // exchange displacement
892  }
893 
894  if(is_acc){
895 #ifdef _XMP_XACC
896  coarray_desc->addr_dev = each_addr;
897  coarray_desc->real_addr_dev = addr;
898  coarray_desc->win_acc = win;
899  coarray_desc->nodes = nodes;
900 #endif
901  }else{
902  coarray_desc->addr = each_addr;
903  coarray_desc->real_addr = addr;
904  coarray_desc->win = win;
905  coarray_desc->win_acc = MPI_WIN_NULL;
906  coarray_desc->nodes = nodes;
907  }
908 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_deallocate()

void _XMP_mpi_coarray_deallocate ( _XMP_coarray_t c,
bool  is_acc 
)
223 {
225  MPI_Win_unlock_all(c->win);
227  _XMP_mpi_onesided_dealloc_win(&(c->win), (void **)&(c->real_addr), is_acc);
228  }
229 }
Here is the call graph for this function:

◆ _XMP_mpi_coarray_deregmem()

void _XMP_mpi_coarray_deregmem ( _XMP_coarray_t c)
1194 {
1195  if(! _XMP_flag_multi_win){
1196  _XMP_fatal("single window mode does not support coarray deregmem");
1197  }
1198 
1199  MPI_Win_unlock_all(c->win);
1201  _XMP_mpi_onesided_destroy_win(&(c->win));
1202 }
Here is the call graph for this function:

◆ _XMP_mpi_coarray_detach()

void _XMP_mpi_coarray_detach ( _XMP_coarray_t coarray_desc,
const bool  is_acc 
)
911 {
913  MPI_Win win = is_acc? coarray_desc->win_acc : coarray_desc->win;
914  MPI_Win_unlock_all(win);
917  }else{
918  MPI_Win win = _xmp_mpi_distarray_win;
919  void *real_addr = coarray_desc->real_addr;
920 #ifdef _XMP_XACC
921  if(is_acc){
923  real_addr = coarray_desc->real_addr_dev;
924  }
925 #endif
926 
927  MPI_Win_detach(win, real_addr);
928  }
929 
930  if(is_acc){
931 #ifdef _XMP_XACC
932  _XMP_free(coarray_desc->addr_dev); //FIXME may be wrong
933  coarray_desc->addr_dev = NULL;
934  coarray_desc->real_addr_dev = NULL;
935  coarray_desc->win_acc = MPI_WIN_NULL;
936  coarray_desc->nodes = NULL;
937 #endif
938  }else{
939  _XMP_free(coarray_desc->addr);
940  coarray_desc->addr = NULL;
941  coarray_desc->real_addr = NULL;
942  coarray_desc->win = MPI_WIN_NULL;
943  coarray_desc->nodes = NULL;
944  }
945 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_get_local_addr()

char* _XMP_mpi_coarray_get_local_addr ( const _XMP_coarray_t desc,
const bool  is_acc 
)
146 {
147  return get_local_addr(desc, is_acc);
148 }

◆ _XMP_mpi_coarray_get_remote_addr()

char* _XMP_mpi_coarray_get_remote_addr ( const _XMP_coarray_t desc,
const int  target_rank,
const bool  is_acc 
)
141 {
142  return get_remote_addr(desc, target_rank, is_acc);
143 }
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_get_window()

MPI_Win _XMP_mpi_coarray_get_window ( const _XMP_coarray_t desc,
bool  is_acc 
)
112 {
113  return get_window(desc, is_acc);
114 }
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_lastly_deallocate()

void _XMP_mpi_coarray_lastly_deallocate ( bool  is_acc)

Deallocate memory region when calling _XMP_coarray_lastly_deallocate()

216  {
217  struct _shift_queue_t *shift_queue = is_acc? &_shift_queue_acc : &_shift_queue;
218  _pop_shift_queue(shift_queue);
219 }
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_malloc()

void _XMP_mpi_coarray_malloc ( _XMP_coarray_t coarray_desc,
void **  addr,
const size_t  coarray_size,
bool  is_acc 
)
238 {
239  char **each_addr = NULL; // gap_size on each node
240  struct _shift_queue_t *shift_queue = is_acc? &_shift_queue_acc : &_shift_queue;
241  size_t shift;
242  char *real_addr = NULL;
243  MPI_Win win = MPI_WIN_NULL;
245  MPI_Comm comm = *(MPI_Comm *)nodes->comm;
246 
247  if(coarray_size == 0){
248  _XMP_fatal("_XMP_mpi_coarray_malloc: zero size is not allowed");
249  }
250 
252  _XMP_mpi_onesided_alloc_win(&win, (void**)&real_addr, coarray_size, comm, is_acc);
253  MPI_Win_lock_all(MPI_MODE_NOCHECK, win);
254 
255  XACC_DEBUG("addr=%p, size=%zd, is_acc=%d", real_addr, coarray_size, is_acc);
256  }else{
257  each_addr = (char**)_XMP_alloc(sizeof(char *) * _XMP_world_size);
258  for(int i=0;i<_XMP_world_size;i++){
259  each_addr[i] = (char *)(shift_queue->total_shift);
260  }
261  real_addr = _xmp_mpi_onesided_buf;
262 #ifdef _XMP_XACC
263  if(is_acc){
264  real_addr = _xmp_mpi_onesided_buf_acc;
265  }
266 #endif
267  real_addr += shift_queue->total_shift;
268 
269  XACC_DEBUG("malloc_do: addr=%p, shift=%zd, is_acc=%d", real_addr, shift_queue->total_shift, is_acc);
270 
271  if(coarray_size % _XMP_MPI_ALIGNMENT == 0)
272  shift = coarray_size;
273  else{
274  shift = ((coarray_size / _XMP_MPI_ALIGNMENT) + 1) * _XMP_MPI_ALIGNMENT;
275  }
276 
277  _push_shift_queue(shift_queue, shift);
278 
279  size_t total_shift = shift_queue->total_shift;
280 
282  fprintf(stderr, "_xmp_mpi_onesided_heap_size=%zd\n", _xmp_mpi_onesided_heap_size);
283  if(_XMP_world_rank == 0){
284  fprintf(stderr, "[ERROR] Cannot allocate coarray. Heap memory size of coarray is too small.\n");
285  fprintf(stderr, " Please set the environmental variable \"XMP_ONESIDED_HEAP_SIZE\".\n");
286  fprintf(stderr, " e.g.) export XMP_ONESIDED_HEAP_SIZE=%zuM (or more).\n",
287  (total_shift/1024/1024)+1);
288  }
290  }
291  }
292 
293  if(is_acc){
294 #ifdef _XMP_XACC
295  coarray_desc->addr_dev = each_addr;
296  coarray_desc->real_addr_dev = real_addr;
297  coarray_desc->win_acc = win;
298  coarray_desc->nodes = nodes;
299 #endif
300  }else{
301  coarray_desc->addr = each_addr;
302  coarray_desc->real_addr = real_addr;
303  coarray_desc->win = win;
304  coarray_desc->win_acc = MPI_WIN_NULL;
305  coarray_desc->nodes = nodes;
306  }
307  *addr = real_addr;
308 }
Here is the caller graph for this function:

◆ _XMP_mpi_coarray_regmem()

void _XMP_mpi_coarray_regmem ( _XMP_coarray_t coarray_desc,
void *  real_addr,
const size_t  coarray_size,
bool  is_acc 
)
1158 {
1159  char **each_addr = NULL;
1160  MPI_Win win = MPI_WIN_NULL;
1162  MPI_Comm comm = *(MPI_Comm *)nodes->comm;
1163 
1164  if(! _XMP_flag_multi_win){
1165  _XMP_fatal("single window mode does not support coarray regmem");
1166  }
1167 
1168  if(coarray_size == 0){
1169  _XMP_fatal("_XMP_mpi_coarray_regmem: zero size is not allowed");
1170  }
1171 
1172  _XMP_mpi_onesided_create_win(&win, real_addr, coarray_size, comm);
1173  MPI_Win_lock_all(MPI_MODE_NOCHECK, win);
1174 
1175  XACC_DEBUG("addr=%p, size=%zd, is_acc=%d", real_addr, coarray_size, is_acc);
1176 
1177  if(is_acc){
1178 #ifdef _XMP_XACC
1179  coarray_desc->addr_dev = each_addr;
1180  coarray_desc->real_addr_dev = real_addr;
1181  coarray_desc->win_acc = win;
1182  coarray_desc->nodes = nodes;
1183 #endif
1184  }else{
1185  coarray_desc->addr = each_addr;
1186  coarray_desc->real_addr = real_addr;
1187  coarray_desc->win = win;
1188  coarray_desc->win_acc = MPI_WIN_NULL;
1189  coarray_desc->nodes = nodes;
1190  }
1191 }
Here is the call graph for this function:

◆ _XMP_mpi_contiguous_get()

void _XMP_mpi_contiguous_get ( const int  org_target_rank,
const _XMP_coarray_t dst_desc,
const _XMP_coarray_t src_desc,
const size_t  dst_offset,
const size_t  src_offset,
const size_t  dst_elmts,
const size_t  src_elmts,
const size_t  elmt_size,
const bool  is_dst_on_acc,
const bool  is_src_on_acc 
)
380 {
381  const int target_rank = _XMP_mpi_trans_rank(src_desc, org_target_rank);
382 
383  size_t transfer_size = elmt_size * dst_elmts;
384  char *dst = get_local_addr(dst_desc, is_dst_on_acc);
385  if(dst_elmts == src_elmts){
386  _mpi_contiguous(_XMP_N_COARRAY_GET,
387  target_rank,
388  src_desc, dst,
389  src_offset, dst_offset,
390  transfer_size, is_src_on_acc);
391  }else if(src_elmts == 1){
392  _XMP_array_section_t dst_info;
393  dst_info.start = dst_offset / elmt_size;
394  dst_info.length = dst_elmts;
395  dst_info.stride = 1;
396  dst_info.elmts = dst_info.start + dst_info.length;
397  dst_info.distance = elmt_size;
398  _mpi_scalar_mget(target_rank,
399  dst, src_desc,
400  dst_offset, src_offset,
401  1 /*dst_dims*/,
402  &dst_info,
403  is_src_on_acc);
404  }else{
405  _XMP_fatal("Coarray Error ! transfer size is wrong.\n");
406  }
407 }
Here is the caller graph for this function:

◆ _XMP_mpi_contiguous_put()

void _XMP_mpi_contiguous_put ( const int  org_target_rank,
const _XMP_coarray_t dst_desc,
const _XMP_coarray_t src_desc,
const size_t  dst_offset,
const size_t  src_offset,
const size_t  dst_elmts,
const size_t  src_elmts,
const size_t  elmt_size,
const bool  is_dst_on_acc,
const bool  is_src_on_acc 
)
330 {
331  const int target_rank = _XMP_mpi_trans_rank(dst_desc, org_target_rank);
332 
333  size_t transfer_size = elmt_size * dst_elmts;
334  char *src = get_local_addr(src_desc, is_src_on_acc);
335  if(dst_elmts == src_elmts){
336  _mpi_contiguous(_XMP_N_COARRAY_PUT,
337  target_rank,
338  dst_desc, src,
339  dst_offset, src_offset,
340  transfer_size, is_dst_on_acc);
341  }else if(src_elmts == 1){
342  _XMP_array_section_t dst_info;
343  dst_info.start = dst_offset / elmt_size;
344  dst_info.length = dst_elmts;
345  dst_info.stride = 1;
346  dst_info.elmts = dst_info.start + dst_info.length;
347  dst_info.distance = elmt_size;
348 
349  _mpi_scalar_mput(target_rank,
350  dst_desc, src,
351  dst_offset, src_offset,
352  1 /*dst_dims*/,
353  &dst_info,
354  is_dst_on_acc);
355  }else{
356  _XMP_fatal("Coarray Error ! transfer size is wrong.\n");
357  }
358 }
Here is the caller graph for this function:

◆ _XMP_mpi_destroy_shift_queue()

void _XMP_mpi_destroy_shift_queue ( bool  is_acc)

Destroy shift queue.

167 {
168  struct _shift_queue_t *shift_queue = is_acc? &_shift_queue_acc : &_shift_queue;
169 
170  _XMP_free(shift_queue->shifts);
171  shift_queue->shifts = NULL;
172 }
Here is the caller graph for this function:

◆ _XMP_mpi_get()

void _XMP_mpi_get ( const int  src_contiguous,
const int  dst_contiguous,
const int  org_target_rank,
const int  src_dims,
const int  dst_dims,
const _XMP_array_section_t src_info,
const _XMP_array_section_t dst_info,
const _XMP_coarray_t src_desc,
void *  dst,
const int  src_elmts,
const int  dst_elmts,
const int  is_src_on_acc 
)
488 {
489  size_t dst_offset = _XMP_get_offset(dst_info, dst_dims);
490  size_t src_offset = _XMP_get_offset(src_info, src_dims);
491  size_t transfer_size = src_desc->elmt_size * src_elmts;
492 
493  const int target_rank = _XMP_mpi_trans_rank(src_desc, org_target_rank);
494 
495  XACC_DEBUG("_XMP_mpi_get, dst_elmts = %d, src_elmts = %d\n", src_elmts, dst_elmts);
496 
497  if(src_elmts == dst_elmts){
498  if(src_contiguous == _XMP_N_INT_TRUE && dst_contiguous == _XMP_N_INT_TRUE){
499  _mpi_contiguous(_XMP_N_COARRAY_GET,
500  target_rank,
501  src_desc, dst,
502  src_offset, dst_offset,
503  transfer_size, is_src_on_acc);
504  }else{
505  _mpi_non_contiguous(_XMP_N_COARRAY_GET, target_rank,
506  src_desc, dst,
507  src_offset, dst_offset,
508  src_dims, dst_dims,
509  src_info, dst_info,
510  src_elmts, is_src_on_acc);
511  }
512  }else if(src_elmts == 1){
513  _mpi_scalar_mget(target_rank,
514  dst, src_desc,
515  dst_offset, src_offset,
516  dst_dims,
517  dst_info,
518  is_src_on_acc);
519  }else{
520  _XMP_fatal("Number of elements is invalid");
521  }
522 }
Here is the call graph for this function:

◆ _XMP_mpi_put()

void _XMP_mpi_put ( const int  dst_contiguous,
const int  src_contiguous,
const int  org_target_rank,
const int  dst_dims,
const int  src_dims,
const _XMP_array_section_t dst_info,
const _XMP_array_section_t src_info,
const _XMP_coarray_t dst_desc,
const void *  src,
const int  dst_elmts,
const int  src_elmts,
const int  is_dst_on_acc 
)
429 {
430  size_t dst_offset = _XMP_get_offset(dst_info, dst_dims);
431  size_t src_offset = _XMP_get_offset(src_info, src_dims);
432  size_t transfer_size = dst_desc->elmt_size * dst_elmts;
433 
434  const int target_rank = _XMP_mpi_trans_rank(dst_desc, org_target_rank);
435 
436  if(dst_elmts == src_elmts){
437  if(dst_contiguous == _XMP_N_INT_TRUE && src_contiguous == _XMP_N_INT_TRUE){
438  _mpi_contiguous(_XMP_N_COARRAY_PUT,
439  target_rank,
440  dst_desc, src,
441  dst_offset, src_offset,
442  transfer_size, is_dst_on_acc);
443  }
444  else{
445  _mpi_non_contiguous(_XMP_N_COARRAY_PUT, target_rank,
446  dst_desc, src,
447  dst_offset, src_offset,
448  dst_dims, src_dims,
449  dst_info, src_info,
450  dst_elmts, is_dst_on_acc);
451  }
452  }
453  else{
454  if(src_elmts == 1){
455  _mpi_scalar_mput(target_rank,
456  dst_desc, src,
457  dst_offset, src_offset,
458  dst_dims,
459  dst_info,
460  is_dst_on_acc);
461  }
462  else{
463  _XMP_fatal("Number of elements is invalid");
464  }
465  }
466 }
Here is the call graph for this function:

◆ _XMP_mpi_sync_all()

void _XMP_mpi_sync_all ( )

Execute sync_all.

604 {
608 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ _XMP_mpi_sync_images()

void _XMP_mpi_sync_images ( const int  num,
const int *  image_set,
int *  status 
)

Execute sync images.

Parameters
[in]numnumber of nodes
[in]*image_setimage set
[out]statusstatus
1081 {
1083 
1084  if(num == 0){
1085  return;
1086  }
1087  else if(num < 0){
1088  fprintf(stderr, "Invalid value is used in xmp_sync_memory. The first argument is %d\n", num);
1089  _XMP_fatal_nomsg();
1090  }
1091 
1092  _notify_sync_images(num, image_set);
1093  _wait_sync_images(num, image_set);
1094 
1096 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ _XMP_mpi_sync_memory()

void _XMP_mpi_sync_memory ( )

Execute sync_memory.

543 {
545  int num = 0;
547  for(int i = 0; i < num; i++){
548  MPI_Win win = coarrays[i]->win;
549  if(win != MPI_WIN_NULL){
550  XACC_DEBUG("flush_all for host a coarray (%ld)", (long)win);
551  MPI_Win_flush_all(win);
552  XACC_DEBUG("sync for host a coarray (%ld)", (long)win);
553  MPI_Win_sync(win);
554  }
555 #ifdef _XMP_XACC
556  MPI_Win win_acc = coarrays[i]->win_acc;
557  if(win_acc != MPI_WIN_NULL){
558  XACC_DEBUG("flush_all for acc a coarray (%ld)", (long)win_acc);
559  MPI_Win_flush_all(win_acc);
560  XACC_DEBUG("sync for acc a coarray (%ld)", (long)win_acc);
561  MPI_Win_sync(win_acc);
562  }
563 #endif
564  }
565  }else{
566  if(! _is_coarray_win_flushed){
567  XACC_DEBUG("flush_all for host single coarray(%ld)", (long)_xmp_mpi_onesided_win);
568  MPI_Win_flush_all(_xmp_mpi_onesided_win);
569 
570  _is_coarray_win_flushed = true;
571  }
572 
573  if(! _is_distarray_win_flushed){
574  XACC_DEBUG("flush_all for host single distarray(%ld)", (long)_xmp_mpi_distarray_win);
575  MPI_Win_flush_all(_xmp_mpi_distarray_win);
576 
577  _is_distarray_win_flushed = true;
578  }
579 
580 #ifdef _XMP_XACC
581  if(! _is_coarray_win_acc_flushed){
582  XACC_DEBUG("flush_all for acc single coarray(%ld)", (long)_xmp_mpi_onesided_win_acc);
583  MPI_Win_flush_all(_xmp_mpi_onesided_win_acc);
584 
585  _is_coarray_win_acc_flushed = true;
586  }
587 
588  if(! _is_distarray_win_acc_flushed){
589  XACC_DEBUG("flush_all for acc single distarray(%ld)", (long)_xmp_mpi_distarray_win_acc);
590  MPI_Win_flush_all(_xmp_mpi_distarray_win_acc);
591 
592  _is_distarray_win_acc_flushed = true;
593  }
594 #endif
595 
596  _win_sync();
597  }
598 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ _XMP_sync_images_COMM()

void _XMP_sync_images_COMM ( MPI_Comm *  comm,
int *  status 
)
1106 {
1108  MPI_Barrier(*comm);
1109 }

◆ _XMP_sync_images_EXEC()

void _XMP_sync_images_EXEC ( int *  status)
1100 {
1103 }
Here is the call graph for this function:

Variable Documentation

◆ _XMP_flag_get_nb

int _XMP_flag_get_nb

◆ _XMP_flag_multi_win

int _XMP_flag_multi_win

◆ _XMP_flag_put_nb

int _XMP_flag_put_nb

These variables are temporral.

_XMP_mpi_onesided_destroy_win
void _XMP_mpi_onesided_destroy_win(MPI_Win *win)
Definition: xmp_onesided_mpi.c:124
_xmp_mpi_onesided_win
MPI_Win _xmp_mpi_onesided_win
Definition: xmp_onesided_mpi.c:12
_XMP_barrier_EXEC
void _XMP_barrier_EXEC(void)
Definition: xmp_barrier.c:16
_XMP_fatal_nomsg
void _XMP_fatal_nomsg()
Definition: xmp_util.c:48
_XMP_nodes_type::comm_size
int comm_size
Definition: xmp_data_struct.h:48
_xmp_mpi_onesided_win_acc
MPI_Win _xmp_mpi_onesided_win_acc
Definition: xmp_onesided_mpi.c:17
xmp_coarray::addr
char ** addr
Definition: xmp_data_struct.h:329
_xmp_mpi_distarray_win_acc
MPI_Win _xmp_mpi_distarray_win_acc
Definition: xmp_onesided_mpi.c:18
_XMP_alloc
void * _XMP_alloc(size_t size)
Definition: xmp_util.c:21
_XMP_array_section::length
long length
Definition: xmp_data_struct.h:377
_xmp_mpi_onesided_buf_acc
char * _xmp_mpi_onesided_buf_acc
Definition: xmp_onesided_mpi.c:16
xmp_coarray::real_addr
char * real_addr
Definition: xmp_data_struct.h:336
_XMP_world_size
int _XMP_world_size
Definition: xmp_world.c:8
_XMP_mpi_onesided_create_win
void _XMP_mpi_onesided_create_win(MPI_Win *win, void *addr, size_t size, MPI_Comm comm)
Definition: xmp_onesided_mpi.c:89
xmp_coarray::elmt_size
size_t elmt_size
Definition: xmp_data_struct.h:339
_shift_queue_t::shifts
size_t * shifts
shifts array
Definition: xmp_coarray_gasnet.c:11
_XMP_mpi_sync_memory
void _XMP_mpi_sync_memory()
Execute sync_memory.
Definition: xmp_coarray_mpi.c:542
_shift_queue_t::num
int num
How many shifts are in this queue.
Definition: xmp_coarray_gasnet.c:10
_XMP_flag_multi_win
int _XMP_flag_multi_win
Definition: xmp_onesided_mpi.c:23
_XMP_world_rank
int _XMP_world_rank
Definition: xmp_world.c:9
_shift_queue_t
Definition: xmp_coarray_gasnet.c:8
_shift_queue_t::max_size
size_t max_size
Max size of queue.
Definition: xmp_coarray_gasnet.c:9
_XMP_coarray_get_list
_XMP_coarray_t ** _XMP_coarray_get_list(int *num)
Definition: xmp_coarray.c:1774
_shift_queue_t::total_shift
size_t total_shift
all amount of shifts
Definition: xmp_coarray_mpi.c:14
_XMP_array_section::start
long start
Definition: xmp_data_struct.h:376
_xmp_mpi_onesided_buf
char * _xmp_mpi_onesided_buf
Definition: xmp_onesided_mpi.c:11
_XMP_mpi_onesided_dealloc_win
void _XMP_mpi_onesided_dealloc_win(MPI_Win *win, void **addr, bool is_acc)
Definition: xmp_onesided_mpi.c:129
_XMP_N_COARRAY_PUT
#define _XMP_N_COARRAY_PUT
Definition: xmp_constant.h:112
_xmp_mpi_onesided_heap_size
size_t _xmp_mpi_onesided_heap_size
Definition: xmp_onesided_mpi.c:10
_XMP_get_offset
size_t _XMP_get_offset(const _XMP_array_section_t *array_info, const int dims)
Definition: xmp_coarray_utils.c:22
xmp_coarray
Definition: xmp_data_struct.h:328
_XMP_free
void _XMP_free(void *p)
Definition: xmp_util.c:37
XACC_DEBUG
#define XACC_DEBUG(...)
Definition: xmp_internal.h:768
_xmp_mpi_distarray_win
MPI_Win _xmp_mpi_distarray_win
Definition: xmp_onesided_mpi.c:13
_XMP_nodes_type::comm
_XMP_comm_t * comm
Definition: xmp_data_struct.h:53
_XMP_fatal
void _XMP_fatal(char *msg)
Definition: xmp_util.c:42
_XMP_array_section::stride
long stride
Definition: xmp_data_struct.h:378
_XMP_N_COARRAY_GET
#define _XMP_N_COARRAY_GET
Definition: xmp_constant.h:111
_XMP_array_section::distance
long distance
Definition: xmp_data_struct.h:380
_XMP_array_section
Definition: xmp_data_struct.h:375
_XMP_nodes_type
Definition: xmp_data_struct.h:40
_XMP_mpi_onesided_alloc_win
void _XMP_mpi_onesided_alloc_win(MPI_Win *win, void **addr, size_t size, MPI_Comm comm, bool is_acc)
Definition: xmp_onesided_mpi.c:99
_XMP_array_section::elmts
long elmts
Definition: xmp_data_struct.h:379
_XMP_N_INT_TRUE
#define _XMP_N_INT_TRUE
Definition: xmp_constant.h:4
_XMP_get_execution_nodes
void * _XMP_get_execution_nodes(void)
Definition: xmp_nodes_stack.c:46