MPICH: Como enviar uma struct e o que ela aponta recursivamente

[brunoais]

Eu tenho, para um trabalho que estou a fazer, que usar o MPICH (não me dão hipotese, tem mm q ser o MPICH) para por um programa a executar distribuido por várias máquinas.

Na faze em que estou, preciso de enviar uma struct pela rede. O problema é que todo o conteúdo que ela aponta tem que ir atráz. Isto significa que num caso como o meu que tenho algo do tipo:

struct A{
   int a;
   B* b;
   C** c;
};
struct B{
   char* d;
   int e;
   D* f;
};
struct C{
   int g;
};
struct D{
   int h;
};

Podem encontrar, se precisarem, o manual aqui:

http://www.mpi-forum.org/docs/mpi-3.0/mpi30-report.pdf

A parte sobre o assunto começa na página 131.

Há alguém que consiga ajudar-me como fazer isto para, por exemplo, o caso simplista que mostrei?

Eu não consigo perceber o manual correctamente

Edited June 15, 2013 at 06:24 PM by brunoais

[HappyHippyHippo]

existe algum problema em fazer :

struct A{
   int a;
   B* b;
   C** c;
};
struct B{
   char* d;
   int e;
   D* f;
};
struct C{
   int g;
};
struct D{
   int h;
};

struct Pack {
   int a;
   struct {
       char* d;
       int e;
       struct {
           int h;
       } f;
   } b;
   struct {
       int g;
   } c;
}

struct Pack do_pack(struct A)
{
 // pegar na info de struct A e enfiar numa struct Pack
}

[Rui Carlos]

A única solução que conheço passa por serializar os dados (mais ou menos o que o HHH fez).

Sempre que possível, convém ter estes pormenores em conta no planeamento das estruturas de dados, pois corres o risco de introduzir overheads com serializações que limitam fortemente a escalabilidade da solução que estás a desenvolver.

À partida também podias enviar os dados correspondentes a cada região contígua de memória em separado, evitando a serialização. Mas regra geral isso não compensa, devido ao peso da latência nas comunicações.

EDIT: Aparentemente pretendes usar o MPI_Pack (função à qual nunca recorri).

Em todo o caso, penso que precisas de algo deste género:

struct A x;
char buffer[N];
int position = 0;

MPI_Pack(&(x.a), 1, MPI_INT, buffer, N, &position, MPI_COMM_WORLD);
int len = strlen(x.b.d)+1;  // só funciona com strings...
MPI_Pack(&len, 1, MPI_INT, buffer, N, &position, MPI_COMM_WORLD); // isto é necessário para o MPI_Unpack
MPI_Pack(x.b.d, len, MPI_CHAR, buffer, N, &position, MPI_COMM_WORLD);
MPI_Pack(&(x.b.e), 1, MPI_INT, buffer, N, &position, MPI_COMM_WORLD);
//...

Mas penso que as vantagens em usar o MPI_Pack são reduzidas.

[brunoais]

EDIT: Aparentemente pretendes usar o MPI_Pack (função à qual nunca recorri).

Era sobre isso que eu referia-me 🙂 . É isso que planeio usar. Mas preciso de saber melhor como usar para o que quero...

Pelo que li do manual, ele é capaz de copiar isso tudo directamente para algo correspondente do outro lado (uma struct igual, mas pode ter as várias memórias contíguas em locais diferentes).

O programa usa pouca comunicação e está bem preparado para esconder bem a latência da comunicação.

Só falta mm lidar com isto. Foi um problema que me esqueci de verificar correctamente, infelizmente... O prazo que falta para entrega é curto e se n conseguir descobrir como usar o pack correctamente vou ter que arranjar uma maneira de serializar isto tudo...

A resposta do @HappyHippyHippo não é muito completa mas vou pegar no manual e no que o @HappyHippyHippo fez e tentar fazer...

@HappyHippyHippo Se poderes fazer uma resposta mais completa seria bom. Especialmente se indicasses um código exemplo.

[Rui Carlos]

brunoais, vê o código que adicionei à minha mensagem anterior.

[HappyHippyHippo]

o código do exemplo seria seria:

struct Pack do_pack(struct A dados)
{
 struct Pack pack;

 pack.a = dados.a;        // guarda a info da struct A
 pack.b = *dados.b;       // guarda a info da struct B
 pack.b.f = *(*dados.b).f;// guarda a info da struct D
 pack.c = **dados.c;      // guarda a info da struct C

 return pask;
}

struct A dados;
struct Pack pack = do_pack(dados);

// pack é feito de dados contíguos (serializável sem problemas)

[Rui Carlos]

Já agora, penso que o que o HHH tem precisa de algumas melhorias, nomeadamente, tens que remover de lá o char* d;.

Se tiveres uma estrutura sem apontadores, já podes fazer send como se a estrutura fosse um array de bytes, e usas o sizeof para calcular o tamanho.

EDIT1: Para campos de tamanho variável (arrays, strings, etc.), tens que enviar o tamanho primeiro, e depois envias o campo.

EDIT2: Estava aqui a pensar como é que faria a serialização à mão e cheguei à conclusão que, assumindo que o B.d e o A.c são arrays, usar o MPI_Pack até é capaz de ajudar. Sem o MPI_Pack, penso que será mais simples serializar para um array de bytes do que para uma struct.

[brunoais]

Pois... Esqueci-me de indicar que o:

   C** c;

É um array variável de elementos.

Pode-se assumir que o seu tamanho é o valor que está em a (na struct A).

Pelo menos, Rui Carlos... Pensaste nisso 🙂

Edited June 16, 2013 at 08:20 AM by brunoais