Deadlock mit MPI

Ich experimentiere mit MPI und Frage mich, ob dieser code kann einen deadlock verursachen.

MPI_Comm_rank (comm, &my_rank);
if (my_rank == 0) {
   MPI_Send (sendbuf, count, MPI_INT, 1, tag, comm);
   MPI_Recv (recvbuf, count, MPI_INT, 1, tag, comm, &status);
} else if (my_rank == 1) {
   MPI_Send (sendbuf, count, MPI_INT, 0, tag, comm);
   MPI_Recv (recvbuf, count, MPI_INT, 0, tag, comm, &status);
}

InformationsquelleAutor user1170330 | 2013-12-08

deadlock mpi

13

MPI_Send kann oder nicht blockieren kann. Es wird blockiert, bis der sender wieder verwenden können, die Absender-Puffer. Einige Implementierungen wird an den Aufrufer zurückgeben, wenn der Puffer wurde an einer unteren Kommunikationsschicht. Einige andere werden an den Aufrufer zurückgeben, wenn es einen passenden MPI_Recv() am anderen Ende. So ist es bis zu Ihrem MPI-Implementierung, ob es sich bei diesem Programm wird deadlock oder nicht.

Weil dieses Programm verhält sich anders bei verschiedenen MPI-Implementierungen, können Sie erwägen, nach dem umschreiben des es so es wird nicht möglich sein deadlocks:
```
MPI_Comm_rank (comm, &my_rank);
if (my_rank == 0) {
   MPI_Send (sendbuf, count, MPI_INT, 1, tag, comm);
   MPI_Recv (recvbuf, count, MPI_INT, 1, tag, comm, &status);
} else if (my_rank == 1) {
   MPI_Recv (recvbuf, count, MPI_INT, 0, tag, comm, &status);
   MPI_Send (sendbuf, count, MPI_INT, 0, tag, comm);
}
```
Immer bewusst sein, dass für jeden MPI_Send() es muss ein pairing MPI_Recv() beide "parallel" in der Zeit. Dies kann zum Beispiel der Ende in der Sackgasse, weil die pairing-send/recv-Aufrufe werden nicht ausgerichtet in der Zeit. Sie kreuzen einander:
```
RANK 0                          RANK 1
----------                      -------
MPI_Send() ---            ----  MPI_Send()    |
              ---      ---                    |
                 ------                       |
                   --                         | TIME
                 ------                       |
              ---      ---                    |
MPI_Recv() <--            --->  MPI_Recv()    v
```
Diese Prozesse, auf die andere Weise, nicht das Ende in der Sackgasse, vorausgesetzt natürlich, dass es in der Tat zwei Prozesse, die Reihen mit 0 und 1 in die gleiche communicator-Domäne.
```
RANK 0                          RANK 1
----------                      -------
MPI_Send() ------------------>  MPI_Recv()   |
                                             | TIME
                                             |
MPI_Recv() <------------------  MPI_Send()   v
```
Den oben genannten festen Programm kann fehlschlagen, wenn die Größe des communicator com nicht erlauben, Rang 1 (nur 0). So, die if-else nicht nehmen, die else route und somit kein Prozess, hören für die MPI_Send() und Rang 0 wird deadlock.

Wenn Sie müssen verwenden Sie Ihre aktuelle Kommunikation layout, dann können Sie es vorziehen, verwenden Sie MPI_Isend() oder MPI_Issend() statt für nichtblockierende sends, also die Vermeidung von deadlock.

InformationsquelleAutor mcleod_ideafix
5

Den post von @mcleod_ideafix ist sehr gut. Ich will hinzufügen, ein paar mehr Dinge über nicht-blockierende MPI-Aufrufe.

Den meisten MPI-Implementierungen ist, dass Sie kopieren Sie die Daten aus dem user-buffer in einen anderen Ort. Könnte es einen internen Puffer, um die Umsetzung, es könnte etwas besser auf die richtige Art von Netzwerken. Wenn die Daten kopiert aus der Benutzer-Puffer und der Puffer kann wiederverwendet werden, indem die Anwendung, die MPI_SEND Aufruf zurückgegeben. Dies kann sein, bevor die passende MPI_RECV aufgerufen wird, oder es kann nicht. Je größer die Daten, die Sie senden, desto mehr wahrscheinlich, dass Ihre Nachricht wird blockiert, bis der MPI_RECV Anruf.

Der beste Weg, um dies zu vermeiden, ist die Verwendung nicht-blockierende Aufrufe MPI_IRECV und MPI_ISEND. Auf diese Weise können Sie nach Ihrem MPI_IRECV ersten, dann machen Sie Ihren Anruf zu MPI_ISEND. Dies vermeidet zusätzliche Kopien, wenn die Nachrichten ankommen (weil der Puffer zu halten, ist bereits über die MPI_IRECV), das macht es schneller, und es vermeidet die deadlock-situation. So, jetzt würde der code wie folgt Aussehen:
```
MPI_Comm_rank (comm, &my_rank);
if (my_rank == 0) {
   MPI_Irecv (recvbuf, count, MPI_INT, 1, tag, comm, &status, &requests[0]);
   MPI_Isend (sendbuf, count, MPI_INT, 1, tag, comm, &requests[1]);
} else if (my_rank == 1) {
   MPI_Irecv (recvbuf, count, MPI_INT, 0, tag, comm, &status, &requests[0]);
   MPI_Isend (sendbuf, count, MPI_INT, 0, tag, comm, &requests[1]);
}
MPI_Waitall(2, request, &statuses);
```
InformationsquelleAutor Wesley Bland
2

Als mcleod_ideafix erklärte Ihr code kann in eine Sackgasse.
Hier gehen Sie: Erklärung und zwei mögliche Problem-Lösungen, die einen durch Neuanordnen der Reihenfolge der Ausführung, eines nach dem asynchronen send-recv Aufrufe

Hier ist die Lösung mit async Aufrufe:
```
if (rank == 0) {
        MPI_Isend(..., 1, tag, MPI_COMM_WORLD, &req);
        MPI_Recv(..., 1, tag, MPI_COMM_WORLD, &status);
        MPI_Wait(&req, &status);
} else if (rank == 1) {
        MPI_Recv(..., 0, tag, MPI_COMM_WORLD, &status);
        MPI_Send(..., 0, tag, MPI_COMM_WORLD);
}
```
InformationsquelleAutor Markus Weber

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.