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 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; }
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); MTest_Join_threads(); MPI_Comm_free(&comm4); MPI_Comm_free(&comm1); MPI_Comm_free(&comm2); MTest_Finalize(0); 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"); }