int main(int argc, char *argv[])
{
int provided;
MPI_Request request;
int flag;
int outcount = -1;
int indices[1] = { -1 };
MPI_Status status;
char *env;
env = getenv("MPITEST_VERBOSE");
if (env) {
if (*env != '0')
verbose = 1;
}
MPI_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);
}
IF_VERBOSE(("Post Init ...\n"));
MPI_Grequest_start(query_fn, free_fn, cancel_fn, NULL, &request);
grequest = request; /* copy the handle */
MTest_Start_thread(do_work, &grequest);
IF_VERBOSE(("Testing ...\n"));
flag = 0;
while (!flag) {
MPI_Test(&request, &flag, &status);
}
MTest_Join_threads();
MPI_Grequest_start(query_fn, free_fn, cancel_fn, NULL, &request);
grequest = request; /* copy the handle */
MTest_Start_thread(do_work, &grequest);
IF_VERBOSE(("Testing ...\n"));
outcount = 0;
while (!outcount) {
MPI_Testsome(1, &request, &outcount, indices, &status);
}
MTest_Join_threads();
MPI_Grequest_start(query_fn, free_fn, cancel_fn, NULL, &request);
grequest = request; /* copy the handle */
MTest_Start_thread(do_work, &grequest);
IF_VERBOSE(("Testing ...\n"));
flag = 0;
while (!flag) {
MPI_Testall(1, &request, &flag, &status);
}
MTest_Join_threads();
IF_VERBOSE(("Goodbye !!!\n"));
MTest_Finalize(0);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int thread_args[NUM_THREADS];
int i, provided;
int errs = 0;
MPI_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);
MPI_Finalize();
return 0;
}
int main( int argc, char *argv[] )
{
int rank, size;
int provided;
char buffer[100];
MPI_Status status;
MPI_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);
}
MPI_Finalize();
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);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int thread_args[NUM_THREADS];
int i, provided;
MPI_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++) {
start_idup[i] = 1;
MPI_Comm_dup(MPI_COMM_WORLD, &comms[i]);
}
for (i = 0; i < NUM_THREADS; i++) {
thread_args[i] = i;
MTest_Start_thread(test_comm_dup, (void *) &thread_args[i]);
}
MTest_Join_threads();
for (i = 0; i < NUM_THREADS; i++) {
MPI_Comm_free(&comms[i]);
}
if (rank == 0)
printf(" No Errors\n");
MPI_Finalize();
return 0;
}
int main(int argc, char ** argv)
{
int zero = 0, pmode, nprocs;
MPI_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 two processes\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
MTest_Start_thread(run_test, NULL);
run_test(&zero);
MTest_Join_threads();
MPI_Finalize();
/* This program works if it gets here */
if (rank == 0) {
printf( " No Errors\n" );
}
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 rank, size;
int provided;
int buffer[1];
MPI_Comm comm1, comm2, comm4;
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
/* Check that we're multi-threaded */
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);
}
MPI_Finalize();
return 1;
}
/* The test is this:
* The main thread on ODD processors tells the other thread to start
* a comm dup(on comm2), then starts a comm dup(on comm1) after a delay.
* The main thread on even processors starts a comm dup(on comm1)
*
* The second thread on ODD processors waits until it gets a message
* (from the same process) before starting the comm dup on comm2.
*/
/* Create two communicators */
MPI_Comm_dup(MPI_COMM_WORLD, &comm1);
MPI_Comm_dup(MPI_COMM_WORLD, &comm2);
/* Start a thread that will perform a dup comm2 */
MTest_Start_thread(dup_thread, (void *) &comm2);
/* If we're odd, send to our new thread and then delay */
if (rank & 0x1) {
MPI_Ssend(buffer, 0, MPI_INT, rank, 0, MPI_COMM_WORLD);
MTestSleep(1);
}
MPI_Comm_dup(comm1, &comm4);
/* Tell the threads to exit after we've created our new comm */
MPI_Barrier(comm4);
MPI_Ssend(buffer, 0, MPI_INT, rank, 1, MPI_COMM_WORLD);
MPI_Recv(buffer, 0, MPI_INT, rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
MPI_Comm_free(&comm4);
MPI_Comm_free(&comm1);
MPI_Comm_free(&comm2);
MTest_Finalize(0);
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int x;
int threaded;
int err;
MPI_Comm comms[NTHREADS];
int num_threads_obtained = 1;
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &threaded);
if (threaded != MPI_THREAD_MULTIPLE) {
printf("unable to initialize with MPI_THREAD_MULTIPLE\n");
goto fn_fail;
}
for (x = 0; x < NTHREADS; ++x) {
MPI_Comm_dup(MPI_COMM_WORLD, &comms[x]);
if (x != 0) {
err = MTest_Start_thread(do_thread, (void *) &comms[x]);
if (err) {
/* attempt to continue with fewer threads, we may be on a
* thread-constrained platform like BG/P in DUAL mode */
MPI_Comm_free(&comms[x]);
break;
}
++num_threads_obtained;
}
}
if (num_threads_obtained <= 1) {
printf("unable to create any additional threads, exiting\n");
goto fn_fail;
}
do_thread((void *) &comms[0]); /* we are thread 0 */
err = MTest_Join_threads();
if (err) {
printf("error joining threads, err=%d", err);
goto fn_fail;
}
for (x = 0; x < num_threads_obtained; ++x) {
MPI_Comm_free(&comms[x]);
}
fn_exit:
MTest_Finalize(err);
MPI_Finalize();
return 0;
fn_fail:
err = 1;
goto fn_exit;
}
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;
MPI_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);
#ifdef USE_BARRIER
MPI_Barrier( MPI_COMM_WORLD );
#endif
/* 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 (i = 0; i < size; ++i) {
MPI_Send(&buf, 1, MPI_INT, i, REQ_TAG, MPI_COMM_WORLD);
}
/* and wait for others to do the same */
MTest_Join_threads();
MPI_Finalize();
/* This program works if it gets here */
if (rank == 0) {
printf( " No Errors\n" );
}
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;
}
int main(int argc, char **argv)
{
int thread_args[NUM_THREADS];
int i, provided;
int toterrs = 0;
int size;
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (provided < MPI_THREAD_MULTIPLE) {
printf("MPI_THREAD_MULTIPLE for the test\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
if (size < 2) {
printf("This test requires at least two processes\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
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_idup, (void *) &thread_args[i]);
}
MTest_Join_threads();
for (i = 0; i < NUM_THREADS; i++) {
MPI_Comm_free(&comms[i]);
toterrs += errs[i];
}
MTest_Finalize(toterrs);
MPI_Finalize();
return 0;
}
void loops(void)
{
int i, nt;
double latency, mrate, avg_latency, agg_mrate;
int err;
err = MTest_thread_lock_create(&num_threads_lock);
if (err) ABORT_MSG("unable to create lock, aborting\n");
for (nt = 1; nt <= MAX_THREADS; nt++) {
err = MTest_thread_lock(&num_threads_lock);
if (err) ABORT_MSG("unable to acquire lock, aborting\n");
num_threads = 1;
MPI_Barrier(MPI_COMM_WORLD);
MTest_thread_barrier_init();
for (i = 1; i < nt; i++) {
err = MTest_Start_thread(run_test, (void *)(long)i);
if (err) {
/* attempt to continue with fewer threads, we may be on a
* thread-constrained platform like BG/P in DUAL mode */
break;
}
++num_threads;
}
err = MTest_thread_unlock(&num_threads_lock);
if (err) ABORT_MSG("unable to release lock, aborting\n");
if (nt > 1 && num_threads <= 1) {
ABORT_MSG("unable to create any additional threads, aborting\n");
}
run_test((void *) 0); /* we are thread 0 */
err = MTest_Join_threads();
if (err) {
printf("error joining threads, err=%d", err);
MPI_Abort(MPI_COMM_WORLD, 1);
}
MTest_thread_barrier_free();
latency = 0;
for (i = 0; i < num_threads; i++)
latency += tp[i].latency;
latency /= num_threads; /* Average latency */
mrate = num_threads / latency; /* Message rate */
/* Global latency and message rate */
MPI_Reduce(&latency, &avg_latency, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
avg_latency /= size;
MPI_Reduce(&mrate, &agg_mrate, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
if (!rank && verbose) {
printf("Threads: %d; Latency: %.3f; Mrate: %.3f\n",
num_threads, latency, mrate);
}
}
err = MTest_thread_lock_free(&num_threads_lock);
if (err) ABORT_MSG("unable to free lock, aborting\n");
}
