通过创建 MPI 驱动的数据类型发送包含 void* 的 typedef 结构。

Question

我对 MPI 规范的理解是 MPI 发送原语指的是要发送的数据所指向的内存位置（或发送缓冲区） 并获取该位置的数据，然后将其作为消息传递给另一个进程。

虽然给定进程的虚拟地址在另一个进程的内存地址中是没有意义的； 可以发送指针所指向的数据，例如 void 指针，因为 MPI 会以任何方式将数据本身作为消息传递

例如以下正确工作：

    // Sender Side.
    int x = 100;
    void* snd;
    MPI_Send(snd,4,MPI_BYTE,1,0,MPI_COMM_WORLD);   

    // Receiver Side.
    void* rcv;
    MPI_Recv(rcv, 4,MPI_BYTE,0,0,MPI_COMM_WORLD); 

但是当我在结构中添加 void* snd 并尝试发送结构时，这将不会成功。

我不明白为什么前面的例子可以正常工作，但下面的例子却不能。

在这里，我定义了一个 typedef 结构，然后从中创建了一个 MPI_DataType。 与上述相同的解释，以下也应该成功， 不幸的是，它不起作用。

代码如下：

    #include "mpi.h"
    #include<stdio.h>

    int main(int args, char *argv[])
    {
        int rank, source =0, tag=1, dest=1;
        int bloackCount[2];

        MPI_Init(&args, &argv);

        typedef struct {
            void* data;
            int tag; 
        } data;

        data myData;    

        MPI_Datatype structType, oldType[2];
        MPI_Status stat;

        /* MPI_Aint type used to idetify byte displacement of each block (array)*/      
        MPI_Aint offsets[2], extent;
        MPI_Comm_rank(MPI_COMM_WORLD, &rank);


        offsets[0] = 0;
        oldType[0] = MPI_BYTE;
            bloackCount[0] = 1;

        MPI_Type_extent(MPI_INT, &extent);

        offsets[1] = 4 * extent;  /*let say the MPI_BYTE will contain ineteger :         size of int * extent */
        oldType[1] = MPI_INT;
        bloackCount[1] = 1;

        MPI_Type_create_struct(2, bloackCount,offsets,oldType, &structType);
        MPI_Type_commit(&structType);


        if(rank == 0){
    int x = 100;
    myData.data = &x;
    myData.tag = 99;
    MPI_Send(&myData,1,structType, dest, tag, MPI_COMM_WORLD);
}
if(rank == 1 ){ 
    MPI_Recv(&myData, 1, structType, source, tag, MPI_COMM_WORLD, &stat);
          // with out this the following printf() will properly print the value 99 for 
          // myData.tag
    int x = *(int *) myData.data;
    printf(" \n Process %d, Received : %d , %d \n\n", rank , myData.tag, x); 
    }   
       MPI_Type_free(&structType);             
       MPI_Finalize();
    }

运行代码的错误信息： [看起来我试图在第二个进程中访问无效的内存地址空间]

    [ubuntu:04123] *** Process received signal ***
    [ubuntu:04123] Signal: Segmentation fault (11)
    [ubuntu:04123] Signal code: Address not mapped (1)
    [ubuntu:04123] Failing at address: 0xbfe008bc
    [ubuntu:04123] [ 0] [0xb778240c]
    [ubuntu:04123] [ 1] GenericstructType(main+0x161) [0x8048935]
    [ubuntu:04123] [ 2] /lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)         [0xb750f4d3]
    [ubuntu:04123] [ 3] GenericstructType() [0x8048741]
    [ubuntu:04123] *** End of error message ***

请向我解释为什么它不起作用。 任何建议也将不胜感激

谢谢，

Answer 1

// Sender Side.
int x = 100;
void* snd;
MPI_Send(snd,4,MPI_BYTE,1,0,MPI_COMM_WORLD);

// Receiver Side.
void* rcv;
MPI_Recv(rcv, 4,MPI_BYTE,0,0,MPI_COMM_WORLD);

我不明白为什么前面的例子能正常工作，但下面的例子却不能。

它可以工作（当然，snd 和 rcv 必须分配有意义的内存位置作为值），因为 MPI_Send 和 MPI_Recv 获取数据位置的地址，snd 和 @987654327 @ 是指针，即它们的值就是这样的地址。例如，MPI_Send 行不是发送指针本身的值，而是发送从 snd 指向的位置开始的 4 个字节。对MPI_Recv 的调用和rcv 的使用也是如此。为了发送指针的值而不是它指向的值，您必须使用：

