矩阵乘法（暴力，并行加速，stressen，并行加速stressen）

最新推荐文章于 2024-05-26 17:31:07 发布
最新推荐文章于 2024-05-26 17:31:07 发布
阅读量2.3k 收藏 19
点赞数 3
文章标签： 矩阵 线性代数 linux 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56273009/article/details/127449183
版权

1. 有两个矩阵：A和B（矩阵实际上就是二维数组）

A矩阵和B矩阵可以做乘法运算必须满足A矩阵的列的数量等于B矩阵的行的数量

运算规则：A的每一行中的数字对应乘以B的每一列的数字把结果相加起来

   

 

 

矩阵乘法的结果为行与列的关系为：行数量为A的行数量， 列数量为B的列数量
 

2.stressen加速矩阵乘法原理：

在这里插入图片描述

 通俗的说，斯特拉森算法把原先普通二阶矩阵相乘需要的8次乘法压缩到7次乘法，而在计算机，乘法运算的耗时远远高于加减运算，所以斯特拉森算法可以将O(d^ 3) 压缩到O(d^2.8)。
需要知道的是，斯特拉森算法只是对矩阵分治的算法而不是单独的乘法算法，分治完成时最后使用的还是普通矩阵乘法，在阶数小于等于32（或者64？看过不同的实验结果）时普通的矩阵乘法会有更快的速度，而随着矩阵的阶不断增加，斯特拉森可以提供更快的速度。

一些拓展

在这里，提供另外一种形式的斯特拉森：

在这里插入图片描述

 在这里插入图片描述

 

同样是通过代数的分解与合并，我们构造出另外一种看起来更复杂的算法。这次我们分解出的项数更多，意味着拓展性更高，于是我们在求矩阵平方时有了新的改进。

矩阵的平方-斯特拉森

 我们只需要沿用之前图中的2.s。然后7次乘法使用上图方法，便可以减少一部分的预运算，而上图中，我们依然有P1P2P3可以递归入经过平方优化的斯特拉森算法，获得更快的速度。

利用openMP实现并行加速：

OpenMP基本概念

OpenMP是一种用于共享内存并行系统的多线程程序设计方案，支持的编程语言包括C、C++和Fortran。OpenMP提供了对并行算法的高层抽象描述，特别适合在多核CPU机器上的并行程序设计。编译器根据程序中添加的pragma指令，自动将程序并行处理，使用OpenMP降低了并行编程的难度和复杂度。当编译器不支持OpenMP时，程序会退化成普通（串行）程序。程序中已有的OpenMP指令不会影响程序的正常编译运行。

在VS中启用OpenMP很简单，很多主流的编译环境都内置了OpenMP。在项目上右键->属性->配置属性->C/C++->语言->OpenMP支持，选择“是”即可。

OpenMP执行模式

OpenMP采用fork-join的执行模式。开始的时候只存在一个主线程，当需要进行并行计算的时候，派生出若干个分支线程来执行并行任务。当并行代码执行完成之后，分支线程会合，并把控制流程交给单独的主线程。

一个典型的fork-join执行模型的示意图如下：

OpenMP编程模型以线程为基础，通过编译制导指令制导并行化，有三种编程要素可以实现并行化控制，他们分别是编译制导、API函数集和环境变量。

编译制导

编译制导指令以#pragma omp 开始，后边跟具体的功能指令，格式如：#pragma omp 指令[子句[,子句] …]。常用的功能指令如下：

  • parallel：用在一个结构块之前，表示这段代码将被多个线程并行执行；
    for：用于for循环语句之前，表示将循环计算任务分配到多个线程中并行执行，以实现任务分担，必须由编程人员自己保证每次循环之间无数据相关性；
    parallel for：parallel和for指令的结合，也是用在for循环语句之前，表示for循环体的代码将被多个线程并行执行，它同时具有并行域的产生和任务分担两个功能；
    sections：用在可被并行执行的代码段之前，用于实现多个结构块语句的任务分担，可并行执行的代码段各自用section指令标出（注意区分sections和section）；
    parallel sections：parallel和sections两个语句的结合，类似于parallel for；
    single：用在并行域内，表示一段只被单个线程执行的代码；
    critical：用在一段代码临界区之前，保证每次只有一个OpenMP线程进入；
    flush：保证各个OpenMP线程的数据影像的一致性；
    barrier：用于并行域内代码的线程同步，线程执行到barrier时要停下等待，直到所有线程都执行到barrier时才继续往下执行；
    atomic：用于指定一个数据操作需要原子性地完成；
    master：用于指定一段代码由主线程执行；
    threadprivate：用于指定一个或多个变量是线程专用，后面会解释线程专有和私有的区别。

相应的OpenMP子句为： 


  • private：指定一个或多个变量在每个线程中都有它自己的私有副本；
    firstprivate：指定一个或多个变量在每个线程都有它自己的私有副本，并且私有变量要在进入并行域或任务分担域时，继承主线程中的同名变量的值作为初值；
    lastprivate：是用来指定将线程中的一个或多个私有变量的值在并行处理结束后复制到主线程中的同名变量中，负责拷贝的线程是for或sections任务分担中的最后一个线程； 
    reduction：用来指定一个或多个变量是私有的，并且在并行处理结束后这些变量要执行指定的归约运算，并将结果返回给主线程同名变量；
    nowait：指出并发线程可以忽略其他制导指令暗含的路障同步；
    num_threads：指定并行域内的线程的数目； 
    schedule：指定for任务分担中的任务分配调度类型；
    shared：指定一个或多个变量为多个线程间的共享变量；
    ordered：用来指定for任务分担域内指定代码段需要按照串行循环次序执行；
    copyprivate：配合single指令，将指定线程的专有变量广播到并行域内其他线程的同名变量中；
    copyin：用来指定一个threadprivate类型的变量需要用主线程同名变量进行初始化；
    default：用来指定并行域内的变量的使用方式，缺省是shared。

利用omp_set_num_threads()来设置线程数，

利用#pragma omp parallel sections 声明下面大括号中的语句要并行多线程执行；

利用#pragma omp section 分配线程。

看懂下列helloworld的代码对openmp并行就会有一定了解。

 

代码实现：

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<omp.h>
#include<time.h>
#include<stdlib.h>
using namespace std;
/*
可以传递二维数组作为参数,有两种方法,
1.change(int **a)直接传递一个指针进去
2.change(int a[][10])数组的第二维维度一定要显式指定
*/
int N=1024;//N必须为2的幂次方 
	int** MatrixA = new int *[N];
	int**  MatrixB = new int *[N];
	int** MatrixC = new int *[N];//测试并行Strassen矩阵
    int** MatrixC2 = new int *[N];//测试串行Strassen矩阵
	int** MatrixC1 = new int*[N];//测试串行朴素相乘矩阵
    int** MatrixC3 = new int*[N];//测试并行朴素相乘矩阵
//打印矩阵
void PrintMatrix(int **MatrixA, int N){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			cout << MatrixA[i][j] << " ";
		}
		cout << endl;
	}
}
//矩阵加法
void Matrix_Sum(int N, int** MatrixA, int** MatrixB, int** Sum_Matrix){

	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Sum_Matrix[i][j] = MatrixA[i][j] + MatrixB[i][j];
		}
	}
}
//矩阵减法
void Matrix_Sub(int N, int** MatrixA, int** MatrixB, int** Sub_Matrix){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Sub_Matrix[i][j] = MatrixA[i][j] -MatrixB[i][j];
		}
	}
}
//矩阵乘法
void Matrix_Mul(int N, int** MatrixA, int** MatrixB, int** Mul_Matrix){

	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Mul_Matrix[i][j] = 0;
			for (int k = 0; k < N; k++){
				Mul_Matrix[i][j] += MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}
//矩阵乘法
void Matrix_Mul1(int N, int** MatrixA, int** MatrixB, int** Mul_Matrix){
#pragma omp parallel for
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			Mul_Matrix[i][j] = 0;
			for (int k = 0; k < N; k++){
				Mul_Matrix[i][j] += MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}
//Strassen串行
void Strassen1(int N, int** MatrixA, int** MatrixB, int** MatrixC2){
	//新建矩阵
	int** MatrixA11;
	int** MatrixA12;
	int** MatrixA21;
	int** MatrixA22;

	int** MatrixB11;
	int** MatrixB12;
	int** MatrixB21;
	int** MatrixB22;

	int** MatrixC11;
	int** MatrixC12;
	int** MatrixC21;
	int** MatrixC22;
	//初始化每个小矩阵的大小
	MatrixA11 = new int*[N/2];//数组的第二维一定要显示指定
	MatrixA12 = new int*[N/2];
	MatrixA21 = new int*[N/2];
	MatrixA22 = new int*[N/2];

	MatrixB11 = new int*[N/2];
	MatrixB12 = new int*[N/2];
	MatrixB21 = new int*[N/2];
	MatrixB22 = new int*[N/2];

	MatrixC11 = new int*[N/2];
	MatrixC12 = new int*[N/2];
	MatrixC21 = new int*[N/2];
	MatrixC22 = new int*[N/2];
	
	for (int i = 0; i < N/2; i++)//分配连续内存
	{
		MatrixA11[i] = new int[N/2];
		MatrixA12[i] = new int[N / 2];
		MatrixA21[i] = new int[N / 2];
		MatrixA22[i] = new int[N / 2];

		MatrixB11[i] = new int[N / 2];
		MatrixB12[i] = new int[N / 2];
		MatrixB21[i] = new int[N / 2];
		MatrixB22[i] = new int[N / 2];
		
		MatrixC11[i] = new int[N / 2];
		MatrixC12[i] = new int[N / 2];
		MatrixC21[i] = new int[N / 2];
		MatrixC22[i] = new int[N / 2];
	}
	 //为每个小矩阵赋值，将大矩阵分割为4个小矩阵
	 
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixA11[i][j] = MatrixA[i][j];
			MatrixA12[i][j] = MatrixA[i][j + N / 2];
			MatrixA21[i][j] = MatrixA[i + N / 2][j];
			MatrixA22[i][j] = MatrixA[i + N / 2][j + N / 2];

			MatrixB11[i][j] = MatrixB[i][j];
			MatrixB12[i][j] = MatrixB[i][j + N / 2];
			MatrixB21[i][j] = MatrixB[i + N / 2][j];
			MatrixB22[i][j] = MatrixB[i + N / 2][j + N / 2];
		}
	}
   //做10个辅助矩阵S，计算加法
	int** MatrixS1=new int*[N/2];
	int** MatrixS2 = new int*[N/2];
	int** MatrixS3 = new int*[N/2];
	int** MatrixS4 = new int*[N / 2];
	int** MatrixS5 = new int*[N / 2];
	int** MatrixS6 = new int*[N / 2];
	int** MatrixS7 = new int*[N / 2];
	int** MatrixS8 = new int*[N / 2];
	int** MatrixS9 = new int*[N / 2];
	int** MatrixS10 = new int*[N / 2];
	
	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixS1[i] = new int[N / 2];
		MatrixS2[i] = new int[N / 2];
		MatrixS3[i] = new int[N / 2];
		MatrixS4[i] = new int[N / 2];
		MatrixS5[i] = new int[N / 2];
		MatrixS6[i] = new int[N / 2];
		MatrixS7[i] = new int[N / 2];
		MatrixS8[i] = new int[N / 2];
		MatrixS9[i] = new int[N / 2];
		MatrixS10[i] = new int[N / 2];
	}

	Matrix_Sub(N/2, MatrixB12, MatrixB22, MatrixS1);//S1 = B12 - B22
	Matrix_Sum(N / 2, MatrixA11, MatrixA12, MatrixS2);//S2 = A11 + A12
	Matrix_Sum(N / 2, MatrixA21, MatrixA22, MatrixS3);//S3 = A21 + A22
	Matrix_Sub(N / 2, MatrixB21, MatrixB11, MatrixS4);//S4 = B21 - B11
	Matrix_Sum(N / 2, MatrixA11, MatrixA22, MatrixS5);//S5 = A11 + A22
	Matrix_Sum(N / 2, MatrixB11, MatrixB22, MatrixS6);//S6 = B11 + B22
	Matrix_Sub(N / 2, MatrixA12, MatrixA22, MatrixS7);//S7 = A12 - A22
	Matrix_Sum(N / 2, MatrixB21, MatrixB22, MatrixS8);//S8 = B21 + B22
	Matrix_Sub(N / 2, MatrixA11, MatrixA21, MatrixS9);//S9 = A11 - A21
	Matrix_Sum(N / 2, MatrixB11, MatrixB12, MatrixS10);//S10 = B11 + B12

	//做7个辅助矩阵P，计算乘法
	int** MatrixP1 = new int*[N / 2];
	int** MatrixP2 = new int*[N / 2];
	int** MatrixP3 = new int*[N / 2];
	int** MatrixP4 = new int*[N / 2];
	int** MatrixP5 = new int*[N / 2];
	int** MatrixP6 = new int*[N / 2];
	int** MatrixP7 = new int*[N / 2];
    
	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixP1[i] = new int[N / 2];
		MatrixP2[i] = new int[N / 2];
		MatrixP3[i] = new int[N / 2];
		MatrixP4[i] = new int[N / 2];
		MatrixP5[i] = new int[N / 2];
		MatrixP6[i] = new int[N / 2];
		MatrixP7[i] = new int[N / 2];
	}
	Matrix_Mul(N / 2, MatrixA11, MatrixS1, MatrixP1);//P1 = A11 ? S1
	Matrix_Mul(N / 2, MatrixS2, MatrixB22, MatrixP2);//P2 = S2 ? B22
	Matrix_Mul(N / 2, MatrixS3, MatrixB11, MatrixP3);//P3 = S3 ? B11
	Matrix_Mul(N / 2, MatrixA22, MatrixS4, MatrixP4);//P4 = A22 ? S4
	Matrix_Mul(N / 2, MatrixS5, MatrixS6, MatrixP5);//P5 = S5 ? S6
	Matrix_Mul(N / 2, MatrixS7, MatrixS8, MatrixP6);//P6 = S7 ? S8
	Matrix_Mul(N / 2, MatrixS9, MatrixS10, MatrixP7);//P7 = S9 ? S10

	//根据以上7个结果计算C2矩阵
	Matrix_Sum(N / 2, MatrixP5, MatrixP4, MatrixC11); //C11 = P5 + P4 - P2 + P6
	Matrix_Sub(N / 2, MatrixC11, MatrixP2, MatrixC11);
	Matrix_Sum(N / 2, MatrixC11, MatrixP6, MatrixC11);
	Matrix_Sum(N / 2, MatrixP1, MatrixP2, MatrixC12);//C12 = P1 + P2
	Matrix_Sum(N / 2, MatrixP3, MatrixP4, MatrixC21);	//C21 = P3 + P4
	Matrix_Sum(N / 2, MatrixP5, MatrixP1, MatrixC22);	//C22 = P5 + P1 - P3 - P7
	Matrix_Sub(N / 2, MatrixC22, MatrixP3, MatrixC22);
	Matrix_Sub(N / 2, MatrixC22, MatrixP7, MatrixC22);
	//将C11，C12,C21,C21合并为C2矩阵
	
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixC2[i][j] = MatrixC11[i][j];
			MatrixC2[i][j+N/2] = MatrixC12[i][j];
			MatrixC2[i+N/2][j] = MatrixC21[i][j];
			MatrixC2[i+N/2][j+N/2] = MatrixC22[i][j];
		}
	}
}


//并行Strassen的矩阵乘法,输入矩阵A，B，C
void Strassen(int N, int** MatrixA, int** MatrixB, int** MatrixC){
	//新建矩阵
	int** MatrixA11;
	int** MatrixA12;
	int** MatrixA21;
	int** MatrixA22;

	int** MatrixB11;
	int** MatrixB12;
	int** MatrixB21;
	int** MatrixB22;

	int** MatrixC11;
	int** MatrixC12;
	int** MatrixC21;
	int** MatrixC22;
	//初始化每个小矩阵的大小
	MatrixA11 = new int*[N/2];//数组的第二维一定要显示指定
	MatrixA12 = new int*[N/2];
	MatrixA21 = new int*[N/2];
	MatrixA22 = new int*[N/2];

	MatrixB11 = new int*[N/2];
	MatrixB12 = new int*[N/2];
	MatrixB21 = new int*[N/2];
	MatrixB22 = new int*[N/2];

	MatrixC11 = new int*[N/2];
	MatrixC12 = new int*[N/2];
	MatrixC21 = new int*[N/2];
	MatrixC22 = new int*[N/2];
	//#pragma omp parallel for
	for (int i = 0; i < N/2; i++)//分配连续内存
	{
		MatrixA11[i] = new int[N/2];
		MatrixA12[i] = new int[N / 2];
		MatrixA21[i] = new int[N / 2];
		MatrixA22[i] = new int[N / 2];

		MatrixB11[i] = new int[N / 2];
		MatrixB12[i] = new int[N / 2];
		MatrixB21[i] = new int[N / 2];
		MatrixB22[i] = new int[N / 2];
		
		MatrixC11[i] = new int[N / 2];
		MatrixC12[i] = new int[N / 2];
		MatrixC21[i] = new int[N / 2];
		MatrixC22[i] = new int[N / 2];
	}
	 //为每个小矩阵赋值，将大矩阵分割为4个小矩阵
	 //#pragma omp parallel for
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixA11[i][j] = MatrixA[i][j];
			MatrixA12[i][j] = MatrixA[i][j + N / 2];
			MatrixA21[i][j] = MatrixA[i + N / 2][j];
			MatrixA22[i][j] = MatrixA[i + N / 2][j + N / 2];

			MatrixB11[i][j] = MatrixB[i][j];
			MatrixB12[i][j] = MatrixB[i][j + N / 2];
			MatrixB21[i][j] = MatrixB[i + N / 2][j];
			MatrixB22[i][j] = MatrixB[i + N / 2][j + N / 2];
		}
	}
   //做10个辅助矩阵S，计算加法
	int** MatrixS1=new int*[N/2];
	int** MatrixS2 = new int*[N/2];
	int** MatrixS3 = new int*[N/2];
	int** MatrixS4 = new int*[N / 2];
	int** MatrixS5 = new int*[N / 2];
	int** MatrixS6 = new int*[N / 2];
	int** MatrixS7 = new int*[N / 2];
	int** MatrixS8 = new int*[N / 2];
	int** MatrixS9 = new int*[N / 2];
	int** MatrixS10 = new int*[N / 2];
	//#pragma omp parallel for
	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixS1[i] = new int[N / 2];
		MatrixS2[i] = new int[N / 2];
		MatrixS3[i] = new int[N / 2];
		MatrixS4[i] = new int[N / 2];
		MatrixS5[i] = new int[N / 2];
		MatrixS6[i] = new int[N / 2];
		MatrixS7[i] = new int[N / 2];
		MatrixS8[i] = new int[N / 2];
		MatrixS9[i] = new int[N / 2];
		MatrixS10[i] = new int[N / 2];
	}

	Matrix_Sub(N/2, MatrixB12, MatrixB22, MatrixS1);//S1 = B12 - B22
	Matrix_Sum(N / 2, MatrixA11, MatrixA12, MatrixS2);//S2 = A11 + A12
	Matrix_Sum(N / 2, MatrixA21, MatrixA22, MatrixS3);//S3 = A21 + A22
	Matrix_Sub(N / 2, MatrixB21, MatrixB11, MatrixS4);//S4 = B21 - B11
	Matrix_Sum(N / 2, MatrixA11, MatrixA22, MatrixS5);//S5 = A11 + A22
	Matrix_Sum(N / 2, MatrixB11, MatrixB22, MatrixS6);//S6 = B11 + B22
	Matrix_Sub(N / 2, MatrixA12, MatrixA22, MatrixS7);//S7 = A12 - A22
	Matrix_Sum(N / 2, MatrixB21, MatrixB22, MatrixS8);//S8 = B21 + B22
	Matrix_Sub(N / 2, MatrixA11, MatrixA21, MatrixS9);//S9 = A11 - A21
	Matrix_Sum(N / 2, MatrixB11, MatrixB12, MatrixS10);//S10 = B11 + B12

	//做7个辅助矩阵P，计算乘法
	int** MatrixP1 = new int*[N / 2];
	int** MatrixP2 = new int*[N / 2];
	int** MatrixP3 = new int*[N / 2];
	int** MatrixP4 = new int*[N / 2];
	int** MatrixP5 = new int*[N / 2];
	int** MatrixP6 = new int*[N / 2];
	int** MatrixP7 = new int*[N / 2];
    //#pragma omp parallel for
	for (int i = 0; i < N / 2; i++)//分配连续内存
	{
		MatrixP1[i] = new int[N / 2];
		MatrixP2[i] = new int[N / 2];
		MatrixP3[i] = new int[N / 2];
		MatrixP4[i] = new int[N / 2];
		MatrixP5[i] = new int[N / 2];
		MatrixP6[i] = new int[N / 2];
		MatrixP7[i] = new int[N / 2];
	}
	Matrix_Mul1(N / 2, MatrixA11, MatrixS1, MatrixP1);//P1 = A11 ? S1
	Matrix_Mul1(N / 2, MatrixS2, MatrixB22, MatrixP2);//P2 = S2 ? B22
	Matrix_Mul1(N / 2, MatrixS3, MatrixB11, MatrixP3);//P3 = S3 ? B11
	Matrix_Mul1(N / 2, MatrixA22, MatrixS4, MatrixP4);//P4 = A22 ? S4
	Matrix_Mul1(N / 2, MatrixS5, MatrixS6, MatrixP5);//P5 = S5 ? S6
	Matrix_Mul1(N / 2, MatrixS7, MatrixS8, MatrixP6);//P6 = S7 ? S8
	Matrix_Mul1(N / 2, MatrixS9, MatrixS10, MatrixP7);//P7 = S9 ? S10

	//根据以上7个结果计算C矩阵
	Matrix_Sum(N / 2, MatrixP5, MatrixP4, MatrixC11); //C11 = P5 + P4 - P2 + P6
	Matrix_Sub(N / 2, MatrixC11, MatrixP2, MatrixC11);
	Matrix_Sum(N / 2, MatrixC11, MatrixP6, MatrixC11);
	Matrix_Sum(N / 2, MatrixP1, MatrixP2, MatrixC12);//C12 = P1 + P2
	Matrix_Sum(N / 2, MatrixP3, MatrixP4, MatrixC21);	//C21 = P3 + P4
	Matrix_Sum(N / 2, MatrixP5, MatrixP1, MatrixC22);	//C22 = P5 + P1 - P3 - P7
	Matrix_Sub(N / 2, MatrixC22, MatrixP3, MatrixC22);
	Matrix_Sub(N / 2, MatrixC22, MatrixP7, MatrixC22);
	//将C11，C12,C21,C21合并为C矩阵
	//#pragma omp parallel for
	for (int i = 0; i < N / 2; i++){
		for (int j = 0; j < N / 2; j++){
			MatrixC[i][j] = MatrixC11[i][j];
			MatrixC[i][j+N/2] = MatrixC12[i][j];
			MatrixC[i+N/2][j] = MatrixC21[i][j];
			MatrixC[i+N/2][j+N/2] = MatrixC22[i][j];
		}
	}
}
//朴素矩阵相乘算法
void NormalMul_Matrix(int N, int **MatrixA, int **MatrixB, int **MatrixC){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixC[i][j] = 0;
			for (int k = 0; k < N; k++){
				MatrixC[i][j] = MatrixC[i][j]+MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}


void NormalMul_Matrix1(int N, int **MatrixA, int **MatrixB, int **MatrixC3){
    #pragma omp parallel for
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixC3[i][j] = 0;
			for (int k = 0; k < N; k++){
				MatrixC3[i][j] = MatrixC3[i][j]+MatrixA[i][k] * MatrixB[k][j];
			}
		}
	}
}
	//初始化矩阵A，B
void Init_Matrix(int N,int** MatrixA, int** MatrixB){
	srand(time(NULL)+rand());
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixA[i][j] = rand() % 10 + 1;//产生1~10
			MatrixB[i][j] = rand() % 10 + 1;
		}
	}
	/*
	C++中rand() 函数的用法
	1、rand()不需要参数，它会返回一个从0到最大随机数的任意整数，最大随机数的大小通常是固定的一个大整数。
	2、如果你要产生0~99这100个整数中的一个随机整数，可以表达为：int num = rand() % 100;
	这样，num的值就是一个0~99中的一个随机数了。
	3、如果要产生1~100，则是这样：int num = rand() % 100 + 1;
	4、总结来说，可以表示为：int num = rand() % n +a;
	其中的a是起始值，n-1+a是终止值，n是整数的范围。
	*/
}
//矩阵A,B测试用例
void Test_Matrix(int N, int** MatrixA, int** MatrixB){
	for (int i = 0; i < N; i++){
		for (int j = 0; j < N; j++){
			MatrixA[i][j] = 1;
			MatrixB[i][j] = 2;
		}
	}
	}

int main(){
	
	for (int i = 0; i < N; i++)//分配连续内存
	{
		MatrixA[i] = new int[N];
		MatrixB[i] = new int[N];
		MatrixC[i] = new int[N];

		MatrixC1[i] = new int[N];
        MatrixC2[i] = new int[N];

	}

	Init_Matrix(N, MatrixA, MatrixB);//给矩阵A B赋值 
	//Test_Matrix(N, MatrixA, MatrixB);
	//cout << "A矩阵为：" << endl;
	//PrintMatrix(MatrixA, N);
	//cout << "B矩阵为：" << endl;
    //PrintMatrix(MatrixB, N);	
	//cout << "朴素矩矩阵为：" << endl;
	
	double starttime=omp_get_wtime();
	NormalMul_Matrix(N, MatrixA, MatrixB, MatrixC1);
	double endtime=omp_get_wtime();
	printf("\n朴素串行时间:%lfs\n",endtime-starttime);


    double starttime3=omp_get_wtime();
	NormalMul_Matrix1(N, MatrixA, MatrixB, MatrixC1);
	double endtime3=omp_get_wtime();
	printf("\n朴素并行时间:%lfs\n",endtime3-starttime3);

	//PrintMatrix(MatrixC1, N);
	//cout << "Strassen矩阵为：" << endl;
	

   



   double starttime2=omp_get_wtime();
	Strassen1(N, MatrixA, MatrixB, MatrixC2);
	double endtime2=omp_get_wtime();
	printf("\nStrassen串行时间:%lfs\n",endtime2-starttime2);



	double starttime1=omp_get_wtime();
	Strassen(N, MatrixA, MatrixB, MatrixC);
	double endtime1=omp_get_wtime();
	printf("\nStrassen并行时间:%lfs\n",endtime1-starttime1);

	
	
	//PrintMatrix(MatrixC, N);
	//system("pause");
	return 0;				//等待按任意键退出
	
}

编译：g++ -fopenMP stressen.c -o stressen

运行：./stressen

结果如下：

 所有矩阵均为随机生成的大小统一为1024*1024 可自行修改。

K3V2
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
矩阵乘法MPI并行程序报告.pdf
06-06
矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf矩阵乘法MPI并行程序报告.pdf
如何加速矩阵乘法
sinat_22510827的博客
07-25 1370
矩阵的内存格式矩阵A中第i行第j列可以表示为A[i][j]。但是在系统底层的内存中，只有连续的存储空间，编译器会将高级语言的二维数组的访存转换为对一维内存的访问。将二维坐标映射成一维坐标有很多方法，直接的有两种行主序（row-majororder)和列主序（column-majororder)。简单地说，对于前面提到的A[i][j]元素，如果映射为一维数组，既可以用行主序的方式，如果一行的内存元素有lda个，则A[i][j]对应于A[i+j*lda]。的做法。利用寄存器减少访存次数。...
矩阵加速 （线性递推）
最新发布
qijingbo_的博客
05-26 1214
矩阵加速算法
快速排序的并行算法_omp_快速排序的并行算法_MPI并行_
09-29
快速排序是一种最基本的排序算法。对于一个有序数组采取了取首位为基准的方法，快速排序的时间复杂度将会是（O (n^2)），这将会与冒泡排序无差别，针对其过程，对每次划分后的两个子区分别使用两个处理器完成递归排序，那么排序的效率将会有质的飞跃。本程序分别运用了MPI和omp的方法。
并行实现快速排序
weixin_56273009的博客
10-21 1636
1：环境：Linux 系统CentOS 7。openMP 快排
Strassen矩阵乘法
Ben的专栏
10-20 2030
Strassen矩阵乘法矩阵乘法是线性代数中最常见的运算之一，它在数值计算中有广泛的应用。若A和B是2个n×n的矩阵，则它们的乘积C=AB同样是一个n×n的矩阵。A和B的乘积矩阵C中的元素C[i,j]定义为:　若依此定义来计算A和B的乘积矩阵C，则每计算C的一个元素C[i,j]，需要做n个乘法和n-1次加法。因此，求出矩阵C的n2个元素所需的计算时间为0(n3)。60年代末
矩阵乘法的并行化算法讨论
白马负金羁
09-26 3万+
矩阵乘法是线性代数里面会讲到的一种非常基础、也十分普遍的计算规则。另一方面，矩阵乘法同时也是并行计算领域常常被用来作为范例的一个话题。它的特点是首先计算量可能相当大，适合利用并行实现来提高效率。其次，它所使用的各种数据之间（矩阵中的元素）没有相互依赖性，可以充分使用并行处理的计算资源
快速排序的并行实现
m0_56147044的博客
05-05 1080
数据结构小班课--第十二周--并行排序
GPU并行加速矩阵乘法
12-01
GPU并行加速矩阵乘法 GPU并行加速矩阵乘法是利用GPU的并行计算能力来加速矩阵乘法运算的技术。矩阵乘法是机器学习、计算机视觉、科学计算等领域中的一个基本运算，它的计算复杂度很高，占用了大量的计算资源。传统...
并行矩阵乘法
09-24
并行矩阵乘法是计算机科学中的一个重要概念，特别是在高性能计算和大数据处理领域。它通过将一个大任务分解成多个小任务，然后在多个处理器或核心上同时执行这些小任务，来显著提高计算效率。在本项目中，我们将讨论...
openmp矩阵乘法_openmp_并行矩阵乘法_
09-29
本篇文章将详细讲解如何使用OpenMP来并行化矩阵乘法，以提高计算效率。 首先，我们要理解矩阵乘法的基本概念。给定两个矩阵A (m×n) 和B (n×p)，它们的乘积C (m×p) 是通过以下公式计算得出的： ``` C[i][j] = Σ...
基于Epiphany计算并行矩阵乘法的研究
04-16
为了提高矩阵乘法的计算效率，首先通过分析串行实现的矩阵乘法当中的不足之处，找出在单核上计算所存在的问题，提出将操作矩阵进行二维块状划分并行计算的解决方案。基于二维网状结构的多核处理器，先从一般矩阵与...
利用硬件实现矩阵乘法加速
zzc_zhuyu的博客
05-07 6616
对于绝大多数程序员来说，优化程序往往是在算法方面。但了解一定的计算机硬件知识后，可以隐式地优化程序。下面以矩阵乘法为例，探讨计算机硬件在程序优化中的作用。 原理 学过计算机组成原理的都知道，CPU访问内存的速度比CPU计算速度慢得多，为了解决速度不匹配的问题，在CPU与内存之间加了高速缓存cache。cache的存在大大提高了CPU访问数据的速度。由于价格等原因，cache都比较小。因此，较好地利...
[算法系列之十五]Strassen矩阵相乘算法
SmartSi
02-06 1105
引言 Strassen矩阵乘法是一种典型的分治算法。目前为止，我们已经见过一些分治策略的算法了，例如归并排序和Karatsuba大数快速乘法。现在，让我们看看分治策略的背后原理是什么。 同动态规划不同，在动态规划中，为了得到最终的答案，我们需要把一个大的问题“展开”为几个子问题（“expand” the solutions of sub-problems），但是在这里，我们会更多的谈到如何把...
矩阵乘法加速递推
killer的博客
10-30 471
矩阵快速幂加速递推式
快速矩阵乘法的算法实现
qq_42327795的博客
03-10 1万+
快速矩阵乘法
【MPI、OpenMP】并行快速排序(C语言)
热门推荐
qq_45801887的博客
03-31 3万+
（语言是C语言，有 例子+图 阐述原理，代码注释很全很详细）本文记录了使用MPI与OpenMP两种并行计算方法实现快速排序算法，主要分享一下自己的做法，希望大家不吝赐教。
矩阵相乘的快速算法
01-18 1652
http://dev.gameres.com/Program/Visual/3D/Mxquick.htm   
【芯片原理】NPU矩阵乘法加速详解
HaoBBNuanMM的博客
10-11 9561
概述 深度学习模型中费时的算子是往往是卷积操作，而卷积的本质是矩阵的乘加计算，所以通过硬件加速矩阵的乘加运算就能达到加速深度学习训练与推理的目标；本文旨在形象化的解释Google TPU与Nvidia TensorCore对矩阵乘加的加速过程 Nvidia TensorCore NV TensorCore 加速矩阵乘加运算示意图 Nvidia官方给出的TensorCore 加速矩阵...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值