MPI实现矩阵乘法的Cannon算法

最新推荐文章于 2024-06-06 00:02:15 发布
最新推荐文章于 2024-06-06 00:02:15 发布
阅读量5.3k 收藏 41
点赞数 7
文章标签： MPI Cannon 并行 矩阵乘法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34149581/article/details/95528479
版权

1. 实验内容与方法

1) 对矩阵进行分块，之后按块进行乘法，使用的是cannon算法。Cannon算法是一种存储有效的算法。为了使两矩阵下标满足相乘的要求，它和并行分块乘法不同，不是仅仅让B矩阵的各列块循环移动，而是有目的地让A的各行块以及B的各列块皆施行循环移位，从而实现对C的子块的计算。将矩阵A和B分成p个方块Aij和Bij，，每块大小为，并将它们分配给个处理器。开始时处理器Pij存放块Aij和Bij，并负责计算块Cij，然后算法开始执行：

⑴将块Aij向左循环移动i步；将块Bij向上循环移动j步；

⑵Pij执行乘加运算后将块Aij向左循环移动1步，块Bij向上循环移动1步；

⑶重复第⑵步，总共执行次乘加运算和次块Aij和Bij的循环单步移位。

2) 初始化数组。使用vector定义矩阵A、B和C，设置矩阵大小均为6000 * 6000。使用srand((unsigned) time(NULL))设置使用系统定时器的值作为随机种子，随机初始化矩阵A和矩阵B的值。

3) 程序计时。使用MPI自带的MPI_Wtime()函数，MPI_Wtime()记录的是墙上时间，在CPU时间的基础上包括了空闲等待时间。在各进程计算过程分块矩阵C之前和之后使用MPI_Wtime()函数计时，不计算最开始的初始化过程MPI发送的时间和最后接收数据汇总成矩阵C的时间。

2. 运行时间

矩阵A、B和C的大小均为6000 * 6000，且。经过代码运行计时，得到以下的实验结果表格。

处理器个数

用时/秒

串行

1734.048241

4核

321.548999

9核

194.883003

16核

111.360064

25核

61.248356

36核（3 * 12）

35.795692

 

3. 加速比

处理器个数

加速比

串行

1

4核

5.39279627

9核

8.89789368

16核

15.5715449

25核

28.3117516

36核（3 * 12）

48.4429311

4. 实验分析

从实验结果和加速比可以看出：

1 随着核数的增加，矩阵乘法所需要的时间在相应缩短；

2 矩阵乘法的加速比与运行的核心数近似成正比；

3 核心数越多，每个核分到的分块矩阵就越小，每个核计算速度就越快，加速比比核心数更高。

5. 源代码

#include "iostream"
#include "cstdlib"
#include "cstring"
#include "mpi.h"
#include "ctime"
#include "cmath"
#include "algorithm"
#include "vector"

using namespace std;
#define N 6000 //n是矩阵大小

// 全局变量声明
int block, block_size, p, sp;//， block是块的大小，block_size是块元素个数，等于block*block，p是处理器个数，sp是sqrt(p)
vector<vector<double>> A(N, vector<double>(N, 0)), B(N, vector<double>(N, 0)), C(N, vector<double>(N, 0));
double *a, *b, *c, *temp_a, *temp_b;
int my_rank, my_row, my_col;// my_rank是处理器的id，(my_row, my_col)是处理器逻辑阵列坐标
MPI_Status status;

double start_time, end_time;

int get_index(int row, int col, int sp);//处理器逻辑阵列坐标到rank的转换
void init_Matrix();//随机生成矩阵A和B
void scatter_A_B();//id为0的处理器向其他处理器发送矩阵A、B的分块
void init_alignment();//矩阵A和B的初始化，即A每行不同程度的左移，B每行不同程度的上移
void shift();//矩阵A每行左移一位，矩阵B每行上移一位，同时计算分块的中间结果C
void collect_C();//id为0的处理器从其余处理器收集分块矩阵C
void serial_Multiplication();//矩阵串行的计算

int main() {
    MPI_Init(NULL, NULL);
    MPI_Comm_size(MPI_COMM_WORLD, &p);
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
    
    sp = sqrt(p);
    
    if (sp * sp != p) {
        if (my_rank == 0)
            cout << "not a quadratic number" << endl;
        MPI_Finalize();
        exit(1);
    }
    
    block = N / sp;
    block_size = block * block;
    
    my_col = my_rank % sp;
    my_row = my_rank / sp;
    
    a = (double *) malloc(block_size * sizeof(double));
    b = (double *) malloc(block_size * sizeof(double));
    c = (double *) malloc(block_size * sizeof(double));;
    
    for (int i = 0; i < block_size; ++i) {
        c[i] = 0;
    }
    temp_a = (double *) malloc(block_size * sizeof(double));
    temp_b = (double *) malloc(block_size * sizeof(double));
    
    if (my_rank == 0) {
        init_Matrix();
        scatter_A_B();
    } else {
        MPI_Recv(a, block_size, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
        MPI_Recv(b, block_size, MPI_FLOAT, 0, 2, MPI_COMM_WORLD, &status);
    }
    start_time = MPI_Wtime();
    init_alignment();
    shift();
    end_time = MPI_Wtime();
    
    if (my_rank == 0) {
        cout << "matrix size : " << N << " * " << N << endl;
        printf("time = %lf\n", end_time - start_time);
    }
    if (my_rank == 0) {
        collect_C();
    } else {
        MPI_Send(c, block_size, MPI_FLOAT, 0, 1, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Finalize();
    
    return 0;
}

/*
 处理器逻辑阵列坐标到rank的转换
 输入：坐标(row, col)，sqrt(p)
 输出：rank
 */
int get_index(int row, int col, int sp) {
    return ((row + sp) % sp) * sp + (col + sp) % sp;
}

/*
 随机生成矩阵A和B
 */
void init_Matrix() {
    srand((unsigned int) time(NULL)); //设置随机数种子
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            A[i][j] = rand();
            B[i][j] = rand();
        }
    }
}

/*
 id为0的处理器向其他处理器发送矩阵A、B的分块
 */
void scatter_A_B() {
    int p_i_min, p_j_min, p_i_max, p_j_max;
    for (int k = 0; k < p; k++) {
        p_j_min = (k % sp) * block;
        p_j_max = (k % sp + 1) * block - 1;
        p_i_min = k / sp * block;
        p_i_max = (k / sp + 1) * block - 1;
        // id为0的处理器将矩阵A和B中的数据转换成一位数组传到temp中
        for (int i = p_i_min; i <= p_i_max; ++i) {
            for (int j = p_j_min; j <= p_j_max; j++) {
                temp_a[(i - p_i_min) * block + j - p_j_min] = A[i][j];
                temp_b[(i - p_i_min) * block + j - p_j_min] = B[i][j];
            }
        }
        if (k == 0) { // id为0的处理器直接拷贝过去，其他处理器则发送过去
            memcpy(a, temp_a, block_size * sizeof(double));
            memcpy(b, temp_b, block_size * sizeof(double));
        } else {
            MPI_Send(temp_a, block_size, MPI_FLOAT, k, 1, MPI_COMM_WORLD);
            MPI_Send(temp_b, block_size, MPI_FLOAT, k, 2, MPI_COMM_WORLD);
        }
    }
}

/*
 将A中坐标为(i, j)的分块循环左移i步
 将B中坐标为(i, j)的分块循环上移j步
 */
void init_alignment() {
    MPI_Sendrecv(a, block_size, MPI_FLOAT, get_index(my_row, my_col - my_row, sp), 1, temp_a, block_size, MPI_FLOAT,
                 get_index(my_row, my_col + my_row, sp), 1, MPI_COMM_WORLD, &status);
    memcpy(a, temp_a, block_size * sizeof(double));
    MPI_Sendrecv(b, block_size, MPI_FLOAT, get_index(my_row - my_col, my_col, sp), 1, temp_b, block_size, MPI_FLOAT,
                 get_index(my_row + my_col, my_col, sp), 1, MPI_COMM_WORLD, &status);
    memcpy(b, temp_b, block_size * sizeof(double));
}

/*
 矩阵A每行左移一位，矩阵B每行上移一位，同时计算分块的中间结果C
 */
void shift() {
    double total = 0;
    for (int l = 0; l < sp; l++) {
        for (int i = 0; i < block; i++) {
            for (int j = 0; j < block; j++) {
                total = c[i * block + j];
                for (int k = 0; k < block; k++) {
                    total += a[i * block + k] * b[k * block + j];
                }
                c[i * block + j] = total;
            }
            
        }
        // 将A全部循环左移1位
        MPI_Sendrecv(a, block_size, MPI_FLOAT, get_index(my_row, my_col - 1, sp), 1, temp_a, block_size, MPI_FLOAT,
                     get_index(my_row, my_col + 1, sp), 1, MPI_COMM_WORLD, &status);
        memcpy(a, temp_a, block_size * sizeof(double));
        // 将B全部循环上移1位
        MPI_Sendrecv(b, block_size, MPI_FLOAT, get_index(my_row - 1, my_col, sp), 1, temp_b, block_size, MPI_FLOAT,
                     get_index(my_row + 1, my_col, sp), 1, MPI_COMM_WORLD, &status);
        memcpy(b, temp_b, block_size * sizeof(double));
    }
}

/*
 id为0的处理器从其余处理器收集分块矩阵C
 */
void collect_C() {
    int p_i_min, p_j_min, p_i_max, p_j_max;
    // 将id为0的处理器的分块矩阵c结果赋给C对应位置
    for (int i = 0; i < block; i++) {
        for (int j = 0; j < block; j++) {
            C[i][j] = c[i * block + j];
        }
    }
    for (int k = 1; k < p; k++) {
        MPI_Recv(c, block_size, MPI_FLOAT, k, 1, MPI_COMM_WORLD, &status);
        p_j_min = (k % sp) * block;
        p_j_max = (k % sp + 1) * block - 1;
        p_i_min = k / sp * block;
        p_i_max = (k / sp + 1) * block - 1;
        for (int i = p_i_min; i <= p_i_max; i++) {
            for (int j = p_j_min; j <= p_j_max; ++j) {
                C[i][j] = c[(i - p_i_min) * block + j - p_j_min];
            }
        }
    }
}

void serial_Multiplication();//矩阵串行的计算  使用1个线程即串行的计算

 

dadan9
关注
  • 7
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
MPI矩阵乘法的两种实现方法
Francis Li
05-21 3710
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 实现 SUMMA 矩阵乘法
charles的专栏
11-19 5187
SUMMA 算法 SUMMA 算法和Fox 算法一样,将A , B 和C 划分为相同大小的矩阵,对应放在r×c 二维 mesh 上. 但 SUMMA 算法将矩阵乘法分解为一系列的秩nb 修正,即各处理器中的A 和B 分别被分解为nb 大小的列块 和行块进行相乘, nb≤min( k/ r , k / c) , 前面所说的分块尺寸就是指nb 的大小. 算法中, 广播实现为逻辑处理
MPI实现矩阵乘法
12-24
通过分块利用MPI通讯实现矩阵乘法的并行计算。
【数据结构】排序（直接插入、折半插入、希尔排序、快排、冒泡、选择、堆排序、归并排序、基数排序）
最新发布
ChenZHIHAO_y的博客
06-06 1312
排序！！！——直接插入、折半插入、希尔排序、快排、冒泡、选择、堆排序、归并排序、基数排序
高性能计算实验——矩阵乘法基于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并行程序
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 2242
矩阵乘法（C++ mpi 并行实现）
mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
weixin_56273009的博客
06-19 906
【代码】mpi实现矩阵乘法，卷积，池化（gemm,covn,pooling）
MPI矩阵乘法
Jerryrry的博客
05-02 1215
#include “stdafx.h” #include <stdio.h> #include “mpi.h” #include <Windows.h> #define N 200 //矩阵的阶数 #define MASTER 0 //主进程号 #define FROM_MASTER 1 //设置消息类型 #define FROM_WORKER 2 //设置消息
基于MPI得并行矩阵乘法 Cannon算法实现
09-10
在Cannon算法的实现中，MPI主要负责处理进程间的通信，包括发送和接收数据，确保矩阵乘法的正确执行。 Cannon算法的基本思想是将两个待乘矩阵分割成小块，然后在一个二维网格的处理器阵列上分布这些块。每个处理器...
矩阵相乘cannon算法的mpi实现
12-01
经典的cannon算法，主要用于矩阵相乘的并行求解问题。这个实现简单易懂，里面有详细注释。
Cannon乘法.rar_Cannon矩阵乘法_cannon_cannon矩阵相乘_mpi cannon_sell1k3
07-15
基于MPI的cannon算法，实现矩阵的相乘
MPI编程——分块矩阵乘法
03-31
分块矩阵乘法，利用cannon算法进行实现。运行环境：Centos7、mpic++3.2.0 分析见 MPI编程——分块矩阵乘法的博客
con1.rar_cannon算法
09-19
Cannon算法是由James Cannon在1969年提出的一种矩阵乘法的并行算法，它主要应用于分布式内存的多处理机系统，特别是那些具有二维处理器网格结构的系统。该算法充分利用了二维网格中的对角线交换特性，有效地实现了大...
基于超算平台的矩阵乘法MPI并行实验
Finddog的博客
07-16 209
基于超算平台的矩阵乘法MPI并行实验
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实现矩阵乘法（按行并行，分块并行，Cannon卡农算法）
WinterShiver
04-03 1万+
分为三个步骤：首先提供最简单的按行并行实现，之后基于分块并行、卡农算法的思路，逐渐改良算法。
mpi大规模矩阵乘法C语言,MPI多进程并行计算矩阵乘法实现
weixin_30678145的博客
05-24 2013
MPI多进程并行计算矩阵乘法实现，对原始矩阵A、B进行初始化算为： 其主要思想：是把相乘的矩阵按行分解(任务分解)，分别分给不同的进程，然后在汇总到一个进程上，在程序上实现则用到了主从模式，人为的把进程分为主进程和从进程，主进程负责对原始矩阵初始化赋值，并把数据均匀分发(为了负载均衡)到从进程上进行相乘运算，主要用到的知识是MPI点对点通信的机制。具体代码为：// YinXing_Matrix_m...
【HNU分布式与云计算系统】MPI实现矩阵乘矩阵运算
lisiyu0816的博客
05-25 1696
【HNU分布式与云计算系统】MPI实现矩阵乘矩阵运算 实验环境 操作系统：Ubuntu 20.04 编程语言：C++ 实验原理 什么是MPI MPI是一个跨语言的通讯协议，用于编写并行计算机。支持点对点和广播。MPI是一个信息传递应用程序接口，包括协议和和语义说明，他们指明其如何在各种实现中发挥其特性。MPI的目标是高性能，大规模性，和可移植性。MPI在今天仍为高性能计算的主要模型。 尽管MPI属于OSI参考模型的第五层或者更高，他的实现可能通过传输层的sockets和Transmission Contro
基于mpi实现矩阵乘法
03-29
以下是基于MPI实现矩阵乘法的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <mpi.h> #define N 100 int main(int argc, char *argv[]) { int rank, size; int i, j, k; int A[N][N], B[N][N], C[N][N]; int rowA[N], rowC[N]; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (size != N) { printf("Error: number of processes must be %d\n", N); MPI_Finalize(); return 0; } // Initialize matrices A and B for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { A[i][j] = i + j; B[i][j] = i - j; C[i][j] = 0; } } // Scatter matrix A to all processes MPI_Scatter(A, N*N/N, MPI_INT, rowA, N, MPI_INT, 0, MPI_COMM_WORLD); // Broadcast matrix B to all processes MPI_Bcast(B, N*N, MPI_INT, 0, MPI_COMM_WORLD); // Compute rows of matrix C for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { rowC[j] = 0; for (k = 0; k < N; k++) { rowC[j] += rowA[k] * B[k][j]; } } MPI_Reduce(rowC, &C[i], N, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); } // Gather matrix C from all processes MPI_Gather(rowC, N*N/N, MPI_INT, C, N*N/N, MPI_INT, 0, MPI_COMM_WORLD); // Print matrix C if (rank == 0) { printf("Matrix C:\n"); for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { printf("%d ", C[i][j]); } printf("\n"); } } MPI_Finalize(); return 0; } ``` 该程序将矩阵A均分给所有进程，每个进程计算矩阵C的一行。使用MPI_Reduce函数将每个进程计算出的行向量相加，得到最终的矩阵C。最后，使用MPI_Gather函数将矩阵C收集到进程0中，并打印输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值