基于超算平台的矩阵乘法MPI并行实验

已于 2023-07-16 21:12:07 修改
阅读量214 收藏
点赞数 1
文章标签： 分布式
于 2023-07-16 20:58:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Finddog/article/details/131754592
版权

基于超算平台的矩阵乘法MPI并行实验

一、实验目的

  • 熟悉超算环境，掌握在超算上如何运行作业
  • 熟悉MPI编程环境，掌握MPI编程基本函数及MPI的相关通信函数用法；
  • 将通用矩阵乘法转为MPI并行实现，减少大型矩阵乘法计算所需的时间，进一步加深MPI的使用与理解

二、实践平台与环境：

本实验在国家超级计算郑州中心先进计算平台上进行，郑州中心于2020 年建成并投入运行，理论峰值计算能力达到 100PFlops，存储裸容量 100PB，网络系统带宽 200Gb/s，网络延迟微秒级；同时配备国产安全可靠的云计算平台、高性能计算集群管理调度平台、人工智能平台以及专业的在线运维平台，提供类型多样的先进计算服务；采用绿色节能的浸没式相变液冷冷却技术，PUE 值小于 1.04。

  • 系统平台：超算平台（郑州超算中心）

  • 加载的module:

    compiler/devtoolset/7.3.1

    mpi/hpcx/2.4.1/gcc-7.3.1

三、实验方案

(一)问题描述

通过MPI并行对两个大型矩阵A（MxN）,B(NxK)做乘法得到矩阵C(MxK)

(二)方案描述

将矩阵A按行“平均”分配给所有进程，将整个矩阵B分配给所有进程，最终每个进程都将获得A的部分行和矩阵B，然后每个进程将自己所获得的A矩阵的行与B矩阵进行矩阵乘法运算，最终将每个进程所计算的结果进行组装，获得最终的矩阵C。

1、矩阵A的分配。由于矩阵A的行数可能不能够被总的进程数目整除，为尽可能的做到“平均”，且一次性将A矩阵的行数全部分给所有的进程，需要先计算每个进程分配的行数， 可以采用以下的方式计算每个进程分配的行数：

/*
    M：矩阵A的总的行数
    world_size: 总的进程数目
    lines: 数组，存放每个进程需要分配的行数
*/
int *lines = new int[world_size];
int equal_rows = M / world_size;
int remain_lines = M % world_size;
for (int i = 0; i < world_size; i++)
{
    int rows = equal_rows;
    if (remain_lines != 0)
    {
        rows++;
        remain_lines--;
    }
    lines[i] = rows;
}

然后可以采用集合通信的方式实现分配，这里采用MPI_Scatterv；MPI_Scatterv的语法如下：

其中两个关键的参数:

因此需要计算发送到每个进程的元素数，和要发送每个进程数据相对于矩阵A中元素的偏移，这里计算的方式就比较简单，不在过多叙述：

