int main(int argc, char **argv)
{
int my_rank, shared_rank;
void *mybase = NULL;
MPI_Win win;
MPI_Info win_info;
MPI_Comm shared_comm;
int i;
int shm_win_size = 1024 * 1024 * 1024 * sizeof(char); /* 1GB */
MTest_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
for (i = 0; i < 2; i++) {
if (i == 0) {
MPI_Info_create(&win_info);
MPI_Info_set(win_info, (char *) "alloc_shm", (char *) "true");
} else {
win_info = MPI_INFO_NULL;
}
MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, my_rank, MPI_INFO_NULL,
&shared_comm);
MPI_Comm_rank(shared_comm, &shared_rank);
/* every processes allocate 1GB window memory */
MPI_Win_allocate(shm_win_size, sizeof(char), win_info, MPI_COMM_WORLD, &mybase, &win);
MPI_Win_free(&win);
MPI_Win_allocate_shared(shm_win_size, sizeof(char), win_info, shared_comm, &mybase, &win);
MPI_Win_free(&win);
/* some processes allocate 1GB and some processes allocate zero bytes */
if (my_rank % 2 == 0)
MPI_Win_allocate(shm_win_size, sizeof(char), win_info, MPI_COMM_WORLD, &mybase, &win);
else
MPI_Win_allocate(0, sizeof(char), win_info, MPI_COMM_WORLD, &mybase, &win);
MPI_Win_free(&win);
if (shared_rank % 2 == 0)
MPI_Win_allocate_shared(shm_win_size, sizeof(char), win_info, shared_comm, &mybase,
&win);
else
MPI_Win_allocate_shared(0, sizeof(char), win_info, shared_comm, &mybase, &win);
MPI_Win_free(&win);
/* some processes allocate 1GB and some processes allocate smaller bytes */
if (my_rank % 2 == 0)
MPI_Win_allocate(shm_win_size, sizeof(char), win_info, MPI_COMM_WORLD, &mybase, &win);
else
MPI_Win_allocate(shm_win_size / 2, sizeof(char), win_info, MPI_COMM_WORLD, &mybase,
&win);
MPI_Win_free(&win);
/* some processes allocate 1GB and some processes allocate smaller bytes */
if (shared_rank % 2 == 0)
MPI_Win_allocate_shared(shm_win_size, sizeof(char), win_info, shared_comm, &mybase,
&win);
else
MPI_Win_allocate_shared(shm_win_size / 2, sizeof(char), win_info, shared_comm, &mybase,
&win);
MPI_Win_free(&win);
MPI_Comm_free(&shared_comm);
if (i == 0)
MPI_Info_free(&win_info);
}
MTest_Finalize(0);
return 0;
}
int main(int argc, char *argv[])
{
int i, errs;
int min_time = D_SLEEP_TIME, max_time = D_SLEEP_TIME, iter_time = 2, time;
MPI_Info win_info = MPI_INFO_NULL;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
debug_printf("[%d]init done, %d/%d\n", rank, rank, nprocs);
if (nprocs < 2) {
fprintf(stderr, "Please run using at least 2 processes\n");
goto exit;
}
#ifdef MTCORE
/* first argv is nh */
if (argc >= 5) {
min_time = atoi(argv[2]);
max_time = atoi(argv[3]);
iter_time = atoi(argv[4]);
}
if (argc >= 6) {
NOP = atoi(argv[5]);
}
#else
if (argc >= 4) {
min_time = atoi(argv[1]);
max_time = atoi(argv[2]);
iter_time = atoi(argv[3]);
}
if (argc >= 5) {
NOP = atoi(argv[4]);
}
#endif
locbuf = malloc(sizeof(double) * NOP);
for (i = 0; i < NOP; i++) {
locbuf[i] = 1.0;
}
MPI_Info_create(&win_info);
MPI_Info_set(win_info, (char *) "epoch_type", (char *) "fence");
// size in byte
MPI_Win_allocate(sizeof(double) * nprocs, sizeof(double), win_info,
MPI_COMM_WORLD, &winbuf, &win);
debug_printf("[%d]win_allocate done\n", rank);
for (time = min_time; time <= max_time; time *= iter_time) {
for (i = 0; i < nprocs; i++) {
winbuf[i] = 0.0;
}
MPI_Barrier(MPI_COMM_WORLD);
errs = run_test(time);
if (errs > 0)
break;
if (time == 0)
break;
}
exit:
if (win_info != MPI_INFO_NULL)
MPI_Info_free(&win_info);
if (win != MPI_WIN_NULL)
MPI_Win_free(&win);
if (locbuf)
free(locbuf);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int i, j, length, my_rank, left, right, size, test_value, mid;
double start, finish, transfer_time;
float snd_buf_left[max_length], snd_buf_right[max_length];
float *rcv_buf_left, *rcv_buf_right;
MPI_Win win_rcv_buf_left, win_rcv_buf_right;
/* Naming conventions */
/* Processes: */
/* my_rank-1 my_rank my_rank+1 */
/* "left neighbor" "myself" "right neighbor" */
/* ... rcv_buf_right <--- snd_buf_left snd_buf_right ---> rcv_buf_left ... */
/* ... snd_buf_right ---> rcv_buf_left rcv_buf_right <--- snd_buf_left ... */
/* | | */
/* halo-communication halo-communication */
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
right = (my_rank+1) % size;
left = (my_rank-1+size) % size;
MPI_Win_allocate((MPI_Aint)(max_length*sizeof(float)), sizeof(float), MPI_INFO_NULL, MPI_COMM_WORLD, &rcv_buf_left, &win_rcv_buf_left );
MPI_Win_allocate((MPI_Aint)(max_length*sizeof(float)), sizeof(float), MPI_INFO_NULL, MPI_COMM_WORLD, &rcv_buf_right, &win_rcv_buf_right);
if (my_rank == 0) printf(" message size transfertime duplex bandwidth per process and neighbor\n");
length = start_length;
for (j = 1; j <= number_package_sizes; j++)
{
for (i = 0; i <= number_of_messages; i++)
{
if(i==1) start = MPI_Wtime();
test_value = j*1000000 + i*10000 + my_rank*10 ; mid = (length-1)/number_of_messages*i;
snd_buf_left[0]=test_value+1 ; snd_buf_left[mid]=test_value+2 ; snd_buf_left[length-1]=test_value+3;
snd_buf_right[0]=test_value+6 ; snd_buf_right[mid]=test_value+7 ; snd_buf_right[length-1]=test_value+8;
MPI_Win_fence(MPI_MODE_NOSTORE + MPI_MODE_NOPRECEDE, win_rcv_buf_left );
MPI_Win_fence(MPI_MODE_NOSTORE + MPI_MODE_NOPRECEDE, win_rcv_buf_right);
MPI_Put(snd_buf_left, length, MPI_FLOAT, left, (MPI_Aint)0, length, MPI_FLOAT, win_rcv_buf_right);
MPI_Put(snd_buf_right, length, MPI_FLOAT, right, (MPI_Aint)0, length, MPI_FLOAT, win_rcv_buf_left );
MPI_Win_fence(MPI_MODE_NOSTORE + MPI_MODE_NOPUT + MPI_MODE_NOSUCCEED, win_rcv_buf_left );
MPI_Win_fence(MPI_MODE_NOSTORE + MPI_MODE_NOPUT + MPI_MODE_NOSUCCEED, win_rcv_buf_right);
/* ...snd_buf_... is used to store the values that were stored in snd_buf_... in the neighbor process */
test_value = j*1000000 + i*10000 + left*10 ; mid = (length-1)/number_of_messages*i;
snd_buf_right[0]=test_value+6 ; snd_buf_right[mid]=test_value+7 ; snd_buf_right[length-1]=test_value+8;
test_value = j*1000000 + i*10000 + right*10 ; mid = (length-1)/number_of_messages*i;
snd_buf_left[0]=test_value+1 ; snd_buf_left[mid]=test_value+2 ; snd_buf_left[length-1]=test_value+3;
if ((rcv_buf_left[0] != snd_buf_right[0]) || (rcv_buf_left[mid] != snd_buf_right[mid]) ||
(rcv_buf_left[length-1] != snd_buf_right[length-1])) {
printf("%d: j=%d, i=%d --> snd_buf_right[0,%d,%d]=(%f,%f,%f)\n",
my_rank, j, i, mid, length-1, snd_buf_right[0], snd_buf_right[mid], snd_buf_right[length-1]);
printf("%d: is not identical to rcv_buf_left[0,%d,%d]=(%f,%f,%f)\n",
my_rank, mid, length-1, rcv_buf_left[0], rcv_buf_left[mid], rcv_buf_left[length-1]);
}
if ((rcv_buf_right[0] != snd_buf_left[0]) || (rcv_buf_right[mid] != snd_buf_left[mid]) ||
(rcv_buf_right[length-1] != snd_buf_left[length-1])) {
printf("%d: j=%d, i=%d --> snd_buf_left[0,%d,%d]=(%f,%f,%f)\n",
my_rank, j, i, mid, length-1, snd_buf_left[0], snd_buf_left[mid], snd_buf_left[length-1]);
printf("%d: is not identical to rcv_buf_right[0,%d,%d]=(%f,%f,%f)\n",
my_rank, mid, length-1, rcv_buf_right[0], rcv_buf_right[mid], rcv_buf_right[length-1]);
}
}
finish = MPI_Wtime();
if (my_rank == 0)
{
transfer_time = (finish - start) / number_of_messages;
printf("%10i bytes %12.3f usec %13.3f MB/s\n",
length*(int)sizeof(float), transfer_time*1e6, 1.0e-6*2*length*sizeof(float) / transfer_time);
}
length = length * length_factor;
}
MPI_Win_free(&win_rcv_buf_left );
MPI_Win_free(&win_rcv_buf_right);
MPI_Finalize();
}
int main(int argc, char *argv[])
{
int rank, size, i, j, k;
int errors = 0;
int origin_shm, origin_am, dest;
int *orig_buf = NULL, *result_buf = NULL, *compare_buf = NULL,
*target_buf = NULL, *check_buf = NULL;
MPI_Win win;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (size != 3) {
/* run this test with three processes */
goto exit_test;
}
/* this works when MPIR_PARAM_CH3_ODD_EVEN_CLIQUES is set */
dest = 2;
origin_shm = 0;
origin_am = 1;
if (rank != dest) {
MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &orig_buf);
MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &result_buf);
MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &compare_buf);
}
MPI_Win_allocate(sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &target_buf, &win);
for (k = 0; k < LOOP_SIZE; k++) {
/* init buffers */
if (rank == origin_shm) {
orig_buf[0] = 1;
compare_buf[0] = 0;
result_buf[0] = 0;
}
else if (rank == origin_am) {
orig_buf[0] = 0;
compare_buf[0] = 1;
result_buf[0] = 0;
}
else {
MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
target_buf[0] = 0;
MPI_Win_unlock(rank, win);
}
MPI_Barrier(MPI_COMM_WORLD);
/* perform FOP */
MPI_Win_lock_all(0, win);
if (rank != dest) {
MPI_Compare_and_swap(orig_buf, compare_buf, result_buf, MPI_INT, dest, 0, win);
MPI_Win_flush(dest, win);
}
MPI_Win_unlock_all(win);
MPI_Barrier(MPI_COMM_WORLD);
/* check results */
if (rank != dest) {
MPI_Gather(result_buf, 1, MPI_INT, check_buf, 1, MPI_INT, dest, MPI_COMM_WORLD);
}
else {
MPI_Alloc_mem(sizeof(int) * 3, MPI_INFO_NULL, &check_buf);
MPI_Gather(target_buf, 1, MPI_INT, check_buf, 1, MPI_INT, dest, MPI_COMM_WORLD);
if (!(check_buf[dest] == 0 && check_buf[origin_shm] == 0 && check_buf[origin_am] == 1)
&& !(check_buf[dest] == 1 && check_buf[origin_shm] == 0 &&
check_buf[origin_am] == 0)) {
printf
("Wrong results: target result = %d, origin_shm result = %d, origin_am result = %d\n",
check_buf[dest], check_buf[origin_shm], check_buf[origin_am]);
printf
("Expected results (1): target result = 1, origin_shm result = 0, origin_am result = 0\n");
printf
("Expected results (2): target result = 0, origin_shm result = 0, origin_am result = 1\n");
errors++;
}
MPI_Free_mem(check_buf);
}
}
MPI_Win_free(&win);
if (rank == origin_am || rank == origin_shm) {
MPI_Free_mem(orig_buf);
MPI_Free_mem(result_buf);
MPI_Free_mem(compare_buf);
}
exit_test:
if (rank == dest && errors == 0)
printf(" No Errors\n");
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int rank, nproc;
MPI_Info info_in, info_out;
int errors = 0, all_errors = 0;
MPI_Win win;
void *base;
char invalid_key[] = "invalid_test_key";
char buf[MPI_MAX_INFO_VAL];
int flag;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
/* Test#1: setting a valid key at window-create time */
MPI_Info_create(&info_in);
MPI_Info_set(info_in, (char *)"no_locks", (char *)"true");
MPI_Win_allocate(sizeof(int), sizeof(int), info_in, MPI_COMM_WORLD, &base, &win);
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, (char *)"no_locks", MPI_MAX_INFO_VAL, buf, &flag);
if (!flag || strncmp(buf, "true", strlen("true")) != 0) {
if (!flag)
printf("%d: no_locks is not defined\n", rank);
else
printf("%d: no_locks = %s, expected true\n", rank, buf);
errors++;
}
MPI_Info_free(&info_in);
MPI_Info_free(&info_out);
/* We create a new window with no info argument for the next text to ensure that we have the
* default settings */
MPI_Win_free(&win);
MPI_Win_allocate(sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &base, &win);
/* Test#2: setting and getting invalid key */
MPI_Info_create(&info_in);
MPI_Info_set(info_in, invalid_key, (char *)"true");
MPI_Win_set_info(win, info_in);
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, invalid_key, MPI_MAX_INFO_VAL, buf, &flag);
#ifdef USE_STRICT_MPI
/* Check if our invalid key was ignored. Note, this check's MPICH's
* behavior, but this behavior may not be required for a standard
* conforming MPI implementation. */
if (flag) {
printf("%d: %s was not ignored\n", rank, invalid_key);
errors++;
}
#endif
MPI_Info_free(&info_in);
MPI_Info_free(&info_out);
/* Test#3: setting info key "no_lock" to false and getting the key */
MPI_Info_create(&info_in);
MPI_Info_set(info_in, (char *)"no_locks", (char *)"false");
MPI_Win_set_info(win, info_in);
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, (char *)"no_locks", MPI_MAX_INFO_VAL, buf, &flag);
if (!flag || strncmp(buf, "false", strlen("false")) != 0) {
if (!flag)
printf("%d: no_locks is not defined\n", rank);
else
printf("%d: no_locks = %s, expected false\n", rank, buf);
errors++;
}
if (flag && VERBOSE)
printf("%d: no_locks = %s\n", rank, buf);
MPI_Info_free(&info_in);
MPI_Info_free(&info_out);
/* Test#4: setting info key "no_lock" to true and getting the key */
MPI_Info_create(&info_in);
MPI_Info_set(info_in, (char *)"no_locks", (char *)"true");
MPI_Win_set_info(win, info_in);
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, (char *)"no_locks", MPI_MAX_INFO_VAL, buf, &flag);
if (!flag || strncmp(buf, "true", strlen("true")) != 0) {
if (!flag)
printf("%d: no_locks is not defined\n", rank);
else
printf("%d: no_locks = %s, expected true\n", rank, buf);
errors++;
}
if (flag && VERBOSE)
printf("%d: no_locks = %s\n", rank, buf);
MPI_Info_free(&info_in);
MPI_Info_free(&info_out);
/* Test#4: getting other info keys */
MPI_Win_get_info(win, &info_out);
MPI_Info_get(info_out, (char *)"accumulate_ordering", MPI_MAX_INFO_VAL, buf, &flag);
if (flag && VERBOSE)
printf("%d: accumulate_ordering = %s\n", rank, buf);
MPI_Info_get(info_out, (char *)"accumulate_ops", MPI_MAX_INFO_VAL, buf, &flag);
if (flag && VERBOSE)
printf("%d: accumulate_ops = %s\n", rank, buf);
MPI_Info_get(info_out, (char *)"same_size", MPI_MAX_INFO_VAL, buf, &flag);
if (flag && VERBOSE)
printf("%d: same_size = %s\n", rank, buf);
MPI_Info_get(info_out, (char *)"alloc_shm", MPI_MAX_INFO_VAL, buf, &flag);
if (flag && VERBOSE)
printf("%d: alloc_shm = %s\n", rank, buf);
MPI_Info_free(&info_out);
MPI_Win_free(&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");
MPI_Finalize();
return 0;
}
