MPI 集体通信（collective communication）

最新推荐文章于 2024-05-29 14:10:32 发布
最新推荐文章于 2024-05-29 14:10:32 发布
阅读量563 收藏 8
点赞数 7
分类专栏： 并行&高性能计算 文章标签： 算法 分布式 MPI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdnzzt/article/details/135897301
版权

1、MPI调用接口

（1）广播MPI_BCAST

（2）散发MPI_SCATTER

（3）收集MPI_GATHER

（4）归约MI_REDUCE

MPI_REDUCE将组内每个进程输入缓冲区中的数据按给定的操作op进行运算，并将其结果返回到序列号为root的进程的输出缓冲区中。

（5）MPI_ALLREDUCE

MPI_Allreduce 与 MPI_Reduce 相同，不同之处在于它不需要根进程 ID（因为结果分配给所有进程）。 

MPI_Allreduce 等效于先执行 MPI_Reduce，然后执行 MPI_Bcast。 

2. 例子

（1）利用MPI_Scatter和MPI_Gather计算0, 1, 2, ..., 99的平均值

思路：

  1. 在根进程（进程0）上生成一个数组0, 1, 2, ..., 99。
  2. 把所有数字用MPI_Scatter分发给4进程，每个进程得到25个数字。
  3. 每个进程计算它们各自得到的数字的平均数。
  4. 根进程用MPI_Gather收集各进程的平均数，然后计算这4个平均数的平均数，得出最后结果。
// Program that computes the average of an array of elements in parallel using
// MPI_Scatter and MPI_Gather
//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#include <assert.h>

// Creates an array of 0, 1, 2, ..., 99
float *create_array(int num_elements) {
  float *array_nums = (float *)malloc(sizeof(float) * num_elements);
  for (int i = 0; i < num_elements; i++) {
    array_nums[i] = i;
  }
  return array_nums;
}

// Computes the average of an array of numbers
float compute_avg(float *array, int num_elements) {
  float sum = 0.f;
  int i;
  for (i = 0; i < num_elements; i++) {
    sum += array[i];
  }
  return sum / num_elements;
}

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

  MPI_Init(NULL, NULL);

  int world_rank;
  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
  int world_size;
  MPI_Comm_size(MPI_COMM_WORLD, &world_size);
  assert(world_size == 4);

  // Create a random array of elements on the root process. Its total
  // size will be the number of elements per process times the number
  // of processes
  float *array_nums = NULL;
  if (world_rank == 0) {
    array_nums = create_array(100);
  }

  // For each process, create a buffer that will hold a subset of the entire array
  int num_elements_per_proc = 25;
  float *sub_array_nums = (float *)malloc(sizeof(float) * num_elements_per_proc);
  assert(sub_array_nums != NULL);

  // Scatter the random numbers from the root process to all processes in
  // the MPI world
  MPI_Scatter(array_nums, num_elements_per_proc, MPI_FLOAT, sub_array_nums,
              num_elements_per_proc, MPI_FLOAT, 0, MPI_COMM_WORLD);

  // Compute the average of your subset
  float sub_avg = compute_avg(sub_array_nums, num_elements_per_proc);

  // Gather all partial averages down to the root process
  float *sub_avgs = NULL;
  if (world_rank == 0) {
    sub_avgs = (float *)malloc(sizeof(float) * world_size);
    assert(sub_avgs != NULL);
  }
  MPI_Gather(&sub_avg, 1, MPI_FLOAT, sub_avgs, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);

  // Now that we have all of the partial averages on the root, compute the
  // total average of all numbers. Since we are assuming each process computed
  // an average across an equal amount of elements, this computation will
  // produce the correct answer.
  if (world_rank == 0) {
    float avg = compute_avg(sub_avgs, world_size);
    printf("Avg of all elements is %f\n", avg);
    // Compute the average across the original data for comparison
    float original_data_avg =
      compute_avg(array_nums, num_elements_per_proc * world_size);
    printf("Avg computed across original data is %f\n", original_data_avg);
  }

  // Clean up
  if (world_rank == 0) {
    free(array_nums);
    free(sub_avgs);
  }
  free(sub_array_nums);

  MPI_Barrier(MPI_COMM_WORLD);
  MPI_Finalize();
}

编译命令：

mpicc -o avg.c avg

运行命令：

mpirun -n 4 ./avg

输出结果：

（2）利用MPI_Reduce计算0, 1, 2, ..., 99的平均值

使用 MPI_Reduce 可以简化上一个例子的代码中，各进程平均数求和的写法。

在下面的代码中，每个进程都会创建随机数并计算和保存在 local_sum 中。 然后使用 MPI_SUM 将 local_sum 归约至根进程。 然后，全局平均值为 global_sum / (world_size * num_elements_per_proc)。

// Program that computes the average of an array of elements in parallel using
// MPI_Scatter and MPI_Reduce
//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#include <assert.h>

// Creates an array of 0, 1, 2, ..., 99
float *create_array(int num_elements)
{
  float *array_nums = (float *)malloc(sizeof(float) * num_elements);
  for (int i = 0; i < num_elements; i++)
  {
    array_nums[i] = i;
  }
  return array_nums;
}

// Computes the average of an array of numbers
float compute_avg(float *array, int num_elements)
{
  float sum = 0.f;
  int i;
  for (i = 0; i < num_elements; i++)
  {
    sum += array[i];
  }
  return sum / num_elements;
}

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

  MPI_Init(NULL, NULL);

  int world_rank;
  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
  int world_size;
  MPI_Comm_size(MPI_COMM_WORLD, &world_size);
  assert(world_size == 4);

  // Create a random array of elements on the root process. Its total
  // size will be the number of elements per process times the number
  // of processes
  float *array_nums = NULL;
  if (world_rank == 0)
  {
    array_nums = create_array(100);
  }

  // For each process, create a buffer that will hold a subset of the entire array
  int num_elements_per_proc = 25;
  float *sub_array_nums = (float *)malloc(sizeof(float) * num_elements_per_proc);
  assert(sub_array_nums != NULL);

  // Scatter the random numbers from the root process to all processes in
  // the MPI world
  MPI_Scatter(array_nums, num_elements_per_proc, MPI_FLOAT, sub_array_nums,
              num_elements_per_proc, MPI_FLOAT, 0, MPI_COMM_WORLD);

  /*--------------- Use MPI_Reduce --------------- */
  // Sum the numbers locally
  float local_sum = 0;
  int i;
  for (i = 0; i < num_elements_per_proc; i++)
  {
    local_sum += sub_array_nums[i];
  }
  // Print the random numbers on each process
  printf("Local sum for process %d - %f, avg = %f\n",
         world_rank, local_sum, local_sum / num_elements_per_proc);
  // Reduce all of the local sums into the global sum
  float global_sum;
  MPI_Reduce(&local_sum, &global_sum, 1, MPI_FLOAT, MPI_SUM, 0,
             MPI_COMM_WORLD);

  // Print the result
  if (world_rank == 0)
  {
    printf("Total sum = %f, avg = %f\n", global_sum,
           global_sum / (world_size * num_elements_per_proc));

    // Compute the average across the original data for comparison
    float original_data_avg =
        compute_avg(array_nums, num_elements_per_proc * world_size);
    printf("Avg computed across original data is %f\n", original_data_avg);
  }

  // Clean up
  if (world_rank == 0)
  {
    free(array_nums);
  }
  free(sub_array_nums);

  MPI_Barrier(MPI_COMM_WORLD);
  MPI_Finalize();
}

输出结果：

（3）计算0, 1, 2, ..., 99的标准差

标准差定义：

  1. 首先计算所有数字的平均值，用MPI_Allreduce
  2. 累计每个数字与平均值的偏差，用MPI_Reduce
  3. 求平均
// Program that computes the standard deviation of an array of elements in parallel using
// MPI_Scatter, MPI_Allreduce and MPI_Reduce
//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#include <math.h>
#include <assert.h>

// Creates an array of 0, 1, 2, ..., 99
float *create_array(int num_elements)
{
  float *array_nums = (float *)malloc(sizeof(float) * num_elements);
  for (int i = 0; i < num_elements; i++)
  {
    array_nums[i] = i;
  }
  return array_nums;
}

