gemm算法优化

已于 2024-03-18 14:56:49 修改
阅读量266 收藏
点赞数 2
文章标签： 算法 c语言
于 2024-02-06 18:18:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Begoniaish/article/details/136025223
版权

源码

#include <stdlib.h>
#include <string.h>
#include "InitMatrix.h"
#include "MatrixMultiply.h"
#include "PrintMatrix.h"
#include "mpi.h"

#define M 512
#define P 512
#define N 512



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

    MPI_Init(&argc, &argv);
	float * MatrixA;
	float * MatrixB;
	float * MatrixC;
	
	MatrixA = (float *)malloc(M * P * sizeof(float));
	MatrixB = (float *)malloc(P * N * sizeof(float));
	MatrixC = (float *)malloc(M * N * sizeof(float));
	
	memset(MatrixC, 0, M * N * sizeof(float)); 
	
	//给矩阵A和B赋值	
	InitMatrixA(MatrixA, M, P);
	InitMatrixB(MatrixB, P, N);


	double start = MPI_Wtime();
	//计算矩阵乘C=AB
	MatrixMultiply(MatrixA, MatrixB, MatrixC, M, P, N);
	
	double finish=MPI_Wtime();
	printf("MatrixMultiply kernel function cost time(clock):%lf s\n",finish-start);

	//输出矩阵C到文件，用于验证计算结果
	PrintMatrix(MatrixC, M, N);
	
	free(MatrixA);
	free(MatrixB);
	free(MatrixC);

	
	return 0;	
}

 当阶数为512时，运行结果如下：

 当阶数为5120时，运行时间超过10分钟以上

1、行列分块算法的程序实现

#include <stdlib.h>
#include <string.h>
#include "mpi.h"
#include "InitMatrix.h"
#include "MatrixMultiply.h"
#include "PrintMatrix.h"
#include <unistd.h>

#define M 1024
#define P 1024
#define N 1024

void printMatrix(float *data,int len){
	for (int i = 0; i <  len  ; i++)
		printf("%.3f\t",   data[i]);
	printf("\n");
}


int main(int argc, char *argv[]) {
    int rank, size;	
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
	
	MPI_Status status;	
    //MPI_Request request[2];

	MPI_Datatype newtype, tmp_block;
	MPI_Type_vector(M, P/size, N, MPI_FLOAT, &tmp_block);
	MPI_Type_create_resized(tmp_block, 0, sizeof(float), &newtype);
	MPI_Type_commit(&newtype);

	float * MatrixA;
	float * MatrixB;
	float * MatrixC; 
	
	float *SubMatrixA;
	float *SubMatrixB;
    float *SubMatrixC;
	MatrixA = (float *)malloc(M * P * sizeof(float));
	MatrixB = (float *)malloc(P * N * sizeof(float));
	MatrixC = (float *)malloc(M * N * sizeof(float));
	SubMatrixA = (float *)malloc(M * P / size * sizeof(float));
	SubMatrixB = (float *)malloc(N * P / size * sizeof(float));
    SubMatrixC = (float *)malloc(M * N / size * sizeof(float));

	memset(MatrixC, 0, M * N * sizeof(float));
    memset(SubMatrixC, 0, M * N / size * sizeof(float));
	
	int up = (rank == 0) ? (size-1) : (rank - 1);
    int down = (rank == (size-1)) ? 0: (rank + 1);
	//printf("Rank %d:  \n",  rank);
	//printf("down, up:%d,%d:  \n", down, up);
	
    if (rank == 0) {
        InitMatrixA(MatrixA, M, P);
        InitMatrixB(MatrixB, P, N);
		//printf("MatrixA Rank %d:  \n",  rank);		
		//printMatrix(MatrixA,M * P);
		//printf("MatrixB Rank %d:  \n",  rank);		
		//printMatrix(MatrixB,N * P);
    }
	
	MPI_Scatter(MatrixA, M * P / size, MPI_FLOAT, SubMatrixA, M * P / size, MPI_FLOAT, 0, MPI_COMM_WORLD);
	MPI_Scatter(MatrixB, 1, newtype, SubMatrixB, M * P / size, MPI_FLOAT, 0, MPI_COMM_WORLD);


	//重复非阻塞模式
	//MPI_Send_init(SubMatrixA, M * P / size, MPI_FLOAT,  up, 1, MPI_COMM_WORLD,&request[0]);
	//MPI_Recv_init(SubMatrixA, M * P / size, MPI_FLOAT,  down, 1, MPI_COMM_WORLD,&request[1]);	
	double start=MPI_Wtime();
	for(int i=0; i<size; i++){
		

		MatrixMultiply(SubMatrixA, SubMatrixB, SubMatrixC, M / size, P, N/size);
		//阻塞
		//MPI_Sendrecv( SubMatrixA, M * P/size, MPI_FLOAT, up, 1,SubMatrixA, M * P / size, MPI_FLOAT, down , 1, MPI_COMM_WORLD, &status );/*向上数据传送*/
		MPI_Sendrecv_replace(SubMatrixA, M * P / size, MPI_FLOAT, up, 1, down, 1, MPI_COMM_WORLD, &status);
		//非阻塞
		//MPI_Isend(SubMatrixA, M * P / size, MPI_FLOAT, up, 1, MPI_COMM_WORLD,&request[0]);
		//MPI_Irecv(SubMatrixA, M * P / size, MPI_FLOAT, down, 1, MPI_COMM_WORLD,&request[1]);
		//重复非阻塞
		//MPI_Startall(2, request);
		//MPI_Wait(&request[0], MPI_STATUS_IGNORE);
		//MPI_Wait(&request[1], MPI_STATUS_IGNORE);
		//sleep(i);
		//printf("SubMatrixA Rank %d i=%d:  \n",  rank,i);		
		//printMatrix(SubMatrixA,M * P / size);
		//printf("SubMatrixC Rank %d i=%d:  \n",  rank,i);		
		//printMatrix(SubMatrixC,N/size);
		MPI_Gather(SubMatrixC, N/size, MPI_FLOAT, &MatrixC[i*N],  N/size, MPI_FLOAT, 0, MPI_COMM_WORLD);
	}
	//printf("SubMatrixB Rank %d:  \n",  rank);		
	//printMatrix(SubMatrixB,N * P / size);
    if (rank == 0) {
		double finish=MPI_Wtime();
		printf("MatrixMultiply kernel function cost time(clock):%lf s\n",finish-start);
        // 输出矩阵C到文件，用于验证计算结果
        PrintMatrix(MatrixC, M, N);
		//printf("MatrixC %d:  \n",  rank);
		//printMatrix(MatrixC,M * N);
		free(MatrixA);
		free(MatrixB);
		free(MatrixC);

    }

	free(SubMatrixA);
	free(SubMatrixB);
	free(SubMatrixC);
	MPI_Type_free( &tmp_block);
	MPI_Type_free( &newtype);
	//MPI_Request_free(&request[0]);
	//MPI_Request_free(&request[1]);

    MPI_Finalize();
    return 0;
}

运行结果如下：

当阶数为512时，运行结果如下：

阻塞：

非阻塞：

重复非阻塞：

当阶数为5120时，运行结果如下：

阻塞：

非阻塞：

重复非阻塞：

当阶数为10240时，运行结果如下：

阻塞：

非阻塞：

重复非阻塞：

2、cannon算法的程序实现


#include <stdlib.h>
#include <string.h>
#include "InitMatrix.h"
#include "MatrixMultiply.h"
#include "PrintMatrix.h"
#include <mpi.h>
#include <unistd.h>
#include <math.h>

#define M 4
#define P 4
#define N 4


void printMatrix(float *data,int len){
	for (int i = 0; i <  len  ; i++)
		printf("%.3f\t",   data[i]);
	printf("\n");
}


int main(int argc, char * argv [])
{	
	int rank, size;
	MPI_Comm comm2d;
	MPI_Status status;
	//MPI_Request request[4];
	
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
	int q = sqrt(size);


	int periods[2]={1,1};
	int dims[2]={q,q};
	int right,left,down,top;
	MPI_Cart_create( MPI_COMM_WORLD, 2, dims, periods, 0,&comm2d);/*定义虚拟进程拓扑 它是一个n´n的网格 得到的包含进程拓扑信息的新的通信域是comm2d*/
	MPI_Cart_shift( comm2d, 0, 1, &left, &right);/*得到当前进程左右两侧的进程标识*/
	MPI_Cart_shift( comm2d, 1, 1, &down, &top);/* 得到当前进程上下方的进程标识*/

	//printf("Rank %d:  \n",  rank);
	//printf("left, right,down, top:%d,%d,%d,%d:  \n",  left, right,down, top);
	

	MPI_Datatype newtype, tmp_block;
	MPI_Type_vector(N/q, N/q, N, MPI_FLOAT, &tmp_block);
	MPI_Type_create_resized(tmp_block, 0, sizeof(float), &newtype);
	MPI_Type_commit(&newtype);
	

	float * MatrixA;
	float * MatrixB;
	float * MatrixC;
	float *SubMatrixA;
	float *SubMatrixB;
    float *SubMatrixC;
	MatrixA = (float *)malloc(M * P * sizeof(float));
	MatrixB = (float *)malloc(P * N * sizeof(float));
	MatrixC = (float *)malloc(M * N * sizeof(float));
	SubMatrixA = (float *)malloc(M * P / size * sizeof(float));
	SubMatrixB = (float *)malloc(N * P / size * sizeof(float));
    SubMatrixC = (float *)malloc(M * N / size * sizeof(float));

	memset(MatrixC, 0, M * N * sizeof(float));
    memset(SubMatrixC, 0, M * N / size * sizeof(float));
	
	int recvcounts[size];
	int displs[size];
	for(int i=0;i<q;i++){
		for(int j=0;j<q;j++){
			displs[i*q+j] = i*N*M/q + j*M/q;
			recvcounts[i*q+j] = 1;
			//printf("偏移量 %d,",  displs[i*q+j]);
		}
	}
	//给矩阵A和B赋值
	if(rank==0){

		InitMatrixA(MatrixA, M, P);
		InitMatrixB(MatrixB, P, N);
		//MPI_Sendrecv(&MatrixA[0], 1, newtype, 0, 2,MatrixB,4, MPI_FLOAT, 0, 2, comm2d, &status );
		//printf("MatrixA Rank %d:  \n",  rank);		
		//printMatrix(MatrixA,M * P);
		//printf("MatrixB Rank %d:  \n",  rank);		
		//printMatrix(MatrixB,P * N);
    }
	
		MPI_Scatterv(MatrixA, recvcounts,displs, newtype, SubMatrixA, M * P / size, MPI_FLOAT, 0, MPI_COMM_WORLD);
		MPI_Scatterv(MatrixB, recvcounts,displs, newtype, SubMatrixB, N * P / size, MPI_FLOAT, 0, MPI_COMM_WORLD);
		//sleep(rank); 
		//printf("SubMatrixA Rank %d:  \n",  rank);
		//printMatrix(SubMatrixA,M * P / size);
		//printf("SubMatrixB Rank %d:  \n",  rank);		
		//printMatrix(SubMatrixB,N * P / size);
		//MPI_Send_init(SubMatrixA, M * P / size, MPI_FLOAT,  down, 1, comm2d,&request[0]);
		//MPI_Send_init(SubMatrixB, M * P / size, MPI_FLOAT,  left, 2, comm2d,&request[1]);
		//MPI_Recv_init(SubMatrixA, M * P / size, MPI_FLOAT,  top, 1, comm2d,&request[2]);	
		//MPI_Recv_init(SubMatrixB, M * P / size, MPI_FLOAT,  right, 2, comm2d,&request[3]);
	double start = MPI_Wtime();
	for(int i=0; i < q; i++)
	{
		//MPI_Isend(SubMatrixA, M * P / size, MPI_FLOAT,  down, 4, comm2d,&request[0]);
		//MPI_Isend(SubMatrixB, M * P / size, MPI_FLOAT,  left, 5, comm2d,&request[1]);
		//MPI_Wait(&request[0], MPI_STATUS_IGNORE);
		//MPI_Wait(&request[1], MPI_STATUS_IGNORE);
		//MPI_Startall(2, &request[0]);
		//sleep(rank); 
		//printf("SubMatrixB Rank %d 第%d轮:  \n",  rank,i);
		//printMatrix(SubMatrixB,M * P / size);
		//计算矩阵乘C=AB
		MatrixMultiply(SubMatrixA, SubMatrixB, SubMatrixC, M/q, P/q, N/q );
		
		MPI_Sendrecv_replace(SubMatrixA, M * P / size, MPI_FLOAT, down, 2, top, 2, comm2d, &status);
		MPI_Sendrecv_replace(SubMatrixB, N * P / size, MPI_FLOAT, left,   1, right,  1, comm2d, &status);
		//MPI_Irecv(SubMatrixA, M * P / size, MPI_FLOAT,  top, 4, comm2d,&request[2]);	
		//MPI_Irecv(SubMatrixB, N * P / size, MPI_FLOAT,  right, 5, comm2d,&request[3]);
		//MPI_Startall(2, &request[2]);
		//MPI_Wait(&request[2], MPI_STATUS_IGNORE);
		//MPI_Wait(&request[3], MPI_STATUS_IGNORE);
		//MPI_Sendrecv( SubMatrixA, M * P/size, MPI_FLOAT, down, 2,SubMatrixA, M * P / size, MPI_FLOAT, top, 2, comm2d, &status );/*向上数据传送*/
		//MPI_Sendrecv( SubMatrixB, M * P/size,MPI_FLOAT, left, 1,SubMatrixB, N * P / size, MPI_FLOAT,right, 1, comm2d, &status );/*向左数据传送*/
		//sleep(rank); 
		//printf("SubMatrixB Rank %d 第%d轮:  \n",  rank,i+1);
		//printMatrix(SubMatrixB,M * P / size);
		sleep(rank); 
		printf("SubMatrixC %d 第%d轮:  \n",  rank,i);
		printMatrix(SubMatrixC,N * M / size);
	}

		MPI_Gatherv(SubMatrixC, N * M / size, MPI_FLOAT, MatrixC, recvcounts,displs, newtype, 0, MPI_COMM_WORLD);

	if (rank == 0) {
		double finish=MPI_Wtime();
		printf("MatrixMultiply kernel function cost time(clock):%lf s\n",finish-start);
        // 输出矩阵C到文件，用于验证计算结果
        PrintMatrix(MatrixC, M, N);
		//printf("MatrixC %d:  \n",  rank);
		//printMatrix(MatrixC,M * N);
		free(MatrixA);
		free(MatrixB);
		free(MatrixC);
    }

	free(SubMatrixA);
	free(SubMatrixB);
	free(SubMatrixC);
	MPI_Type_free( &tmp_block);
	MPI_Type_free( &newtype);
	MPI_Comm_free( &comm2d );
	//MPI_Request_free(&request[0]);
	//MPI_Request_free(&request[1]);
	//MPI_Request_free(&request[2]);
	//MPI_Request_free(&request[3]);
	MPI_Finalize();
	return 0;	
}

当阶数为512时，运行结果如下：

当阶数为5120时，运行结果如下：

当阶数为10240时，运行结果如下：

综上：

非阻塞通信可以让通信与计算同时进行，可以进一步缩短运行时间。

阶数低于512运行时间降低到一定程度开始升高，说明数据通信时间超过计算时间

阶数超过512运行时间呈现指数级增长，是因为cache大小为2*1024*1024

进程数量超过256，cannon算法计算时间比行列算法效率更高

Begoniaish
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
GEMM算法优化库
11-11
GEMM算法优化库，支持自调优，能够运行在Linux和Windows平台，可以获得很高的矩阵乘加速性能。
GEMM算法及优化流程详解
独行侠
02-16 2万+
前言 神经网络前向耗时主要由卷积的耗时决定，参考賈杨青毕业论文，那么如何对卷积加速便成了重要的一个点，主流的加速方法有 以下几种： im2col+GEMM：目前几乎所有的主流计算框架包括 Caffe, MXNet 等都实现了该方法. 该方法把整个卷积过程转化成了GEMM过程，而GEMM在各种 BLAS 库中都是被极致优化的，一般来说，速度较快。 Winograd： Winograd 是存在...
通用矩阵乘（GEMM）优化与卷积计算
u013250861的博客
11-26 1194
前两节探讨的是传统优化矩阵乘的两者思想，近年来兴起的神经网络中广泛应用的矩阵乘也可用类似方法优化（实际上深度学习软件可以直接使用已有的数学加速库，如 BLAS）。随着技术的演进，神经网络技术出现了一个重要的方向——神经网络量化。在常规的数据规模中，由于左侧会发生太多的高速缓存缺失，又由于矩阵乘这样的计算对数据的访问具有很高的重复性，将它重排成右侧的内存布局减少高速缓存缺失，可显著地改进性能。到目前为止（2019 年中），QNNPACK 是已公开的，用于移动端（手机）的，性能最优的量化神经网络加速库。
GEMM矩阵相乘与深度学习
weixin_43728590的博客
07-08 3863
GEMM矩阵相乘与深度学习1. GEMM矩阵相乘1.1 GEMM算法基础1.2 GEMM算法优化1.2.1 循环重排充分利用缓存1.2.2 平铺（Tiling）充分利用缓存1.2.3 展开（Unrolling）1.2.4 内存对齐1.2.5 向量化1.2.6 矩阵分块1.2.7 双缓冲2. GEMM与卷积计算2.1 计算卷积的方法2.2 Img2col2.2.1 CNN中张量的存储2.2.2 卷积运算转化为GEMM 1. GEMM矩阵相乘 1.1 GEMM算法基础   GEMM（General Matrix
如何在 CPU 上优化 GEMM
吴建明wujianming_110117
10-05 347
如何在 CPU 上优化 GEMM (TL;DR) TVM 提供抽象接口，允许用户分别描述算法和算法的实施组织（所谓的调度）。通常，在高性能调度中编写算法，会破坏算法的可读性和模块化。尝试各种看似有前途的调度也很耗时。在 TVM 的帮助下，可以有效地尝试这些调度，提高性能。 将演示如何使用 TVM 优化矩阵乘法，通过简单地添加 18 行额外代码，实现比基线快 200 倍。 在 CPU 上执行的密集计算应用程序，有两个重要的优化： 提高内存访问的缓存命中率。复杂的数值计算和热点内存访问，都可以通过高缓存命中率
利用GEMM算法优化深度学习模型的高性能计算方法
Cbibad的博客
07-19 153
通过矩阵分块、并行化计算、优化内存访问和算法优化等技术，可以大大提高深度学习模型的性能。通过矩阵分块、并行化计算、优化内存访问和算法优化等技术，可以大大提高深度学习模型的性能。通过合理地利用GEMM算法的矩阵分块、并行化计算和优化内存访问，我们可以大大提高CNN的计算性能。通过优化算法，减少不必要的计算和内存访问，可以进一步提高计算性能。通过这种优化方法，我们可以在保持模型准确性的前提下，大大减少计算时间，提高计算效率。通过利用GEMM算法的并行计算和优化内存访问，可以提高计算性能。步骤3：优化内存访问。
AI移动端优化
春秋繁露
07-10 791
原文地址：https://zhuanlan.zhihu.com/p/65436463 一、前言 数学是科学的基础，一般涉及算法的项目拆分到底层也都是基本的科学计算：单个数字、数组、各种维度矩阵之间的操作。BLAS 是一个数学计算库的标准，定义了一套矩阵数组操作的API，例如: sgemm float矩阵乘法、sgemv float矩阵乘以数组… 诸如此类。 OpenBLAS 是BLAS标准的一种具...
GEMM.rar_GEMM
09-24
使用微软最新发布的c++amp开发的 关于gemm算法的源码，大家可以参考，以此来学习c++amp
tvm-使用tvm+gpu优化矩阵乘法GEMM的实现-附完整源码.zip
最新发布
04-15
tvm_使用tvm+gpu优化矩阵乘法GEMM的实现_附完整源码
MIOpenGEMM_OpencL_GPU_GEMM_amd_
09-29
用于AMD GPU的MIOpenGEMM算法库代码，用于加速GEMM算法和深度学习
gemm.c
11-07
gemm.c
Winograd，GEMM算法综述（CNN中高效卷积实现）（上）
是否龍磊磊真的一无所有的博客
01-09 1万+
                       高效卷积实现算法和应用综述（上） 在下一篇文章会介绍Winograd算法的应用，在ICLR，CVPR，FPGA，FCCM等机器学习和FPGA领域的定会上的研究实现和新的突破。下一篇理论分析链接。https://blog.csdn.net/qq_32998593/article/details/86181663 摘要： 首先要说明的是，卷积是指Co...
通用矩阵乘（GEMM）优化算法从入门到实践
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
10-13 1256
矩阵乘的算法优化可分为两类：基于算法分析的方法：根据矩阵乘计算特性，从数学角度优化，典型的算法包括 Strassen 算法和 Coppersmith–Winograd 算法。基于软件优化的方法：根据计算机存储系统的层次结构特性，选择性地调整计算顺序，主要有循环拆分向量化、内存重排等。
如何加速矩阵乘法——优化GEMM (CPU单线程篇)
sinat_22510827的博客
07-22 4779
矩阵乘法GEMM(Generalmatrixmultiply)是一个被广泛使用的基础算法，各种领域都需要应用，例如神经网络的核心计算任务就是矩阵乘法，交易中的各种信号计算也可能用到矩阵乘法。因此矩阵乘法的效率是极其关键的。关于如何优化矩阵乘法，我准备写一个较短的系列博文，包括CPU单线程篇、CPU多线程篇、GPU篇。原本计划还有一个稀疏矩阵乘法篇，由于这学期毕业前也没有时间把GPU篇做到满意，因此，稀疏矩阵篇就没了，GPU篇也很不完整。如果日后有时间且有那冲动可能会补上（大概率没有）。...
BLAS库中level3的GEMM简单计算优化
wusy的博客
07-15 2062
最近由于工作需要，研究了GEMM算子的简单优化。在这里做一个简单的记录，方便以后的查阅。目前，开源的BLAS库已经有很多的，例如OpenBLAS，BLIS等。而可以发现，这些开源的计算库，大多是根据之前GotoBLAS库的优化方法基础上进一步开发的。而GotoBLAS的优化主要是基于论文&quot;BLISlab: A Sandbox for Optimizing GEMM&quot;进行的。本文主要对这篇论文进行分析理解，希望对大家有所帮助。
GEMM优化、并行优化、算子优化，从BLISlab项目入手！
weixin_45571628的博客
08-22 2484
GEMM优化在深度学习、科学计算等领域都有重要意义，本文通过视频、文字、转载等各种方式，让你对gemm有一个系统的、全面的、深入的认识。
EM算法原理详解
热门推荐
皮皮blog
01-09 4万+
http://blog.csdn.net/pipisorry/article/details/42550815EM算法有很多的应用，最广泛的就是GMM混合高斯模型、聚类、HMM、基于概率的PLSA模型等等。本文详细讲述EM算法的由来、EM算法的实现思路、EM算法解决PLSA和LDA的方法。概述、EM是一种解决存在隐含变量优化问题的有效方法。EM的意思是“Expectation Maximizati
darknet源码分析（三）gemm实现
zhengmingzhang的博客
07-13 1808
上一节中我们分析了darknet卷积层的前向操作过程，darknet对卷积计算的处理实际上是： 先使用im2col将input_channel*(height*width)的输入特征图（实际存储是按照行存储的，即是1*(input_channel*height*width)的一维数组）转化成(input_channel*kernel_size*kernel_size)*(out_height*o...
O3优化中包含GEMM优化算法吗
07-11
O3优化级别是GCC编译器中的一种优化选项，它主要用于优化代码的执行速度和效率。在O3优化级别中，并不直接包含针对GEMM（General Matrix Multiplication）的特定优化算法。O3优化级别主要关注于整体的代码优化，包括但不限于循环优化、内存优化、矢量化等。 然而，由于GEMM是一种常见且重要的计算操作，GCC编译器在进行O3优化时会尝试对GEMM相关的代码进行一些常规的优化，比如循环展开、内存访问优化等。这些通用的优化技巧可以提高GEMM算法在编译后的执行效率。 需要注意的是，针对特定硬件平台和GEMM算法的高级优化通常需要手动实现，使用专门的数学库或进行硬件特定的编程。这些优化技术可以充分利用硬件特性和算法特点，进一步提高GEMM算法的性能。 因此，虽然O3优化级别可能会对GEMM相关代码进行一些常规的优化，但要实现更高级的GEMM优化，可能需要使用特定的数学库或进行硬件特定的编程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值