Question

我正在尝试使用C ++发送/接收如下所示的数据结构：

/* PSEUDOCODE */
const int N = getN(); // not available at compile time
const int M = getM();
struct package{
    int    foo;
    double bar;
    /* I know array members do not work this way,
       this is pseudocode. */
    int    flop[N];
    double blep[M];
};

由于M和N在运行时是恒定的，因此我可以执行MPI_Type_create_struct()并且新的数据类型在整个过程中都很好。

我的问题是如何实现如上所述的数据结构。

std::vector<>无法使用，因为它不是串行的。

像[]或[0]这样的灵活数组成员在c ++中是未定义的行为，它不适用于M和N的两个。

因此，我不得不使用malloc()：

class Package {
public:
  // in buffer[]: bar, blep[], foo, flop[]
  // in that order and one directly follows another.
  Package():
    buffer((double*) malloc((M + 1) * sizeof(double) + 
                            (N + 1) * sizeof(int))),
    bar(buffer), blep(buffer + 1),
    foo((int*) (blep + M)),
    flop(foo + 1) {}
  ~Package(){
    free(buffer);
  }

  // construct / free the derived datatype
  static void initialize(unsigned inN, unsigned inM) {
    N = inN;
    M = inM;
    MPI_Aint offsets[2] = {0, (int)(sizeof(double)) * (M + 1)};
    int      blocks[2]  = {M + 1, N + 1};
    MPI_Datatype types[2] = {MPI_DOUBLE, MPI_INT};
    MPI_Type_create_struct(2, blocks, offsets, types, &packageType);
    MPI_Type_commit(&packageType);
  }
  static void finalize() {
    MPI_Type_free(&packageType);
  }

  int send(int rank, int tag) {
    return MPI_Send(buffer, 1, packageType, 
                    rank, tag, MPI_COMM_WORLD);
  }
  int recv(int rank, int tag) {
    return MPI_Recv(buffer, 1, packageType, 
                    rank, tag, MPI_COMM_WORLD, 
                    MPI_STATUS_IGNORE);
  }
private:
  double * buffer;

  static int M;
  static int N;
  static MPI_Datatype packageType;
public:
  // interface variables
  double * const bar;
  double * const blep;
  int    * const foo;
  int    * const flop;
};

int Package::N = 0;
int Package::M = 0;
MPI_Datatype Package::packageType = MPI_CHAR;

我测试了上面的代码，它似乎可以正常工作，但是我不确定我是否正在执行实际上未定义的行为。具体来说：

为sizeof()使用MPI_Type_create_struct()可以吗？我发现一些示例使用MPI_Type_get_extent()，但我不知道有什么区别。
我不确定将新数据类型存储在static成员中是否是一个好主意。我发现的示例将其作为参数传递了出去。有什么具体原因吗？
如果此方法可移植，我也会感到困惑。我希望，它应该与基于struct的方法一样可移植，但是也许我遗漏了一些东西？

Answer 1

如果此方法可移植，我也会感到困惑。我希望它应该与基于结构的方法一样可移植，但是也许我遗漏了一些东西？

1。假设您有一些类型\'80 - \'a5和double而不是int和A。然后可能会发生类型B的对象未对齐，您为此对象分配了 B之后的空间。在某些尝试访问此类对象（例如A位于（4N + 2）字节边界处）的体系结构上，会导致 Bus错误。因此，通常情况下，您必须确保在第一个int对象之前填充正确。当您使用B时，编译器会为您完成。

2。访问struct的方式是UB。本质上，您正在执行此操作：

buffer

这里的问题是在double* buffer = reinterpret_cast<double*>(malloc(...)); double* bar = buffer; int* foo = reinterpret_cast<int*>(buffer + 1); do_something(buffer); double bar_value = *bar; // This is UB int foo_value = *foo; // This is UB, too和double上没有int和*bar类型的对象。您可以使用展示位置*foo创建它们：

new

请参阅this question。

对于数组，您可以使用char* buffer = reinterpret_cast<char*>(malloc(...)); double* bar = new(buffer) double; int* foo = new(buffer + sizeof(double)) int;来构造给定范围内的对象。

我不确定将新数据类型存储在静态成员中是否是一个好主意。我发现的示例将其作为参数传递了出去。有什么具体原因吗？

如果std::uninitialized_default_construct和N是静态的，那么将M也设为静态似乎很好。如果只有一种类型的packageType固定了Package和N，则可能希望避免每次构造M时都要调用MPI_Type_create_struct基本相同的MPI数据类型。

但是这种设计看起来不太好：应该在进行首次构造之前调用Package。可能您可以创建一个工厂，该工厂首先创建MPI数据类型，然后根据用户请求使用initialize()之类的构造Package。然后每个工厂可以有自己的非静态Package make_package()和N。

具有灵活大小的结构的MPI派生数据类型

1 个答案: