矩阵乘法的优化

矩阵乘法(C语言版)串行程序优化之一 一. 优化核心思想: 提升缓存命中率: 1.矩阵乘法传统算法描述: 2.算法图形化展示: 根据矩阵乘法的计算特征以及C语言的访存特性(按行优先的存储),CPU在访问B矩阵数据的时候处于一个非连续的状态,那么CPU的缓存命中率会被极大的降低,为了扭转这样的局面,我们可以先给B矩阵做一个转置操作(耗时相对于乘法计算几乎可以忽略不计),先把行变成列,再“行行对应”计算,这样在计算过程中可以极大的提升缓存的命中率,从而实现一定程度的加速。 二. 优化前的代码 三. 优化后的代码: 转置: 乘法: 四. 阅读详情

源于微博上一个同学发了一条微博:“如何对C语言下的矩阵乘法进行优化?我试了几种小技巧,但是发现怎么试都远远比不上MATLAB。”

然后他贴了一下他的基本实现方法如下图:


基于他的方法,我也做了一下程序实现,代码如下:

/*
 * =====================================================================================
 *
 *       Filename:  matrix_multi.cpp
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  2013年01月15日 13时43分36秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Weidong Yang (cn), ywdong@mail2.sysu.edu.cn
 *        Company:  
 *
 * =====================================================================================
 */

#include <cstdio>
#include <cstdlib>
#include <ctime>

#define MAXNUM 1024
#define BASE 10
#define BLOCK (MAXNUM / 8)

double matrix[MAXNUM][MAXNUM];
double res[MAXNUM][MAXNUM];

double matrix_oneD[MAXNUM * MAXNUM];
double res_oneD[MAXNUM * MAXNUM];

char fileName[] = "Matrix_Data.txt";
clock_t start,  finish;
double duration;
bool isPrint = false;

void GenData()
{
    srand(time(NULL));
    FILE* fp = fopen(fileName, "w+");
    if (fp)
    {
        for (int i = 0; i < MAXNUM; i++)
        {
            for (int j = 0; j < MAXNUM; j++)
            {
                double value = (double)rand() / 100000;
                fprintf(fp, "%lf\t", value);
            }
            fprintf(fp, "\n");
        }
    }
    fclose(fp);
}

void ReadData()
{
    FILE* fp;
    int index = 0;
    if ((fp = fopen(fileName, "r")) != NULL)
    {
        for (int i = 0; i < MAXNUM; i++)
        {
            for (int j = 0; j < MAXNUM; j++)
            {
                double tmp;
                fscanf(fp, "%lf", &tmp);
                matrix[i][j] = tmp;
                matrix_oneD[index++] = tmp;
            }
        }
        printf("Data num is %d\n", index);
    }
    else
    {
        printf("Read file %s failed.\n", fileName);
    }
    fclose(fp);
}

void MM_Normal()
{
    int i,j,k;
    for (i = 0; i < MAXNUM; i++)
        for (j = 0; j < MAXNUM; j++)
            res[i][j] = 0.0;
    
    start = clock();

    for (i = 0; i < MAXNUM; i++)
        for (j = 0; j < MAXNUM; j++)
            for (k = 0; k < MAXNUM; k++)
                res[i][j] += matrix[i][k] * matrix[k][j];

    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("Normal method costs %lf seconds.\n", duration);
}

void MM_Block()
{
    int i,j,k,i0,j0,k0;
    for (i = 0; i < MAXNUM; i++)
        for (j = 0; j < MAXNUM; j++)
            res[i][j] = 0.0;

    start = clock();

    for (i = 0; i < MAXNUM; i += BLOCK)
        for (j = 0; j < MAXNUM; j += BLOCK)
            for (k = 0; k < MAXNUM; k += BLOCK)
                for (i0 = i; i0 < (i + BLOCK); i0++)
                    for (j0 = j; j0 < (j + BLOCK); j0++)
                        for (k0 = k; k0 < (k + BLOCK); k0++)
                            res[i0][j0] += matrix[i0][k0] * matrix[k0][j0];

    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("Block method costs %lf seconds.\n", duration);

}

void MM_Transpose()
{
    int i,j,k;
    for (i = 0; i < MAXNUM; i++)
        for (j = 0; j < MAXNUM; j++)
            res[i][j] = 0.0;
    
    start = clock();

    for (i = 0; i < MAXNUM; i++)
        for (k = 0; k < MAXNUM; k++)
            for (j = 0; j < MAXNUM; j++)
                res[i][j] += matrix[i][k] * matrix[k][j];

    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("Transpose method costs %lf seconds.\n", duration);
}

