MPI benutzerdefinierte Datentypen, ist das, was ich tue sicher?

Question

Zum ersten Mal mit MPI außerhalb einiger einfachen Praxis-Anwendungen, und etwas nicht richtig abgeht.

Ich habe eine Klasse mit den folgenden Mitgliedern (Methoden aus Gründen der Lesbarkeit und zur Erhaltung des Platz auf dem Bildschirm weggelassen) definiert:

class particle
{
    public:
        double _lastUpdate;
    float _x, _y, _xvel, _yvel;
    bool _isStatic;
        bool _isForeign;
        float _size;

    private:
        int _isStaticInt;           // integer copy of _isStatic to be sent over MPI ( since there's no MPI_BOOL :C )
};

Ich möchte Sätze von Partikeln zwischen Prozessen senden, indem die Werte einiger Schlüsselelemente jedes Teilchen sendet und an Ort und Stelle, die anderen zu replizieren. Zu diesem Zweck definiere ich einen MPI-Datentyp als solche; wie Sie sehen können, die Mitglieder _lastUpdate, _isStatic und _isForeign sind nicht enthalten:

MPI_Datatype types[] = { MPI_FLOAT, MPI_FLOAT, MPI_FLOAT, MPI_FLOAT, MPI_INTEGER, MPI_FLOAT };
std::vector<int> len(6, 1);
std::vector<MPI_Aint> disp(6, 0);
particle temp;
MPI_Aint base;
MPI_Address(&temp, &base);
MPI_Address(&temp._x, &disp[0]);
MPI_Address(&temp._y, &disp[1]);
MPI_Address(&temp._xvel, &disp[2]);
MPI_Address(&temp._yvel, &disp[3]);
MPI_Address(&temp._isStaticInt, &disp[4]);
MPI_Address(&temp._size, &disp[5]);
for (int i=0; i<6; ++i)
{
    disp[i] = disp[i] - base;
}
MPI_Type_struct(6, &len[0], &disp[0], types, &_particleType);
MPI_Type_commit(&_particleType);

Dies ist, wie ich die Partikel zu senden; ‚Teile‘ ist ein Vektor von Teilchen *, die Zeiger auf die Partikel Objekte enthält ich senden wollen, und ‚Größe‘ ist parts.size ().

std::vector<int> len(size, 1);
std::vector<MPI_Aint> disp(size, 0);
MPI_Aint base;
MPI_Address(parts[0], &base);                   // datatype begins at the first selected object
for (int select = 1; select < size; ++select)
{
    MPI_Address(parts[select], &disp[select]);
    disp[select] = disp[select] - base;
}
MPI_Type_hindexed(size, &len[0], &disp[0], _particleType, &_sendType);
MPI_Type_commit(&_sendType);

MPI_Request payload_req;
MPI_Isend(parts[0], 1, _sendType, ngb, 0, _cartesian_comm, &payload_req);

Empfangen geschieht ähnlich, nur in diesem Fall ‚Teile‘ ist ein Vektor von Teilchen *, die zuvor erstellten „leer“ particle Objekte verweist, deren Mitglieder mit den Daten gefüllt werden wir erhalten:

std::vector<int> len(size, 1);
std::vector<MPI_Aint> disp(size, 0);
MPI_Aint base;
MPI_Address(parts[0], &base);                       // datatype begins at the first newly inserted object
for (int part = 1; part < size; ++part)
{
    MPI_Address(parts[part], &disp[part]);
    disp[part] = disp[part] - base;
}
MPI_Type_hindexed(size, &len[0], &disp[0], _particleType, &_recvType);
MPI_Type_commit(&_recvType);
MPI_Status status;
MPI_Recv(parts[0], size, _particleType, ngb, 0, _cartesian_comm, &status);

Das Problem ist, dass alle empfangenen Teilchen mit Ausnahme der ersten die Standard „leeren“ Werte in ihre Mitglieder haben. Ich schrieb einen kleinen Test-App vor, dass hätte etwas ähnliches, und das funktionierte einwandfrei, obwohl es nur ein paar einfachen Werte übertragen. Dies führt mich zu glauben, es sei denn, eine Codierung Fehler ist Ich bin nicht hier zu bemerken (durchaus möglich), diese Art von Datentyp List ist nicht garantiert, und die kleine, die nur tut dies durch Zufall funktioniert.

Kann jemand bestätigen / verweigern, wenn diese Art von Speichermanipulationssicher ist und soll darauf verlassen?

Answer 1

Es macht nichts, es scheint, dass einfach die Frage eingeben aus machte mir klar, was los ist.

Der Befehl sollte erhalten werden:

MPI_Recv(parts[0], 1, _recvType, ngb, 0, _cartesian_comm, &status);