一种基于另一个变量执行值的 MPI 全部减少的有效方法？

编程问答 2022-05-28

问题描述

举个例子，假设我有

int a = ...;
int b = ...;
int c;

其中 a 是一些复杂局部计算的结果，b 是 a 质量的一些度量。

我想将 a 的最佳值发送到每个进程并将其存储在 c 中，其中最佳值定义为 b 的最大值。

我想我只是想知道是否有比在 allgather 和 a 上执行 b 然后搜索结果数组更有效的方法。>

实际代码涉及在多达数百/数千个进程中发送和比较数百个值，因此欢迎提高效率。

解决方法

您可以将 b 的值与进程的排名配对，以找到包含 b 最大值的排名。 MPI_DOUBLE_INT 类型对此非常有用。然后，您可以从此排名中广播 a，以便在每个进程中获得该值。

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

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

    MPI_Init(&argc,&argv);
    MPI_Comm_rank(MPI_COMM_WORLD,&my_rank);

    // Create random a and b on each rank.
    srand(123 + my_rank);
    double a = rand() / (double)RAND_MAX;
    double b = rand() / (double)RAND_MAX;

    struct
    {
        double value;
        int rank;
    } s_in,s_out;

    s_in.value = b;
    s_in.rank = my_rank;

    printf("before: %d,%f,%f\n",my_rank,a,b);

    // Find the maximum value of b and the corresponding rank.
    MPI_Allreduce(&s_in,&s_out,1,MPI_DOUBLE_INT,MPI_MAXLOC,MPI_COMM_WORLD);
    b = s_out.value;

    // Broadcast from the rank with the maximum value.
    MPI_Bcast(&a,MPI_DOUBLE,s_out.rank,MPI_COMM_WORLD);

    printf("after: %d,b);

    MPI_Finalize();
}
,

我想我只是想知道是否有更有效的方法 这比在 a 和 b 上进行 allgather 然后搜索 结果数组。

这可以通过一个 MPI_AllReduce 来实现。

我将介绍两种方法，一种更简单（适合您的用例）；和一个更通用的，用于更复杂的用例。后者也可用于展示案例 MPI 功能，例如自定义 MPI 数据类型和自定义 MPI 归约运算符。

方法一

代表

int a = ...;
int b = ...;

您可以使用以下结构：

typedef struct MyStruct {
    int b;
    int a;
} S;

然后您可以使用 MPI 数据类型 MPI_2INT 和 MPI 运算符 MAXLOC

运算符 MPI_MINLOC 用于计算全局最小值，也用于计算全局最小值 附加到最小值的索引。 **MPI_MAXLOC 类似地计算 全局最大值和索引。 其中一个应用是计算一个 全局最小值（最大值）和包含这个的进程的等级 价值。

在您的情况下，我们将使用 'a' 的值而不是 rank。因此，MPI_AllReduce 调用：

 S  local,global;
 ...
 MPI_Allreduce(&local,&global,MPI_2INT,MPI_COMM_WORLD);

完整的代码如下所示：

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

typedef struct MyStruct {
    int b;
    int a;
} S;


int main(int argc,char *argv[]){
    MPI_Init(NULL,NULL); // Initialize the MPI environment
    int world_rank; 
    int world_size;
    MPI_Comm_rank(MPI_COMM_WORLD,&world_rank);
    MPI_Comm_size(MPI_COMM_WORLD,&world_size);
    
    // Some fake data
    S local,global;
    local.a = world_rank;
    local.b = world_size - world_rank;

    MPI_Allreduce(&local,MPI_COMM_WORLD);
          
    if(world_rank == 0){
      printf("%d %d\n",global.b,global.a);
    }

    MPI_Finalize();
    return 0;
 }

第二种方法

MPI_MAXLOC 仅适用于特定数量的 predefined datatypes。尽管如此，对于其余情况，您可以使用以下方法（基于此 SO thread）：

  1. 创建一个包含值 struct 和 a 的 b；
  2. 创建一个自定义的 MPI_Datatype，代表 1. struct 以发送跨进程；
  3. 使用MPI_AllReduce：

int MPI_Allreduce(const void *sendbuf,void *recvbuf,int count,MPI_Datatype 数据类型，MPI_Op op，MPI_Comm comm)

组合来自所有进程的值并将结果分发回 所有进程

  1. 使用操作MAX;

我想将 'a' 的最佳值发送到每个进程并将其存储在 'c' 其中 best 定义为 'b' 的最大值。

  1. 然后您必须告诉 MPI 只考虑结构的元素 b。因此，您需要创建一个自定义的 MPI_Op 最大操作。

编码方法

那么让我们一步一步地分解上述实现：

首先定义struct：

typedef struct MyStruct {
    double a,b;
} S;

第二次创建自定义MPI_Datatype：

void defineStruct(MPI_Datatype *tstype) {
    const int count = 2;
    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);

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

非常重要 请注意，由于我们使用的是 struct，因此您必须小心 (source)

C 标准允许在字段之间任意填充。

因此，使用两个 struct 减少 double 与使用两个 double 减少数组不相同。

在 main 中，您必须执行以下操作：

MPI_Datatype structtype;
defineStruct(&structtype);

第三次创建自定义最大操作：

void max_struct(void *in,void *inout,int *len,MPI_Datatype *type){
    S *invals    = in;
    S *inoutvals = inout;
    for (int i=0; i < *len; i++)
        inoutvals[i].b  = (inoutvals[i].b > invals[i].b) ? inoutvals[i].b  : invals[i].b;
}

在main中做：

MPI_Op       maxstruct;
MPI_Op_create(max_struct,&maxstruct);

最后，调用 MPI_AllReduce：

S local,global;
...
MPI_Allreduce(&local,structtype,maxstruct,MPI_COMM_WORLD);

整个代码放在一起：

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

typedef struct MyStruct {
    double a,b;
} S;

void max_struct(void *in,MPI_Datatype *type){
    S *invals    = in;
    S *inoutvals = inout;
    for (int i=0; i<*len; i++)
        inoutvals[i].b  = (inoutvals[i].b > invals[i].b) ? inoutvals[i].b  : invals[i].b;
}

void defineStruct(MPI_Datatype *tstype) {
    const int count = 2;
    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,tstype);
    MPI_Type_commit(tstype);
}

int main(int argc,&world_size);
    MPI_Datatype structtype;
    MPI_Op       maxstruct;
    S  local,global;

    defineStruct(&structtype);
    MPI_Op_create(max_struct,&maxstruct);

    // Just some random values
    local.a = world_rank;
    local.b = world_size - world_rank;

    MPI_Allreduce(&local,MPI_COMM_WORLD);  
          
    if(world_rank == 0){
      double c = global.a;
      printf("%f %f\n",c);
    }

    MPI_Finalize();
    return 0;
 }
cmpiparallel-processingperformanceperformanceperformancereduction