* that return value as well.
*
*/
-static int interCommIdx = 0;
-static int intraCommIdx = 0;
-static const char *intraCommName = 0;
-static const char *interCommName = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(interCommIdx, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(intraCommIdx, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(intraCommName, const char *, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(interCommName, const char *, 0);
/*
* Get an intracommunicator with at least min_size members. If "allowSmaller"
* MPI_COMM_NULL is always considered large enough */
while (!done) {
isBasic = 0;
- intraCommName = "";
- switch (intraCommIdx) {
+ SMPI_VARGET_GLOBAL(intraCommName) = "";
+ switch (SMPI_VARGET_GLOBAL(intraCommIdx)) {
case 0:
*comm = MPI_COMM_WORLD;
isBasic = 1;
- intraCommName = "MPI_COMM_WORLD";
+ SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_WORLD";
break;
case 1:
/* dup of world */
merr = MPI_Comm_dup(MPI_COMM_WORLD, comm);
if (merr)
MTestPrintError(merr);
- intraCommName = "Dup of MPI_COMM_WORLD";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Dup of MPI_COMM_WORLD";
break;
case 2:
/* reverse ranks */
merr = MPI_Comm_split(MPI_COMM_WORLD, 0, size - rank, comm);
if (merr)
MTestPrintError(merr);
- intraCommName = "Rank reverse of MPI_COMM_WORLD";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of MPI_COMM_WORLD";
break;
case 3:
/* subset of world, with reversed ranks */
size - rank, comm);
if (merr)
MTestPrintError(merr);
- intraCommName = "Rank reverse of half of MPI_COMM_WORLD";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of half of MPI_COMM_WORLD";
break;
case 4:
*comm = MPI_COMM_SELF;
isBasic = 1;
- intraCommName = "MPI_COMM_SELF";
+ SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_SELF";
break;
case 5:
{
MTestPrintError(merr);
MPI_Comm_free(&inter_comm);
MPI_Comm_free(&local_comm);
- intraCommName = "Dup of WORLD created by MPI_Intercomm_merge";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Dup of WORLD created by MPI_Intercomm_merge";
}
else {
*comm = MPI_COMM_NULL;
if (rank % 2 == 0) {
/* Even processes create a comm. for themselves */
MPI_Comm_create_group(MPI_COMM_WORLD, even_group, 0, comm);
- intraCommName = "Even of WORLD created by MPI_Comm_create_group";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Even of WORLD created by MPI_Comm_create_group";
}
else {
*comm = MPI_COMM_NULL;
MTestPrintError(merr);
MPI_Group_free(&world_group);
MPI_Group_free(&high_group);
- intraCommName = "High half of WORLD created by MPI_Comm_create";
+ SMPI_VARGET_GLOBAL(intraCommName) = "High half of WORLD created by MPI_Comm_create";
}
else {
*comm = MPI_COMM_NULL;
merr = MPI_Comm_size(MPI_COMM_WORLD, &size);
if (merr)
MTestPrintError(merr);
- newsize = size - (intraCommIdx - 7);
+ newsize = size - (SMPI_VARGET_GLOBAL(intraCommIdx) - 7);
if (allowSmaller && newsize >= min_size) {
merr = MPI_Comm_rank(MPI_COMM_WORLD, &rank);
*comm = MPI_COMM_NULL;
}
else {
- intraCommName = "Split of WORLD";
+ SMPI_VARGET_GLOBAL(intraCommName) = "Split of WORLD";
}
}
else {
/* Act like default */
*comm = MPI_COMM_NULL;
- intraCommIdx = -1;
+ SMPI_VARGET_GLOBAL(intraCommIdx) = -1;
}
}
break;
/* Other ideas: dup of self, cart comm, graph comm */
default:
*comm = MPI_COMM_NULL;
- intraCommIdx = -1;
+ SMPI_VARGET_GLOBAL(intraCommIdx) = -1;
break;
}
done = 1;
}
else {
- intraCommName = "MPI_COMM_NULL";
+ SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_NULL";
isBasic = 1;
done = 1;
}
/* Advance the comm index whether we are done or not, otherwise we could
* spin forever trying to allocate a too-small communicator over and
* over again. */
- intraCommIdx++;
+ SMPI_VARGET_GLOBAL(intraCommIdx)++;
if (!done && !isBasic && *comm != MPI_COMM_NULL) {
/* avoid leaking communicators */
}
}
- return intraCommIdx;
+ return SMPI_VARGET_GLOBAL(intraCommIdx);
}
/*
/* Return the name of an intra communicator */
const char *MTestGetIntracommName(void)
{
- return intraCommName;
+ return SMPI_VARGET_GLOBAL(intraCommName);
}
/*
while (!done) {
*comm = MPI_COMM_NULL;
*isLeftGroup = 0;
- interCommName = "MPI_COMM_NULL";
+ SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL";
- switch (interCommIdx) {
+ switch (SMPI_VARGET_GLOBAL(interCommIdx)) {
case 0:
/* Split comm world in half */
merr = MPI_Comm_rank(MPI_COMM_WORLD, &rank);
merr = MPI_Intercomm_create(mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm);
if (merr)
MTestPrintError(merr);
- interCommName = "Intercomm by splitting MPI_COMM_WORLD";
+ SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD";
}
else
*comm = MPI_COMM_NULL;
merr = MPI_Intercomm_create(mcomm, 0, MPI_COMM_WORLD, rleader, 12346, comm);
if (merr)
MTestPrintError(merr);
- interCommName = "Intercomm by splitting MPI_COMM_WORLD into 1, rest";
+ SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 1, rest";
}
else
*comm = MPI_COMM_NULL;
merr = MPI_Intercomm_create(mcomm, 0, MPI_COMM_WORLD, rleader, 12347, comm);
if (merr)
MTestPrintError(merr);
- interCommName = "Intercomm by splitting MPI_COMM_WORLD into 2, rest";
+ SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 2, rest";
}
else
*comm = MPI_COMM_NULL;
merr = MPI_Comm_dup(mcomm, comm);
if (merr)
MTestPrintError(merr);
- interCommName = "Intercomm by splitting MPI_COMM_WORLD then dup'ing";
+ SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then dup'ing";
}
else
*comm = MPI_COMM_NULL;
merr = MPI_Comm_split(mcomm, 0, rank, comm);
if (merr)
MTestPrintError(merr);
- interCommName = "Intercomm by splitting MPI_COMM_WORLD then then splitting again";
+ SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then then splitting again";
}
else
*comm = MPI_COMM_NULL;
if (merr)
MTestPrintError(merr);
}
- interCommName =
+ SMPI_VARGET_GLOBAL(interCommName) =
"Intercomm by splitting MPI_COMM_WORLD (discarding rank 0 in the left group) then MPI_Intercomm_create'ing";
}
else {
if (merr)
MTestPrintError(merr);
- interCommName =
+ SMPI_VARGET_GLOBAL(interCommName) =
"Intercomm by splitting MPI_COMM_WORLD then discarding 0 ranks with MPI_Comm_create";
}
else {
default:
*comm = MPI_COMM_NULL;
- interCommIdx = -1;
+ SMPI_VARGET_GLOBAL(interCommIdx) = -1;
break;
}
done = 1;
}
else {
- interCommName = "MPI_COMM_NULL";
+ SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL";
done = 1;
}
/* Advance the comm index whether we are done or not, otherwise we could
* spin forever trying to allocate a too-small communicator over and
* over again. */
- interCommIdx++;
+ SMPI_VARGET_GLOBAL(interCommIdx)++;
if (!done && *comm != MPI_COMM_NULL) {
/* avoid leaking communicators */
}
}
- return interCommIdx;
+ return SMPI_VARGET_GLOBAL(interCommIdx);
}
int MTestTestIntercomm(MPI_Comm comm)
{
int local_size, remote_size, rank, **bufs, *bufmem, rbuf[2], j;
- int errs = 0, wrank, nsize;
+ int errs = 0, wrank_loc, nsize;
char commname[MPI_MAX_OBJECT_NAME + 1];
MPI_Request *reqs;
- MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
+ MPI_Comm_rank(MPI_COMM_WORLD, &wrank_loc);
MPI_Comm_size(comm, &local_size);
MPI_Comm_remote_size(comm, &remote_size);
MPI_Comm_rank(comm, &rank);
reqs = (MPI_Request *) malloc(remote_size * sizeof(MPI_Request));
if (!reqs) {
printf("[%d] Unable to allocated %d requests for testing intercomm %s\n",
- wrank, remote_size, commname);
+ wrank_loc, remote_size, commname);
errs++;
return errs;
}
bufs = (int **) malloc(remote_size * sizeof(int *));
if (!bufs) {
printf("[%d] Unable to allocated %d int pointers for testing intercomm %s\n",
- wrank, remote_size, commname);
+ wrank_loc, remote_size, commname);
errs++;
return errs;
}
bufmem = (int *) malloc(remote_size * 2 * sizeof(int));
if (!bufmem) {
printf("[%d] Unable to allocated %d int data for testing intercomm %s\n",
- wrank, 2 * remote_size, commname);
+ wrank_loc, 2 * remote_size, commname);
errs++;
return errs;
}
for (j = 0; j < remote_size; j++) {
MPI_Recv(rbuf, 2, MPI_INT, j, 0, comm, MPI_STATUS_IGNORE);
if (rbuf[0] != j) {
- printf("[%d] Expected rank %d but saw %d in %s\n", wrank, j, rbuf[0], commname);
+ printf("[%d] Expected rank %d but saw %d in %s\n", wrank_loc, j, rbuf[0], commname);
errs++;
}
if (rbuf[1] != rank) {
printf("[%d] Expected target rank %d but saw %d from %d in %s\n",
- wrank, rank, rbuf[1], j, commname);
+ wrank_loc, rank, rbuf[1], j, commname);
errs++;
}
}
/* Return the name of an intercommunicator */
const char *MTestGetIntercommName(void)
{
- return interCommName;
+ return SMPI_VARGET_GLOBAL(interCommName);
}
/* Get a communicator of a given minimum size. Both intra and inter
/*
* Create MPI Windows
*/
-static int win_index = 0;
-static const char *winName;
+SMPI_VARINIT_GLOBAL_AND_SET(win_index, int, 0);
+SMPI_VARINIT_GLOBAL(winName, const char *);
/* Use an attribute to remember the type of memory allocation (static,
malloc, or MPI_Alloc_mem) */
-static int mem_keyval = MPI_KEYVAL_INVALID;
+SMPI_VARINIT_GLOBAL_AND_SET(mem_keyval, int, MPI_KEYVAL_INVALID);
int MTestGetWin(MPI_Win * win, int mustBePassive)
{
static char actbuf[1024];
int n, rank, merr;
MPI_Info info;
- if (mem_keyval == MPI_KEYVAL_INVALID) {
+ if (SMPI_VARGET_GLOBAL(mem_keyval) == MPI_KEYVAL_INVALID) {
/* Create the keyval */
- merr = MPI_Win_create_keyval(MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN, &mem_keyval, 0);
+ merr = MPI_Win_create_keyval(MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN, &SMPI_VARGET_GLOBAL(mem_keyval), 0);
if (merr)
MTestPrintError(merr);
}
- switch (win_index) {
+ switch (SMPI_VARGET_GLOBAL(win_index)) {
case 0:
/* Active target window */
merr = MPI_Win_create(actbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win);
if (merr)
MTestPrintError(merr);
- winName = "active-window";
- merr = MPI_Win_set_attr(*win, mem_keyval, (void *) 0);
+ SMPI_VARGET_GLOBAL(winName) = "active-window";
+ merr = MPI_Win_set_attr(*win, SMPI_VARGET_GLOBAL(mem_keyval), (void *) 0);
if (merr)
MTestPrintError(merr);
break;
merr = MPI_Win_create(pasbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win);
if (merr)
MTestPrintError(merr);
- winName = "passive-window";
- merr = MPI_Win_set_attr(*win, mem_keyval, (void *) 2);
+ SMPI_VARGET_GLOBAL(winName) = "passive-window";
+ merr = MPI_Win_set_attr(*win, SMPI_VARGET_GLOBAL(mem_keyval), (void *) 2);
if (merr)
MTestPrintError(merr);
break;
merr = MPI_Win_create(buf, n, 1, MPI_INFO_NULL, MPI_COMM_WORLD, win);
if (merr)
MTestPrintError(merr);
- winName = "active-all-different-win";
- merr = MPI_Win_set_attr(*win, mem_keyval, (void *) 1);
+ SMPI_VARGET_GLOBAL(winName) = "active-all-different-win";
+ merr = MPI_Win_set_attr(*win, SMPI_VARGET_GLOBAL(mem_keyval), (void *) 1);
if (merr)
MTestPrintError(merr);
break;
merr = MPI_Info_free(&info);
if (merr)
MTestPrintError(merr);
- winName = "active-nolocks-all-different-win";
- merr = MPI_Win_set_attr(*win, mem_keyval, (void *) 1);
+ SMPI_VARGET_GLOBAL(winName) = "active-nolocks-all-different-win";
+ merr = MPI_Win_set_attr(*win, SMPI_VARGET_GLOBAL(mem_keyval), (void *) 1);
if (merr)
MTestPrintError(merr);
break;
default:
- win_index = -1;
+ SMPI_VARGET_GLOBAL(win_index) = -1;
}
- win_index++;
- return win_index;
+ SMPI_VARGET_GLOBAL(win_index)++;
+ return SMPI_VARGET_GLOBAL(win_index);
}
/* Return a pointer to the name associated with a window object */
const char *MTestGetWinName(void)
{
- return winName;
+ return SMPI_VARGET_GLOBAL(winName);
}
/* Free the storage associated with a window object */
}
if (addr) {
void *val;
- merr = MPI_Win_get_attr(*win, mem_keyval, &val, &flag);
+ merr = MPI_Win_get_attr(*win, SMPI_VARGET_GLOBAL(mem_keyval), &val, &flag);
if (merr)
MTestPrintError(merr);
if (flag) {
static void MTestRMACleanup(void)
{
- if (mem_keyval != MPI_KEYVAL_INVALID) {
- MPI_Win_free_keyval(&mem_keyval);
+ if (SMPI_VARGET_GLOBAL(mem_keyval) != MPI_KEYVAL_INVALID) {
+ MPI_Win_free_keyval(&SMPI_VARGET_GLOBAL(mem_keyval));
}
}
#else
