MPI_SEND - 将结构作为向量发送

Question

Considering this structure:

struct Book {
 int id;
 string title;
};

And this vector:

vector<Book> books;

How can I use MPI_Send in order to send the elements of vector books ?

I have tried to find a way to do this the entire day, but no results.

Answer 1

With title being a char[N] array of fixed size N , you could've created a new datatype and use it in MPI_Send . Unfortunately, this approach won't work with std::string as a data member. But you can send std::vector<Book> element-by-element.

For example:

std::vector<Book> books;
// ...
const unsigned long long size = books.size();
MPI_Send(&size, 1, MPI_UNSIGNED_LONG_LONG, ...);
for (const auto& book : books) {
    MPI_Send(&book.id, 1, MPI_INT, ...);
    const unsigned long long len = book.title.length(); 
    MPI_Send(&len, 1, MPI_UNSIGNED_LONG_LONG, ...);
    MPI_Send(book.title.data(), len, MPI_CHAR, ...);
}

and

std::vector<Book> books;
unsigned long long size;
MPI_Recv(&size, 1, MPI_UNSIGNED_LONG_LONG, ...);
books.resize(size);
for (auto& book : books) {    
    MPI_Recv(&book.id, 1, MPI_INT, ...);
    unsigned long long len;
    MPI_Recv(&len, 1, MPI_UNSIGNED_LONG_LONG, ...);
    std::vector<char> str(len);
    MPI_Recv(str.data(), len, MPI_CHAR, ...);
    book.title.assign(str.begin(), str.end());
}
// ...

Answer 2

Method 1

One way to do this is to set the title to a constant length. You can then build an MPI data type around your struct, like so:

#include "mpi.h"
#include <iostream>
#include <string>
#include <vector>

const int MAX_TITLE_LENGTH = 256;

struct Book {
  int id;
  char title[MAX_TITLE_LENGTH];
};

int main(int argc, char *argv[]){
  MPI_Init(&argc, &argv);

  std::vector<Book> books(343);

  MPI_Datatype BookType;
  MPI_Datatype type[2] = { MPI_INTEGER, MPI_CHAR };
  int blocklen[2] = { 1, MAX_TITLE_LENGTH };

  MPI_Aint disp[2];
  disp[0] = 0;
  disp[1] = sizeof(int);
  MPI_Type_create_struct(2, blocklen, disp, type, &BookType);
  MPI_Type_commit(&BookType);

  int myrank;
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  if (myrank == 0) {
    books[3].id = 4;
    MPI_Send(books.data(), 343, BookType, 1, 123, MPI_COMM_WORLD);
  } else if (myrank == 1) {
    MPI_Status status;
    MPI_Recv(books.data(), 343, BookType, 0, 123, MPI_COMM_WORLD, &status);
    std::cout<<books[3].id<<std::endl;
  }
  MPI_Finalize();
  return 0;
}

Method 2

MPI is best used for quickly exchange numbers across grids of known size. But it can also work as a handy communication layer. To do so, we can use the Cereal library to serialize arbitrary C++ objects and then send the serialized representations using MPI, as follows. This is slower than using MPI as designed because there are more intermediate copies, but provides the flexibility of using the full flexibility of C++.

#include "mpi.h"
#include <cereal/types/vector.hpp>
#include <cereal/types/string.hpp>
#include <cereal/archives/binary.hpp>
#include <sstream>
#include <string>

struct Book {
  int id;
  std::string title;
  template <class Archive>
  void serialize( Archive & ar ) { ar(id,title); }
};

template<class T>
int MPI_Send(const T &data, int dest, int tag, MPI_Comm comm){
  std::stringstream ss;
  { //Needed for RAII in Cereal
    cereal::BinaryOutputArchive archive( ss );
    archive( data );
  }
  const auto serialized = ss.str();
  return MPI_Send(serialized.data(), serialized.size(), MPI_CHAR, dest, tag, MPI_COMM_WORLD);
}

template<class T>
int MPI_Recv(T &data, int source, int tag, MPI_Comm comm, MPI_Status *status){
  //Get number of bytes in incoming message
  MPI_Probe(source, tag, MPI_COMM_WORLD, status);
  int num_incoming;
  MPI_Get_count(status, MPI_CHAR, &num_incoming);

  //Allocate a buffer of appropriate size
  std::vector<char> incoming(num_incoming);

  //Receive the data
  auto ret = MPI_Recv(incoming.data(), num_incoming, MPI_CHAR, source, tag, MPI_COMM_WORLD, status);
  std::stringstream ss;
  ss.write(incoming.data(), num_incoming);

  //Unpack the data
  {
    cereal::BinaryInputArchive archive(ss);
    archive(data);
  }

  return ret;
}

int main(int argc, char **argv){
  MPI_Init(&argc, &argv);

  std::vector<Book> books(343);

  int myrank;
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  if (myrank == 0) {
    books[3].id    = 4;
    books[3].title = "Hello, world!";

    MPI_Send(books, 1, 123, MPI_COMM_WORLD);

  } else if (myrank == 1){
    MPI_Status status;
    MPI_Recv(books, 0, 123, MPI_COMM_WORLD, &status);
    std::cout<<books[3].id<<" "<<books[3].title<<std::endl;
  }

  MPI_Finalize();

  return 0;
}