void MM_T_OneDimension()
{
    int i,j,k;
    for (i = 0; i < MAXNUM * MAXNUM; i++)
            res_oneD[i] = 0.0;
    
    start = clock();

    for (i = 0; i < MAXNUM; i++)
        for (k = 0; k < MAXNUM; k++)
            for (j = 0; j < MAXNUM; j++)
                res_oneD[i * MAXNUM + j] += matrix_oneD[i * MAXNUM + k] * matrix_oneD[k * MAXNUM + j];

    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("Transpose OneDimention method costs %lf seconds.\n", duration);

}

void MM_Transpose_Block()
{
    int i,j,k,i0,j0,k0;
    for (i = 0; i < MAXNUM; i++)
        for (j = 0; j < MAXNUM; j++)
            res[i][j] = 0.0;

    start = clock();

    for (i = 0; i < MAXNUM; i += BLOCK)
        for (k = 0; k < MAXNUM; k += BLOCK)
            for (j = 0; j < MAXNUM; j += BLOCK)
                for (i0 = i; i0 < (i + BLOCK); i0++)
                    for (k0 = k; k0 < (k + BLOCK); k0++)
                        for (j0 = j; j0 < (j + BLOCK); j0++)
                            res[i0][j0] += matrix[i0][k0] * matrix[k0][j0];

    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("Transpose Block method costs %lf seconds.\n", duration);

}

void PrintResOneD()
{
    if (!isPrint)
        return;
    int i,j;
    for (i = 0; i < MAXNUM; i++)
    {
        for (j = 0; j < MAXNUM; j++)
            printf("%lf ", res_oneD[i * MAXNUM + j]);
        printf("\n");
    }
    printf("\n");
}

void PrintRes()
{
    if (!isPrint)
        return;
    int i,j;
    for (i = 0; i < MAXNUM; i++)
    {
        for (j = 0; j < MAXNUM; j++)
            printf("%lf ", res[i][j]);
        printf("\n");
    }
    printf("\n");
}

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

    MM_Normal();
    PrintRes();

    MM_Transpose();
    PrintRes();

    MM_T_OneDimension();
    PrintResOneD();

    MM_Block();
    PrintRes();

    MM_Transpose_Block();
    PrintRes();

	return 0;
}		// ----------  end of function main  ---------- 


在我机子上实验结果如下:


(未完待续......)


