MPI_Isend/MPI_Recv vs. MPI_Send/MPI_Irecv
up vote
1
down vote
favorite
For asynchronous communication in MPI which of the following is better (in terms of performance, reliability, readability, etc.):
- MPI_Isend with buffer and then MPI_Iprobe & MPI_Recv once the receiver is ready, or
- MPI_Irecv with buffer (such that there is always and MPI_Irecv posted with sufficient buffer) and then MPI_Send when the sender is ready?
The communication scenario is that data has to be exchanged asynchronously and the arrival times do not matter and both processes have workload. Only the overall performance (especially no blocking) is considered.
Below is a minimal working example (I did not include workload and the timings are thus probably not meaningful).
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char const *argv)
MPI_Init(NULL, NULL);
int world_size, world_rank;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
if (world_rank == 0 && world_size != 2)
fprintf(stderr, "This example requires two MPI processes.n");
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
/* Non Blocking Send */
int buf[100] = 0;
MPI_Barrier(MPI_COMM_WORLD);
double time = MPI_Wtime();
if (world_rank == 1)
MPI_Request request;
MPI_Isend(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
else
MPI_Recv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
usleep(100);
if (world_rank == 0)
printf("---n");
/* Non Blocking Receive */
MPI_Barrier(MPI_COMM_WORLD);
time = MPI_Wtime();
if (world_rank == 1)
MPI_Send(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD);
else
MPI_Request request;
MPI_Irecv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
On my machine this generates:
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000036 sec
---
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000026 sec
Thank you already for your answers and have a nice day :)
mpi
New contributor
add a comment |
up vote
1
down vote
favorite
For asynchronous communication in MPI which of the following is better (in terms of performance, reliability, readability, etc.):
- MPI_Isend with buffer and then MPI_Iprobe & MPI_Recv once the receiver is ready, or
- MPI_Irecv with buffer (such that there is always and MPI_Irecv posted with sufficient buffer) and then MPI_Send when the sender is ready?
The communication scenario is that data has to be exchanged asynchronously and the arrival times do not matter and both processes have workload. Only the overall performance (especially no blocking) is considered.
Below is a minimal working example (I did not include workload and the timings are thus probably not meaningful).
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char const *argv)
MPI_Init(NULL, NULL);
int world_size, world_rank;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
if (world_rank == 0 && world_size != 2)
fprintf(stderr, "This example requires two MPI processes.n");
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
/* Non Blocking Send */
int buf[100] = 0;
MPI_Barrier(MPI_COMM_WORLD);
double time = MPI_Wtime();
if (world_rank == 1)
MPI_Request request;
MPI_Isend(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
else
MPI_Recv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
usleep(100);
if (world_rank == 0)
printf("---n");
/* Non Blocking Receive */
MPI_Barrier(MPI_COMM_WORLD);
time = MPI_Wtime();
if (world_rank == 1)
MPI_Send(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD);
else
MPI_Request request;
MPI_Irecv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
On my machine this generates:
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000036 sec
---
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000026 sec
Thank you already for your answers and have a nice day :)
mpi
New contributor
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mindMPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.
– Gilles Gouaillardet
21 hours ago
add a comment |
up vote
1
down vote
favorite
up vote
1
down vote
favorite
For asynchronous communication in MPI which of the following is better (in terms of performance, reliability, readability, etc.):
- MPI_Isend with buffer and then MPI_Iprobe & MPI_Recv once the receiver is ready, or
- MPI_Irecv with buffer (such that there is always and MPI_Irecv posted with sufficient buffer) and then MPI_Send when the sender is ready?
The communication scenario is that data has to be exchanged asynchronously and the arrival times do not matter and both processes have workload. Only the overall performance (especially no blocking) is considered.
Below is a minimal working example (I did not include workload and the timings are thus probably not meaningful).
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char const *argv)
MPI_Init(NULL, NULL);
int world_size, world_rank;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
if (world_rank == 0 && world_size != 2)
fprintf(stderr, "This example requires two MPI processes.n");
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
/* Non Blocking Send */
int buf[100] = 0;
MPI_Barrier(MPI_COMM_WORLD);
double time = MPI_Wtime();
if (world_rank == 1)
MPI_Request request;
MPI_Isend(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
else
MPI_Recv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
usleep(100);
if (world_rank == 0)
printf("---n");
/* Non Blocking Receive */
MPI_Barrier(MPI_COMM_WORLD);
time = MPI_Wtime();
if (world_rank == 1)
MPI_Send(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD);
else
MPI_Request request;
MPI_Irecv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
On my machine this generates:
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000036 sec
---
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000026 sec
Thank you already for your answers and have a nice day :)
mpi
New contributor
For asynchronous communication in MPI which of the following is better (in terms of performance, reliability, readability, etc.):
- MPI_Isend with buffer and then MPI_Iprobe & MPI_Recv once the receiver is ready, or
- MPI_Irecv with buffer (such that there is always and MPI_Irecv posted with sufficient buffer) and then MPI_Send when the sender is ready?
The communication scenario is that data has to be exchanged asynchronously and the arrival times do not matter and both processes have workload. Only the overall performance (especially no blocking) is considered.
Below is a minimal working example (I did not include workload and the timings are thus probably not meaningful).
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char const *argv)
MPI_Init(NULL, NULL);
int world_size, world_rank;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
if (world_rank == 0 && world_size != 2)
fprintf(stderr, "This example requires two MPI processes.n");
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
/* Non Blocking Send */
int buf[100] = 0;
MPI_Barrier(MPI_COMM_WORLD);
double time = MPI_Wtime();
if (world_rank == 1)
MPI_Request request;
MPI_Isend(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
else
MPI_Recv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
usleep(100);
if (world_rank == 0)
printf("---n");
/* Non Blocking Receive */
MPI_Barrier(MPI_COMM_WORLD);
time = MPI_Wtime();
if (world_rank == 1)
MPI_Send(buf, 100, MPI_INT, 0, 0, MPI_COMM_WORLD);
else
MPI_Request request;
MPI_Irecv(buf, 100, MPI_INT, 1, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request, MPI_STATUS_IGNORE);
time = MPI_Wtime() - time;
printf("rank = %d, time = %f secn", world_rank, time);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
On my machine this generates:
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000036 sec
---
rank = 0, time = 0.000035 sec
rank = 1, time = 0.000026 sec
Thank you already for your answers and have a nice day :)
mpi
mpi
New contributor
New contributor
New contributor
asked 22 hours ago
Lukas Koestler
61
61
New contributor
New contributor
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mindMPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.
– Gilles Gouaillardet
21 hours ago
add a comment |
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mindMPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.
– Gilles Gouaillardet
21 hours ago
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mind
MPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.– Gilles Gouaillardet
21 hours ago
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mind
MPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.– Gilles Gouaillardet
21 hours ago
add a comment |
active
oldest
votes
active
oldest
votes
active
oldest
votes
active
oldest
votes
active
oldest
votes
Lukas Koestler is a new contributor. Be nice, and check out our Code of Conduct.
Lukas Koestler is a new contributor. Be nice, and check out our Code of Conduct.
Lukas Koestler is a new contributor. Be nice, and check out our Code of Conduct.
Lukas Koestler is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53204330%2fmpi-isend-mpi-recv-vs-mpi-send-mpi-irecv%23new-answer', 'question_page');
);
Post as a guest
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
The latter avoids unexpected messages (that could cause an increased memory usage). Also, keep in mind
MPI_Send()
might block if no matching receive has been posted. These are two reasons to go with the second option.– Gilles Gouaillardet
21 hours ago