/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
* (C) 2001 by Argonne National Laboratory.
* See COPYRIGHT in top-level directory.
*/
/*
Exercise communicator routines.
This C++ version derived from a Fortran test program from ....
*/
#include "mpi.h"
#include "mpitestconf.h"
#ifdef HAVE_IOSTREAM
// Not all C++ compilers have iostream instead of iostream.h
#include <iostream>
#ifdef HAVE_NAMESPACE_STD
// Those that do often need the std namespace; otherwise, a bare "cout"
// is likely to fail to compile
using namespace std;
#endif
#else
#include <iostream.h>
#endif
#include <stdio.h>
#include "mpitestcxx.h"
#ifdef HAVE_STRING_H
#include <string.h>
#endif
/* #define DEBUG */
int test_communicators(void);
int copy_fn(const MPI::Comm &, int, void *, void *, void *, bool &);
int delete_fn(MPI::Comm &, int, void *, void *);
int main(int argc, char **argv)
{
int errs = 0;
MTest_Init();
errs = test_communicators();
MTest_Finalize(errs);
return 0;
}
int copy_fn(const MPI::Comm & oldcomm, int keyval, void *extra_state,
void *attribute_val_in, void *attribute_val_out, bool & flag)
{
/* Note that if (sizeof(int) < sizeof(void *), just setting the int
* part of attribute_val_out may leave some dirty bits
*/
*(MPI::Aint *) attribute_val_out = (MPI::Aint) attribute_val_in;
flag = 1;
return MPI::SUCCESS;
}
int delete_fn(MPI::Comm & comm, int keyval, void *attribute_val, void *extra_state)
{
int world_rank;
world_rank = MPI::COMM_WORLD.Get_rank();
if ((MPI::Aint) attribute_val != (MPI::Aint) world_rank) {
cout << "incorrect attribute value " << *(int *) attribute_val << "\n";
MPI::COMM_WORLD.Abort(1005);
}
return MPI::SUCCESS;
}
int test_communicators(void)
{
MPI::Intracomm dup_comm_world, lo_comm, rev_comm, dup_comm, split_comm, world_comm;
MPI::Group world_group, lo_group, rev_group;
void *vvalue;
int ranges[1][3];
int flag, world_rank, world_size, rank, size, n, key_1, key_3;
int color, key, result;
int errs = 0;
MPI::Aint value;
world_rank = MPI::COMM_WORLD.Get_rank();
world_size = MPI::COMM_WORLD.Get_size();
#ifdef DEBUG
if (world_rank == 0) {
cout << "*** Communicators ***\n";
}
#endif
dup_comm_world = MPI::COMM_WORLD.Dup();
/*
* Exercise Comm_create by creating an equivalent to dup_comm_world
* (sans attributes) and a half-world communicator.
*/
#ifdef DEBUG
if (world_rank == 0) {
cout << " Comm_create\n";
}
#endif
world_group = dup_comm_world.Get_group();
world_comm = dup_comm_world.Create(world_group);
rank = world_comm.Get_rank();
if (rank != world_rank) {
errs++;
cout << "incorrect rank in world comm: " << rank << "\n";
MPI::COMM_WORLD.Abort(3001);
}
n = world_size / 2;
ranges[0][0] = 0;
ranges[0][1] = (world_size - n) - 1;
ranges[0][2] = 1;
#ifdef DEBUG
cout << "world rank = " << world_rank << " before range incl\n";
#endif
lo_group = world_group.Range_incl(1, ranges);
#ifdef DEBUG
cout << "world rank = " << world_rank << " after range incl\n";
#endif
lo_comm = world_comm.Create(lo_group);
#ifdef DEBUG
cout << "world rank = " << world_rank << " before group free\n";
#endif
lo_group.Free();
#ifdef DEBUG
cout << "world rank = " << world_rank << " after group free\n";
#endif
if (world_rank < (world_size - n)) {
rank = lo_comm.Get_rank();
if (rank == MPI::UNDEFINED) {
errs++;
cout << "incorrect lo group rank: " << rank << "\n";
MPI::COMM_WORLD.Abort(3002);
} else {
lo_comm.Barrier();
}
} else {
if (lo_comm != MPI::COMM_NULL) {
errs++;
cout << "incorrect lo comm:\n";
MPI::COMM_WORLD.Abort(3003);
}
}
#ifdef DEBUG
cout << "worldrank = " << world_rank << "\n";
#endif
world_comm.Barrier();
#ifdef DEBUG
cout << "bar!\n";
#endif
/*
* Check Comm_dup by adding attributes to lo_comm & duplicating
*/
#ifdef DEBUG
if (world_rank == 0) {
cout << " Comm_dup\n";
}
#endif
if (lo_comm != MPI::COMM_NULL) {
value = 9;
key_1 = MPI::Comm::Create_keyval(copy_fn, delete_fn, &value);
value = 8;
value = 7;
key_3 = MPI::Comm::Create_keyval(MPI::Comm::NULL_COPY_FN,
MPI::Comm::NULL_DELETE_FN, &value);
/* This may generate a compilation warning; it is, however, an
* easy way to cache a value instead of a pointer */
lo_comm.Set_attr(key_1, (void *) (MPI_Aint) world_rank);
lo_comm.Set_attr(key_3, (void *) 0);
dup_comm = lo_comm.Dup();
/* Note that if sizeof(int) < sizeof(void *), we can't use
* (void **)&value to get the value we passed into Attr_put. To avoid
* problems (e.g., alignment errors), we recover the value into
* a (void *) and cast to int. Note that this may generate warning
* messages from the compiler. */
flag = dup_comm.Get_attr(key_1, (void **) &vvalue);
value = (MPI::Aint) vvalue;
if (!flag) {
errs++;
cout << "dup_comm key_1 not found on " << world_rank << "\n";
MPI::COMM_WORLD.Abort(3004);
}
if (value != world_rank) {
errs++;
cout << "dup_comm key_1 value incorrect: " << (long) value << "\n";
MPI::COMM_WORLD.Abort(3005);
}
flag = dup_comm.Get_attr(key_3, (void **) &vvalue);
if (flag) {
errs++;
cout << "dup_comm key_3 found!\n";
MPI::COMM_WORLD.Abort(3008);
}
// Some C++ compilers (e.g., Solaris) refuse to
// accept a straight cast to an int.
// value = (MPI::Aint)vvalue;
MPI::Comm::Free_keyval(key_1);
MPI::Comm::Free_keyval(key_3);
}
/*
* Split the world into even & odd communicators with reversed ranks.
*/
#ifdef DEBUG
if (world_rank == 0) {
cout << " Comm_split\n";
}
#endif
color = world_rank % 2;
key = world_size - world_rank;
split_comm = dup_comm_world.Split(color, key);
size = split_comm.Get_size();
rank = split_comm.Get_rank();
if (rank != ((size - world_rank / 2) - 1)) {
errs++;
cout << "incorrect split rank: " << rank << "\n";
MPI::COMM_WORLD.Abort(3009);
}
split_comm.Barrier();
/*
* Test each possible Comm_compare result
*/
#ifdef DEBUG
if (world_rank == 0) {
cout << " Comm_compare\n";
}
#endif
result = MPI::Comm::Compare(world_comm, world_comm);
if (result != MPI::IDENT) {
errs++;
cout << "incorrect ident result: " << result << "\n";
MPI::COMM_WORLD.Abort(3010);
}
if (lo_comm != MPI::COMM_NULL) {
result = MPI::Comm::Compare(lo_comm, dup_comm);
if (result != MPI::CONGRUENT) {
errs++;
cout << "incorrect congruent result: " << result << "\n";
MPI::COMM_WORLD.Abort(3011);
}
}
ranges[0][0] = world_size - 1;
ranges[0][1] = 0;
ranges[0][2] = -1;
rev_group = world_group.Range_incl(1, ranges);
rev_comm = world_comm.Create(rev_group);
result = MPI::Comm::Compare(world_comm, rev_comm);
if (result != MPI::SIMILAR && world_size != 1) {
errs++;
cout << "incorrect similar result: " << result << "\n";
MPI::COMM_WORLD.Abort(3012);
}
if (lo_comm != MPI::COMM_NULL) {
result = MPI::Comm::Compare(world_comm, lo_comm);
if (result != MPI::UNEQUAL && world_size != 1) {
errs++;
cout << "incorrect unequal result: " << result << "\n";
MPI::COMM_WORLD.Abort(3013);
}
}
/*
* Free all communicators created
*/
#ifdef DEBUG
if (world_rank == 0)
cout << " Comm_free\n";
#endif
world_comm.Free();
dup_comm_world.Free();
rev_comm.Free();
split_comm.Free();
world_group.Free();
rev_group.Free();
if (lo_comm != MPI::COMM_NULL) {
lo_comm.Free();
dup_comm.Free();
}
return errs;
}