Uso de vectores en MPI (C++)

Question

Soy nuevo en la programación MPI, stiil learning, tuve éxito hasta crear los tipos de datos derivados definiendo las estructuras. Ahora quiero incluir Vector en mi estructura y quiero enviar los datos a través del Proceso. por ejemplo:

struct Structure{ 

//Constructor 
Structure(): X(nodes),mass(nodes),ac(nodes) { 

//code to calculate the mass and accelerations 
} 
//Destructor 
Structure() {} 

//Variables 
double radius; 
double volume; 
vector<double> mass; 
vector<double> area; 

//and some other variables 

//Methods to calculate some physical properties 

Ahora, al usar MPI, deseo enviar los datos en la estructura a través de los procesos. ¿Es posible para mí crear los vectores MPI_type_struct incluidos y enviar los datos?

He intentado leer a través de foros, pero no puedo obtener una imagen clara de las respuestas dadas allí. Espero poder obtener una idea clara o un enfoque para enviar los datos

PD: puedo enviar los datos individualmente, pero es una sobrecarga de enviar los datos usando MPI_Send/Receve si consideramos que el dominio es muy grande (digamos 10000 * 10000)

Answer 1

La definición de estructuras en MPI es un problema. Creo que un enfoque más fácil sería utilizar el hecho de que se garantiza que los vectores STL tienen memoria asignada contiguamente. Es decir, puedes tratarlos como matrices C al obtener un puntero al primer elemento.

std::vector<float> data; 
// ... add elements to your vector ... 
MPI_Send(&data.front(), data.size(), MPI_FLOAT, 0, 1, MPI_COMM_WORLD); 

Answer 2

Definitivamente no soy un experto en estructura de datos MPI, pero no creo que esto se pueda hacer. La razón es que básicamente tienes una estructura con punteros a los datos que se enviarán. Todas las funciones de tipo de datos MPI suponen que los datos que desea enviar se encuentran en un área contigua de la memoria. Si los vectores son de un tamaño máximo fijo, y se podía hacer

double radius; 
double volume; 
int mass_size; 
int area_size; 
double mass[MASS_MAXLEN]; 
double area[AREA_MAXLEN]; 

y luego enviar sólo los elementos que están llenos de.

Como alternativa, puede empaquetar los datos usted mismo en una matriz antes de la envía y envía la matriz. Tendría que hacer algunos perfiles para ver si esto era más rápido que hacer envíos por separado.

Answer 3

describo mi solución a un problema similar aquí:

Message Passing Arbitrary Object Graphs?

Recuerde que puede crear tipos de datos personalizados desde MPI MPI tipos de datos personalizados prevoiusly definidos. Por ejemplo, puede definir un Struct que describa el diseño y el contenido de una única instancia de Structure, luego un Vector de estos tipos de datos Struct para todo el vector de objetos. Diablos, si tiene varios de esos vectores, puede crear una tercera capa de abstracción, crear un tipo de datos HIndexed de Vectors of Structs, y luego enviarlos todos con un solo mensaje.

En la publicación que he vinculado anteriormente encontrará enlaces a las descripciones de los distintos tipos de datos MPI personalizados, que le ayudarán a decidir el enfoque adecuado.

Answer 4

Hago cosas como las que estás haciendo, y sé que la arquitectura de mi procesador es homogénea. Evito un montón de intercambio de bytes y un montón de MPI embalaje y desembalaje mediante el uso de Boost serialization.

Envío:

ostringstream oss; 
    { 
    binary_oarchive oa(oss); 
    oa << BOOST_SERIALIZATION_NVP(myStruct); 
    } 

    MPI::COMM_WORLD.Send(oss.str().c_str(), 
         oss.str().size(), 
         MPI::Datatype(MPI_BYTE), 
         MpiLibWrapper::DEST_PROC_RANK, 
         MpiLibWrapper::MY_STRUCT_TAG); 

Recepción:

vector<char> incomingBuffer(MAX_BUFFER_SIZE); 

    MPI::COMM_WORLD.Recv(&incomingBuffer[0], incomingBuffer.size(), 
         MPI::Datatype(MPI_BYTE), 
         MpiLibWrapper::SRC_PROC_RANK, 
         MpiLibWrapper::MY_STRUCT_TAG, 
         msgStatus); 
    if (MpiLibWrapper::ErrorOccurred(msgStatus.Get_error(), 
            info.logging)) { 
     break; 
    } 
    incomingBuffer.resize(msgStatus.Get_count(MPI::Datatype(MPI_BYTE))); 

    if (incomingBuffer.size() > 0) { 
     // Shockingly, this does not result in a memory allocation. 
     istringstream iss(string(&incomingBuffer[0], incomingBuffer.size())); 

     binary_iarchive ia(iss); 

     ia >> BOOST_SERIALIZATION_NVP(myStruct); 
    } 

Answer 5

Hmm ...Enviar C/C++ struct como una secuencia de datos funciona solo cuando se garantiza que el diseño de datos en todas las máquinas participantes es exactamente el mismo. En general, esto no funcionará. Además, hay personas que argumentan que el envío de una estructura empaquetada como un tipo de datos derivado de MPI es +1 para la claridad del código y para mostrar la intención.