0

考虑这样的事情：

typedef struct TS { 
    double a,b,c; 
} S; 

... 
S x,y; 
... 
MPI_Allreduce(&x, &y, 3, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);

上面的代码是否完全可移植（不使用 MPI_Type_struct 和 all；结构中的所有变量都假定为相同类型）？同样在不同节点上使用不同硬件的情况下？

提前致谢， 杰克

4

2 回答 2

2

Hristo Iliev 完全正确；C 标准允许在字段之间进行任意填充。因此，不能保证这与三个双精度数组的内存布局相同，并且您的 reduce 可能会给您带来垃圾。

因此，您可以在这里采取两种不同的方法。一个是忽略这个问题，因为大多数 C 编译器可能会将其视为三个连续双精度数的数组。我通常根本不会提到这个作为一个选项，除非在这种情况下很容易测试假设。在您的代码中，您可以拥有

assert ( offsetof(S,b) == sizeof(double) );
assert ( offsetof(S,c) == 2*sizeof(double) );

如果您的代码通过断言进行，那么您很好。（请注意，这仍然不能保证其中两个结构的数组等效于 6 个连续双精度的数组......）

第二种方法是自己创建结构并减少操作以确保安全。真的，这不是太难，然后你知道它会起作用，所以这真的是要走的路；然后您可以安全地将该类型用于任何其他操作：

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

typedef struct TS {
    double a,b,c;
} S;

/* our reduction operation */
void sum_struct_ts(void *in, void *inout, int *len, MPI_Datatype *type){
    /* ignore type, just trust that it's our struct type */

    S *invals    = in;
    S *inoutvals = inout;

    for (int i=0; i<*len; i++) {
        inoutvals[i].a  += invals[i].a;
        inoutvals[i].b  += invals[i].b;
        inoutvals[i].c  += invals[i].c;
    }

    return;
}

void defineStruct(MPI_Datatype *tstype) {
    const int count = 3;
    int          blocklens[count];
    MPI_Datatype types[count];
    MPI_Aint     disps[count];

    for (int i=0; i < count; i++) {
        types[i] = MPI_DOUBLE;
        blocklens[i] = 1;
    }

    disps[0] = offsetof(S,a);
    disps[1] = offsetof(S,b);
    disps[2] = offsetof(S,c);

    MPI_Type_create_struct(count, blocklens, disps, types, tstype);
    MPI_Type_commit(tstype);
}

int main (int argc, char **argv) {

    int rank, size;
    MPI_Datatype structtype;
    MPI_Op       sumstruct;
    S   local, global;

    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    defineStruct(&structtype);
    MPI_Op_create(sum_struct_ts, 1, &sumstruct);

    local.a = rank;
    local.b = 2*rank;
    local.c = 3*rank;

    MPI_Reduce(&local, &global, 1, structtype, sumstruct, 0, MPI_COMM_WORLD);

    if (rank == 0) {
        printf("global.a = %lf; expected %lf\n", global.a, 1.*size*(size-1)/2);
        printf("global.b = %lf; expected %lf\n", global.b, 2.*size*(size-1)/2);
        printf("global.c = %lf; expected %lf\n", global.c, 3.*size*(size-1)/2);
    }

    MPI_Finalize();
    return 0;
}

运行给

$ mpicc -o foo foo.c -std=c99

$ mpirun -np 1 ./foo
global.a = 0.000000; expected 0.000000
global.b = 0.000000; expected 0.000000
global.c = 0.000000; expected 0.000000

$ mpirun -np 2 ./foo
global.a = 1.000000; expected 1.000000
global.b = 2.000000; expected 2.000000
global.c = 3.000000; expected 3.000000

$ mpirun -np 3 ./foo
global.a = 3.000000; expected 3.000000
global.b = 6.000000; expected 6.000000
global.c = 9.000000; expected 9.000000

$ mpirun -np 12 ./foo
global.a = 66.000000; expected 66.000000
global.b = 132.000000; expected 132.000000
global.c = 198.000000; expected 198.000000
于 2013-02-05T22:35:04.547 回答
1

这种情况下的可移植性取决于三个double元素的结构是否可移植地等效于三个元素的数组double。我想说这对于大多数 C 编译器来说可能是正确的，但不会打赌它是否是 C 标准的一部分。

异构情况下的可移植性将MPI_DOUBLE通过 MPI 实现对类型进行的转换来保证。

于 2013-02-05T17:27:34.427 回答