#endif
#include <errno.h>
-static int dbgflag = 0; /* Flag used for debugging */
+SMPI_VARINIT_GLOBAL_AND_SET(dbgflag2, int, 0); /* Flag used for debugging */
SMPI_VARINIT_GLOBAL_AND_SET(wrank2, int, -1); /* World rank */
-static int verbose = 0; /* Message level (0 is none) */
+SMPI_VARINIT_GLOBAL_AND_SET(verbose2,int, 0); /* Message level (0 is none) */
/*
* Utility routines for writing MPI datatype communication tests.
* Full : MTestInitFullDatatypes
*/
-static int datatype_index = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(datatype_index,int,0);
/* ------------------------------------------------------------------------ */
/* Routine and internal parameters to define the range of datatype tests */
/* ------------------------------------------------------------------------ */
#define MTEST_DDT_NUM_SUBTESTS 7 /* 7 kinds of derived datatype structure */
-static MTestDdtCreator mtestDdtCreators[MTEST_DDT_MAX];
+SMPI_VARINIT_GLOBAL_AND_SET( mtestDdtCreators, MTestDdtCreator*,NULL);
-static int MTEST_BDT_START_IDX = -1;
-static int MTEST_BDT_NUM_TESTS = 0;
-static int MTEST_BDT_RANGE = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_BDT_START_IDX, int, -1);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_BDT_NUM_TESTS, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_BDT_RANGE, int, 0);
-static int MTEST_DDT_NUM_TYPES = 0;
-static int MTEST_SEND_DDT_START_IDX = 0;
-static int MTEST_SEND_DDT_NUM_TESTS = 0;
-static int MTEST_SEND_DDT_RANGE = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_DDT_NUM_TYPES, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_SEND_DDT_START_IDX, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_SEND_DDT_NUM_TESTS, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_SEND_DDT_RANGE, int, 0);
-static int MTEST_RECV_DDT_START_IDX = 0;
-static int MTEST_RECV_DDT_NUM_TESTS = 0;
-static int MTEST_RECV_DDT_RANGE = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_RECV_DDT_START_IDX, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_RECV_DDT_NUM_TESTS, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_RECV_DDT_RANGE, int, 0);
enum {
MTEST_DATATYPE_TEST_LEVEL_FULL,
};
/* current datatype test level */
-static int MTEST_DATATYPE_TEST_LEVEL = MTEST_DATATYPE_TEST_LEVEL_FULL;
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_DATATYPE_TEST_LEVEL,int, MTEST_DATATYPE_TEST_LEVEL_FULL);
/* default datatype test level specified by environment variable */
-static int MTEST_DATATYPE_TEST_LEVEL_ENV = -1;
+SMPI_VARINIT_GLOBAL_AND_SET(MTEST_DATATYPE_TEST_LEVEL_ENV, int, -1);
/* default datatype initialization function */
static void (*MTestInitDefaultTestFunc) (void) = NULL;
static void MTestInitDatatypeGen(int basic_dt_num, int derived_dt_num)
{
- MTEST_BDT_START_IDX = 0;
- MTEST_BDT_NUM_TESTS = basic_dt_num;
- MTEST_BDT_RANGE = MTEST_BDT_START_IDX + MTEST_BDT_NUM_TESTS;
- MTEST_DDT_NUM_TYPES = derived_dt_num;
- MTEST_SEND_DDT_START_IDX = MTEST_BDT_NUM_TESTS;
- MTEST_SEND_DDT_NUM_TESTS = MTEST_DDT_NUM_TYPES * MTEST_DDT_NUM_SUBTESTS;
- MTEST_SEND_DDT_RANGE = MTEST_SEND_DDT_START_IDX + MTEST_SEND_DDT_NUM_TESTS;
- MTEST_RECV_DDT_START_IDX = MTEST_SEND_DDT_START_IDX + MTEST_SEND_DDT_NUM_TESTS;
- MTEST_RECV_DDT_NUM_TESTS = MTEST_DDT_NUM_TYPES * MTEST_DDT_NUM_SUBTESTS;
- MTEST_RECV_DDT_RANGE = MTEST_RECV_DDT_START_IDX + MTEST_RECV_DDT_NUM_TESTS;
+ SMPI_VARGET_GLOBAL(MTEST_BDT_START_IDX) = 0;
+ SMPI_VARGET_GLOBAL(MTEST_BDT_NUM_TESTS) = basic_dt_num;
+ SMPI_VARGET_GLOBAL(MTEST_BDT_RANGE) = SMPI_VARGET_GLOBAL(MTEST_BDT_START_IDX) + SMPI_VARGET_GLOBAL(MTEST_BDT_NUM_TESTS);
+ SMPI_VARGET_GLOBAL(MTEST_DDT_NUM_TYPES) = derived_dt_num;
+ SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_START_IDX) = SMPI_VARGET_GLOBAL(MTEST_BDT_NUM_TESTS);
+ SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_NUM_TESTS) = SMPI_VARGET_GLOBAL(MTEST_DDT_NUM_TYPES) * MTEST_DDT_NUM_SUBTESTS;
+ SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_RANGE) = SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_START_IDX) + SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_NUM_TESTS);
+ SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_START_IDX) = SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_START_IDX) + SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_NUM_TESTS);
+ SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_NUM_TESTS) = SMPI_VARGET_GLOBAL(MTEST_DDT_NUM_TYPES) * MTEST_DDT_NUM_SUBTESTS;
+ SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_RANGE) = SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_START_IDX) + SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_NUM_TESTS);
}
static int MTestIsDatatypeGenInited()
{
- return (MTEST_BDT_START_IDX < 0) ? 0 : 1;
+ return (SMPI_VARGET_GLOBAL(MTEST_BDT_START_IDX) < 0) ? 0 : 1;
}
static void MTestPrintDatatypeGen()
{
MTestPrintfMsg(1, "MTest datatype test level : %s. %d basic datatype tests, "
"%d derived datatype tests will be generated\n",
- (MTEST_DATATYPE_TEST_LEVEL == MTEST_DATATYPE_TEST_LEVEL_FULL) ? "FULL" : "MIN",
- MTEST_BDT_NUM_TESTS, MTEST_SEND_DDT_NUM_TESTS + MTEST_RECV_DDT_NUM_TESTS);
+ (SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL) == MTEST_DATATYPE_TEST_LEVEL_FULL) ? "FULL" : "MIN",
+ SMPI_VARGET_GLOBAL(MTEST_BDT_NUM_TESTS), SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_NUM_TESTS) + SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_NUM_TESTS));
}
static void MTestResetDatatypeGen()
{
- MTEST_BDT_START_IDX = -1;
+ SMPI_VARGET_GLOBAL(MTEST_BDT_START_IDX) = -1;
}
void MTestInitFullDatatypes(void)
{
+ if(SMPI_VARGET_GLOBAL(mtestDdtCreators)==NULL)
+ SMPI_VARGET_GLOBAL(mtestDdtCreators)= (MTestDdtCreator*)malloc(sizeof(MTestDdtCreator)*MTEST_DDT_MAX);
/* Do not allow to change datatype test level during loop.
* Otherwise indexes will be wrong.
* Test must explicitly call reset or wait for current datatype loop being
* done before changing to another test level. */
if (!MTestIsDatatypeGenInited()) {
- MTEST_DATATYPE_TEST_LEVEL = MTEST_DATATYPE_TEST_LEVEL_FULL;
- MTestTypeCreatorInit((MTestDdtCreator *) mtestDdtCreators);
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL) = MTEST_DATATYPE_TEST_LEVEL_FULL;
+ MTestTypeCreatorInit((MTestDdtCreator *) SMPI_VARGET_GLOBAL(mtestDdtCreators));
MTestInitDatatypeGen(MTEST_BDT_MAX, MTEST_DDT_MAX);
}
else {
void MTestInitMinDatatypes(void)
{
+ if(SMPI_VARGET_GLOBAL(mtestDdtCreators)==NULL)
+ SMPI_VARGET_GLOBAL(mtestDdtCreators)= (MTestDdtCreator*)malloc(sizeof(MTestDdtCreator)*MTEST_DDT_MAX);
/* Do not allow to change datatype test level during loop.
* Otherwise indexes will be wrong.
* Test must explicitly call reset or wait for current datatype loop being
* done before changing to another test level. */
if (!MTestIsDatatypeGenInited()) {
- MTEST_DATATYPE_TEST_LEVEL = MTEST_DATATYPE_TEST_LEVEL_MIN;
- MTestTypeMinCreatorInit((MTestDdtCreator *) mtestDdtCreators);
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL) = MTEST_DATATYPE_TEST_LEVEL_MIN;
+ MTestTypeMinCreatorInit((MTestDdtCreator *) SMPI_VARGET_GLOBAL(mtestDdtCreators));
MTestInitDatatypeGen(MTEST_BDT_MAX, MTEST_MIN_DDT_MAX);
}
else {
void MTestInitBasicDatatypes(void)
{
+ if(SMPI_VARGET_GLOBAL(mtestDdtCreators)==NULL)
+ SMPI_VARGET_GLOBAL(mtestDdtCreators)= (MTestDdtCreator*)malloc(sizeof(MTestDdtCreator)*MTEST_DDT_MAX);
/* Do not allow to change datatype test level during loop.
* Otherwise indexes will be wrong.
* Test must explicitly call reset or wait for current datatype loop being
* done before changing to another test level. */
if (!MTestIsDatatypeGenInited()) {
- MTEST_DATATYPE_TEST_LEVEL = MTEST_DATATYPE_TEST_LEVEL_BASIC;
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL) = MTEST_DATATYPE_TEST_LEVEL_BASIC;
MTestInitDatatypeGen(MTEST_BDT_MAX, 0);
}
else {
/* Read global test level specified by user environment variable.
* Only initialize once at the first time that test calls datatype routine. */
- if (MTEST_DATATYPE_TEST_LEVEL_ENV > -1)
+ if (SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL_ENV) > -1)
return;
/* default full */
- MTEST_DATATYPE_TEST_LEVEL_ENV = MTEST_DATATYPE_TEST_LEVEL_FULL;
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL_ENV) = MTEST_DATATYPE_TEST_LEVEL_FULL;
MTestInitDefaultTestFunc = MTestInitFullDatatypes;
envval = getenv("MPITEST_DATATYPE_TEST_LEVEL");
if (envval && strlen(envval)) {
if (!strncmp(envval, "min", strlen("min"))) {
- MTEST_DATATYPE_TEST_LEVEL_ENV = MTEST_DATATYPE_TEST_LEVEL_MIN;
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL_ENV) = MTEST_DATATYPE_TEST_LEVEL_MIN;
MTestInitDefaultTestFunc = MTestInitMinDatatypes;
}
else if (!strncmp(envval, "basic", strlen("basic"))) {
- MTEST_DATATYPE_TEST_LEVEL_ENV = MTEST_DATATYPE_TEST_LEVEL_BASIC;
+ SMPI_VARGET_GLOBAL(MTEST_DATATYPE_TEST_LEVEL_ENV) = MTEST_DATATYPE_TEST_LEVEL_BASIC;
MTestInitDefaultTestFunc = MTestInitBasicDatatypes;
}
else if (strncmp(envval, "full", strlen("full"))) {
MTestDatatype * recvtype, MPI_Aint tot_count)
{
int merr = 0;
- int bdt_index = datatype_index - MTEST_BDT_START_IDX;
+ int bdt_index = SMPI_VARGET_GLOBAL(datatype_index) - SMPI_VARGET_GLOBAL(MTEST_BDT_START_IDX);
if (bdt_index >= MTEST_BDT_MAX) {
- printf("Wrong index: global %d, bst %d in %s\n", datatype_index, bdt_index, __FUNCTION__);
- merr++;
- return merr;
+ printf("Wrong index: global %d, bst %d in %s\n", SMPI_VARGET_GLOBAL(datatype_index), bdt_index, __func__);
+ merr++;
+ return merr;
}
switch (bdt_index) {
MPI_Datatype old_type = MPI_DOUBLE;
/* Check index */
- ddt_datatype_index = datatype_index - MTEST_SEND_DDT_START_IDX;
+ ddt_datatype_index = SMPI_VARGET_GLOBAL(datatype_index) - SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_START_IDX);
ddt_c_dt = ddt_datatype_index / MTEST_DDT_NUM_SUBTESTS;
- if (ddt_c_dt >= MTEST_DDT_MAX || !mtestDdtCreators[ddt_c_dt]) {
- printf("Wrong index: global %d, send %d send-ddt %d, or undefined creator in %s\n",
- datatype_index, ddt_datatype_index, ddt_c_dt, __FUNCTION__);
- merr++;
- return merr;
+ if (ddt_c_dt >= MTEST_DDT_MAX || !SMPI_VARGET_GLOBAL(mtestDdtCreators)[ddt_c_dt]) {
+ printf("Wrong index: global %d, send %d send-ddt %d, or undefined creator in %s\n",
+ SMPI_VARGET_GLOBAL(datatype_index), ddt_datatype_index, ddt_c_dt, __func__);
+ merr++;
+ return merr;
}
/* Set datatype structure */
merr = MTestDdtStructDefine(ddt_datatype_index, tot_count, &count, &blen,
&stride, &align_tot_count, &lb);
if (merr) {
- printf("Wrong index: global %d, send %d send-ddt %d, or undefined ddt structure in %s\n",
- datatype_index, ddt_datatype_index, ddt_c_dt, __FUNCTION__);
- merr++;
- return merr;
+ printf("Wrong index: global %d, send %d send-ddt %d, or undefined ddt structure in %s\n",
+ SMPI_VARGET_GLOBAL(datatype_index), ddt_datatype_index, ddt_c_dt, __func__);
+ merr++;
+ return merr;
}
/* Create send datatype */
- merr = mtestDdtCreators[ddt_c_dt] (count, blen, stride, lb, old_type, "send", sendtype);
+ merr = SMPI_VARGET_GLOBAL(mtestDdtCreators)[ddt_c_dt] (count, blen, stride, lb, old_type, "send", sendtype);
if (merr)
return merr;
MPI_Datatype old_type = MPI_DOUBLE;
/* Check index */
- ddt_datatype_index = datatype_index - MTEST_RECV_DDT_START_IDX;
+ ddt_datatype_index = SMPI_VARGET_GLOBAL(datatype_index) - SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_START_IDX);
ddt_c_dt = ddt_datatype_index / MTEST_DDT_NUM_SUBTESTS;
- if (ddt_c_dt >= MTEST_DDT_MAX || !mtestDdtCreators[ddt_c_dt]) {
- printf("Wrong index: global %d, recv %d recv-ddt %d, or undefined creator in %s\n",
- datatype_index, ddt_datatype_index, ddt_c_dt, __FUNCTION__);
- merr++;
- return merr;
+ if (ddt_c_dt >= MTEST_DDT_MAX || !SMPI_VARGET_GLOBAL(mtestDdtCreators)[ddt_c_dt]) {
+ printf("Wrong index: global %d, recv %d recv-ddt %d, or undefined creator in %s\n",
+ SMPI_VARGET_GLOBAL(datatype_index), ddt_datatype_index, ddt_c_dt, __func__);
+ merr++;
+ return merr;
}
/* Set datatype structure */
merr = MTestDdtStructDefine(ddt_datatype_index, tot_count, &count, &blen,
&stride, &align_tot_count, &lb);
if (merr) {
- printf("Wrong index: global %d, recv %d recv-ddt %d, or undefined ddt structure in %s\n",
- datatype_index, ddt_datatype_index, ddt_c_dt, __FUNCTION__);
- return merr;
+ printf("Wrong index: global %d, recv %d recv-ddt %d, or undefined ddt structure in %s\n",
+ SMPI_VARGET_GLOBAL(datatype_index), ddt_datatype_index, ddt_c_dt, __func__);
+ return merr;
}
/* Create receive datatype */
- merr = mtestDdtCreators[ddt_c_dt] (count, blen, stride, lb, old_type, "recv", recvtype);
+ merr = SMPI_VARGET_GLOBAL(mtestDdtCreators)[ddt_c_dt] (count, blen, stride, lb, old_type, "recv", recvtype);
if (merr)
return merr;
{
int merr = 0;
- MTestGetDbgInfo(&dbgflag, &verbose);
+ MTestGetDbgInfo(&SMPI_VARGET_GLOBAL(dbgflag2), &SMPI_VARGET_GLOBAL(verbose2));
MTestInitDatatypeEnv();
MPI_Comm_rank(MPI_COMM_WORLD, &SMPI_VARGET_GLOBAL(wrank2));
MTestInitDefaultTestFunc();
}
- if (datatype_index == 0) {
+ if (SMPI_VARGET_GLOBAL(datatype_index) == 0) {
MTestPrintDatatypeGen();
}
/* Start generating tests */
- if (datatype_index < MTEST_BDT_RANGE) {
+ if (SMPI_VARGET_GLOBAL(datatype_index) < SMPI_VARGET_GLOBAL(MTEST_BDT_RANGE)) {
merr = MTestGetBasicDatatypes(sendtype, recvtype, tot_count);
}
- else if (datatype_index < MTEST_SEND_DDT_RANGE) {
+ else if (SMPI_VARGET_GLOBAL(datatype_index) < SMPI_VARGET_GLOBAL(MTEST_SEND_DDT_RANGE)) {
merr = MTestGetSendDerivedDatatypes(sendtype, recvtype, tot_count);
}
- else if (datatype_index < MTEST_RECV_DDT_RANGE) {
+ else if (SMPI_VARGET_GLOBAL(datatype_index) < SMPI_VARGET_GLOBAL(MTEST_RECV_DDT_RANGE)) {
merr = MTestGetRecvDerivedDatatypes(sendtype, recvtype, tot_count);
}
else {
/* out of range */
- datatype_index = -1;
+ SMPI_VARGET_GLOBAL(datatype_index) = -1;
MTestResetDatatypeGen();
}
/* stop if error reported */
if (merr) {
- datatype_index = -1;
+ SMPI_VARGET_GLOBAL(datatype_index) = -1;
}
- if (datatype_index > 0) {
+ if (SMPI_VARGET_GLOBAL(datatype_index) > 0) {
/* general initialization for receive buffer. */
recvtype->InitBuf = MTestTypeInitRecv;
}
- datatype_index++;
+ SMPI_VARGET_GLOBAL(datatype_index)++;
- if (verbose >= 2 && datatype_index > 0) {
+ if (SMPI_VARGET_GLOBAL(verbose2) >= 2 && SMPI_VARGET_GLOBAL(datatype_index) > 0) {
MPI_Count ssize, rsize;
MPI_Aint slb, rlb, sextent, rextent;
const char *sendtype_nm = MTestGetDatatypeName(sendtype);
fflush(stdout);
}
- return datatype_index;
+ return SMPI_VARGET_GLOBAL(datatype_index);
}
/* Reset the datatype index (start from the initial data type.
*/
void MTestResetDatatypes(void)
{
- datatype_index = 0;
+ SMPI_VARGET_GLOBAL(datatype_index) = 0;
MTestResetDatatypeGen();
}
is provided mostly to enable debugging of the MTest package itself */
int MTestGetDatatypeIndex(void)
{
- return datatype_index;
+ return SMPI_VARGET_GLOBAL(datatype_index);
}
/* Free the storage associated with a datatype */
return errs;
}
+ SMPI_VARINIT_GLOBAL_AND_SET(name , char*,NULL);
+ SMPI_VARINIT_GLOBAL_AND_SET(sp,int,0);
+
/* This next routine uses a circular buffer of static name arrays just to
simplify the use of the routine */
const char *MTestGetDatatypeName(MTestDatatype * dtype)
{
- static char name[4][MPI_MAX_OBJECT_NAME];
- static int sp = 0;
+ if(SMPI_VARGET_GLOBAL(name)==NULL) SMPI_VARGET_GLOBAL(name)=(char*)malloc(4*MPI_MAX_OBJECT_NAME*sizeof(char));
int rlen, merr;
- if (sp >= 4)
- sp = 0;
- merr = MPI_Type_get_name(dtype->datatype, name[sp], &rlen);
+ if (SMPI_VARGET_GLOBAL(sp) >= 4)
+ SMPI_VARGET_GLOBAL(sp) = 0;
+ merr = MPI_Type_get_name(dtype->datatype, &SMPI_VARGET_GLOBAL(name)[SMPI_VARGET_GLOBAL(sp)*MPI_MAX_OBJECT_NAME], &rlen);
if (merr)
MTestPrintError(merr);
- return (const char *) name[sp++];
+ return (const char *) &SMPI_VARGET_GLOBAL(name)[(SMPI_VARGET_GLOBAL(sp)++) *MPI_MAX_OBJECT_NAME];
}
