/*
* Initialize the tests, using an MPI-1 style init. Supports
* MTEST_THREADLEVEL_DEFAULT to test with user-specified thread level
*/
void MTest_Init( int *argc, char ***argv )
{
int provided;
#if MPI_VERSION >= 2 || defined(HAVE_MPI_INIT_THREAD)
const char *str = 0;
int threadLevel;
threadLevel = MPI_THREAD_SINGLE;
str = getenv( "MTEST_THREADLEVEL_DEFAULT" );
if (str && *str) {
if (strcmp(str,"MULTIPLE") == 0 || strcmp(str,"multiple") == 0) {
threadLevel = MPI_THREAD_MULTIPLE;
}
else if (strcmp(str,"SERIALIZED") == 0 ||
strcmp(str,"serialized") == 0) {
threadLevel = MPI_THREAD_SERIALIZED;
}
else if (strcmp(str,"FUNNELED") == 0 || strcmp(str,"funneled") == 0) {
threadLevel = MPI_THREAD_FUNNELED;
}
else if (strcmp(str,"SINGLE") == 0 || strcmp(str,"single") == 0) {
threadLevel = MPI_THREAD_SINGLE;
}
else {
fprintf( stderr, "Unrecognized thread level %s\n", str );
/* Use exit since MPI_Init/Init_thread has not been called. */
exit(1);
}
}
MTest_Init_thread( argc, argv, threadLevel, &provided );
#else
/* If the MPI_VERSION is 1, there is no MPI_THREAD_xxx defined */
MTest_Init_thread( argc, argv, 0, &provided );
#endif
}
int main(int argc, char **argv)
{
int thread_args[NUM_THREADS];
int i, provided;
int errs = 0;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
check(provided == MPI_THREAD_MULTIPLE);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
for (i = 0; i < NUM_THREADS; i++) {
MPI_Comm_dup(MPI_COMM_WORLD, &comms[i]);
}
for (i = 0; i < NUM_THREADS; i++) {
thread_args[i] = i;
MTest_Start_thread(test_iallred, (void *) &thread_args[i]);
}
errs = MTest_Join_threads();
for (i = 0; i < NUM_THREADS; i++) {
MPI_Comm_free(&comms[i]);
}
MTest_Finalize(errs);
return MTestReturnValue(errs);
}
int main(int argc, char *argv[])
{
int rank, size;
int provided;
char buffer[100];
MPI_Status status;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (provided != MPI_THREAD_MULTIPLE) {
if (rank == 0) {
printf
("MPI_Init_thread must return MPI_THREAD_MULTIPLE in order for this test to run.\n");
fflush(stdout);
}
return -1;
}
MTest_Start_thread(send_thread, NULL);
MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
MPI_Recv(buffer, sizeof(buffer), MPI_CHAR, rank, 0, MPI_COMM_WORLD, &status);
MTest_Join_threads();
MTest_Finalize(0);
return 0;
}
int main(int argc, char *argv[])
{
int nprocs, i, pmode;
char *win_buf;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &pmode);
if (pmode != MPI_THREAD_MULTIPLE) {
fprintf(stderr, "Thread Multiple not supported by the MPI implementation\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (nprocs < 2) {
printf("Run this program with 2 or more processes\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
errs += MPI_Win_allocate(COUNT * sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &win_buf, &win);
errs += MPI_Win_lock_all(0, win);
for (i = 0; i < NUM_THREADS; i++)
errs += MTest_Start_thread(run_test, NULL);
errs += MTest_Join_threads();
errs += MPI_Win_unlock_all(win);
errs += MPI_Win_free(&win);
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int provided, rank;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/* The test here is a simple one that Finalize exits, so the only action
* is to write no errors */
MTest_Finalize(0);
return 0;
}
int main(int argc, char ** argv)
{
int i, pmode, nprocs, rank;
int errs = 0, err;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &pmode);
if (pmode != MPI_THREAD_MULTIPLE) {
fprintf(stderr, "Thread Multiple not supported by the MPI implementation\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (nprocs < 2) {
fprintf(stderr, "Need at least two processes\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
if (nprocs > MAX_NTHREAD) nprocs = MAX_NTHREAD;
err = MTest_thread_barrier_init();
if (err) {
fprintf( stderr, "Could not create thread barrier\n" );
MPI_Abort( MPI_COMM_WORLD, 1 );
}
MPI_Barrier( MPI_COMM_WORLD );
if (rank == 0) {
nthreads = nprocs - 1;
for (i=1; i<nprocs; i++)
MTest_Start_thread( run_test_send, (void *)(long)i );
MTest_Join_threads( );
}
else if (rank < MAX_NTHREAD) {
run_test_recv();
}
MTest_thread_barrier_free();
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int errs = 0;
int rank, nprocs, i, pmode;
double *win_mem;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &pmode);
if (pmode != MPI_THREAD_MULTIPLE) {
fprintf(stderr, "MPI_THREAD_MULTIPLE is not supported\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (nprocs < 2) {
printf("Run this program with 2 or more processes\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
if (rank == 0) {
errs += MPI_Win_allocate(COUNT * sizeof(double), sizeof(double),
MPI_INFO_NULL, MPI_COMM_WORLD, &win_mem, &win);
} else {
errs += MPI_Win_allocate(0, sizeof(double), MPI_INFO_NULL,
MPI_COMM_WORLD, &win_mem, &win);
}
errs += MPI_Win_lock_all(0, win);
for (i = 0; i < NUM_THREADS; i++)
errs += MTest_Start_thread(run_test, NULL);
errs += MTest_Join_threads();
errs += MPI_Win_unlock_all(win);
errs += MPI_Win_free(&win);
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int buf = 0;
long int i, j;
MTest_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
if (provided != MPI_THREAD_MULTIPLE) {
printf("This test requires MPI_THREAD_MULTIPLE\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
for (i = 0; i < NUM_ITER; i++) {
/* create listener thread */
MTest_Start_thread(listener, NULL);
/* no more requests to send
* inform other in the group that we have finished */
buf = -1;
for (j = 0; j < size; ++j) {
MPI_Send(&buf, 1, MPI_INT, j, REQ_TAG, MPI_COMM_WORLD);
}
/* and wait for others to do the same */
MTest_Join_threads();
/* barrier to avoid deadlock */
MPI_Barrier(MPI_COMM_WORLD);
}
MTest_Finalize(0);
return 0;
}