// Computes the average of an array of numbers
float compute_avg(float *array, int num_elements)
{
  float sum = 0.f;
  int i;
  for (i = 0; i < num_elements; i++)
  {
    sum += array[i];
  }
  return sum / num_elements;
}

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

  MPI_Init(NULL, NULL);

  int world_rank;
  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
  int world_size;
  MPI_Comm_size(MPI_COMM_WORLD, &world_size);
  assert(world_size == 4);

  // Create a random array of elements on the root process. Its total
  // size will be the number of elements per process times the number
  // of processes
  float *array_nums = NULL;
  if (world_rank == 0)
  {
    array_nums = create_array(100);
  }

  // For each process, create a buffer that will hold a subset of the entire array
  int num_elements_per_proc = 25;
  float *sub_array_nums = (float *)malloc(sizeof(float) * num_elements_per_proc);
  assert(sub_array_nums != NULL);

  // Scatter the random numbers from the root process to all processes in
  // the MPI world
  MPI_Scatter(array_nums, num_elements_per_proc, MPI_FLOAT, sub_array_nums,
              num_elements_per_proc, MPI_FLOAT, 0, MPI_COMM_WORLD);

  /*--------------- Use MPI_Allreduce --------------- */
  float local_sum = 0;
  for (int i = 0; i < num_elements_per_proc; ++i) {
    local_sum += sub_array_nums[i];
  }

  // Reduce all of the local sums into the global sum in order to
  // calculate the mean
  float global_sum;
  MPI_Allreduce(&local_sum, &global_sum, 1, MPI_FLOAT, MPI_SUM,
                MPI_COMM_WORLD);
  float mean = global_sum / (num_elements_per_proc * world_size);

  // Compute the local sum of the squared differences from the mean
  float local_sq_diff = 0;
  for (int i = 0; i < num_elements_per_proc; i++)
  {
    local_sq_diff += (sub_array_nums[i] - mean) * (sub_array_nums[i] - mean);
  }

  // Reduce the global sum of the squared differences to the root
  // process and print off the answer
  float global_sq_diff;
  MPI_Reduce(&local_sq_diff, &global_sq_diff, 1, MPI_FLOAT, MPI_SUM, 0,
             MPI_COMM_WORLD);

  // The standard deviation is the square root of the mean of the
  // squared differences.
  if (world_rank == 0)
  {
    float stddev = sqrt(global_sq_diff /
                        (num_elements_per_proc * world_size));
    printf("Mean - %f, Standard deviation = %f\n", mean, stddev);
  }

  // Clean up
  if (world_rank == 0)
  {
    free(array_nums);
  }
  free(sub_array_nums);

  MPI_Barrier(MPI_COMM_WORLD);
  MPI_Finalize();
}

输出结果：

blogZT
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MPI编程（4）—集合通信MPI_Bcast、MPI_Gather、MPI_Scatter、MPI_Reduce
yiguagua的博客
06-22 5833
1. MPI_Bcast:广播消息 MPI_Bcast用于将一个进程的buffer中的数据广播到其他进程的相同buffer变量中 代码示例如下： int rank, data[10]; MPI_Init(0, 0); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { for (int i = 0; i < 10; ++i) { data[i] = i + 1; } } //进程0广播数据
MPI-3 近邻集合通信
自可乐的博客
06-19 680
本文从本人简书博客同步过来 在上一篇中我们介绍了 mpi4py 中的非阻塞集合通信方法，下面我们将介绍 mpi4py 中的近邻集合通信方法，另一个 MPI-3 引进的新特性。 近邻集合通信（neighborhood collective communication） 是定义在拓扑通信子之上的一类集合通信操作，不同于一般集合通信操作中通信子上的所有进程都会参与，近邻集合通信只要求拓扑通信子上的某...
并行计算编程入门
mc_故事与你的博客
04-08 735
datatype为变量类型，注意该位置的变量类型是MPI预定义的变量类型，比如需要传递的是C++的int型，则在此处需要传入的参数是MPI_INT，其余同理。dest为接收的进程号，即被传递信息进程的进程号。在C和C++中，status的变量类型为MPI_Status，分别有三个域，可以通过status.MPI_SOURCE，status.MPI_TAG和status.MPI_ERROR的方式调用这三个信息。该函数为发送函数，用于进程间发送消息，如进程0计算得到的结果A，需要传给进程1，就需要调用该函数。
MPI之聚合通信collective communication-广播
sinat_22336563的博客
04-12 3513
一、前言 点对点的通信学习已经通过一个案例完成了，现在开始新的一节：collective communication。聚合通信是在通信子中的所有的进程都参与的通信方式。 二、聚合与同步 1、同步 对于所有的进程来说，聚合通信必然包含了一个同步点。也就是说所有的进程必须在他们又一次执行新动作之前都到达某个点。这跟GPU中线程同步的概念很相似，很好理解。如果n个线程或者进程不遵守这个规矩，那么就
MPI Broadcast and Collective Communication
yiran103的专栏
04-08 998
以下内容翻译自：MPI Broadcast and Collective Communication 到目前为止，在MPI教程中，我们已经审视了两个进程之间的点对点通信。本课是集合通信部分的开始。集合通信是一种所有通信进程都参与其中的通信方式。在本课中，我们将讨论集合通信的含义，并讨论标准集体例程——广播。 注——本网站的所有代码均位于GitHub上。本教程的代码位于tutorials/...
并行与分布式计算导论（七）MPI Collective Communication
Kaiser_syndrom的博客
04-08 1993
并行与分布式计算：MPI进阶（七）Section 7 MPI Collective Communication7.1 概述7.1.1 四个通信函数7.1.2 五个通信域函数7.1.3 Collective Communication7.2 一些说明7.3 按行分解MPI_AllgathervMPI_Gatherv7.4 按列分解MPI_ScattervMPI_Alltoallv7.5 棋盘式分解通...
MPI——通信集合
绝尘
09-19 5114
通信集合 树形结构通信 一开始1、3、5、7号进程都将它们的值发送给0、2、4、6。然后0、2、4、6进程都将接收到的值加到它们自己原有的值，整个过程重复两次。 但是这个解决的方案不是最理想的，因为其中一半的进程的工作量与原来方案相同。原来的方案需要0号进程接收comm_sz-1=7次。而新的方案中0号进程只需要3次接收和3次加法，并且其他进程所有的接收与加法操作不超过2次。所以，如果所有进程几...
MPI: 虚拟拓扑和近邻通信
weixin_42849849的博客
12-04 983
MPI虚拟拓扑和近邻通信
Efficient Sparse Collective Communication and its application to Accelerate Distributed Deep Learnin
qq_42890800的博客
09-29 595
最普遍的分布式深度学习（DDL）算法是随机梯度下降（SGD）。分布式 SGD 分为两个步骤：(1) 每个 worker 训练一个模型的局部拷贝，并行地处理训练数据的不同子集。(2) 将所用的 worker 的计算结果组合，得到一个平均的梯度，并将模型参数进行更新。在 DDL 中，通信负载占比很高，严重影响了其并行化的训练速度，是一个众所周知的性能瓶颈。目前，深度学习模型的梯度稀疏性越来越高，其中 DeepLight，LSTM 两个深度神经网络的梯度稀疏度超过了 94%。
【分布式通信论文阅读】xCCL: A Survey of Industry-Led Collective Communication Libraries for Deep Learning-1
参谋谋的博客
04-18 800
但，有时用户预定义的一些预定操作里，可能改变数据类型，来执行复杂Reduce-Scatter操作，所以All-reduce操作中，该算法适用于所有大小的数据。Reduce集合指的是一个过程，在这个过程中，单个节点从系统中的每个节点接收数据，并对这些数据应用一些操作，从而产生单个输出。这个操作在特定场合下，相较于broadcast有更好的优势，因为有些时候不同进程需要分发不同的任务，这样更能节省带宽。Reduce-Scatter集合操作，可以被描述为Reduce操作和Scatter操作按给定顺序的组合。
跨多个集群的MPI集体通信的延迟均衡优化
03-09
它挑战了当前并行计算工具的可伸缩性和性能，尤其是并行应用程序的集体通信。 本文着重于跨多个HPC中心的并行应用程序的集体通信的优化。 本文提出了一种用于多集群MPI的可伸缩延迟均衡广播算法（LB-B）。 它可以...
mpi测试全局通信mpi_Alltoall
01-01
这个代码用于测试mpi全局通信，针对不同的情况，分别使用了MPI_Alltoall和MPI_Alltoallv
MPI划分通信域
11-30
MPI通信域的划分，方法，还有编程，须用远程的服务器连接，并且运行多进程的文件
MPI通信全局数据包通信方式
08-16
SIEMENS S7-300 PLC MPI通信全局数据包通信方式，SIEMENS S7-300 PLC MPI通信全局数据包通信方式
MPI蝶形通信代码
04-08
可以模拟 非2^n个数据的蝶形通信
算法训练营day41
stmfresher的博客
05-27 370
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 533
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
最新发布
2301_76783671的博客
05-29 710
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
mpi_reduce
09-15
MPI_Reduce 是一个用于在并行计算中进行全局规约操作的函数。它将每个进程上的数据收集到一个指定进程上，并进行指定的操作（例如求和、最大值、最小值等），最后将结果广播给所有进程。 该函数的原型如下： ```c int MPI_Reduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm) ``` 参数说明： - `sendbuf`：发送缓冲区的起始地址，对于根进程来说，该缓冲区中存放着发送的数据；对于其他进程来说，该缓冲区中存放着要规约的本地数据。 - `recvbuf`：接收缓冲区的起始地址，对于根进程来说，该缓冲区中存放着规约结果；对于其他进程来说，该缓冲区未被使用。 - `count`：发送缓冲区中的元素个数。 - `datatype`：发送和接收数据的类型。 - `op`：规约操作的类型（例如 MPI_SUM 表示求和）。 - `root`：规约结果所要发送到的进程的秩。 - `comm`：通信子。 MPI_Reduce 函数会在根进程上返回规约结果，而在其他进程上返回 MPI_SUCCESS。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值