// 为每个rank分配发送数据相对于矩阵A的起始位置scatter_info.displs[i],
// 发送数据的个数scatter_info.displs[i]
DataInfo scatter_info = DataInfo(world_size);
int tmp = 0;
for (int i = 0; i < world_size; i++)
{
    scatter_info.cnts[i] = lines[i] * N;
    scatter_info.displs[i] = tmp;
    tmp += scatter_info.cnts[i];
}
double *split_A = new double[lines[rank] * N]; // 每个进程获得矩阵A的部分数据
MPI_Scatterv(Matrix_A, scatter_info.cnts, scatter_info.displs, MPI_DOUBLE,
                split_A, lines[rank] * N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

2、矩阵B的分配。矩阵B的分配可以采用MPI_Bcast函数广播到每一个进程，其实现过程如下：

MPI_Bcast(Matrix_B, N * K, MPI_DOUBLE, 0, MPI_COMM_WORLD);

3、每个进程进行矩阵计算。

void AxB(double *A, double *B, int m, int n, int k, double *C) // A(mxn) B(nxk)
{
    for (int i = 0; i < m; i++)     // A 行数
        for (int j = 0; j < k; j++) // B 列数
        {
            double temp = 0;
            for (int p = 0; p < n; p++) // B 行数
            {
                temp += A[i * n + p] * B[p * k + j];
            }
            C[i * k + j] = temp;
        }
}

double *split_A = new double[lines[rank] * N]; // 每个进程获得矩阵A的部分数据
MPI_Scatterv(Matrix_A, scatter_info.cnts, scatter_info.displs, MPI_DOUBLE,
                split_A, lines[rank] * N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

double *resultbuff = new double[lines[rank] * K]; // 存放每个进程的计算结果

AxB(split_A, Matrix_B, lines[rank], N, K, resultbuff);

4、结果的收集。由于每一个进程计算的结果长度不一致，因此采用MPI_Gatherv函数对结果进行组合，MPI_Gatherv的语法如下：

参数的使用与MPI_Scatterv类似，需要指定从每个进程获取的元素个数，以及从每个进程获取的元素需要存放的位置等。

DataInfo gatherinfo = DataInfo(world_size);
tmp = 0;
for (int i = 0; i < world_size; i++)
{
    gatherinfo.displs[i] = tmp;
    gatherinfo.cnts[i] = lines[i] * K;
    tmp += gatherinfo.cnts[i];
}
MPI_Gatherv(resultbuff, lines[rank] * K, MPI_DOUBLE, Matrix_C, gatherinfo.cnts,
            gatherinfo.displs, MPI_DOUBLE, 0, MPI_COMM_WORLD);

四、实验步骤与结果分析

1、加载并行计算环境

2、编译源文件

3、编写sbatch脚本 param.sh

4、运行脚本。

sbatch param.sh

5、实验时间分析。

依次修改脚本中param.sh中mpirun -np 16 t3 中的进程数16为8、4、2、1进行实验，其运算所需的时间分别为0.4s、0.7s、1.3s、2.9s、4.5s，可以看出当进程数目从16减为8、4、2、1时，计算所用的时间差不多增加为原来的二倍，说明并行进程数可以加快计算的速度。

在这里插入图片描述

6、计算结果准确度分析。当使用两个进程来计算两个小矩阵的成绩，从结果可以看出，采用并行计算的结果和不采用并行计算的结果相同。

五、总结

一直以来，我就对并行计算有很大的兴趣，通过分布式计算这门课，让我了解到了mpi并行技术，于是就按照教程[2]动手尝试做了一些简单的例子，最终用mpi实现了下矩阵的并行运算，并整理了这份课程报告，从中加深了我对mpi并行计算的理解，同时呢，对于C++编程又重新的熟悉了以下，另外也熟悉了超算的使用，相信这门课对我以后的学习具有很大的帮助！

六、参考文献

[1] Microsoft MPI：https://learn.microsoft.com/zh-cn/message-passing-interface/microsoft-mpi

[2] MPI Tutorial: https://mpitutorial.com/tutorials/mpi-hello-world/zh_cn/

七、完整代码

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

struct DataInfo
{
    int *displs;
    int *cnts;
    DataInfo(int world_size)
    {
        this->displs = new int[world_size]();
        this->cnts = new int[world_size]();
    }
    ~DataInfo()
    {
        delete[] this->displs;
        delete[] this->cnts;
    }
};

void AxB(double *A, double *B, int m, int n, int k, double *C) // A(mxn) B(nxk)
{
    for (int i = 0; i < m; i++)     // A 行数
        for (int j = 0; j < k; j++) // B 列数
        {
            double temp = 0;
            for (int p = 0; p < n; p++) // B 行数
            {
                temp += A[i * n + p] * B[p * k + j];
            }
            C[i * k + j] = temp;
        }
}

void PrintMatrix(double *matrix, int m, int n, char *name)
{
    printf("%s:\n", name);
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("%f", matrix[i * n + j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(int argc, char *argv[])
{
    int M = 1000;
    int N = 1100;
    int K = 900;
    if (argc > 0) // 测试计算精度，用小矩阵
    {
        M = 5;
        N = 4;
        K = 3;
    }
    double *Matrix_A = new double[M * N]; // 矩阵A MxN
    double *Matrix_B = new double[N * K]; // 矩阵B NxK
    double *Matrix_C = new double[M * K]; // 结果矩阵

    int rank;               // process id number
    int world_size;         // number of process
    MPI_Init(&argc, &argv); // parallel init
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
    double start, stop; // 计时时间

    /*
        M：矩阵A的总的行数
        world_size: 总的进程数目
        lines: 数组，存放每个进程需要分配的行数
    */
    int *lines = new int[world_size];
    int equal_rows = M / world_size;
    int remain_lines = M % world_size;
    for (int i = 0; i < world_size; i++)
    {
        int rows = equal_rows;
        if (remain_lines != 0)
        {
            rows++;
            remain_lines--;
        }
        lines[i] = rows;
    }

    if (rank == 0)
    {
        // 数组A,B赋值
        start = MPI_Wtime();
        for (int i = 0; i < M; i++)
        {
            for (int j = 0; j < N; j++)
                Matrix_A[i * N + j] = i + 1;
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < K; j++)
                Matrix_B[i * K + j] = j + 1;
        }
    }

    MPI_Bcast(Matrix_B, N * K, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // 为每个rank分配发送数据相对于矩阵A的起始位置scatter_info.displs[i],
    // 发送数据的个数scatter_info.displs[i]
    DataInfo scatter_info = DataInfo(world_size);
    int tmp = 0;
    for (int i = 0; i < world_size; i++)
    {
        scatter_info.cnts[i] = lines[i] * N;
        scatter_info.displs[i] = tmp;
        tmp += scatter_info.cnts[i];
    }
    double *split_A = new double[lines[rank] * N]; // 每个进程获得矩阵A的部分数据
    MPI_Scatterv(Matrix_A, scatter_info.cnts, scatter_info.displs, MPI_DOUBLE,
                 split_A, lines[rank] * N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    double *resultbuff = new double[lines[rank] * K]; // 存放每个进程的计算结果

    AxB(split_A, Matrix_B, lines[rank], N, K, resultbuff);

    DataInfo gatherinfo = DataInfo(world_size);
    tmp = 0;
    for (int i = 0; i < world_size; i++)
    {
        gatherinfo.displs[i] = tmp;
        gatherinfo.cnts[i] = lines[i] * K;
        tmp += gatherinfo.cnts[i];
    }
    MPI_Gatherv(resultbuff, lines[rank] * K, MPI_DOUBLE, Matrix_C, gatherinfo.cnts,
                gatherinfo.displs, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    if (rank == 0 && argc > 0)
    {
        PrintMatrix(Matrix_A, M, N, "A");
        PrintMatrix(Matrix_B, N, K, "B");
        printf("mpi total processes: %d", world_size);
        PrintMatrix(Matrix_C, M, K, "mpi AXB");
        double *resultc = new double[M * K];
        AxB(Matrix_A, Matrix_B, M, N, K, resultc);
        PrintMatrix(resultc, M, K, "AXB");
        delete[] resultc;
    }

    delete[] split_A;
    delete[] resultbuff;
    delete[] Matrix_A;
    delete[] Matrix_B;
    delete[] Matrix_C;
    stop = MPI_Wtime();
    if (rank == 0 && argc == 0)
    {
        printf("consume time: %f s\n", stop - start);
    }
    MPI_Finalize();
}
Finddog
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
MPI矩阵乘法的两种实现方法
Francis Li
05-21 3712
MPI矩阵乘法 去年学习了并行计算，接触了MPI、Pthreads和OpenMP等常用的并行方法实现了并行的矩阵乘法，本章在此总结一下MPI的矩阵乘法使用。 使用简单的MPI_Send和MPI_Recv实现 使用较高级的MPI_Scatter和MPI_Gather实现 MPI_Send和MPI_Recv实现 #include&lt;stdio.h&gt; #include&lt;...
矩阵乘法mpi实现 并行运算
05-27
矩阵乘法mpi实现 并行运算 在linux下成功运行 使用mpicc -o 编译 使用mpirun命令运行
MPI实现矩阵乘法
12-24
通过分块利用MPI通讯实现矩阵乘法的并行计算。
高性能计算实验——矩阵乘法基于MPI的并行实现及优化
热门推荐
weixin_43973089的博客
04-19 1万+
高性能计算实验——矩阵乘法基于MPI的并行实现及优化1.实验目的1.1.通过MPI实现通用矩阵乘法1.2.基于MPI的通用矩阵乘法优化1.3.改造实验1成矩阵乘法库函数2.实验过程和核心代码2.1.通过MPI实现通用矩阵乘法2.2.通用矩阵乘法优化2.3.改造实验1成矩阵乘法库函数3.实验结果3.1.通过MPI实现通用矩阵乘法3.2.基于MPI的通用矩阵乘法优化3.3.改造实验1成矩阵乘法库函数4.实验感想 1.实验目的 1.1.通过MPI实现通用矩阵乘法 熟练掌握MPI编程方法，并将通用矩阵乘法转为MPI
MPI实现矩阵乘法的Cannon算法
dadan的博客
07-11 5384
1. 实验内容与方法 1) 对矩阵进行分块，之后按块进行乘法，使用的是cannon算法。Cannon算法是一种存储有效的算法。为了使两矩阵下标满足相乘的要求，它和并行分块乘法不同，不是仅仅让B矩阵的各列块循环移动，而是有目的地让A的各行块以及B的各列块皆施行循环移位，从而实现对C的子块的计算。将矩阵A和B分成p个方块Aij和Bij，，每块大小为，并将它们分配给个处理器。开始时处理器Pij存放块A...
深圳大学并行计算实验五矩阵乘法的MPI并行程序
最新发布
jannleo的博客
11-29 1077
/计算C的各个分块。cout << proc_num << "个进程的时间为：" << end <<"秒" << endl;cout << "串行时间为：" << time3 << "s" << endl;//b_A：A的分块结果 b_C：A与B分块乘结果 single_C：串行下C矩阵存储结果 用于对比。cout << "加速比为：" << time3 / (sum / 5) << endl;cout << "平均时间为：" << sum / 5 <<"秒" << endl;
并行矩阵乘法（C++ mpi 并行实现）
你的问题在于，读书太少而想得太多。
08-21 2263
矩阵乘法（C++ mpi 并行实现）
矩阵乘法MPI并行程序报告.pdf
06-06
在并行矩阵乘法中，通常通过划分任务，将计算工作分配给不同的进程，然后收集结果。 矩阵乘法的并行化策略通常是将大矩阵划分为多个小块，每个进程处理一部分。通过合理调度，可以大大提高计算效率。在上述代码中，...
MPI并行计算 矩阵乘法
05-31
MPI并行计算 矩阵乘法 如果是10000个线程的话可能会出问题
矩阵乘法MPI并行程序报告.docx
07-12
4. **并行程序设计**：在并行矩阵乘法中，通常采用分治策略，将大矩阵分解为小块，分配给不同的进程进行计算，然后将结果合并。实验中，可能使用`MPI_Send()`将矩阵部分或全部发送给其他进程，同时使用`MPI_Recv()`...
高性能计算导论实验3-矩阵乘法基于MPI的并行实现及优化
05-07
实验报告(高性能计算导论实验3-矩阵乘法基于MPI的并行实现及优化-实验报告.docx)会详细分析各种实现的性能，包括时间复杂度、通信开销和计算效率。mat_mul.h包含了矩阵乘法的公共函数声明，可能包括优化的矩阵运算...
mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
weixin_56273009的博客
06-19 911
【代码】mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
并行程序设计 MPI实现矩阵乘法（按行并行，分块并行，Cannon卡农算法）
WinterShiver
04-03 1万+
分为三个步骤：首先提供最简单的按行并行实现，之后基于分块并行、卡农算法的思路，逐渐改良算法。
mpi实现矩阵相乘
qq_35476482的博客
05-14 2557
主要是用了mpi中的MPI_Scatter()和MPI_Gather()函数#include<stdio.h> #include<string.h> #include<mpi.h> #include <malloc.h> int main(void){ int comm_sz; int my_rank; int size=1000; int *a,*b,*result,*local_a,*local
矩阵向量乘法MPI程序的性能评估
呼啦啦啦啦啦的博客
06-19 346
要求：对矩阵向量乘法MPI程序进行不同输入规模、不同进程数的执行和计时，并对得到运行时间进行计算分析，据此评价该程序的强扩展性和弱扩展性。最后总结学习心得，撰写实验报告。提示：分布式程序的各进程执行进度不同步，为了较为准确地计时，需要在计时开始时插入一个Barrier，最后取各进程计时结果的最大值。为方便矩阵的生成和计算结果的验证，可以通过自定义函数直接生成单位矩阵和元素全为1的向量用于计算。要特别注意注意C语言中传递二维数组给函数时，只能以一维数组的形式传递，并在函数内部把一维数组视为二维数组使用。
mpi大规模矩阵乘法C语言,MPI多进程并行计算矩阵乘法实现
weixin_30678145的博客
05-24 2013
MPI多进程并行计算矩阵乘法实现，对原始矩阵A、B进行初始化算为： 其主要思想：是把相乘的矩阵按行分解(任务分解)，分别分给不同的进程，然后在汇总到一个进程上，在程序上实现则用到了主从模式，人为的把进程分为主进程和从进程，主进程负责对原始矩阵初始化赋值，并把数据均匀分发(为了负载均衡)到从进程上进行相乘运算，主要用到的知识是MPI点对点通信的机制。具体代码为：// YinXing_Matrix_m...
【HNU分布式与云计算系统】MPI实现矩阵乘矩阵运算
lisiyu0816的博客
05-25 1702
【HNU分布式与云计算系统】MPI实现矩阵乘矩阵运算 实验环境 操作系统：Ubuntu 20.04 编程语言：C++ 实验原理 什么是MPI MPI是一个跨语言的通讯协议，用于编写并行计算机。支持点对点和广播。MPI是一个信息传递应用程序接口，包括协议和和语义说明，他们指明其如何在各种实现中发挥其特性。MPI的目标是高性能，大规模性，和可移植性。MPI在今天仍为高性能计算的主要模型。 尽管MPI属于OSI参考模型的第五层或者更高，他的实现可能通过传输层的sockets和Transmission Contro
【MPI编程】矩阵向量乘法--解法二（高性能计算）
肥宅Sean
11-26 8650
简述 有留心过的朋友可能会发现，其实我没写过解法一。 因为解法一就是大家最直观的感受的一种解法。 将矩阵按照行划分，之后，再每个线程都用整个向量跟这个块做内积。之后，传回来一个数值。 这里的方法二， 将矩阵按照列进行划分。然后将列向量传递给所有的线程，之后，再传对应的向量的对应的元素，给这个线程。之后，这个元素（数值），乘上传给它的向量的每一个元素。最后，再做一个Reduce的操作，将所有的...
MPI并行程序-矩阵分块乘法( Matrix multiplication : Two-Demension Method)
nupian7153的博客
05-27 5913
问题引入：主体思路：（为了尽可能使计算简便，所有的实验矩阵均是方阵）1.    对于A，B矩阵，首先根据子进程数p将其划分成p块形式相同的小矩阵块，其中每个矩阵块只要求是方阵即可，具体可以是1阶的，2阶的或n阶的。这里的子进程数p我采用了用于具体计算的进程数量，即除0进程以外的所有进程。划分完毕后，每个进程都持有矩阵A与矩阵B对应位置的一对儿分块阵。2.    对A，B矩阵进行初始位置分配，这里不...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值