MPI types de données utilisateur, est ce que je fais en toute sécurité?

Question

La première fois en utilisant MPI en dehors de certaines applications pratiques simples, et quelque chose ne va pas droit.

J'ai une classe définie par les membres suivants (méthodes omis par souci de lisibilité et de conservation de l'espace de l'écran):

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 )
};

Je veux envoyer des ensembles de particules entre les processus en envoyant les valeurs de certains membres clés de chaque particule, et reproduisant les autres sur place. A cet effet, je définir un type de données MPI en tant que tel; comme vous pouvez le voir, les membres _lastUpdate, _isStatic et _isForeign ne sont pas inclus:

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);

Voici comment j'envoie les particules; « Parties » est un vecteur de particules * qui contient des pointeurs vers les objets de particules que je veux envoyer, et « taille » est 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);

De même se réception, seulement dans ce cas, « parties » est un vecteur de particules * qui pointe vers les objets créés précédemment de particules « blanc », dont les membres doivent être remplis avec les données que nous recevons:

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);

Le problème est que toutes les particules reçues sauf la première ont les valeurs par défaut « blanc » dans leurs membres. J'ai écrit une petite application de test avant que quelque chose de semblable a fait, et cela a fonctionné parfaitement, même si elle ne transmet quelques valeurs simples. Cela me conduit à beleive que si il y a une erreur de codage Je ne suis pas remarquer ici (tout à fait possible), ce genre de supercherie datatype est pas garanti, et le petit qui fonctionne le fait que par accident.

Quelqu'un peut-il confirmer / nier si ce type de manipulation de la mémoire est sûre et doit se fier?

Answer 1

Peu importe, il semble que tout simplement taper la question m'a fait comprendre ce qui ne va pas.

La commande doit être recevoir:

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