int main(int argc, char **argv){
MPI_Init(&argc, &argv);
int rank, nproc;
MPI_Comm_size(MPI_COMM_WORLD, &(nproc));
MPI_Comm_rank(MPI_COMM_WORLD, &(rank));
MPI_Win win;
MPI_Aint remote;
MPI_Aint local;
MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &win);
if(rank==0){
//int *a = (int*)malloc(sizeof(int));
int a= 4;
MPI_Win_attach(win, &a, sizeof(int));
MPI_Get_address(&a, &local);
MPI_Send(&local, 1, MPI_AINT, 1, 1, MPI_COMM_WORLD);
}
else{
//MPI_Status reqstat;
//MPI_Recv(&sdisp_remote, 1, MPI_AINT, 0, 1, MPI_COMM_WORLD, &reqstat );
int val;
MPI_Status reqstat;
MPI_Recv(&remote, 1, MPI_AINT, 0, 1, MPI_COMM_WORLD, &reqstat );
MPI_Get(&val, 1, MPI_INT, 0, remote, 1, MPI_INT, win);
}
//MPI_Win_free(&win);
}
void allocate_memory(int rank, char *rbuf, int size, WINDOW type, MPI_Win *win)
{
MPI_Status reqstat;
switch (type){
case WIN_DYNAMIC:
MPI_CHECK(MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, win));
MPI_CHECK(MPI_Win_attach(*win, (void *)rbuf, size));
MPI_CHECK(MPI_Get_address(rbuf, &sdisp_local));
if(rank == 0){
MPI_CHECK(MPI_Send(&sdisp_local, 1, MPI_AINT, 1, 1, MPI_COMM_WORLD));
MPI_CHECK(MPI_Recv(&sdisp_remote, 1, MPI_AINT, 1, 1, MPI_COMM_WORLD, &reqstat));
}
else{
MPI_CHECK(MPI_Recv(&sdisp_remote, 1, MPI_AINT, 0, 1, MPI_COMM_WORLD, &reqstat));
MPI_CHECK(MPI_Send(&sdisp_local, 1, MPI_AINT, 0, 1, MPI_COMM_WORLD));
}
break;
case WIN_CREATE:
MPI_CHECK(MPI_Win_create(rbuf, size, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win));
break;
default:
MPI_CHECK(MPI_Win_allocate(size, 1, MPI_INFO_NULL, MPI_COMM_WORLD, rbuf, win));
break;
}
}
JNIEXPORT void JNICALL Java_mpi_Win_attach(
JNIEnv *env, jobject jthis, jlong win, jobject jBase,
jint size)
{
void *base = (*env)->GetDirectBufferAddress(env, jBase);
int rc = MPI_Win_attach((MPI_Win)win, base, (MPI_Aint)size);
ompi_java_exceptionCheck(env, rc);
}
int main(int argc, char **argv)
{
int i, rank, nproc;
int errors = 0, all_errors = 0;
int val = 0, one = 1;
int iter;
MPI_Aint *val_ptrs;
MPI_Win dyn_win;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
iter = ITER_PER_RANK * nproc;
val_ptrs = malloc(nproc * sizeof(MPI_Aint));
MPI_Get_address(&val, &val_ptrs[rank]);
MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, val_ptrs, 1, MPI_AINT, MPI_COMM_WORLD);
MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &dyn_win);
MPI_Win_attach(dyn_win, &val, sizeof(int));
for (i = 0; i < iter; i++) {
MPI_Win_fence(MPI_MODE_NOPRECEDE, dyn_win);
MPI_Accumulate(&one, 1, MPI_INT, i % nproc, val_ptrs[i % nproc], 1, MPI_INT, MPI_SUM,
dyn_win);
MPI_Win_fence(MPI_MODE_NOSUCCEED, dyn_win);
}
MPI_Barrier(MPI_COMM_WORLD);
/* Read and verify my data */
if (val != iter) {
errors++;
printf("%d -- Got %d, expected %d\n", rank, val, iter);
}
MPI_Win_detach(dyn_win, &val);
MPI_Win_free(&dyn_win);
MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0 && all_errors == 0)
printf(" No Errors\n");
free(val_ptrs);
MPI_Finalize();
return 0;
}
void _XMP_mpi_coarray_attach(_XMP_coarray_t *coarray_desc, void *addr, const size_t coarray_size, const bool is_acc)
{
MPI_Win win = MPI_WIN_NULL;
char **each_addr = NULL; // head address of a local array on each node
_XMP_nodes_t *nodes = _XMP_get_execution_nodes();
int comm_size = nodes->comm_size;
MPI_Comm comm = *(MPI_Comm *)nodes->comm;
XACC_DEBUG("attach addr=%p, size=%zd, is_acc=%d", addr, coarray_size, is_acc);
if(_XMP_flag_multi_win){
_XMP_mpi_onesided_create_win(&win, addr, coarray_size, comm);
MPI_Win_lock_all(MPI_MODE_NOCHECK, win);
}else{
win = _xmp_mpi_distarray_win;
#ifdef _XMP_XACC
if(is_acc){
win = _xmp_mpi_distarray_win_acc;
}
#endif
MPI_Win_attach(win, addr, coarray_size);
each_addr = (char**)_XMP_alloc(sizeof(char *) * comm_size);
MPI_Allgather(&addr, sizeof(char *), MPI_BYTE,
each_addr, sizeof(char *), MPI_BYTE,
comm); // exchange displacement
}
if(is_acc){
#ifdef _XMP_XACC
coarray_desc->addr_dev = each_addr;
coarray_desc->real_addr_dev = addr;
coarray_desc->win_acc = win;
coarray_desc->nodes = nodes;
#endif
}else{
coarray_desc->addr = each_addr;
coarray_desc->real_addr = addr;
coarray_desc->win = win;
coarray_desc->win_acc = MPI_WIN_NULL;
coarray_desc->nodes = nodes;
}
}
/* Allocate a new shared linked list element */
MPI_Aint alloc_elem(int value, MPI_Win win) {
MPI_Aint disp;
llist_elem_t *elem_ptr;
/* Allocate the new element and register it with the window */
MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
elem_ptr->value = value;
elem_ptr->next = nil;
MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
/* Add the element to the list of local elements so we can free it later. */
if (my_elems_size == my_elems_count) {
my_elems_size += 100;
my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
}
my_elems[my_elems_count] = elem_ptr;
my_elems_count++;
MPI_Get_address(elem_ptr, &disp);
return disp;
}
void run_rma_test(int nprocs_per_node)
{
int myrank, nprocs;
int mem_rank;
MPI_Win win;
int *baseptr;
MPI_Aint local_size;
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (nprocs < nprocs_per_node * 2)
{
if (!myrank) printf("should start program with at least %d processes\n", nprocs_per_node * 2);
MPI_Finalize();
exit(EXIT_FAILURE);
}
mem_rank = nprocs_per_node + nprocs_per_node / 2;
local_size = (myrank == mem_rank) ? COUNT : 0;
MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &win);
MPI_Win_lock_all(0, win);
int type_size;
MPI_Type_size(MPI_INT, &type_size);
size_t nbytes = COUNT * type_size;
assert(MPI_Alloc_mem(nbytes, MPI_INFO_NULL, &baseptr) == MPI_SUCCESS);
assert(MPI_Win_attach(win, baseptr, nbytes) == MPI_SUCCESS);
MPI_Aint ldisp;
MPI_Aint *disps = malloc(nprocs * sizeof(MPI_Aint));
assert(MPI_Get_address(baseptr, &ldisp) == MPI_SUCCESS);
assert(MPI_Allgather(&ldisp, 1, MPI_AINT, disps, nprocs, MPI_AINT, MPI_COMM_WORLD) == MPI_SUCCESS);
if (myrank == 0)
{
for (size_t idx = 0; idx < COUNT; ++idx) {
baseptr[idx] = idx * COUNT + 1;
}
}
MPI_Barrier(MPI_COMM_WORLD);
if (myrank == mem_rank) {
assert(MPI_Get(baseptr, 10, MPI_INT, 0, disps[0], 10, MPI_INT, win) == MPI_SUCCESS);
assert(MPI_Win_flush(0, win) == MPI_SUCCESS);
for (size_t idx = 0; idx < COUNT; ++idx) {
assert(baseptr[idx] == idx * 10 + 1);
}
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Win_unlock_all(win);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Win_free(&win);
MPI_Free_mem(baseptr);
printf("Test finished\n");
}
int main(int argc, char **argv)
{
int rank, nproc;
int errs = 0;
int array[1024];
int val = 0;
int target_rank;
MPI_Aint bases[2];
MPI_Aint disp, offset;
MPI_Win win;
MTest_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (rank == 0 && nproc != 2) {
MTestError("Must run with 2 ranks\n");
}
/* Get the base address in the middle of the array */
if (rank == 0) {
target_rank = 1;
array[0] = 1234;
MPI_Get_address(&array[512], &bases[0]);
} else if (rank == 1) {
target_rank = 0;
array[1023] = 1234;
MPI_Get_address(&array[512], &bases[1]);
}
/* Exchange bases */
MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, bases, 1, MPI_AINT, MPI_COMM_WORLD);
MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &win);
MPI_Win_attach(win, array, sizeof(int)*1024);
/* Do MPI_Aint addressing arithmetic */
if (rank == 0) {
disp = sizeof(int)*511;
offset = MPIX_Aint_add(bases[1], disp); /* offset points to array[1023]*/
} else if (rank == 1) {
disp = sizeof(int)*512;
offset = MPIX_Aint_diff(bases[0], disp); /* offset points to array[0] */
}
/* Get val and verify it */
MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
MPI_Get(&val, 1, MPI_INT, target_rank, offset, 1, MPI_INT, win);
MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
if (val != 1234) {
errs++;
printf("%d -- Got %d, expected 1234\n", rank, val);
}
MPI_Win_detach(win, array);
MPI_Win_free(&win);
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}