如何使用MPI_Gatherv从不同的处理器，包括主节点收集diiferent长度的字符串？ [英] How to use MPI_Gatherv for collecting strings of diiferent length from different processor including master node?
问题描述
我想收集所有处理器（包括主节点）不同长度的不同的字符串成主节点一个字符串（字符数组）。这里是原型MPI_Gatherv：
I am trying to collect different strings of different length from all processors (including the master node) into a single string (array of characters) at the master node. Here is the prototype for MPI_Gatherv:
int MPI_Gatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
void *recvbuf, const int *recvcounts, const int *displs,
MPI_Datatype recvtype, int root, MPI_Comm comm)**.
我无法确定像 recvbuf ， recvcounts 和 displs 。难道任何一个为此提供C源$ C $ C例子吗？
I am unable to define some parameters like recvbuf,recvcounts and displs. Could any one provide source code example in C for this?
推荐答案
正如已经指出的那样，有很多使用的例子 MPI_Gatherv ，这里包括对堆栈溢出;这开始了描述散射和如何收集工作，然后scatterv / gatherv变种如何扩展该，可以发现<一个答案href=\"http://stackoverflow.com/questions/9269399/sending-blocks-of-2d-array-in-c-using-mpi/9271753#9271753\">here.
As has been pointed out, there are lots of examples of using MPI_Gatherv, including here on stack overflow; an answer which starts off describing how scatter and gather work, and then how the scatterv/gatherv variants extend that, can be found here.
重要的是，对于较简单的收集操作，其中每一个块是相同尺寸的，在MPI库可以轻松precompute其中每块应该在最终编译阵列中去;在更普遍gatherv操作，其中这是不太清楚，你可以选择 - 事实上，要求 - 拼出正是每个项目应该启动
Crucially, for the simpler Gather operation, where every chunk is of the same size, the MPI library can easily precompute where each chunk should go in the final compiled array; in the more general gatherv operation, where this is less clear, you have the option - in fact, the requirement - to spell out exactly where each item should start.
这里唯一的额外的复杂之处在于你处理字符串，所以你可能不想要的一切猛向右在一起;你会想在月底空间微胖，当然还有空终止符。
The only extra complication here is that you're dealing with strings, so you probably don't want everything shoved right together; you'll want extra padding for spaces, and of course a null terminator at the end.
因此，让我们说你有五道工序想发送的字符串：
So let's say you have five processes wanting to send strings:
Rank 0: "Hello" (len=5)
Rank 1: "world!" (len=6)
Rank 2: "Bonjour" (len=7)
Rank 3: "le" (len=2)
Rank 4: "monde!" (len=6)
您会希望这个被组装成一个全球性的字符串：
You'll want this to be assembled into a global string:
Hello world! Bonjour le monde!\0
111111111122222222223
0123456789012345678901234567890
recvcounts={5,6,7,2,6}; /* just the lengths */
displs = {0,6,13,21,24}; /* cumulative sum of len+1 for padding */
可以看到，位移0是0，和位移i是等于对于j的总和（recvcounts [j]的+1）= 0..i-1：
You can see that displacement 0 is 0, and displacement i is equal to the sum of (recvcounts[j]+1) for j=0..i-1:
i count[i] count[i]+1 displ[i] displ[i]-displ[i-1]
------------------------------------------------------------
0 5 6 0
1 6 7 6 6
2 7 8 13 7
3 2 3 21 8
4 6 7 24 3
这就是直截了当地实现：
And that's straightforwardly implemented:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "mpi.h"
#define nstrings 5
const char *const strings[nstrings] = {"Hello","world!","Bonjour","le","monde!"};
int main(int argc, char **argv) {
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
/* Everyone gets a string */
int myStringNum = rank % nstrings;
char *mystring = (char *)strings[myStringNum];
int mylen = strlen(mystring);
printf("Rank %d: %s\n", rank, mystring);
/*
* Now, we Gather the string lengths to the root process,
* so we can create the buffer into which we'll receive the strings
*/
const int root = 0;
int *recvcounts = NULL;
/* Only root has the received data */
if (rank == root)
recvcounts = malloc( size * sizeof(int)) ;
MPI_Gather(&mylen, 1, MPI_INT,
recvcounts, 1, MPI_INT,
root, MPI_COMM_WORLD);
/*
* Figure out the total length of string,
* and displacements for each rank
*/
int totlen = 0;
int *displs = NULL;
char *totalstring = NULL;
if (rank == root) {
displs = malloc( size * sizeof(int) );
displs[0] = 0;
totlen += recvcounts[0]+1;
for (int i=1; i<size; i++) {
totlen += recvcounts[i]+1; /* plus one for space or \0 after words */
displs[i] = displs[i-1] + recvcounts[i-1] + 1;
}
/* allocate string, pre-fill with spaces and null terminator */
totalstring = malloc(totlen * sizeof(char));
for (int i=0; i<totlen-1; i++)
totalstring[i] = ' ';
totalstring[totlen-1] = '\0';
}
/*
* Now we have the receive buffer, counts, and displacements, and
* can gather the strings
*/
MPI_Gatherv(mystring, mylen, MPI_CHAR,
totalstring, recvcounts, displs, MPI_CHAR,
root, MPI_COMM_WORLD);
if (rank == root) {
printf("%d: <%s>\n", rank, totalstring);
free(totalstring);
free(displs);
free(recvcounts);
}
MPI_Finalize();
return 0;
}
运行提供了：
$ mpicc -o gatherstring gatherstring.c -Wall -std=c99
$ mpirun -np 5 ./gatherstring
Rank 0: Hello
Rank 3: le
Rank 4: monde!
Rank 1: world!
Rank 2: Bonjour
0: <Hello world! Bonjour le monde!>
这篇关于如何使用MPI_Gatherv从不同的处理器，包括主节点收集diiferent长度的字符串？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