MPI_Send(&snd, sizeof(void *), MPI_BYTE, ...);

这将发送sizeof(void *) 字节，从存储指针值的地址开始。除非有一些超级特殊的情况，否则这没什么意义。

为什么您的第二个示例不起作用？ MPI 不是魔术师，它无法识别部分内存包含指向另一个内存块的指针并跟随该指针。也就是说，当你构造一个结构化数据类型时，没有办法告诉 MPI 结构的第一个元素实际上是一个指针，并让它读取这个指针指向的数据。换句话说，您必须执行显式数据编组 - 构造和中间缓冲区，其中包含由data.data 指向的内存区域的副本。此外，您的数据结构不包含有关data 指向的内存区域长度的信息。

请注意一些非常重要的事情。所有 MPI 数据类型都有一个叫做类型映射的东西。类型映射是一个元组列表，其中每个元组，也称为类型签名，具有(basic_type, offset) 的形式，其中basic_type 是原始语言类型，例如char、int、double 等，offset 是相对于缓冲区开头的偏移量。 MPI 的一个特殊功能是偏移量也可以是负数，这意味着MPI_Send（或MPI_Recv，或任何其他通信函数）的参数实际上可能指向内存区域的中间，这将服务作为数据源。发送数据时，MPI 遍历类型映射并从对应的offset 中获取一个类型为basic_type 的元素，相对于提供的数据缓冲区地址。内置的 MPI 数据类型只有一个条目的类型映射，偏移量为0，例如：

MPI_INT      -> (int, 0)
MPI_FLOAT    -> (float, 0)
MPI_DOUBLE   -> (double, 0)

MPI 中不存在任何数据类型，这可以使其脱离指针并获取它指向的值而不是指针值本身。

offsets[0] = 0;
oldType[0] = MPI_BYTE;
blockCount[0] = 1;

MPI_Type_extent(MPI_INT, &extent);

offsets[1] = 4 * extent;
oldType[1] = MPI_INT;
blockCount[1] = 1;

MPI_Type_create_struct(2, blockCount, offsets, oldType, &structType);

此代码创建具有以下类型映射的 MPI 数据类型（假设 int 为 4 个字节）：

{(byte, 0), (int, 16)}

当作为 MPI_Send 的类型参数提供时，它将指示 MPI 库从数据缓冲区的开头获取一个字节，然后获取位于数据缓冲区开头之后 16 个字节处的整数值.尽管缓冲区的跨度为 20 字节，但消息的总长度为 5 个字节。

offsets[0] = offsetof(data, data);
oldType[0] = MPI_CHAR;
blockCount[0] = sizeof(void *);

offsets[1] = offsetof(data, tag);
oldType[1] = MPI_INT;
blockCount[1] = 1;

MPI_Type_create_struct(2, blockCount, offsets, oldType, &structType);

这段代码取自 Greg Inozemtsev 的回答，创建了一个具有以下类型映射的数据类型（假设 32 位机器具有 32 位宽的指针和零填充）：

{(char, 0), (char, 1), (char, 2), (char, 3), (int, 4)}

(char, x) 类型的数量等于sizeof(void *)（假设为 4）。如果用作数据类型，这将占用缓冲区开头的 4 个字节（即指针的值，地址，而不是它指向的实际 int！），然后它将占用 4 个字节后的整数开头，即结构中tag字段的值。再一次，您将发送指针的地址，而不是该指针指向的数据。

MPI_CHAR 和MPI_BYTE 之间的区别在于，MPI_BYTE 类型的数据不会进行类型转换。这仅在异构环境中运行 MPI 代码时相关。使用MPI_CHAR，库可能会执行数据转换，例如将每个字符从 ASCII 转换为 EBCDIC 字符集，反之亦然。在这种情况下使用MPI_CHAR 是错误的，但是在异构环境中发送指针则更加错误，所以不用担心；）

鉴于这一切，如果我是你，我会考虑 suszterpatt 提出的解决方案。

---

对于显式数据编组，有两种可能的情况：

场景 1.data.data 指向的每个数据项的大小都是恒定的。在这种情况下，您可以通过以下方式构造结构数据类型：

