int main(int argc, char *argv[])
{
int numprocs, myid, i;
int namelen;
char processor_name[MPI_MAX_PROCESSOR_NAME];
struct stat fileStat;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
MPI_Get_processor_name(processor_name, &namelen);
for (i = 0; i < 22; i++) {
MPI_Barrier(MPI_COMM_WORLD);
MTestSleep(1);
}
if (myid == 0) {
if (stat("/tmp/context-num2-0-0", &fileStat) < 0) {
printf("failed to find ckpoint file\n");
}
else if (fileStat.st_size == 0) {
printf("ckpoint file is empty\n");
}
else {
printf("No Errors\n");
}
}
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;
}
MTEST_THREAD_RETURN_TYPE do_work(void *arg)
{
MPI_Request *req = (MPI_Request *)arg;
IF_VERBOSE(("Starting work in thread ...\n"));
MTestSleep(3);
IF_VERBOSE(("Work in thread done !!!\n"));
MPI_Grequest_complete(*req);
return MTEST_THREAD_RETVAL_IGN;
}
MTEST_THREAD_RETURN_TYPE test_iallred(void *arg)
{
MPI_Request req;
int tid = *(int *) arg;
int buf[BUF_SIZE];
MTEST_VG_MEM_INIT(buf, BUF_SIZE * sizeof(int));
if (tid == rank)
MTestSleep(1);
MPI_Allreduce(MPI_IN_PLACE, buf, BUF_SIZE, MPI_INT, MPI_BAND, comms[tid]);
return (MTEST_THREAD_RETURN_TYPE) 0;
}
int main( int argc, char *argv[] )
{
int errs = 0;
int rank, size, dest, source;
int i, indices[40];
MPI_Aint extent;
int *buf, *bufs[MAX_MSGS];
MPI_Comm comm;
MPI_Datatype dtype;
MPI_Request req[MAX_MSGS];
MTest_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
source = 0;
dest = size - 1;
/* Setup by creating a blocked datatype that is likely to be processed
in a piecemeal fashion */
for (i=0; i<30; i++) {
indices[i] = i*40;
}
/* 30 blocks of size 10 */
MPI_Type_create_indexed_block( 30, 10, indices, MPI_INT, &dtype );
MPI_Type_commit( &dtype );
/* Create the corresponding message buffers */
MPI_Type_extent( dtype, &extent );
for (i=0; i<MAX_MSGS; i++) {
bufs[i] = (int *)malloc( extent );
if (!bufs[i]) {
fprintf( stderr, "Unable to allocate buffer %d of size %ld\n",
i, (long)extent );
MPI_Abort( MPI_COMM_WORLD, 1 );
}
}
buf = (int *)malloc( 10 * 30 * sizeof(int) );
MPI_Barrier( MPI_COMM_WORLD );
if (rank == dest) {
MTestSleep( 2 );
for (i=0; i<MAX_MSGS; i++) {
MPI_Recv( buf, 10*30, MPI_INT, source, i, comm,
MPI_STATUS_IGNORE );
}
}
else if (rank == source ) {
for (i=0; i<MAX_MSGS; i++) {
MPI_Isend( bufs[i], 1, dtype, dest, i, comm, &req[i] );
}
MPI_Waitall( MAX_MSGS, req, MPI_STATUSES_IGNORE );
}
MPI_Type_free( &dtype );
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main( int argc, char *argv[] )
{
int num_errors = 0, total_num_errors = 0;
int rank, size;
char port1[MPI_MAX_PORT_NAME];
char port2[MPI_MAX_PORT_NAME];
char port3[MPI_MAX_PORT_NAME];
MPI_Status status;
MPI_Comm comm1, comm2, comm3;
int verbose = 0;
int data = 0;
if (getenv("MPITEST_VERBOSE"))
{
verbose = 1;
}
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (size < 4)
{
printf("Four processes needed to run this test.\n");
MPI_Finalize();
return 0;
}
if (rank == 0)
{
IF_VERBOSE(("0: opening ports.\n"));
MPI_Open_port(MPI_INFO_NULL, port1);
MPI_Open_port(MPI_INFO_NULL, port2);
MPI_Open_port(MPI_INFO_NULL, port3);
IF_VERBOSE(("0: opened port1: <%s>\n", port1));
IF_VERBOSE(("0: opened port2: <%s>\n", port2));
IF_VERBOSE(("0: opened port3: <%s>\n", port3));
IF_VERBOSE(("0: sending ports.\n"));
MPI_Send(port1, MPI_MAX_PORT_NAME, MPI_CHAR, 1, 0, MPI_COMM_WORLD);
MPI_Send(port2, MPI_MAX_PORT_NAME, MPI_CHAR, 2, 0, MPI_COMM_WORLD);
MPI_Send(port3, MPI_MAX_PORT_NAME, MPI_CHAR, 3, 0, MPI_COMM_WORLD);
IF_VERBOSE(("0: accepting port3.\n"));
MPI_Comm_accept(port3, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm3);
IF_VERBOSE(("0: accepting port2.\n"));
MPI_Comm_accept(port2, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm2);
IF_VERBOSE(("0: accepting port1.\n"));
MPI_Comm_accept(port1, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm1);
IF_VERBOSE(("0: closing ports.\n"));
MPI_Close_port(port1);
MPI_Close_port(port2);
MPI_Close_port(port3);
IF_VERBOSE(("0: sending 1 to process 1.\n"));
data = 1;
MPI_Send(&data, 1, MPI_INT, 0, 0, comm1);
IF_VERBOSE(("0: sending 2 to process 2.\n"));
data = 2;
MPI_Send(&data, 1, MPI_INT, 0, 0, comm2);
IF_VERBOSE(("0: sending 3 to process 3.\n"));
data = 3;
MPI_Send(&data, 1, MPI_INT, 0, 0, comm3);
IF_VERBOSE(("0: disconnecting.\n"));
MPI_Comm_disconnect(&comm1);
MPI_Comm_disconnect(&comm2);
MPI_Comm_disconnect(&comm3);
}
else if (rank == 1)
{
IF_VERBOSE(("1: receiving port.\n"));
MPI_Recv(port1, MPI_MAX_PORT_NAME, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &status);
IF_VERBOSE(("1: received port1: <%s>\n", port1));
IF_VERBOSE(("1: connecting.\n"));
MPI_Comm_connect(port1, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm1);
MPI_Recv(&data, 1, MPI_INT, 0, 0, comm1, &status);
if (data != 1)
{
printf("Received %d from root when expecting 1\n", data);
fflush(stdout);
num_errors++;
}
IF_VERBOSE(("1: disconnecting.\n"));
MPI_Comm_disconnect(&comm1);
}
else if (rank == 2)
{
IF_VERBOSE(("2: receiving port.\n"));
MPI_Recv(port2, MPI_MAX_PORT_NAME, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &status);
IF_VERBOSE(("2: received port2: <%s>\n", port2));
/* make sure process 1 has time to do the connect before this process
attempts to connect */
MTestSleep(2);
IF_VERBOSE(("2: connecting.\n"));
MPI_Comm_connect(port2, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm2);
MPI_Recv(&data, 1, MPI_INT, 0, 0, comm2, &status);
if (data != 2)
{
printf("Received %d from root when expecting 2\n", data);
fflush(stdout);
num_errors++;
}
IF_VERBOSE(("2: disconnecting.\n"));
MPI_Comm_disconnect(&comm2);
}
else if (rank == 3)
{
IF_VERBOSE(("3: receiving port.\n"));
MPI_Recv(port3, MPI_MAX_PORT_NAME, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &status);
IF_VERBOSE(("2: received port2: <%s>\n", port2));
/* make sure process 1 and 2 have time to do the connect before this
process attempts to connect */
MTestSleep(4);
IF_VERBOSE(("3: connecting.\n"));
MPI_Comm_connect(port3, MPI_INFO_NULL, 0, MPI_COMM_SELF, &comm3);
MPI_Recv(&data, 1, MPI_INT, 0, 0, comm3, &status);
if (data != 3)
{
printf("Received %d from root when expecting 3\n", data);
fflush(stdout);
num_errors++;
}
IF_VERBOSE(("3: disconnecting.\n"));
MPI_Comm_disconnect(&comm3);
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Reduce(&num_errors, &total_num_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0)
{
if (total_num_errors)
{
printf(" Found %d errors\n", total_num_errors);
}
else
{
printf(" No Errors\n");
}
fflush(stdout);
}
MPI_Finalize();
return total_num_errors;
}
int main(int argc, char *argv[])
{
int errs = 0;
int rank, size, source, dest, partner;
int i, testnum;
double tsend;
static int msgsizes[] = { 100, 1000, 10000, 100000, -1 };
static int nmsgs[] = { 100, 10, 10, 4 };
MPI_Comm comm;
MTest_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &size);
source = 0;
dest = 1;
if (size < 2) {
printf("This test requires at least 2 processes\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
for (testnum = 0; msgsizes[testnum] > 0; testnum++) {
if (rank == source || rank == dest) {
int nmsg = nmsgs[testnum];
int msgSize = msgsizes[testnum];
MPI_Request r[MAX_NMSGS];
int *buf[MAX_NMSGS];
for (i = 0; i < nmsg; i++) {
buf[i] = (int *) malloc(msgSize * sizeof(int));
if (!buf[i]) {
fprintf(stderr, "Unable to allocate %d bytes\n", msgSize);
MPI_Abort(MPI_COMM_WORLD, 1);
}
MTEST_VG_MEM_INIT(buf[i], msgSize * sizeof(int));
}
partner = (rank + 1) % size;
MPI_Sendrecv(MPI_BOTTOM, 0, MPI_INT, partner, 10,
MPI_BOTTOM, 0, MPI_INT, partner, 10, comm, MPI_STATUS_IGNORE);
/* Try to fill up the outgoing message buffers */
for (i = 0; i < nmsg; i++) {
MPI_Isend(buf[i], msgSize, MPI_INT, partner, testnum, comm, &r[i]);
}
for (i = 0; i < nmsg; i++) {
MPI_Recv(buf[i], msgSize, MPI_INT, partner, testnum, comm, MPI_STATUS_IGNORE);
}
MPI_Waitall(nmsg, r, MPI_STATUSES_IGNORE);
/* Repeat the test, but make one of the processes sleep */
MPI_Sendrecv(MPI_BOTTOM, 0, MPI_INT, partner, 10,
MPI_BOTTOM, 0, MPI_INT, partner, 10, comm, MPI_STATUS_IGNORE);
if (rank == dest)
MTestSleep(1);
/* Try to fill up the outgoing message buffers */
tsend = MPI_Wtime();
for (i = 0; i < nmsg; i++) {
MPI_Isend(buf[i], msgSize, MPI_INT, partner, testnum, comm, &r[i]);
}
tsend = MPI_Wtime() - tsend;
for (i = 0; i < nmsg; i++) {
MPI_Recv(buf[i], msgSize, MPI_INT, partner, testnum, comm, MPI_STATUS_IGNORE);
}
MPI_Waitall(nmsg, r, MPI_STATUSES_IGNORE);
if (tsend > 0.5) {
printf("Isends for %d messages of size %d took too long (%f seconds)\n", nmsg,
msgSize, tsend);
errs++;
}
MTestPrintfMsg(1, "%d Isends for size = %d took %f seconds\n", nmsg, msgSize, tsend);
for (i = 0; i < nmsg; i++) {
free(buf[i]);
}
}
}
MTest_Finalize(errs);
return MTestReturnValue(errs);
}
int main(int argc, char *argv[])
{
int wrank, wsize, rank, size, color;
int j, tmp;
int err, toterrs, errs = 0;
MPI_Comm newcomm;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &wsize);
MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
/* Color is 0 or 1; 1 will be the processes that "fault" */
/* process 0 and wsize/2+1...wsize-1 are in non-faulting group */
color = (wrank > 0) && (wrank <= wsize / 2);
MPI_Comm_split(MPI_COMM_WORLD, color, wrank, &newcomm);
MPI_Comm_size(newcomm, &size);
MPI_Comm_rank(newcomm, &rank);
/* Set errors return on COMM_WORLD and the new comm */
MPI_Comm_set_errhandler(MPI_ERRORS_RETURN, MPI_COMM_WORLD);
MPI_Comm_set_errhandler(MPI_ERRORS_RETURN, newcomm);
err = MPI_Barrier(MPI_COMM_WORLD);
if (err)
errs += ReportErr(err, "Barrier");
if (color) {
/* Simulate a fault on some processes */
exit(1);
}
else {
/* To improve the chance that the "faulted" processes will have
* exited, wait for 1 second */
MTestSleep(1);
}
/* Can we still use newcomm? */
for (j = 0; j < rank; j++) {
err = MPI_Recv(&tmp, 1, MPI_INT, j, 0, newcomm, MPI_STATUS_IGNORE);
if (err)
errs += ReportErr(err, "Recv");
}
for (j = rank + 1; j < size; j++) {
err = MPI_Send(&rank, 1, MPI_INT, j, 0, newcomm);
if (err)
errs += ReportErr(err, "Recv");
}
/* Now, try sending in MPI_COMM_WORLD on dead processes */
/* There is a race condition here - we don't know for sure that the faulted
* processes have exited. However, we can ensure a failure by using
* synchronous sends - the sender will wait until the reciever handles
* receives the message, which will not happen (the process will exit
* without matching the message, even if it has not yet exited). */
for (j = 1; j <= wsize / 2; j++) {
err = MPI_Ssend(&rank, 1, MPI_INT, j, 0, MPI_COMM_WORLD);
if (!err) {
errs++;
fprintf(stderr, "Ssend succeeded to dead process %d\n", j);
}
}
err = MPI_Allreduce(&errs, &toterrs, 1, MPI_INT, MPI_SUM, newcomm);
if (err)
errs += ReportErr(err, "Allreduce");
MPI_Comm_free(&newcomm);
MPI_Finalize();
if (wrank == 0) {
if (toterrs > 0) {
printf(" Found %d errors\n", toterrs);
}
else {
printf(" No Errors\n");
}
}
return 0;
}