矩阵乘法的分块优化 普通矩阵乘法一般采用3重循环完成。 void dgemm (int n, double* A, double* B, double* C) { for (int i = 0; i &lt; n; ++i) for (int j = 0; j &lt; n; ++j) { double cij = C[i+j*n]; /* cij = C[i][j] *... 阅读详情

相关推荐

CUDA矩阵乘法的优化

本文以 深入浅出谈cuda 中矩阵乘法优化的部分为主线,体会cuda的并行执行过程。 文章目录1 实验环境2 实验过程2.1 初始版本2.2 第一次改良——提高精度2.3 第二次改良——使用共享内存2.4 第三次改良——使用cudaMallocPitch()2.5 第四次改良——矩阵分块2.6 第五次改良——去掉if条件判断3 遇到的问题和解决4 最后版本代码 1 实验环境 个人笔记本电脑,显卡N...

weixin_43202895的博客 2691

矩阵乘法 递归 优化 c语言,矩阵乘法优化递归式

序:在OI比赛中,很多情况下我们可以能通过打表(找规律)或者某些方式发现一个递归式。例如:f(n) = f(n - 1)+f(n - 2),(斐波那契数列)。通常情况下,我们计算f(n)的时间复杂度就是O(n)(分别计算f(1), f(2) ... f(n - 1)).但是当n很大又或者还有其他处理的复杂度一叠加便会超时。如果不学习矩阵乘法优化的话,我们恐怕永远不会想到计算递推式还可以进行优化。实...

weixin_32445895的博客 828

C中实现矩阵乘法的一种高效的方法

本篇文章介绍了,在C中实现矩阵乘法的一种高效的方法。需要的朋友参考下

C语言代码优化11种实用方法

点击蓝字关注我1、选择合适的算法和数据结构选择一种合适的数据结构很重要,如果在一堆随机存放的数中使用了大量的插入和删除指令,那使用链表要快得多。数组与指针语句具有十分密切的关系,一般来说,指针比较灵活简洁,而数组则比较直观,容易理解。对于大部分的编译器,使用指针比使用数组生成的代码更短,执行效率更高。在许多种情况下,可以用指针运算代替数组索引,这样做常常能产生又快又短的代...

轻松学C语言 1649

win2012没有远程桌面授权服务器可以提供许可证 如何远程

如果远程windows服务器时,提示“没有远程桌面授权服务器可以提供许可证 如何远程”,先通过以下方式进行强制登录,然后在对服务器进行设置即可,延期使用。 强制登录服务器方式; 1、运行—输入:mstsc /admin /v ip:端口 回车即可 2、进入远程桌面,输入 ip:端口 /admin 例如:mstsc /admin /v 192.168.0.131:23568 进入服务器以后,按照以下步骤进行设置即可: ...

蜗牛快爬 1万+

【树莓派4B】八、树莓派软路由,Ubuntu18.04配置路由转发

我的目的是通过把树莓派做成一个软路由,相当于一个智能路由器。 材料 树莓派4B,操作系统其实可以是其他的Linux版本。以为4B自带无线网卡,就用自带无线网卡作为路由出口。 大概思路 具体步骤 配置两个网卡的IP sudo vim /etc/network/interface 这里设置静态IP,也可以动态获取。 #Local loopback auto lo iface lo inet loopback #Ethernet0 auto eth0 iface eth0 inet static addr

林愿留的博客 10万+

C/C++ 利用位运算优化整数乘法

本文参考自《深入理解计算机系统》中文版

缤纷冷泪的专栏 3655

Kisssoft软件在行星齿轮设计上的初试

行星齿轮传动与链传动相比较,具有质量小,体积小,承载能力强,传动比大,传动效率高等优点,但在行星齿轮传动种种优点下,不可避免的带来一些缺点,对其材料的要求过高,在追求传动比大而体积小的同时,其传动结构大大的复杂化,以及在制造和安装过程中较困难,对于行星齿轮传动设计来说,不仅应该了解其优点,而且应该在设计中,充分发挥其优点,且把其缺点降低到最低的限度。从而才能设计出性能优良的行星齿轮传动装置,为我们赛车提供更加强大的动力保证。 Kisssoft软件为我们行星齿轮传动设计提供了一体化方案,从设...

m0_69808569的博客 1万+

C语言 | 编程小技巧(三)

循环展开 简单的循环可以展开以获取更好的性能,但需要付出代码体积增加的代价。循环展开后,循环计数应该越来越小从而执行更少的代码分支。如果循环迭代次数只有几次,那么可以完全展开循环,以便消除循坏带来的负担。例如: for(i=0; i<3; i++) { something(i); } 展开为: something(0); something(1); something(2); 这...

嵌入式大杂烩 986

OpenClaw人人养虾:接入即时通讯平台Zalo

通过 Zalo Official Account(OA,官方账号)API,可以将 OpenClaw 接入 Zalo,实现面向越南用户的自动化客服和互动。

王国平的博客 438

【Docker】一招解决超时镜像超时报错:`ERROR: Get https://registry-1.docker.io/v2/`

Docker 镜像拉取超时或失败并不是 Docker 本身的缺陷,而是网络环境和默认配置在特定场景下的限制所导致的结果。通过本文的分析可以看到,问题的核心往往集中在三个方面:网络访问延迟、DNS 解析速度以及客户端默认超时时间。针对这些问题,最直接、有效的做法是使用国内镜像加速器,这不仅能够显著提升拉取速度,还能保证在企业内网或家庭网络中更加稳定

博客 1030

DP优化:矩阵乘法

话说这是博主的第一篇博客。。。 咳咳咳,今天讲的是DP的一种优化策略——矩阵乘法 关于能用矩阵乘法优化的DP题目,有如下几个要求: 转移式只有加法,清零,减法etc.,max和min运算不允许 转移式中关于前几位dp结果得到的系数必须是常量 转移次数一般超级多 综上,举一个例子: dp[ i ]=a×dp[ i-1 ]+b×dp[ i-2]+c×dp[ i-3 ] 其中,a,b,c是常量,...

china_xyc的博客 2670

opencv案例实战——银行卡模式匹配识别

在之前的几篇文章中我们已经介绍了opencv的一些基础知识,本篇文章我们将结合一个案例运用之前的知识并且学习opencv中模式匹配的应用,用到的知识点如果有不清楚的可以查看上面列出来的系列文章。具体代码会放在最后。

艾醒的博客 1340

程序性能优化探讨(6)——矩阵乘法优化之分块矩阵

有一种性格叫做偏执,有一种矩阵优化运算叫做分块。实话说,也许我这辈子也用不上这种随牛B但很复杂的算法,有些版本的教材直接删除这个内容。但越是这样我越想不过,因此借写这篇博客,把分块矩阵乘法彻底分析清楚。          把矩阵乘法进行分块优化,很奇妙的算法,假设我们要做11X11矩阵乘法,AXB = C原本是这样算的:         比如我们要计算C1.2,就要把上图的

u013471946的专栏 2万+

构建OneService:打造高效、安全、灵活的企业级数据服务平台

数据服务(OneService)作为统一的数据服务出口,实现了数据的统一市场化管理,有效地降低数据开放门槛的同时,保障了数据开放的安全。

数据与算法架构提升之路专栏 2114

YOLOv8 Neck改进:BiFPN双向特征金字塔网络解析与实践

本文详细介绍了如何在YOLOv8中集成BiFPN双向特征金字塔网络,包括原理解析、代码实现、配置文件修改和性能分析。BiFPN通过双向特征融合和加权特征机制,显著提升了多尺度目标检测的性能。希望通过本文的讲解,大家能够深入理解BiFPN的工作原理,并成功将其应用到自己的目标检测项目中。如果你有任何问题或建议,欢迎在评论区留言讨论!在下一篇文章中,我们将探讨YOLOv8的其他改进技术,包括注意力机制、新的损失函数等,敬请期待!

QQ_778132974的博客 993

cuda矩阵乘法优化之路

相对于1中的共享内存优化中,相当于每加载一个BLOCK_SIZE* width 的$M_i $ 时候,从N中加载两个 width * BLOCK_SIZE , 重复利用了Mi中读取的值, 其实这也是PMPP中的一个课后习题。在上面共享内存中,优化了数据内存读取,然而仍然是一个线程计算一个值,一次读取和计算的比例很低,在PMPP中提到一个启发式的思路,即一个线程计算两个P中元素。矩阵乘法,首先最朴素的方法,当然是类似CPU的直接计算,不过相对于CPU而言,GPU可以直接进行并行计算,对于矩阵乘。

sinat_41053216的博客 1392

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

CUDA矩阵乘法优化

前言 纸上的来终觉浅,绝知此事要躬行。 专业翻译为白话:https://zhuanlan.zhihu.com/p/410278370 naive写法 __global__ void matrixMul(const float *A, const float *B, float *C, int M, int N, int K) { int col = blockIdx.x * blockDim.x + threadIdx.x; int row = blockIdx.y * blockDim.y

feng__shuai的博客 2545

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

通用矩阵乘法优化GEMM

另一个矩阵加速计算的方式就是并行计算,矩阵的乘法是一个很适合并行化的,CPU本来是串行执行程序的,但现代CPU的核心数量已经比较多了,可以使用多线程的方式进行计算,每个CPU核心都有一套独立的寄存器,加上超线程,每个CPU核心有两套寄存器,超线程技术在同一个核心的两个线程间进行线程切换时的开销比较小,正常的线程切换需要将当前线程中的所有寄存器的数据压栈,后在进行线程切换的操作,有两套寄存器的好处就能减小这种开销。矩阵计算常用设备包括CPU,GPU,NPU,FPGA等,在不同的设备上的优化方法也各不相同。

weixin_69501140的博客 893

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

有关矩阵乘法及优化DP

以上题面提供了计算矩阵乘法的方法,通俗来讲,就是一个新矩阵C,等于两个矩阵:A和B做乘法,而矩阵C中的第i行,第j列元素,即c[i][j]等于A的第i行每个元素和B的第j列每一列元素相乘,把答案加到c[i][j]上。因为得到每个f[i],就相当于上一次运算完的矩阵A乘B,所以我们发现A一直在乘B,一共(n-2)次(因为初始2个数给定)我们知道矩乘的运算规则:对应相乘相加,比如:我们希望得到f[i],那就是希望A的第一行和B的第一列对应相乘得到f[i]也就是a*f[i-1]+c*f[i-2]=f[i]

2509_93020071的博客 534

稠密矩阵乘法单核优化

基于ARM平台(华为鲲鹏920芯片)的稠密矩阵乘法单核优化。优化选项包:编译选项,循环变换,消除指针别名,循环展开,内存对齐,简单Blocking,两级Blocking+转置重组

zongy17的博客 2226

用OpenMP对矩阵乘法运算进行优化

使用parallel for,只会把最外层的循环分给不同的线程,同一个外层循环的内层的循环只能由一个线程执行,要想实现同一个外层循环的内层循环也被多个线程执行,我们可以写循环的时候,内层循环写成:for (int j = 0;后来发现原因挺简单的,就是在双重循环的时候,假如第一层是遍历 i,第二层是遍历 j,这个 j 如果是omp_set_num_threads()之前声明的,就说明 j 被多个线程共用,那么可能这个线程正在使用 j,然后被另一个线程更改了。对于稀疏矩阵,可以采用CSR法对数据进行储存。

m0_74478846的博客 1598
上一篇: google面试题目11
下一篇: 自己动手定制一个高效阅读源代码的vim
overstack
博客等级 码龄14年 115粉丝 55原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值