typedef struct {
   int tag;
   char data[];
} data_flat;

// Put the tag at the beginning
offsets[0] = offsetof(data_flat, tag);
oldType[0] = MPI_INT;
blockCount[0] = 1;

offsets[1] = offsetof(data_flat, data);
oldType[1] = MPI_BYTE;
blockCount[1] = size of the data;

MPI_Type_create_struct(2, blockCount, offsets, oldType, &structType);
MPI_Type_commit(&structType);

然后像这样使用它：

// --- Sender ---

// Make a temporary buffer to hold the data
size_t total_size = offsetof(data_flat, data) + size of the data;
data_flat *temp = malloc(total_size);

// Copy data structure content into the temporary flat structure
temp->tag = data.tag;
memcpy(temp->data, data.data, size of the data);

// Send the temporary structure
MPI_Send(temp, 1, structType, ...);

// Free the temporary structure
free(temp);

您也可能不会释放临时存储空间，而是将其重新用于data 结构的其他实例（因为假设它们都指向相同大小的数据）。接收者是：

// --- Receiver ---

// Make a temporary buffer to hold the data
size_t total_size = offsetof(data_flat, data) + size of the data;
data_flat *temp = malloc(total_size);

// Receive into the temporary structure
MPI_Recv(temp, 1, structType, ...);

// Copy the temporary flat struture into a data structure
data.tag = temp->tag;
data.data = temp->data;
// Do not free the temporary structure as it contains the actual data

场景 2。每个数据项的大小可能不同。这个涉及更多，并且很难以便携的方式进行。如果速度不是您最关心的问题，那么您可以通过两条不同的消息发送数据以获得最大的可移植性。 MPI 保证为使用相同信封(source, destination, tag, communicator) 发送的消息保留顺序。

---

您还可以通过以下方式实现 suszterpatt 建议的内容（假设您的标签符合允许的范围）：

// --- Send a structure ---
MPI_Send(data.data, size of data, MPI_BYTE, dest, data.tag, MPI_COMM_WORLD);

// --- Receive a structure ---
MPI_Status status;
MPI_Aint msg_size;
// Peek for a message, allocate big enough buffer
MPI_Probe(source, MPI_ANY_TAG, &status);
MPI_Get_count(&status, MPI_BYTE, &msg_size);
uint8_t *buffer = malloc(msg_size);
// Receive the message
MPI_Recv(buffer, (int)msg_size, MPI_BYTE, source, status.MPI_TAG,
         MPI_COMM_WORLD, MPI_STATUS_IGNORE);
// Fill in a data structure
data.tag = status.MPI_TAG;
data.data = buffer;

Answer 2

假设您定义此结构是因为您想将不同的数据与不同的标签配对，那么您的解决方案在概念上是错误的。考虑以下示例：

data foo, bar;
int x = 100;
foo.data = bar.data = &x;
foo.tag = bar.tag = 99;

在这种情况下，foo 和 bar 将在内存中各自拥有自己的 tag 副本，但它们指向同一条数据。因此，不可能定义可用于发送这两个元素的单个 MPI 数据类型，因为它们各自的 data 和 tag 元素之间的位移是不同的。除了最幸运的情况外，不同的数据指针也是如此。

如果您希望将数据和标签配对，您仍然可以使用 data 结构体，尽管出于上述原因，您不需要自定义 MPI 数据类型：

MPI_Send(myData.data,extent,MPI_BYTE, dest, myData.tag, MPI_COMM_WORLD);

有匹配的接收：

MPI_Recv(myData.data, extent, MPI_BYTE, source, myData.tag, MPI_COMM_WORLD, &stat);

Answer 3

tag 的偏移量在 MPI 数据类型中错误。一般来说，您不能假设void* 的大小与int 的大小相同。此外，随着更多字段的添加，struct 中可能会引入填充。不过有办法解决这个问题 - 只需使用 offsetof:

offsets[0] = offsetof(data, data);
oldType[0] = MPI_BYTE;
blockCount[0] = sizeof(void *);

offsets[1] = offsetof(data, tag);
oldType[1] = MPI_INT;
blockCount[1] = 1;

MPI_Type_create_struct(2, blockCount, offsets, oldType, &structType);

还有一件事：由于指针在目的地无论如何都没有意义，您可以在 MPI 数据类型中跳过它。